iOS
AWS एसडीके

AWS SDK का उपयोग करके S3 में एक चित्र या वीडियो अपलोड करें

उदाहरण के साथ शुरू करने से पहले मैं एक डेलिगेट वर्ग के सदस्य के साथ एक सिंगलटन बनाने की सिफारिश करूंगा ताकि आप पृष्ठभूमि में एक फ़ाइल अपलोड करने के उपयोग के मामले को प्राप्त कर सकें और उपयोगकर्ता को आपके ऐप का उपयोग करते रहने दें जबकि एप्लिकेशन तब भी अपलोड किए जा रहे हों पृष्ठभूमि है।

आइए शुरू करते हैं, पहले, हमें एक एनम बनाना चाहिए जो 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"
}

अब, जब आपका ऐप पहली बार लॉन्च होता है, तो हमें क्रेडेंशियल सेट करना चाहिए, इस प्रकार, हमें उन्हें AppDelegate अंदर didFinishLaunchingWithOptions मेथड पर सेट करना चाहिए (ध्यान दें कि आपको अपना क्षेत्र 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)
}

चूँकि हम पहले से ही AppDelegate के अंदर हैं, हमें 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)
}

अब, जब उपयोगकर्ता ऐप को पृष्ठभूमि पर ले जाएगा तो आपका अपलोड वास्तविक अपलोड जारी रखेगा।

एडब्ल्यूएस एसडीके का उपयोग करके फाइल अपलोड करने के लिए हमें डिवाइस को फाइल लिखना होगा और एसडीके को वास्तविक रास्ता देना होगा। उदाहरण के लिए, कल्पना करें कि हमारे पास एक UIImage है (एक वीडियो भी हो सकता है ..) और हम इसे एक अस्थायी फ़ोल्डर में लिखेंगे:

// 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 और FileName का उपयोग किया जाएगा।

2 क्लोजर हैं जिन्हें हमें परिभाषित करना होगा कि AWS एसडीके द्वारा प्रदान किए गए हैं,

1. AWSS3TransferUtilityUploadCompletionHandlerBlock - एक क्लोजर जो अपलोड किए जाने पर सूचित करता है (या नहीं)
2. AWSS3TransferUtilityUploadProgressBlock - एक बाइट जो भेजे गए प्रत्येक बाइट को सूचित करता है

यदि आपके पास एक सिंगलटन की योजना है, तो आपको उन प्रकारों को कक्षा के सदस्यों के रूप में परिभाषित करना चाहिए। कार्यान्वयन इस तरह दिखना चाहिए:

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

नोट: यदि आप एक सिंगलटन का उपयोग कर रहे हैं, तो आप एक प्रतिनिधि को परिभाषित करना चाह सकते हैं जो प्रगति के साथ या फ़ाइल होने पर वापस रिपोर्ट करेगा। यदि आप एक सिंगलटन का उपयोग नहीं कर रहे हैं, तो आप एक स्थिर विधि बना सकते हैं जिसमें प्रासंगिक प्रकार होंगे:

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

1. progressFunctionUpdater - progressFunctionUpdater साथ एक समारोह में वापस रिपोर्ट करेगा।
2. resultBlock - यदि आप nil को वापस करते हैं तो अपलोड सफलतापूर्वक था, आप त्रुटि ऑब्जेक्ट भेजते हैं

महिलाओं और सज्जनों, वास्तविक अपलोड:

        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
        }

हैप्पी S3 अपलोडिंग :)