コード例 #1
0
        public bool Append(byte[] binary, string mediaType, TimeSpan?timeout = null, int?segmentIndex = null)
        {
            var parameters = new ChunkUploadAppendParameters(binary, mediaType, timeout);

            parameters.SegmentIndex = segmentIndex;
            return(Append(parameters));
        }
コード例 #2
0
        public IMedia ChunkUploadBinary(IUploadQueryParameters uploadQueryParameters)
        {
            if (uploadQueryParameters.Binaries.Count != 1)
            {
                throw new ArgumentException("ChunkUpload binary can only upload 1 binary at a time.");
            }

            var binary   = uploadQueryParameters.Binaries[0];
            var uploader = CreateChunkedUploader();

            var initParameters = new ChunkUploadInitParameters
            {
                TotalBinaryLength       = binary.Length,
                MediaType               = uploadQueryParameters.MediaType,
                AdditionalOwnerIds      = uploadQueryParameters.AdditionalOwnerIds,
                CustomRequestParameters = uploadQueryParameters.InitCustomRequestParameters,
            };

            if (uploader.Init(initParameters))
            {
                var binaryChunks = GetBinaryChunks(binary, uploadQueryParameters.MaxChunkSize);

                var totalsize = 0;

                foreach (var binaryChunk in binaryChunks)
                {
                    totalsize += binaryChunk.Length;
                    var appendParameters = new ChunkUploadAppendParameters(
                        binaryChunk,
                        "media", // Must be media, if using the real media type as content id, Twitter does not accept when invoking .Finalize().
                        uploadQueryParameters.Timeout);

                    appendParameters.CustomRequestParameters = uploadQueryParameters.AppendCustomRequestParameters;

                    if (!uploader.Append(appendParameters))
                    {
                        return(null);
                    }
                }

                var isTrue = totalsize == binary.Length;

                return(uploader.Complete());
            }

            return(null);
        }
コード例 #3
0
        public async Task <IChunkUploadResult> UploadBinary(IUploadParameters uploadQueryParameters, ITwitterRequest baseRequest)
        {
            var binary   = uploadQueryParameters.Binary;
            var uploader = CreateChunkedUploader();

            var initParameters = new ChunkUploadInitParameters
            {
                TotalBinaryLength       = binary.Length,
                MediaType               = uploadQueryParameters.QueryMediaType,
                MediaCategory           = uploadQueryParameters.QueryMediaCategory,
                AdditionalOwnerIds      = uploadQueryParameters.AdditionalOwnerIds,
                CustomRequestParameters = uploadQueryParameters.InitCustomRequestParameters,
            };

            var initRequest            = new TwitterRequest(baseRequest);
            var initOperationSucceeded = await uploader.Init(initParameters, initRequest).ConfigureAwait(false);

            if (!initOperationSucceeded)
            {
                return(uploader.Result);
            }

            var binaryChunks = GetBinaryChunks(binary, uploadQueryParameters.MaxChunkSize);

            var totalSize = await CalculateSize("media", binary).ConfigureAwait(false);

            long uploadedSize = 0;

            uploadQueryParameters.UploadStateChanged?.Invoke(new MediaUploadProgressChangedEventArgs(UploadProgressState.INITIALIZED, 0, totalSize));

            for (var i = 0; i < binaryChunks.Count; ++i)
            {
                var binaryChunk       = binaryChunks[i];
                var startUploadedSize = uploadedSize;

                var appendParameters = new ChunkUploadAppendParameters(
                    binaryChunk,
                    "media", // Must be `media`, if using the real media type as content id, Twitter does not accept when invoking .Finalize().
                    uploadQueryParameters.Timeout)
                {
                    UploadProgressChanged = (args) =>
                    {
                        uploadedSize = startUploadedSize + args.NumberOfBytesUploaded;
                        uploadQueryParameters.UploadStateChanged?.Invoke(new MediaUploadProgressChangedEventArgs(UploadProgressState.PROGRESS_CHANGED, uploadedSize, totalSize));
                    },
                    CustomRequestParameters = uploadQueryParameters.AppendCustomRequestParameters
                };

                var appendRequest            = new TwitterRequest(baseRequest);
                var appendOperationSucceeded = await uploader.Append(appendParameters, appendRequest).ConfigureAwait(false);

                if (!appendOperationSucceeded)
                {
                    uploadQueryParameters.UploadStateChanged?.Invoke(new MediaUploadProgressChangedEventArgs(UploadProgressState.FAILED, uploadedSize, totalSize));
                    return(uploader.Result);
                }
            }

            var finalizeRequest = new TwitterRequest(baseRequest);

            var finalizeSucceeded = await uploader.Finalize(uploadQueryParameters.FinalizeCustomRequestParameters, finalizeRequest).ConfigureAwait(false);

            if (finalizeSucceeded)
            {
                var result = uploader.Result;
                uploadQueryParameters.UploadStateChanged?.Invoke(new MediaUploadProgressChangedEventArgs(UploadProgressState.COMPLETED, uploadedSize, totalSize));

                var category          = uploadQueryParameters.MediaCategory;
                var isAwaitableUpload = category == MediaCategory.Gif || category == MediaCategory.Video;

                if (isAwaitableUpload && uploadQueryParameters.WaitForTwitterProcessing)
                {
                    var request = new TwitterRequest(baseRequest);
                    await _uploadHelper.WaitForMediaProcessingToGetAllMetadata(result.Media, request).ConfigureAwait(false);
                }
            }

            return(uploader.Result);
        }
コード例 #4
0
        public IMedia UploadBinary(IUploadParameters uploadQueryParameters)
        {
            var binary   = uploadQueryParameters.Binary;
            var uploader = CreateChunkedUploader();

            var initParameters = new ChunkUploadInitParameters
            {
                TotalBinaryLength       = binary.Length,
                MediaType               = uploadQueryParameters.QueryMediaType,
                MediaCategory           = uploadQueryParameters.QueryMediaCategory,
                AdditionalOwnerIds      = uploadQueryParameters.AdditionalOwnerIds,
                CustomRequestParameters = uploadQueryParameters.InitCustomRequestParameters,
            };

            if (uploader.Init(initParameters))
            {
                var binaryChunks = GetBinaryChunks(binary, uploadQueryParameters.MaxChunkSize);

                var totalSize    = binary.Length;
                var uploadedSize = 0;

                uploadQueryParameters.UploadStateChanged?.Invoke(new UploadStateChangedEventArgs(UploadProgressState.INITIALIZED, 0, totalSize));

                for (int i = 0; i < binaryChunks.Count; ++i)
                {
                    var binaryChunk = binaryChunks[i];

                    var appendParameters = new ChunkUploadAppendParameters(
                        binaryChunk,
                        "media", // Must be `media`, if using the real media type as content id, Twitter does not accept when invoking .Finalize().
                        uploadQueryParameters.Timeout)
                    {
                        UploadProgressChanged = (current, total) =>
                        {
                            uploadQueryParameters.UploadStateChanged?.Invoke(new UploadStateChangedEventArgs(UploadProgressState.PROGRESS_CHANGED, uploadedSize + current, totalSize));
                        }
                    };

                    appendParameters.CustomRequestParameters = uploadQueryParameters.AppendCustomRequestParameters;

                    if (!uploader.Append(appendParameters))
                    {
                        uploadQueryParameters.UploadStateChanged?.Invoke(new UploadStateChangedEventArgs(UploadProgressState.FAILED, uploadedSize, totalSize));

                        return(null);
                    }

                    uploadedSize += binaryChunk.Length;
                }

                var media = uploader.Complete();

                uploadQueryParameters.UploadStateChanged?.Invoke(new UploadStateChangedEventArgs(UploadProgressState.COMPLETED, uploadedSize, totalSize));

                var category          = uploadQueryParameters.MediaCategory;
                var isAwaitableUpload = category == MediaCategory.Gif || category == MediaCategory.Video;
                if (isAwaitableUpload && uploadQueryParameters.WaitForTwitterProcessing)
                {
                    _uploadHelper.WaitForMediaProcessingToGetAllMetadata(media);
                }

                return(media);
            }

            return(_mediaFactory.Create());
        }