Swift API Client for Upload & Management, and Uploader UI

1
dependencies: [
2
    .package(url: "https://github.com/uploadcare/uploadcare-swift.git", .branch("master"))
3
]

1
dependencies: [
2
    .package(url: "https://github.com/uploadcare/uploadcare-swift.git", branch("develop"))
3
]

1
final class MyClass {
2
    private var uploadcare: Uploadcare
3
4
    init() {
5
        self.uploadcare = Uploadcare(withPublicKey: "YOUR_PUBLIC_KEY")
6
7
        // Secret key is optional if you want to use Upload API only
8
        // REST API requires both public and secret keys:
9
        self.uploadcare = Uploadcare(withPublicKey: "YOUR_PUBLIC_KEY", secretKey: "YOUR_SECRET_KEY")
10
    }
11
}

1
final class MyClass {
2
    private let project1: Uploadcare
3
    private let project2: Uploadcare
4
5
    init() {
6
        // A project to use Upload API only
7
        self.project1 = Uploadcare(withPublicKey: "YOUR_PUBLIC_KEY_1")
8
9
        // A project to use both REST API and Upload API
10
        self.project2 = Uploadcare(withPublicKey: "YOUR_PUBLIC_KEY_2", secretKey: "YOUR_SECRET_KEY_2")
11
    }
12
}

1
guard let url = URL(string: "https://source.unsplash.com/featured") else { return }
2
guard let data = try? Data(contentsOf: url) else { return }
3
4
// You can create an UploadedFile object to operate with it
5
var fileForUploading1 = uploadcare.file(fromData: data)
6
fileForUploading2.metadata = ["myKey": "myValue"]
7
try await fileForUploading1.upload(withName: "random_file_name.jpg", store: .store)
8
9
// The same method with a completion callback that returns a task that can be paused or cancelled
10
11
var fileForUploading2 = uploadcare.file(withContentsOf: url)!
12
let file = try await uploadcare.uploadFile(data, withName: "random_file_name.jpg", store: .auto) { progress in
13
    print("upload progress: \(progress * 100)%")
14
}
15
16
// Same method with a completion callback that returns a task that can be paused or cancelled:
17
let task = uploadcare.uploadFile(data, withName: "random_file_name.jpg", store: .store, metadata: ["someKey": "someMetaValue"]) { progress in
18
    print("upload progress: \(progress * 100)%")
19
} _: { result in
20
    switch result {
21
    case .failure(let error):
22
        print(error.detail)
23
    case .success(let file):
24
        print(file)
25
    }
26
}
27
28
// Cancel uploading if needed
29
task.cancel()
30
31
// task will confirm UploadTaskable protocol if file size is less than 100 mb, and UploadTaskResumable if file size is >= 100mb
32
// You can pause or resume uploading of file with size >= 100mb if needed
33
(task as? UploadTaskResumable)?.pause()
34
(task as? UploadTaskResumable)?.resume()

1
// Make a list of files object
2
lazy var filesList = uploadcare.listOfFiles()
3
4
func someFilesListMethod() {
5
    // Make a query object
6
    let query = PaginationQuery()
7
        .stored(true)
8
        .ordering(.dateTimeUploadedDESC)
9
        .limit(5)
10
11
    // Get file list
12
    let list = try await filesList.get(withQuery: query)
13
14
    // Same method with a completion callback
15
    filesList.get(withQuery: query) { result in
16
        switch result {
17
        case .failure(let error):
18
            print(error)
19
        case .success(let list):
20
            print(list)
21
        }
22
    }
23
}

1
// Check if the next page is available
2
guard filesList.next != nil else { return }
3
4
// Async:
5
let next = try await filesList.nextPage()
6
7
// With a completion callback:
8
filesList.nextPage { result in
9
    switch result {
10
    case .failure(let error):
11
        print(error)
12
    case .success(let list):
13
        print(list)
14
    }
15
}

1
// Check if the previous page is available
2
guard filesList.previous != nil else { return }
3
4
// Async:
5
let previous = try await filesList.previousPage()
6
7
// With a completion callback:
8
filesList.previousPage { result in
9
    switch result {
10
    case .failure(let error):
11
        print(error)
12
    case .success(let list):
13
        print(list)
14
    }
15
}