val intent = Intent(Intent.ACTION_OPEN_DOCUMENT_TREE).apply {
            flags = Intent.FLAG_GRANT_READ_URI_PERMISSION or
                    Intent.FLAG_GRANT_PERSISTABLE_URI_PERMISSION
        }
        startActivityForResult(intent, SettingsFragment.OPEN_DIRECTORY_REQUEST_CODE)

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)
        if (requestCode == SettingsFragment.OPEN_DIRECTORY_REQUEST_CODE && resultCode == Activity.RESULT_OK) {

            data?.data?.log("FILEPATH_MyLibrary")

            val sdCardTreeUri: Uri = data?.data!!

            myLibraryViewModel.setSDCardTreeUri(sdCardTreeUri)

            

        }
    }

after calling cancellableContinuation.resumeWithException(
                                error?.connectionException ?: Throwable()
                            ) this

/**
 * Resumes the execution of the corresponding coroutine so that the [exception] is re-thrown right after the
 * last suspension point.
 */
@SinceKotlin("1.3")
@InlineOnly
public inline fun <T> Continuation<T>.resumeWithException(exception: Throwable): Unit =
    resumeWith(Result.failure(exception))

@SinceKotlin("1.3")
public interface Continuation<in T> {
    /**
     * The context of the coroutine that corresponds to this continuation.
     */
    public val context: CoroutineContext

    /**
     * Resumes the execution of the corresponding coroutine passing a successful or failed [result] as the
     * return value of the last suspension point.
     */
    public fun resumeWith(result: Result<T>)
}

package kotlin.coroutines

@kotlin.PublishedApi @kotlin.SinceKotlin internal final expect class SafeContinuation<in T> : kotlin.coroutines.Continuation<T> {
    internal constructor(delegate: kotlin.coroutines.Continuation<T>, initialResult: kotlin.Any?) { /* compiled code */ }

    @kotlin.PublishedApi internal constructor(delegate: kotlin.coroutines.Continuation<T>) { /* compiled code */ }

    public expect open val context: kotlin.coroutines.CoroutineContext /* compiled code */

    @kotlin.PublishedApi internal final expect fun getOrThrow(): kotlin.Any? { /* compiled code */ }

    public open expect fun resumeWith(result: kotlin.Result<T>): kotlin.Unit { /* compiled code */ }
}

private final class SequenceBuilderIterator<T> public constructor() : kotlin.sequences.SequenceScope<T>, kotlin.collections.Iterator<T>, kotlin.coroutines.Continuation<kotlin.Unit> {
    public open val context: kotlin.coroutines.CoroutineContext /* compiled code */

    private final var nextIterator: kotlin.collections.Iterator<T>? /* compiled code */

    public final var nextStep: kotlin.coroutines.Continuation<kotlin.Unit>? /* compiled code */

    private final var nextValue: T? /* compiled code */

    private final var state: kotlin.sequences.State /* = kotlin.Int */ /* compiled code */

    private final fun exceptionalState(): kotlin.Throwable { /* compiled code */ }

    public open operator fun hasNext(): kotlin.Boolean { /* compiled code */ }

...