suspend fun getUrl()

in core-kotlin/src/main/java/com/amplifyframework/kotlin/storage/Storage.kt [46:118]
61 lines of code
2 McCabe index (conditional complexity)

    suspend fun getUrl(
        key: String,
        options: StorageGetUrlOptions = StorageGetUrlOptions.defaultInstance()
    ): StorageGetUrlResult

    @ExperimentalCoroutinesApi
    @FlowPreview
    fun downloadFile(
        key: String,
        local: File,
        options: StorageDownloadFileOptions = StorageDownloadFileOptions.defaultInstance()
    ): InProgressStorageOperation<StorageDownloadFileResult>

    @ExperimentalCoroutinesApi
    @FlowPreview
    fun uploadFile(
        key: String,
        local: File,
        options: StorageUploadFileOptions = StorageUploadFileOptions.defaultInstance()
    ): InProgressStorageOperation<StorageUploadFileResult>

    @FlowPreview
    @ExperimentalCoroutinesApi
    fun uploadInputStream(
        key: String,
        local: InputStream,
        options: StorageUploadInputStreamOptions = StorageUploadInputStreamOptions.defaultInstance()
    ): InProgressStorageOperation<StorageUploadInputStreamResult>

    @Throws(StorageException::class)
    suspend fun remove(
        key: String,
        options: StorageRemoveOptions = StorageRemoveOptions.defaultInstance()
    ): StorageRemoveResult

    @Throws(StorageException::class)
    suspend fun list(
        path: String,
        options: StorageListOptions = StorageListOptions.defaultInstance()
    ): StorageListResult

    @FlowPreview
    data class InProgressStorageOperation<T>(
        private val results: Flow<T>,
        private val progress: Flow<StorageTransferProgress>,
        private val errors: Flow<StorageException>,
        private val delegate: Cancelable?
    ) : Cancelable {

        override fun cancel() {
            delegate?.cancel()
        }

        fun progress(): Flow<StorageTransferProgress> {
            return progress
        }

        @Suppress("UNCHECKED_CAST")
        suspend fun result(): T {
            // We want to take the first item from either one,
            // without waiting for the other.
            // Maybe there's a cleaner way to achieve this.
            return flowOf(errors, results)
                .flattenMerge()
                .onEach { emission ->
                    if (emission is StorageException) {
                        throw emission
                    }
                }
                .map { it as T }
                .first()
        }
    }