Teilen Sie videos auf Twitter per iOS-App

Habe ich gelesen, durch die Twitter-Video-upload-API-Dokumentation, und es ist wirklich ziemlich einfach. Im Grunde muss man machen, 3 POST-Anfragen auf die API. Das video, das Sie hochladen, ist begrenzt auf 15 MB in der Größe.

Uploads mit dieser Endpunkt erforderlich, dass mindestens 3 Anrufe, ein bis
initialisieren Sie die Anfrage gibt die media_id, ein oder mehrere Anrufe
Anhängen/hochladen, Binär oder base64-kodierte Daten, und einen letzten Aufruf
abschließen den laden und machen die media_id verwendbar mit anderen Ressourcen.

Also es funktioniert wie folgt:

• Anfrage 1: Senden Sie eine init-request mit der video-Größe in bytes. Dies wird return ein Media-ID-Nummer, die wir verwenden müssen, die in Anforderung 2 und 3.

• Antrag 2: die zurückgegebenen Medien-ID aus Anfrage 1-laden Sie die video-Daten.

• Anfrage 3: Nachdem der video-upload abgeschlossen ist, senden Sie eine "FINALIZE" - Anforderung zurück an die Twitter-API. So können die Twitter-API erfahren, dass alle Teile der video-Datei fertig hochgeladen.

Hinweis Die Twitter-API akzeptiert video-uploads in "chunks". Also, wenn Sie Ihre video-Datei ist Recht groß, man kann ihn aufteilen möchten in mehr als einer Datei und so haben Sie zu wiederholen "Anfrage 2" mehr als einmal (nicht zu vergessen, erhöhen Sie die "segment_index" Anzahl pro Zeit).

Ich hatte einen gehen auf die Codierung dazu weiter unten. Probieren Sie es aus und Experimentieren Sie damit herum. Ich update meine Antwort später auf, es zu verbessern, zu.

-(void)imagePickerController:(UIImagePickerController *)picker didFinishPickingMediaWithInfo:(NSDictionary *)info { 

    //Assign the mediatype to a string 
    NSString *mediaType = [info objectForKey:UIImagePickerControllerMediaType];

    //Check the media type string so we can determine if its a video
    if ([mediaType isEqualToString:@"public.movie"]) {

        NSURL *videoURL = [info objectForKey:UIImagePickerControllerMediaURL];
        NSData *webData = [NSData dataWithContentsOfURL:videoURL];

        //Get the size of the file in bytes.
        NSString *yourPath = [NSString stringWithFormat:@"%", videoURL];
        NSFileManager *man = [NSFileManager defaultManager];
        NSDictionary *attrs = [man attributesOfItemAtPath:yourPath error: NULL];
        UInt32 result = [attrs fileSize];

        //[self tweetVideoStage1:webData :result];
        [self tweetVideo:webData :result :1 :@"n/a"];
    }
}

-(void)tweetVideo:(NSData *)videoData :(int)videoSize :(int)mode :(NSString *)mediaID {

    NSURL *twitterVideo = [NSURL URLWithString:@"https://upload.twitter.com/1.1/media/upload.json"];

    //Set the parameters for the first twitter video request.
     NSDictionary *postDict;

    if (mode == 1) {

        postDict = @{@"command": @"INIT",
                     @"total_bytes" : videoSize,
                     @"media_type" : @"video/mp4"};
    }

    else if (mode == 2) {

        postDict = @{@"command": @"APPEND",
                     @"media_id" : mediaID,
                     @"segment_index" : @"0",
                     @"media" : videoData };
    }

    else if (mode == 3) {

        postDict = @{@"command": @"FINALIZE",
                     @"media_id" : mediaID };
    }

    SLRequest *postRequest = [SLRequest requestForServiceType:SLServiceTypeTwitter requestMethod:SLRequestMethodPOST URL:requestURL:twitterVideo parameters:postDict];

    //Set the account and begin the request.
    postRequest.account = account;
    [postRequest performRequestWithHandler:^(NSData *responseData, NSHTTPURLResponse *urlResponse, NSError *error) {

        if (!error) {

            if (mode == 1) {

                //Parse the returned data for the JSON string
                //which contains the media upload ID.
                NSMutableDictionary *returnedData = [NSJSONSerialization JSONObjectWithData:responseData options:NSJSONReadingMutableContainers error:&error]
                NSString *tweetID = [NSString stringWithFormat:@"%@", [returnedData valueForKey:@"media_id_string"]];
                [self tweetVideo:videoData :result :2 :tweetID];
            }

            else if (mode == 2) {
                [self tweetVideo:videoData :result :3 :mediaID];
            }
        }

        else {
            NSLog(@"Error stage %d - %", mode, error);
        }
    }];
}

Update - Twitter-API-Fehler - https://dev.twitter.com/overview/api/response-codes

Antwort auf Ihren ersten Kommentar, Fehler 503 bedeutet, dass die Twitter-Server überlastet sind und nicht verarbeiten kann Ihre Anfrage jetzt.

503 Service Unavailable Der Twitter-Server sind aber überlastet
mit Anfragen. Versuchen Sie es später erneut.

Gesucht für den Austausch von video-on-Twitter-Lösung mit folgenden Funktionen:

• Unterstützung chunk upload
• Built-in support für Benutzer abrufen von Anmeldeinformationen

Da konnte ich nicht finden, ein treffen in meiner not, so habe ich beschlossen, einen zu schreiben.

https://github.com/mtrung/TwitterVideoUpload

Ich habe die Prüfung für eine Weile jetzt, und es funktioniert gut für mich.

Hoffe es hilft,

Grüße.

Swift

Seine sehr Einfach.
Zuerst müssen Sie sich in Ihrem Twitter-Account. Gehen Sie zu Telefon-Einstellung und klicken Sie auf twitter-app und melden Sie sich an.
Jetzt Rufen diese videoUpload func überall

Video-oder Chunked uploads Methode Referenz

Ersetzen Sie Ihre video-Art/- Erweiterung auf diesen code
Und Lesen Sie Sorgfältig alle twitter Anforderungen.

var twitterAccount = ACAccount()

        func videoUpload{
                let path = Bundle.main.path(forResource: "file-Name", ofType:"mp4")

                let filePath = path
                var fileSize = UInt64()

                do {
                    //return [FileAttributeKey : Any]
                    let attr = try FileManager.default.attributesOfItem(atPath: filePath!)
                    fileSize = attr[FileAttributeKey.size] as! UInt64

                    //if you convert to NSDictionary, you can get file size old way as well.
                    let dict = attr as NSDictionary
                    fileSize = dict.fileSize()
                } catch {
                    print("Error: \(error)")
                }

                let accountStore = ACAccountStore()
                let twitterAccountType = accountStore.accountType(withAccountTypeIdentifier: ACAccountTypeIdentifierTwitter)
                accountStore.requestAccessToAccounts(with: twitterAccountType, options: nil) { (granted, error) in

                    if granted {
                        let accounts = accountStore.accounts(with: twitterAccountType)
                        if (accounts?.count)! > 0 {
                            self.twitterAccount = accounts?.last as! ACAccount
                        }}}


                twitterAccount = Twitter.sharedInstance().sessionStore.session() as! ACAccount
        uploadVideoToTwitter(videoURL: URL(string : path!)! as NSURL, fileSize: UInt32(fileSize))
        }

    func uploadVideoToTwitter(videoURL:NSURL,fileSize: UInt32) {

            if let videoData = NSData(contentsOfFile: videoURL.path!){
                self.tweetVideoInit(videoData: videoData, videoSize: Int(fileSize))
            }
        }

        func tweetVideoInit(videoData:NSData,videoSize:Int) {

            let uploadURL = NSURL(string:"https://upload.twitter.com/1.1/media/upload.json")

            var params = [String:String]()

            params["command"] = "INIT"
            params["total_bytes"]  = String(videoData.length)
            params["media_type"]  = "video/mp4"

            let postRequest = SLRequest(forServiceType: SLServiceTypeTwitter,
                                        requestMethod: SLRequestMethod.POST,
                                        url: uploadURL as URL!,
                                        parameters: params)

            postRequest?.account = self.twitterAccount;

            postRequest?.perform(handler: { ( responseData, urlREsponse,error) in
                if let err = error {
                    print(error as Any)
                }else{
                    do {
                        let object = try JSONSerialization.jsonObject(with: responseData! as Data, options: .allowFragments)
                        if let dictionary = object as? [String: AnyObject] {

                            if let tweetID = dictionary["media_id_string"] as? String{
                                self.tweetVideoApped(videoData: videoData, videoSize: videoSize, mediaId: tweetID, chunk: 0)
                            }
                        }
                    }
                    catch {
                        print(error)
                    }
                }
            })
        }

        func tweetVideoApped(videoData:NSData,videoSize:Int ,mediaId:String,chunk:NSInteger) {

            let uploadURL = NSURL(string:"https://upload.twitter.com/1.1/media/upload.json")

            var params = [String:String]()

            params["command"] = "APPEND"
            params["media_id"]  = mediaId
            params["segment_index"]  = String(chunk)

            let postRequest = SLRequest(forServiceType: SLServiceTypeTwitter,
                                        requestMethod: SLRequestMethod.POST,
                                        url: uploadURL as URL!,
                                        parameters: params)

            postRequest?.account = self.twitterAccount
            postRequest?.addMultipartData(videoData as Data!, withName: "media", type: "video/mov", filename:"mediaFile")

            postRequest?.perform(handler: { ( responseData, urlREsponse,error) in
                if let err = error {
                    print(err)

                }else{
                    self.tweetVideoFinalize(mediaId: mediaId)
                }
            })
        }

        func tweetVideoFinalize(mediaId:String) {
            let uploadURL = NSURL(string:"https://upload.twitter.com/1.1/media/upload.json")

            var params = [String:String]()
            params["command"] = "FINALIZE"
            params["media_id"]  = mediaId

            let postRequest = SLRequest(forServiceType: SLServiceTypeTwitter,
                                        requestMethod: SLRequestMethod.POST,
                                        url: uploadURL as URL!,
                                        parameters: params)

            postRequest?.account = self.twitterAccount;
            postRequest?.perform(handler: { ( responseData, urlREsponse,error) in
                if let err = error {
                    print(err)
                }else{
                    do {
                        let object = try JSONSerialization.jsonObject(with: responseData! as Data, options: .allowFragments)
                        if let dictionary = object as? [String: AnyObject] {
                            self.postStatus(mediaId: mediaId)
                        }
                    }
                    catch {
                        print(error)
                    }
                }
            })
        }

        func postStatus(mediaId:String) {

            let uploadURL = NSURL(string:"https://api.twitter.com/1.1/statuses/update.json")

            var params = [String:String]()
            params["status"] = "my first Video Upload"
            params["media_ids"]  = mediaId

            let postRequest = SLRequest(forServiceType: SLServiceTypeTwitter,
                                        requestMethod: SLRequestMethod.POST,
                                        url: uploadURL as URL!,
                                        parameters: params)

            postRequest?.account = self.twitterAccount;

            postRequest?.perform(handler: { ( responseData, urlREsponse,error) in
                if let err = error {
                    print(err)
                }else{
                    do {
                        let object = try JSONSerialization.jsonObject(with: responseData! as Data, options: .allowFragments)
                        if let dictionary = object as? [String: AnyObject] {
                            print("video uploaded")
                        }
                    }
                    catch {
                        print(error)
                    }
                }
            })
        }