SDAI Cloud instance (#28)

* Custom sdai cloud patch 1

* Custom sdai cloud patch 2

* Custom sdai cloud patch 3

* Custom sdai cloud patch 4

* Custom sdai cloud patch 5

* Custom sdai cloud patch 6

* Custom sdai cloud patch 7

* Custom sdai cloud patch 8

Author: ShiftHackZ

app/app.gradle

@@ -21,6 +21,7 @@ android {
     defaultConfig {
         applicationId "com.shifthackz.aisdv1.app"
 
+        buildConfigField "String", "CLOUD_AI_URL", "\"https://sdai.moroz.cc\""
         buildConfigField "String", "UPDATE_API_URL", "\"https://sdai.moroz.cc\""
         buildConfigField "String", "DEMO_MODE_API_URL", "\"https://sdai.moroz.cc\""
         buildConfigField "String", "POLICY_URL", "\"https://sdai.moroz.cc/policy.html\""

app/src/main/java/com/shifthackz/aisdv1/app/di/ProvidersModule.kt

@@ -27,11 +27,13 @@ val providersModule = module {
         object : ApiUrlProvider {
             override val stableDiffusionAutomaticApiUrl: String = DEFAULT_SERVER_URL
             override val stableDiffusionAppUpdateApiUrl: String = BuildConfig.UPDATE_API_URL
+            override val stableDiffusionCloudAiApiUrl: String = BuildConfig.CLOUD_AI_URL
         }
     }
 
     single<LinksProvider> {
         object : LinksProvider {
+            override val cloudUrl: String = BuildConfig.CLOUD_AI_URL
             override val privacyPolicyUrl: String = BuildConfig.POLICY_URL
             override val gitHubSourceUrl: String = BuildConfig.GITHUB_SOURCE_URL
             override val setupInstructionsUrl: String = BuildConfig.SETUP_INSTRUCTIONS_URL

build.gradle

@@ -1,7 +1,7 @@
 buildscript {
     ext {
         appVersion = "0.2.0"
-        minSdk = 24
+        minSdk = 26
         targetSdk = 33
     }
     dependencies {

core/common/src/main/java/com/shifthackz/aisdv1/core/common/links/LinksProvider.kt

@@ -1,6 +1,7 @@
 package com.shifthackz.aisdv1.core.common.links
 
 interface LinksProvider {
+    val cloudUrl: String
     val privacyPolicyUrl: String
     val gitHubSourceUrl: String
     val setupInstructionsUrl: String

core/common/src/main/java/com/shifthackz/aisdv1/core/common/reactive/RetryExtensions.kt

@@ -0,0 +1,95 @@
+package com.shifthackz.aisdv1.core.common.reactive
+
+import io.reactivex.rxjava3.core.Completable
+import io.reactivex.rxjava3.core.Flowable
+import io.reactivex.rxjava3.core.Observable
+import io.reactivex.rxjava3.core.Single
+import io.reactivex.rxjava3.functions.Function
+import org.reactivestreams.Publisher
+import java.util.concurrent.TimeUnit
+
+fun <T: Any> Single<T>.retryWithDelay(
+    maxRetries: Long,
+    delay: Long,
+    unit: TimeUnit,
+    tryCallback: (Long) -> Unit = {}
+): Single<T> {
+    return this.retryWhen(FlowableRetryWithDelay(maxRetries, unit.toMillis(delay), tryCallback))
+}
+
+fun <T : Any> Observable<T>.retryWithDelay(
+    maxRetries: Long,
+    delay: Long,
+    unit: TimeUnit,
+    tryCallback: (Long) -> Unit = {}
+): Observable<T> {
+    return this.retryWhen(ObservableRetryWithDelay(maxRetries, unit.toMillis(delay), tryCallback))
+}
+
+fun <T : Any> Flowable<T>.retryWithDelay(
+    maxRetries: Long,
+    delay: Long,
+    unit: TimeUnit,
+    tryCallback: (Long) -> Unit = {}
+): Flowable<T> {
+    return this.retryWhen(FlowableRetryWithDelay(maxRetries, unit.toMillis(delay), tryCallback))
+}
+
+fun Completable.retryWithDelay(
+    maxRetries: Long,
+    delay: Long,
+    unit: TimeUnit,
+    tryCallback: (Long) -> Unit = {}
+): Completable {
+    return this.retryWhen(FlowableRetryWithDelay(maxRetries, unit.toMillis(delay), tryCallback))
+}
+
+class ObservableRetryWithDelay(
+    private val maxRetries: Long,
+    private val retryDelayMillis: Long,
+    private val tryCallback: (Long) -> Unit
+) : Function<Observable<Throwable>, Observable<Any>> {
+
+    private var retryCount: Long = 0
+
+    override fun apply(attemps: Observable<Throwable>): Observable<Any> {
+        return attemps.flatMap {
+            if (++retryCount < maxRetries) {
+                // When this Observable calls onNext, the original
+                // Observable will be retried (i.e. re-subscribed).
+                return@flatMap Observable.timer(retryDelayMillis, TimeUnit.MILLISECONDS)
+                    .doOnNext {
+                        tryCallback(retryCount)
+                    }
+            }
+            // Max retries hit. Just pass the error along.
+            Observable.error(it)
+        }
+    }
+
+}
+
+class FlowableRetryWithDelay(
+    private val maxRetries: Long,
+    private val retryDelayMillis: Long,
+    private val tryCallback: (Long) -> Unit
+) : Function<Flowable<Throwable>, Publisher<Any>> {
+
+    private var retryCount: Long = 0
+
+    override fun apply(attemps: Flowable<Throwable>): Publisher<Any> {
+        return attemps.flatMap {
+            if (++retryCount < maxRetries) {
+                // When this Observable calls onNext, the original
+                // Observable will be retried (i.e. re-subscribed).
+                return@flatMap Flowable
+                    .timer(retryDelayMillis, TimeUnit.MILLISECONDS)
+                    .doOnNext {
+                        tryCallback(retryCount)
+                    }
+            }
+            // Max retries hit. Just pass the error along.
+            Flowable.error<Any>(it)
+        }
+    }
+}

core/common/src/main/java/com/shifthackz/aisdv1/core/common/schedulers/SchedulersExtensions.kt

@@ -1,6 +1,7 @@
 package com.shifthackz.aisdv1.core.common.schedulers
 
 import io.reactivex.rxjava3.core.Completable
+import io.reactivex.rxjava3.core.Flowable
 import io.reactivex.rxjava3.core.Observable
 import io.reactivex.rxjava3.core.Single
 
@@ -13,6 +14,12 @@ fun <T : Any> Observable<T>.subscribeOnMainThread(provider: SchedulersProvider):
         .subscribeOn(provider.io)
         .observeOn(provider.ui)
 
+fun <T : Any> Flowable<T>.subscribeOnMainThread(provider: SchedulersProvider): Flowable<T> =
+    this
+        .subscribeOn(provider.io)
+        .observeOn(provider.ui)
+
+
 fun Completable.subscribeOnMainThread(provider: SchedulersProvider): Completable = this
     .subscribeOn(provider.io)
     .observeOn(provider.ui)

data/src/main/java/com/shifthackz/aisdv1/data/di/LocalDataSourceModule.kt

@@ -2,31 +2,20 @@ package com.shifthackz.aisdv1.data.di
 
 import com.shifthackz.aisdv1.data.gateway.DatabaseClearGatewayImpl
 import com.shifthackz.aisdv1.data.local.*
-import com.shifthackz.aisdv1.data.provider.ServerUrlProvider
 import com.shifthackz.aisdv1.domain.datasource.*
 import com.shifthackz.aisdv1.domain.gateway.DatabaseClearGateway
-import com.shifthackz.aisdv1.domain.preference.PreferenceManager
-import io.reactivex.rxjava3.core.Single
 import org.koin.core.module.dsl.factoryOf
 import org.koin.core.module.dsl.singleOf
 import org.koin.dsl.bind
 import org.koin.dsl.module
 
 val localDataSourceModule = module {
-
-    single {
-        ServerUrlProvider { endpoint ->
-            Single
-                .fromCallable(get<PreferenceManager>()::serverUrl)
-                .map { baseUrl -> "$baseUrl/$endpoint" }
-        }
-    }
-
     singleOf(::DatabaseClearGatewayImpl) bind DatabaseClearGateway::class
 
     factoryOf(::StableDiffusionModelsLocalDataSource) bind StableDiffusionModelsDataSource.Local::class
     factoryOf(::StableDiffusionSamplersLocalDataSource) bind StableDiffusionSamplersDataSource.Local::class
     factoryOf(::ServerConfigurationLocalDataSource) bind ServerConfigurationDataSource.Local::class
     factoryOf(::GenerationResultLocalDataSource) bind GenerationResultDataSource.Local::class
     factoryOf(::AppVersionLocalDataSource) bind AppVersionDataSource.Local::class
+    factoryOf(::CoinLocalDataSource) bind CoinDataSource.Local::class
 }

data/src/main/java/com/shifthackz/aisdv1/data/di/RemoteDataSourceModule.kt

@@ -1,18 +1,40 @@
 package com.shifthackz.aisdv1.data.di
 
+import com.shifthackz.aisdv1.core.common.links.LinksProvider
 import com.shifthackz.aisdv1.data.gateway.ServerConnectivityGatewayImpl
+import com.shifthackz.aisdv1.data.provider.ServerUrlProvider
 import com.shifthackz.aisdv1.data.remote.*
 import com.shifthackz.aisdv1.domain.datasource.*
 import com.shifthackz.aisdv1.domain.gateway.ServerConnectivityGateway
+import com.shifthackz.aisdv1.domain.preference.PreferenceManager
+import com.shifthackz.aisdv1.network.connectivity.ConnectivityMonitor
+import io.reactivex.rxjava3.core.Single
 import org.koin.core.module.dsl.factoryOf
+import org.koin.core.parameter.parametersOf
 import org.koin.dsl.bind
 import org.koin.dsl.module
 
 val remoteDataSourceModule = module {
-    factoryOf(::ServerConnectivityGatewayImpl) bind ServerConnectivityGateway::class
+    single {
+        ServerUrlProvider { endpoint ->
+            val prefs = get<PreferenceManager>()
+            val links = get<LinksProvider>()
+            val chain = if (prefs.useSdAiCloud) Single.fromCallable(links::cloudUrl)
+            else Single.fromCallable(prefs::serverUrl)
+            chain.map { baseUrl -> "$baseUrl/$endpoint" }
+        }
+    }
+
     factoryOf(::StableDiffusionGenerationRemoteDataSource) bind StableDiffusionGenerationDataSource.Remote::class
     factoryOf(::StableDiffusionSamplersRemoteDataSource) bind StableDiffusionSamplersDataSource.Remote::class
     factoryOf(::StableDiffusionModelsRemoteDataSource) bind StableDiffusionModelsDataSource.Remote::class
     factoryOf(::ServerConfigurationRemoteDataSource) bind ServerConfigurationDataSource.Remote::class
     factoryOf(::AppVersionRemoteDataSource) bind AppVersionDataSource.Remote::class
+    factoryOf(::CoinRemoteDateSource) bind CoinDataSource.Remote::class
+
+    factory<ServerConnectivityGateway> {
+        val lambda: () -> Boolean = { get<PreferenceManager>().useSdAiCloud }
+        val monitor = get<ConnectivityMonitor> { parametersOf(lambda) }
+        ServerConnectivityGatewayImpl(monitor, get())
+    }
 }

data/src/main/java/com/shifthackz/aisdv1/data/di/RepositoryModule.kt

@@ -13,4 +13,5 @@ val repositoryModule = module {
     factoryOf(::ServerConfigurationRepositoryImpl) bind ServerConfigurationRepository::class
     factoryOf(::GenerationResultRepositoryImpl) bind GenerationResultRepository::class
     factoryOf(::AppVersionRepositoryImpl) bind AppVersionRepository::class
+    factoryOf(::CoinRepositoryImpl) bind CoinRepository::class
 }

data/src/main/java/com/shifthackz/aisdv1/data/local/CoinLocalDataSource.kt

@@ -0,0 +1,20 @@
+package com.shifthackz.aisdv1.data.local
+
+import com.shifthackz.aisdv1.domain.datasource.CoinDataSource
+import com.shifthackz.aisdv1.storage.db.coins.dao.CoinDao
+import com.shifthackz.aisdv1.storage.db.coins.entity.CoinEntity
+import io.reactivex.rxjava3.core.Completable
+import java.util.*
+
+internal class CoinLocalDataSource(
+    private val coinDao: CoinDao,
+) : CoinDataSource.Local {
+
+    override fun observeQuerySpentCoinsForPeriod(start: Long, end: Long) = coinDao
+        .observeQueryAvailableCoinsForPeriod(start, end)
+        .map { it.size }
+
+    override fun onCoinSpent(): Completable = coinDao.insert(
+        CoinEntity(0L, Date())
+    )
+}