iOS
AWS SDK

Prześlij zdjęcie lub film do S3 za pomocą AWS SDK

Zanim zacznę od przykładu, zaleciłbym utworzenie Singletona z członkiem klasy delegowanej, abyś mógł uzyskać przypadek użycia przesłania pliku w tle i pozwolić użytkownikowi nadal korzystać z Twojej aplikacji podczas przesyłania plików, nawet gdy aplikacja jest ładowana jest tłem.

Zacznijmy, po pierwsze, powinniśmy utworzyć wyliczenie reprezentujące konfigurację 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"
}

Teraz powinniśmy ustawić poświadczenia przy pierwszym uruchomieniu aplikacji, dlatego powinniśmy ustawić je w AppDelegate przy didFinishLaunchingWithOptions metody didFinishLaunchingWithOptions (zwróć uwagę, że powinieneś ustawić swój region na parametr 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)
}

Ponieważ jesteśmy już w AppDelegate, powinniśmy zaimplementować wywołanie zwrotne w tle obsługiwane przez 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)
}

Teraz, gdy użytkownik przeniesie aplikację na tło, przesyłanie będzie kontynuowane.

Aby przesłać plik za pomocą AWS SDK, będziemy musieli zapisać plik na urządzeniu i podać SDK rzeczywistą ścieżkę. Na przykład wyobraźmy sobie, że mamy UIImage (może to być również wideo ..) i napiszemy go do folderu tymczasowego:

// 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 i nazwa_pliku zostaną wykorzystane do faktycznego przesłania później.

Istnieją 2 zamknięcia, które musimy zdefiniować, które są dostarczane przez AWS SDK,

1. AWSS3TransferUtilityUploadCompletionHandlerBlock - Zamknięcie powiadamiające o zakończeniu przesyłania (lub nie)
2. AWSS3TransferUtilityUploadProgressBlock - Zamknięcie, które powiadamia każdy wysłany bajt

Jeśli planujesz mieć Singletona, powinieneś zdefiniować te typy jako członków klasy. Implementacja powinna wyglądać następująco:

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

UWAGA: Jeśli używasz Singletona, możesz chcieć zdefiniować delegata, który będzie raportował z postępem lub po zakończeniu pliku. Jeśli nie używasz Singletona, możesz utworzyć metodę statyczną, która będzie miała odpowiednie typy:

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

1. progressFunctionUpdater - zgłosi powrót do funkcji z postępem.
2. resultBlock - Jeśli resultBlock zero, wówczas przesyłanie zakończyło się pomyślnie, to wysłałeś obiekt błędu

Panie i panowie, faktyczne przesyłanie:

        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
        }

Udanego przesyłania S3 :)