iOS
AWS SDK

Upload een afbeelding of video naar S3 met behulp van AWS SDK

Voordat ik met het voorbeeld begin, raad ik aan om een Singleton te maken met een lid van de gedelegeerde klas, zodat u een use case kunt bereiken door een bestand op de achtergrond te uploaden en de gebruiker uw app te laten blijven gebruiken terwijl de bestanden worden geüpload, zelfs wanneer de app is de achtergrond.

Laten we beginnen, eerst moeten we een opsomming maken die de S3-configuratie vertegenwoordigt:

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

Nu moeten we de referenties instellen wanneer uw app voor de eerste keer wordt gestart, dus moeten we ze instellen in de AppDelegate bij de methode didFinishLaunchingWithOptions (let op dat u uw regio moet instellen op de regionType param):

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

Omdat we ons al in de AppDelegate bevinden, moeten we de achtergrond-callback implementeren die wordt afgehandeld door de 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)
}

Wanneer de gebruiker de app naar de achtergrond verplaatst, gaat uw upload nu verder met de daadwerkelijke upload.

Om het bestand met de AWS SDK te uploaden, moeten we het bestand naar het apparaat schrijven en de SDK het daadwerkelijke pad geven. Stel je voor het voorbeeld voor dat we een UII-afbeelding hebben (kan ook een video zijn ...) en we schrijven deze naar een tijdelijke map:

// 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 en fileName worden later gebruikt voor het uploaden.

Er zijn 2 sluitingen die we moeten definiëren die worden geleverd door de AWS SDK,

1. AWSS3TransferUtilityUploadCompletionHandlerBlock - Een afsluiting die AWSS3TransferUtilityUploadCompletionHandlerBlock wanneer het uploaden is voltooid (of niet)
2. AWSS3TransferUtilityUploadProgressBlock - Een sluiting die elke verzonden byte op de hoogte brengt

Als u van plan bent om een Singleton te hebben, moet u die typen als klassenleden definiëren. De implementatie moet er zo uitzien:

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

OPMERKING: Als u een Singleton gebruikt, wilt u misschien een gedelegeerde definiëren die met voortgang of wanneer het bestand klaar is, rapporteert. Als u geen Singleton gebruikt, kunt u een statische methode maken met de relevante typen:

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

1. progressFunctionUpdater - rapporteert terug naar een functie met voortgang.
2. resultBlock - Als u nul retourneert, was het uploaden anders resultBlock , resultBlock u het resultBlock

Dames en heren, de daadwerkelijke 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
        }

Happy S3 uploaden :)