iOS
AWS SDK

Laden Sie ein Bild oder ein Video mit AWS SDK in S3 hoch

Bevor Sie mit dem Beispiel beginnen, würde ich empfehlen, ein Singleton mit einem Delegate-Klassenmitglied zu erstellen, sodass Sie die Möglichkeit haben könnten, eine Datei im Hintergrund hochzuladen, und den Benutzer die Verwendung Ihrer App weiterhin zulassen, während die Dateien auch während der App hochgeladen werden ist der Hintergrund.

Beginnen wir mit dem Erstellen eines Enums, das die S3-Konfiguration darstellt:

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"
}

Jetzt sollten wir die Anmeldeinformationen festlegen, wenn Ihre App zum ersten Mal AppDelegate didFinishLaunchingWithOptions sollten Sie sie in der didFinishLaunchingWithOptions Methode der Methode AppDelegate didFinishLaunchingWithOptions (achten Sie darauf, dass Sie Ihre Region auf regionType param setzen):

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)
}

Da wir uns bereits in AppDelegate befinden, sollten wir den Hintergrund-Callback implementieren, der vom AWS SDK verarbeitet wird:

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)
}

Wenn der Benutzer die App in den Hintergrund verschiebt, wird der Upload nun fortgesetzt.

Um die Datei mit dem AWS SDK hochladen zu können, müssen Sie die Datei auf das Gerät schreiben und dem SDK den tatsächlichen Pfad angeben. Stellen Sie sich vor, wir hätten ein UIImage (könnte auch ein Video sein ...) und wir schreiben es in einen temporären Ordner:

// 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 und Dateiname werden später für das eigentliche Hochladen verwendet.

Es gibt zwei Schließungen, die wir definieren müssen, die vom AWS SDK bereitgestellt werden.

1. AWSS3TransferUtilityUploadCompletionHandlerBlock - Eine Schließung, die benachrichtigt, wenn der Upload abgeschlossen ist (oder nicht).
2. AWSS3TransferUtilityUploadProgressBlock - Eine Schließung, die jedes gesendete Byte benachrichtigt

Wenn Sie ein Singleton planen, sollten Sie diese Typen als Klassenmitglieder definieren. Die Implementierung sollte folgendermaßen aussehen:

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)
    }

ANMERKUNG: Wenn Sie ein Singleton verwenden, möchten Sie möglicherweise einen Delegaten definieren, der den Fortschritt oder die Fertigstellung der Datei anzeigt. Wenn Sie kein Singleton verwenden, können Sie eine statische Methode mit den entsprechenden Typen erstellen:

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

1. progressFunctionUpdater - berichtet an eine Funktion mit Fortschritt.
2. resultBlock - Wenn Sie nil zurückgegeben haben und der Upload erfolgreich war, wurde das resultBlock

Sehr geehrte Damen und Herren, der eigentliche Upload:

        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
        }

Glückliches S3 hochladen :)