private fun initRealm(application: Application) {
     Realm.init(application).also {
         getAppSharedPreferences().run {
             getSharedValue<ByteArray>("RealmKey").let { key ->
                 if (key == null) {
                     val newKey = ByteArray(64)
                     val random: Random = SecureRandom()
                     random.nextBytes(newKey)
                     putSharedValue("RealmKey", newKey)
                     newKey
                 } else {
                     key
                 }
             }
         }.also { key ->
             RealmConfiguration.Builder()
                 .name("AppNameRealmDB.realm")
                 .encryptionKey(key)
                 .allowQueriesOnUiThread(false)
                 .allowWritesOnUiThread(false)
                 .schemaVersion(1)
                 .migration(AppRealmMigrations())
                 .build().run {
                     Realm.setDefaultConfiguration(this)
                 }
         }
     }
 }

class UnitOfWork {
    fun <TResult> queryRealm(action: Realm.() -> TResult): Single<TResult> {
        return Single.create<TResult> { emitter ->
            Realm.getDefaultInstance().run {
                try {
                    emitter.onSuccess(action.invoke(this)!!)
                } catch (ex: Exception) {
                    close()
                    emitter.onError(ex)
                } finally {
                    close()
                }
            }
        }.subscribeOn(Schedulers.io())
    }
}

class CurrentUserHelper(private val unitOfWork: UnitOfWork) {
    
    //This fun is sample original user entity comes after login request
    fun saveCurrentUser(): Single<OperationResult> {
        return unitOfWork.queryRealm {
            executeTransaction {
                copyToRealmOrUpdate(UserEntity().apply {
                    isCurrentUser = true
                })
            }
        }.map {
            OperationResult.Success()
        }
    }

    fun getCurrentUser(): Single<UserEntity> {
        return unitOfWork.queryRealm {
            copyFromRealm(
                where(UserEntity::class.java).equalTo(
                    UserEntity::isCurrentUser.name,
                    true
                ).findFirst()!! <-- Null pointer exception
            )
        }
    }
}

fun clear(): Single<OperationResult> {
        return unitOfWork.queryRealm {
            executeTransaction {
                where(UserEntity::class.java).findAll().deleteAllFromRealm()
            }
        }.map {
            OperationResult.Success()
        }
    }

@RealmClass
open class UserEntity() : RealmModel {
    @PrimaryKey
    var id: String = UUID.randomUUID().toString()

    var isCurrentUser: Boolean = false
}