override suspend fun upsertPartial(key: String, value: String?): ObjectId {
        var objectId: ObjectId? = null
        val insertedValue: PartialEntity? = this.getPartialByKey(key)
        val realm: Realm = Realm.getDefaultInstance()
        realm.executeTransactionAwait(this.dispatcher) {
            objectId = insertedValue?.partialId ?: ObjectId()
            val partialEntity = PartialEntity(
                partialId = objectId!!,
                partitionKey = this.invitationPartitionKey,
                invitationId = this.invitationId,
                key = key,
                value = value
            )

// ERROR
            realm.insertOrUpdate(partialEntity)
        }

        realm.close()

        return objectId!!
    }

2022-02-03 13:15:28.639 18543-18823/? E/REALM_JNI: jni: ThrowingException 7, Permission denied in /tmp/realm-java/realm/realm-library/src/main/cpp/io_realm_internal_OsSharedRealm.cpp line 107, .
2022-02-03 13:15:28.640 18543-18823/? E/REALM_JNI: Exception has been thrown: Permission denied in /tmp/realm-java/realm/realm-library/src/main/cpp/io_realm_internal_OsSharedRealm.cpp line 107

object RealmProviderManager {

    private const val TAG = "RealmProviderManager"

    private var realmApplication: App? = null

    private var user: User? = null

    private var realmSyncConfiguration: SyncConfiguration? = null

    private var syncSession: SyncSession? = null

    suspend fun initialize(context: Context, realmAppId: String, partitionKey: String): Boolean {

        return try {

            Realm.init(context)

            if (BuildConfig.DEBUG) {

                RealmLog.setLevel(LogLevel.ALL)
            }

            val realmAppConfiguration = AppConfiguration.Builder(realmAppId)
                .build()

            this.realmApplication = App(realmAppConfiguration)

            this.initialize(this.realmApplication!!, partitionKey)

            this.initializeRealmSession()

            true
        } catch (ex: Exception) {

            // TODO log error to telemetry

            false
        }
    }

    suspend fun initialize(realmApplication: App, partitionKey: String) {

        this.realmApplication = realmApplication

        this.user = this.loginToRealm()

        realmSyncConfiguration = SyncConfiguration.Builder(
            this.user,
            partitionKey
        ).build()

        if(Realm.getDefaultConfiguration()?.realmFileName != realmSyncConfiguration?.realmFileName) {

            Realm.setDefaultConfiguration(realmSyncConfiguration!!)
        }
    }

    private suspend fun loginToRealm(): User? {

        return suspendCancellableCoroutine { continuation ->

            // TODO update this to use a custom JWT token or maybe a custom function
            val credentials: Credentials = Credentials.anonymous()

            realmApplication!!.loginAsync(credentials) { loginResult ->

                if (loginResult.isSuccess) {

                    val loginUser: User? = loginResult.get()

                    continuation.resume(loginUser) {

                        // implementation not required
                    }
                }
                // otherwise the exception will be thrown in the coroutine
                // and this should be catch in the consumer of this function
                else {

                    val error: AppException = loginResult.error

                    continuation.resumeWithException(error)
                }
            }
        }
    }

    private fun initializeRealmSession() {

        this.syncSession = realmApplication?.sync?.getOrCreateSession(realmSyncConfiguration)

        syncSession?.start()
    }

    @OptIn(ExperimentalCoroutinesApi::class)
    suspend fun waitToDownloadComplete(): Boolean {

        val realm: Realm = Realm.getDefaultInstance()

        return suspendCancellableCoroutine { cancelableContinuation ->

            syncSession?.addDownloadProgressListener(ProgressMode.INDEFINITELY) { progress ->

                if(progress.isTransferComplete) {

                    cancelableContinuation.resume(true){

                        // Implementation not required
                    }

                    realm.close()
                }
            }
        }
    }

class SynchronizationViewModel @Inject constructor(
private val dispatcher: CoroutineDispatcher = Dispatchers.IO
) : ViewModel() {

fun initializeViewModel() {

        this.viewModelScope.launch(this.dispatcher) {

            try {
// ...
RealmProviderManager.waitToDownloadComplete()
            } catch (exception: Exception) {
// ...
            }
        }
    }