AWS3 Fragment upload solution

background

Background: A recent business requirement was to upload a local recording or album video to Amazon services

Research: The front-end partners tried to access SDK and found that AWS3 upload still needs to do a lot of work, such as slice > 5M and ETAG processing

Decision: In order to reduce front-end work, the back-end invokes S3 SDK, and the front-end directly uploads files in segments through the URL pre-signed by the back-end

Making: TWMultiUploadFileManager

The installation

Install using Cocoapods, or drag the project in manually

pod 'TWMultiUploadFileManager'
Copy the code

plan

Back-end execution This section describes how to execute the AWS3 SDK API. The front-end uploads files in segments using the URL pre-signed by the back-end

steps

Step1: Slice files after selecting them in the front end (> 5M)
Step2: request the backend to upload the url of aws3 resources
Step3: Upload the sliced files to the AWS3 server
Step4: request the backend to verify the uploaded resource file

The flow chart

TWMultiUploadFileManager package

function

Encapsulates the file fragmentation processing, and upload functions

Specific function ️
- MaxConcurrentOperationCount: upload threads concurrent number (3) by default
- MaxSize: file size limit (default: 2GB)
- PerSlicedSize: The size of each fragment (default: 5M)
- RetryTimes: Number of upload attempts per fragment (default 3)
- TimeoutInterval: Request duration (default 120 s)
- HeaderFields: Additional header
- MimeType: file upload type not empty (default text/plain)
TODO
- Maximum file upload duration (s) The default value is 7200
- Maximum number of buffered fragments (default 100, recommended not less than 10, not more than 100)
- Additional parameter that currently encapsulates the PUT request and will be supplemented later with the POST request
Concurrent queue management dependenciesQueuer 库
- Based on the scenario: User-definedTWConcurrentOperation

steps

step 1

Select the video source (file) from the album

// MARK: - Action
/// select a movie
fileprivate func selectPhotoAction(animated: Bool = true) {
    let imagePicker: TZImagePickerController! = TZImagePickerController(maxImagesCount: 9, delegate: self)
    imagePicker.allowPickingVideo = true
    imagePicker.allowPreview = false
    imagePicker.videoMaximumDuration = Macro.videoMaximumDuration
    imagePicker.maxCropVideoDuration = Int(Macro.videoMaximumDuration)
    imagePicker.allowPickingOriginalPhoto = false
    imagePicker.allowPickingImage = false
    imagePicker.allowPickingMultipleVideo = false
    imagePicker.autoDismiss = false
    imagePicker.navLeftBarButtonSettingBlock = { leftButton in
        leftButton?.isHidden = true
    }
    present(imagePicker, animated: animated, completion: nil)}/// Get the video resource
fileprivate func handleRequestVideoURL(asset: PHAsset)  {
    /// loading
    print("loading....")
    self.requestVideoURL(asset: asset) { [weak self] (urlasset, url) in
        guard let self = self else { return }
        print("success....")
        self.url = url
        self.asset = asset
        self.uploadVideoView.play(videoUrl: url)
    } failure: { (info) in
        print("fail....")}}Copy the code

Slice the video source file and create the upload resource object (file)

/// Upload a movie
fileprivate func uploadVideoAction(a) {
    guard let url = url, let asset = asset ,let outputPath: String = self.fetchVideoPath(url: url) else { return }
    let relativePath: String = TWMultiFileManager.copyVideoFile(atPath: outputPath, dirPathName: Macro.dirPathName)
    // Create an upload resource object and slice the file
    let fileSource: TWMultiUploadFileSource = TWMultiUploadFileSource(
        configure: self.configure,
        filePath: relativePath,
        fileType: .video,
        localIdentifier: asset.localIdentifier
    )
    //  Before uploading, you need to obtain the url of each fragment uploaded to Amazon from the server and upload it
    // fileSource.setFileFragmentRequestUrls([])
    
    uploadFileManager.uploadFileSource(fileSource)
}
Copy the code

Core logic of slicing

/// slice
- (void)cutFileForFragments {
    NSUInteger offset = self.configure.perSlicedSize;
    / / the total number of pieces
    NSUInteger totalFileFragment = (self.totalFileSize%offset==0)? (self.totalFileSize/offset):(self.totalFileSize/(offset) + 1);
    self.totalFileFragment = totalFileFragment;
    NSMutableArray<TWMultiUploadFileFragment *> *fragments = [NSMutableArray array];
    for (NSUInteger i = 0; i < totalFileFragment; i++) {
        TWMultiUploadFileFragment *fFragment = [[TWMultiUploadFileFragment alloc] init];
        fFragment.fragmentIndex = i+1; // Start at 1
        fFragment.uploadStatus = TWMultiUploadFileUploadStatusWaiting;
        fFragment.fragmentOffset = i * offset;
        if(i ! = totalFileFragment -1) {
            fFragment.fragmentSize = offset;
        } else {
            fFragment.fragmentSize = self.totalFileSize - fFragment.fragmentOffset;
        }
        /// Attribute correlation
        fFragment.localIdentifier = self.localIdentifier;
        fFragment.fragmentId = [NSString stringWithFormat:@"%@-%ld".self.localIdentifier, (long)i];
        fFragment.fragmentName = [NSString stringWithFormat:@"%@-%ld.%@".self.localIdentifier, (long)i, self.fileName.pathExtension];
        fFragment.fileType = self.fileType;
        fFragment.filePath = self.filePath;
        fFragment.totalFileFragment = self.totalFileFragment ;
        fFragment.totalFileSize = self.totalFileSize;
        [fragments addObject:fFragment];
    }
    self.fileFragments = fragments;
}
Copy the code

step 2

Business logic: The backend invokes the AWS3 SDK to obtain the upload urls for resource file fragments, and the backend obtains the URL for uploading AWS3
here you can also upload urls to your own server, the component’s encapsulated upload logic PUT request, which can be modified according to their business

//  Before uploading, you need to obtain the url of each fragment uploaded to Amazon from the server and upload it
fileSource.setFileFragmentRequestUrls([])
Copy the code

step 3

// upload the command to the AWS3 server
uploadFileManager.uploadFileSource(fileSource)
Copy the code

Set up proxy callbacks, which also support blocks

extension ViewController: TWMultiUploadFileManagerDelegate {
    /// ready to upload
    func prepareStart(_ manager: TWMultiUploadFileManager! .fileSource: TWMultiUploadFileSource!).{}/// The file is being uploaded
    func uploadingFileManager(_ manager: TWMultiUploadFileManager! .progress: CGFloat){}/// Upload completed
    func finish(_ manager: TWMultiUploadFileManager! .fileSource: TWMultiUploadFileSource!).{}/// Upload failed
    func fail(_ manager: TWMultiUploadFileManager! .fileSource: TWMultiUploadFileSource! .fail code: TWMultiUploadFileUploadErrorCode){}/// Cancel upload
    func cancleUploadFileManager(_ manager: TWMultiUploadFileManager! .fileSource: TWMultiUploadFileSource!).{}/// Failed to upload a file
    func failUploadingFileManager(_ manager: TWMultiUploadFileManager! .fileSource: TWMultiUploadFileSource! .fileFragment: TWMultiUploadFileFragment! .fail code: TWMultiUploadFileUploadErrorCode){}}Copy the code

step 4

Service logic: Request the back-end interface after the resource is uploaded. Verify the uploaded resource files

instructions

The service logic is processed by the respective business side. This component encapsulates the upload function, including slicing, retry times, file size, fragment size, maximum number of supported fragments, etc
For details, see the configuration object for uploading resources

@interface TWMultiUploadConfigure : NSObject
/// The simultaneous upload thread defaults to 3
@property (nonatomic.assign) NSInteger maxConcurrentOperationCount;
// the maximum number of bytes that can be uploaded is 2GB by default
@property (nonatomic.assign) NSUInteger maxSize;
/// todo: Maximum file upload duration (s) The default value is 7200
@property (nonatomic.assign) NSUInteger maxDuration;
// todo: maximum number of buffered fragments (default 100, recommended not less than 10, not higher than 100)
@property (nonatomic.assign) NSUInteger maxSliceds;
/// the size of each fragment (byte B) is 5M by default
@property (nonatomic.assign) NSUInteger perSlicedSize;
// Number of upload attempts per fragment (default 3)
@property (nonatomic.assign) NSUInteger retryTimes;
The request duration is 120 seconds by default
@property (nonatomic.assign) NSUInteger timeoutInterval;
/// todo: additional argument that currently encapsulates PUT and will be supplemented later with post requests
@property (nonatomic.strong) NSDictionary *parameters;
/ / / add the header
@property (nonatomic.strong) NSDictionary<NSString *, NSString *> *headerFields;
/// File upload type not null Default text/plain
@property (nonatomic.strong) NSString *mimeType;
@end
Copy the code

Business use cases

scenario

Business code Sample

The project is based on ReactorKit framework

Define the states of the video

/// The current state
enum SaleHouseVideoUploadStatus: Equatable {
    /// The default is unselected video
    case unseleted
    /// start to select the video, in order to solve the problem of two failed to select the video, no changes can be entered in the listener callback
    case beginSeletedVideo
    /// Failed to select video
    case seletedVideoFail(code: SaleHouseVideoUploadStatusSeletedVideoFailCode)
    /// Select video successfully, ready to upload navigation: "upload"
    case seletedVideoSuccess(asset: PHAsset, url: URL)
    /// Click Upload to get the server submission information
    case requestUploadData
    // The upload information is successfully obtained
    case requestUploadDataSuccess(uploadInfo: SaleHouseVideoUploadInfoModel)
    /// fragment verification & failed to get upload information navigation: "re-upload"; Code: Error code returned by the backend for statistics
    case requestUploadDataFail(code: String?).// Upload, navigation: "Cancel upload"
    case uploading(progress: CGFloat)
    // upload failed, navigation: "re-upload"
    case uploadFail(code: TWMultiUploadFileUploadErrorCode)
    /// The file has been uploaded to awS3
    case uploadFilesComplete
    /// Failed to submit the service after uploading. Merge aws3; Code: Error code returned by the backend for statistics
    case requestMergeFilesFail(code: String?).Aws3 service merge successfully navigation: "Re-upload" "Submit"
    case requestMergeFilesComplete(mergeInfo: SaleHouseVideoMergeFilesCompleteModel)
    // Upload succeeded, but commit failed; Code: Error code returned by the backend for statistics
    case requestCommitFail(mergeInfo: SaleHouseVideoMergeFilesCompleteModel, code: String?).// Upload successfully, and submit successfully navigation: "re-upload" "Submit"
    case requestCommitSuccess(mergeInfo: SaleHouseVideoMergeFilesCompleteModel)
    /// Cancel upload
    case cancel
    Preprocessing preview navigation: "Delete movie" "Re-upload"
    case requestEditInfoSuccess(fileInfo: SaleHouseVideoEditInfoModel)
    /// Failed to get edit status
    case requestEditInfoFail
    // The deletion succeeds, but the deletion fails as before
    case deleteSuccess
}

Copy the code

SaleHouseVideoUploadReactor implementation agreement of Reactor

// MARK: - Reactor
extension SaleHouseVideoUploadReactor: Reactor {
    enum Action {
        /// video check
        case checkSelectedVideo(asset: PHAsset)
        // click Upload to get the upload data
        case requestUploadData
        /// reset the video selection
        case resetSelectedVideo
        /// Cancel upload
        case cancleUploadVideo
        /// After uploading, submit the video
        case commitUploadedVideo
        // upload failed
        case reuploadVideo
        /// delete the movie
        case deleteVideo
        /// get the movie information
        case requestEditVideoInfo
        // restore the original edited video information
        case resetEditVideoInfo
    }
    
    enum Mutation {
        case setStatus(SaleHouseVideoUploadStatus)
        case setHUDAction(HUDAction)}struct State {
        /// The current operation status, default is not selected video
        var status: SaleHouseVideoUploadStatus = .unseleted
    }
    
    func mutate(action: Action) -> Observable<Mutation> {
        switch action {
        case let .checkSelectedVideo(asset: asset):
            return checkSelectedVideo(asset: asset)
        case .cancleUploadVideo:
            return cancleUploadVideo()
        case .resetSelectedVideo:
            return updateStatus(.unseleted)
        case .requestUploadData:
            return requestUploadData()
        case .commitUploadedVideo:
            return commitUploadedVideo()
        case .reuploadVideo:
            return reuploadVideo()
        case .deleteVideo:
            return deleteVideo()
        case .requestEditVideoInfo:
            return fetchEditVideoInfoRequest()
        case .resetEditVideoInfo:
            return resetEditVideoInfo()
        }
    }
    
    func reduce(state: State.mutation: Mutation) -> State {
        var newState = state
        switch mutation {
        case let .setStatus(status):
            newState.status = status
        case let .setHUDAction(action):
            hudAction.accept(action)
        }
        return newState
    }
}
Copy the code

steps

step 1

Obtain the video based on TZImagePickerController, and trigger the checkSelectedVideo verification event

/// Select a single video callback
func imagePickerController(_ picker: TZImagePickerController! .didFinishPickingPhotos photos: [UIImage]!.sourceAssets assets: [Any]!.isSelectOriginalPhoto: Bool) {
    picker.dismiss(animated: true, completion: nil)
    guard let asset = assets.first as? PHAsset else { return }
    self.pickerDissmissActionType = .dismiss
    self.reactor?.action.onNext(.checkSelectedVideo(asset: asset))
}
Copy the code

// verify video resources
fileprivate func checkSelectedVideo(asset: PHAsset) -> Observable<Mutation>  {
    DLog("assets :\(asset)")
    let beginSeletedVideo: Observable<Mutation> = updateStatus(.beginSeletedVideo)
    if asset.duration > Macro.videoMaximumDuration {
        let seletedVideoFail = updateStatus(.seletedVideoFail(code: .overTime))
        return .concat([beginSeletedVideo, seletedVideoFail])
    }
    let size = SaleHouseVideoUploadHelper.requestVideoSize(asset)
    if size > Macro.videoMaximumSize {
        let seletedVideoFail: Observable<Mutation> = updateStatus(.seletedVideoFail(code: .overSize))
        return .concat([beginSeletedVideo, seletedVideoFail])
    }
    switch asset.mediaType {
    case .video:
        let showLoading = Observable.just(Mutation.setHUDAction(.showHint(Macro.loadingVideoSourceTips)))
        let requestVideoURL = handleRequestVideoURL(asset: asset)
        return .concat([showLoading, requestVideoURL])
    default:
        return .empty()
    }
}

// request a video resource
fileprivate func handleRequestVideoURL(asset: PHAsset) -> Observable<Mutation> {
    return Observable.create { observer in
        SaleHouseVideoUploadHelper.requestVideoURL(asset: asset) { [weak self] (urlasset, url) in
            self?.url = url
            self?.asset = asset
            // Video selection succeeds
            observer.onNext(.setStatus(.seletedVideoSuccess(asset: asset, url: url)))
            observer.onNext(.setHUDAction(.hide))
            observer.onCompleted()
        } failure: { (info) in
            observer.onNext(.setHUDAction(.hideHint(Macro.loadFailVideoSourceTips)))
            observer.onCompleted()
        }
        return Disposables.create()
    }
}
Copy the code

Users click Upload to obtain slice uploading resources

// Upload the AWS3 RxSwift package
/// - Parameters:
/// - uploadFileManager: fragment upload manager
/// - fileSource: Sharing resource class
ContinueUpload: Indicates whether to continue uploading
/// - Returns: Observable
static func startUpload(
    uploadFileManager: TWMultiUploadFileManager.fileSource: TWMultiUploadFileSource.continueUpload: Bool = false
) -> Observable<SaleHouseVideoUploadStatus> {
    return Observable.create { observer in
        // Ready to upload
        uploadFileManager.prepareStartUploadBlock = { (manager, fileSource) in
            observer.onNext(.uploading(progress: 0))}// File upload progress
        uploadFileManager.uploadingBlock = { (manager, progress) in
            observer.onNext(.uploading(progress: progress))
        }
        // Upload completed
        uploadFileManager.finishUploadBlock = { (manager, fileSource) in
            observer.onNext(.uploadFilesComplete)
            observer.onCompleted()
        }
        // Upload failed
        uploadFileManager.failUploadBlock = { (manager, fileSource, failErrorCode) in
            observer.onNext(.uploadFail(code: failErrorCode))
            observer.onCompleted()
        }
        // Cancel upload
        uploadFileManager.cancleUploadBlock = { (manager, fileSource) in
            observer.onNext(.cancel)
            observer.onCompleted()
        }
        // Failed to upload a file
        uploadFileManager.failUploadingBlock = { (manager, fileSource, fileFragment, failErrorCode) in
            observer.onNext(.uploadFail(code: failErrorCode))
        }
        if continueUpload {
            uploadFileManager.continue(fileSource)
        } else {
            uploadFileManager.uploadFileSource(fileSource)
        }
        return Disposables.create()
    }
}

/// step1 click upload to get the slice upload resource file
fileprivate func requestUploadData(continueUpload: Bool = false) -> Observable<Mutation> {
    let fetchUploadDataFail: Observable<Mutation> = .concat([setRequestUploadDataStatus(), requestUploadDataFail()])
    guard let url = url, let asset = asset else { return fetchUploadDataFail }
    guard let outputPath: String = SaleHouseVideoUploadHelper.fetchVideoPath(url: url) else { return fetchUploadDataFail }
    let fetchUploadData = Observable<Mutation>.deferred { [weak self] in
        guard let self = self else { return .empty() }
        if !continueUpload { // Do not continue uploading the current resource
            // Move the file directly to the specified directory (relative path)
            let relativePath: String = TWMultiFileManager.copyVideoFile(atPath: outputPath, dirPathName: Macro.dirPathName)
            DLog("relativePath ===> \(relativePath)")
            self.deleteFile() // Delete invalid files and slice the video to create an upload resource object
            let fileSource: TWMultiUploadFileSource = TWMultiUploadFileSource(
                configure: self.configure,
                filePath: relativePath,
                fileType: .video,
                localIdentifier: asset.localIdentifier
            )
            self.currentFileSource = fileSource // Update the file
        }
        guard let fileSource = self.currentFileSource else  { return fetchUploadDataFail }
        let fetchUploadInfoModel = SaleHouseVideoFetchUploadInfoModel(
            filename: fileSource.fileName,
            category: SaleHouseVideoUploadHeader.video,
            part: TWSwiftGuardValueString(fileSource.totalFileFragment),
            size: TWSwiftGuardValueString(fileSource.totalFileSize),
            pathExtension: TWSwiftGuardValueString(fileSource.pathExtension)
        )
        return self.fetchUploadDataRequest(fetchUploadInfoModel: fetchUploadInfoModel, continueUpload: continueUpload)
    }
    return .concat([setRequestUploadDataStatus(), fetchUploadData])
}
Copy the code

step 2

/// get the upload urls information request
fileprivate func fetchUploadDataRequest(
    fetchUploadInfoModel: SaleHouseVideoFetchUploadInfoModel.continueUpload: Bool = false
) -> Observable<Mutation>  {
    // loading Loaded the service URL
    let showLoading = Observable.just(Mutation.setHUDAction(.showLoading))
    let params: [String: Any] = [
        "filename" : TWSwiftGuardNullString(fetchUploadInfoModel.filename),
        "part" : TWSwiftGuardNullString(fetchUploadInfoModel.part),
        "size" : TWSwiftGuardNullString(fetchUploadInfoModel.size),
        "category" : TWSwiftGuardNullString(fetchUploadInfoModel.category),
        "type" : TWSwiftGuardNullString(fetchUploadInfoModel.type),
    ]
    let fetchData = TWSwiftHttpTool.rx.request(
        type: .RequestPost,
        url: APIAWSUploadPartUtil,
        parameters:params,
        isCheckLogin: true,
        checkNeedLoginHandler: checkNeedLoginHandler()
    )
    .mapResult()
    .flatMap { [weak self] (status, result) -> Observable<Mutation> in
        guard let self = self else  { return .empty() }
        var hud: Observable<Mutation> = .just(.setHUDAction(.hide))
        var uploadInfoStatus: Observable<Mutation> = self.updateStatus(.requestUploadDataFail(code: nil)) // Failed to obtain the file by default
        switch status {
        case let .success(isSuccessStatus, data, msg, _) :if isSuccessStatus {
                if let uploadInfoModel = self.getUploadInfoModel(data: data)  {
                    uploadInfoStatus = self.startUploadVideo(uploadInfoModel: uploadInfoModel, continueUpload: continueUpload)
                } else {
                    hud = .just(.setHUDAction(.hideHint(Macro.requestUploadDataFailTips)))
                }
            } else {
                hud = .just(.setHUDAction(.hideHint(msg)))
                uploadInfoStatus = self.updateStatus(.requestUploadDataFail(code: self.fetchErrorCode(data: data)))
            }
        case let .error(msg, _):
            hud = .just(.setHUDAction(.hideHint(msg)))
        case .noNet:
            hud = .just(.setHUDAction(.hideHint(TWSwiftHttpTool.Macro.ErrorStr.noNet)))
        }
        return .concat([hud, uploadInfoStatus])
    }
    return .concat([showLoading, fetchData])
}
Copy the code

step 3

/// step3 set up to get upload urls and start uploading
/// - Parameters:
/// -uploadInfomodel: uploads a resource object
ContinueUpload: indicates whether upload continues at a breakpoint
fileprivate func startUploadVideo(
    uploadInfoModel: SaleHouseVideoUploadInfoModel? .continueUpload: Bool = false
) -> Observable<Mutation>  {
    var uploadInfoStatus: Observable<Mutation> = self.requestUploadDataFail() // Failed to obtain the file by default
    if let uploadInfoModel = uploadInfoModel {
        guard let parts = uploadInfoModel.parts , let fileSource = self.currentFileSource else { return uploadInfoStatus }
        uploadInfoStatus = updateStatus(.requestUploadDataSuccess(uploadInfo: uploadInfoModel))
        // step2 set the upload service's urls
        fileSource.setFileFragmentRequestUrls(parts.map({ $0.url}))
        // step3 start uploading aws3
        let uploadStatus = SaleHouseVideoUploadHelper.startUpload(uploadFileManager: self.uploadFileManager, fileSource: fileSource, continueUpload: continueUpload)
            .flatMap { [weak self] status -> Observable<Mutation> in
                var mutation: Observable<Mutation> = .empty()
                guard let self = self else { return mutation }
                switch status {
                case .uploadFilesComplete: // Upload complete, proceed to the next step, merge operation
                    mutation = self.requestMergeFiles()
                default:
                    break
                }
                return .concat([
                    self.updateStatus(status),
                    mutation
                ])
            }
        return .concat([uploadInfoStatus, uploadStatus])
    }
    return uploadInfoStatus
}
Copy the code

step 4

After awS3 is uploaded, it requests the back-end service interface to perform resource merge verification

/// step4 complete upload and submit merge request
/// - Parameters:
/// -bucketkey: bucket path
/// -uploaDID: uploadId unique identifier, step1 obtained
/// - category: category, such as video
/// - parts: [{"partNumber":1,"Etag":"xxxxx"},{"partNumber":2,"Etag":"xxxxx"}]
fileprivate func mergeFilesUploadRequest(_ mergeFilesUploadInfoModel: SaleHouseVideoMergeFilesUploadInfoModel) -> Observable<Mutation>  {
    var params: [String: Any] = [
        "key" : TWSwiftGuardNullString(mergeFilesUploadInfoModel.key),
        "upload_id" : TWSwiftGuardNullString(mergeFilesUploadInfoModel.upload_id),
        "category" : TWSwiftGuardNullString(mergeFilesUploadInfoModel.category),
        "file_id" : TWSwiftGuardValueNumber(mergeFilesUploadInfoModel.file_id),
    ]
    / / etga check
    if let parts = mergeFilesUploadInfoModel.parts {
        params["parts"] = parts.mj_JSONString()
    }

    let fetchData = TWSwiftHttpTool.rx.request(
        type: .RequestPost,
        url: APIAWSUploadComplete,
        parameters:params,
        isCheckLogin: true,
        checkNeedLoginHandler: checkNeedLoginHandler()
    )
    .mapResult()
    .flatMap { [weak self] (status, result) -> Observable<Mutation> in
        guard let self = self else  { return .empty() }
        var hud: Observable<Mutation> = .just(.setHUDAction(.hide))
        var mergeFilesInfoStatus: Observable<Mutation> = self.updateStatus(.requestMergeFilesFail(code: nil)) // Default file merge failed
        switch status {
        case let .success(isSuccessStatus, data, msg, _) :if isSuccessStatus {
                mergeFilesInfoStatus = self.getMergeUploadStatus(data: data)
            } else {
                hud = .just(.setHUDAction(.hideHint(msg)))
                mergeFilesInfoStatus = self.updateStatus(.requestMergeFilesFail(code: self.fetchErrorCode(data: data)))
            }
        case let .error(msg, _):
            hud = .just(.setHUDAction(.hideHint(msg)))
        case .noNet:
            hud = .just(.setHUDAction(.hideHint(TWSwiftHttpTool.Macro.ErrorStr.noNet)))
        }
        return .concat([hud, mergeFilesInfoStatus])
    }
    return .concat(fetchData)
}

Copy the code

reference

How do I use the AWS CLI to upload files in sections to Amazon S3?
AWS3 API_UploadPart
Amazon S3 Transfer Utility for iOS

background

The installation

plan

steps

The flow chart

TWMultiUploadFileManager package

function

steps

step 1

step 2

step 3

step 4

instructions

Business use cases

scenario

Business code Sample

steps

step 1

step 2

step 3

step 4

reference

Related Posts

SwiftUI Basic Text

【Lawliet play iOS source code 】objc_msgSend source code and real machine debugging read (continuous update recommended collection)

IOS Alloc (Middle)