iOS
AWS SDK

Télécharger une image ou une vidéo sur S3 en utilisant AWS SDK

Avant de commencer avec l'exemple, je vous recommande de créer un Singleton avec un membre de classe délégué afin de pouvoir télécharger un fichier en arrière-plan et laisser l'utilisateur continuer à utiliser votre application pendant le téléchargement des fichiers, même lorsque l'application est téléchargée. est le fond

Commençons d'abord par créer une énumération représentant la configuration S3:

enum S3Configuration : String
{
    case IDENTITY_POOL_ID   = "YourIdentityPoolId"
    case BUCKET_NAME        = "YourBucketName"
    case CALLBACK_KEY       = "YourCustomStringForCallBackWhenUploadingInTheBackground"
    case CONTENT_TYPE_IMAGE = "image/png"
    case CONTENT_TYPE_VIDEO = "video/mp4"
}

Maintenant, nous devrions définir les informations d'identification lors du lancement de votre application pour la première fois, nous devrions donc les AppDelegate dans la méthode AppDelegate à la méthode didFinishLaunchingWithOptions (faites attention à définir votre région sur le regionType ):

func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool
{
  let credentialProvider = AWSCognitoCredentialsProvider(regionType: .EUWest1, identityPoolId: S3Configuration.IDENTITY_POOL_ID.rawValue)
  let configuration = AWSServiceConfiguration(region: .EUWest1, credentialsProvider: credentialProvider)
  AWSS3TransferUtility.registerS3TransferUtilityWithConfiguration(configuration, forKey: S3Configuration.CALLBACK_KEY.rawValue)
}

Comme nous sommes déjà dans AppDelegate, nous devrions implémenter le rappel en arrière-plan géré par le kit AWS SDK:

func application(application: UIApplication, handleEventsForBackgroundURLSession identifier: String, completionHandler: () -> Void)
{
    //  Will print the identifer you have set at the enum: .CALLBACK_KEY
    print("Identifier: " + identifier)
    //  Stores the completion handler.
    AWSS3TransferUtility.interceptApplication(application,
                                              handleEventsForBackgroundURLSession: identifier,
                                              completionHandler: completionHandler)
}

Maintenant, lorsque l'utilisateur déplacera l'application en arrière-plan, votre téléchargement se poursuivra.

Afin de télécharger le fichier à l'aide du kit AWS SDK, nous devrons écrire le fichier sur le périphérique et donner au SDK le chemin réel. Par souci d’exemple, imaginons que nous ayons un UIImage (qui pourrait aussi être une vidéo) et nous l’écrirons dans un dossier temporaire:

// Some image....
let image = UIImage()
let fileURL = NSURL(fileURLWithPath: NSTemporaryDirectory()).URLByAppendingPathComponent(fileName)
let filePath = fileURL.path!
let imageData = UIImageJPEGRepresentation(image, 1.0)
imageData!.writeToFile(filePath, atomically: true)

FileURL et FileName seront utilisés pour le téléchargement réel ultérieurement.

Il y aura 2 fermetures à définir par le SDK AWS,

1. AWSS3TransferUtilityUploadCompletionHandlerBlock - Une fermeture qui avertit lorsque le téléchargement est terminé (ou non)
2. AWSS3TransferUtilityUploadProgressBlock - Une fermeture qui notifie chaque octet envoyé

Si vous prévoyez d'avoir un singleton, vous devez définir ces types en tant que membres de la classe. L'implémentation devrait ressembler à ceci:

var completionHandler : AWSS3TransferUtilityUploadCompletionHandlerBlock? =
    { (task, error) -> Void in

        if ((error) != nil)
        {
          print("Upload failed")
        }
        else
        {
          print("File uploaded successfully")
        }
    }

var progressBlock : AWSS3TransferUtilityUploadProgressBlock? = 
    { [unowned self] (task, bytesSent:Int64, totalBytesSent:Int64,  totalBytesExpectedToSend:Int64) -> Void in

     let progressInPercentage = Float(Double(totalBytesSent) / Double(totalBytesExpectedToSend)) * 100
     print(progressInPercentage)
    }

REMARQUE: Si vous utilisez un singleton, vous souhaiterez peut-être définir un délégué qui vous informera de la progression ou de la fin du fichier. Si vous n'utilisez pas un Singleton, vous pouvez créer une méthode statique qui aurait les types appropriés:

    static func uploadImageToS3(fileURL : NSURL,
                               fileName : String,
                progressFunctionUpdater : Float -> Void,
                            resultBlock : (NSError?) -> Void)
{
 //    Actual implementation .....
 //    ...
 //    ...
}

1. progressFunctionUpdater - rapportera à une fonction avec progression.
2. resultBlock - Si vous retournez nil puis que le téléchargement a été effectué avec succès, vous envoyez l'objet d'erreur

Mesdames et Messieurs, le téléchargement actuel:

        let fileData = NSData(contentsOfFile: fileURL.relativePath!)

        let expression = AWSS3TransferUtilityUploadExpression()
        expression.uploadProgress = progressBlock
        
        let transferUtility = AWSS3TransferUtility.S3TransferUtilityForKey(S3Configuration.CALLBACK_KEY.rawValue)
        
        transferUtility?.uploadData(fileData!,
            bucket: S3Configuration.BUCKET_NAME.rawValue,
            key: fileName,
            contentType: S3Configuration.CONTENT_TYPE_IMAGE.rawData,
            expression: expression,
            completionHander: completionHandler).continueWithBlock
            { (task : AWSTask) -> AnyObject? in
                
                if let error = task.error
                {
                    print(error)
                }
                if let exception = task.exception
                {
                    print("Exception: " + exception.description)
                }
                if let uploadTask = task.result as? AWSS3TransferUtilityUploadTask
                {
                    print("Upload started...")
                }
                
                return nil
        }

Happy S3 uploading :)