Extract licensing helpers, deduplicate dialog/IAP boilerplate, simplify code

Author: SailReal

domain/src/main/java/org/cryptomator/domain/usecases/DoLicenseCheck.java

@@ -64,13 +64,12 @@ public LicenseCheck execute() throws BackendException {
 	private String useLicenseOrRetrieveFromPreferences(String license) throws NoLicenseAvailableException {
 		if (!license.isEmpty()) {
 			return license;
-		} else {
-			license = sharedPreferencesHandler.licenseToken();
-			if (license.isEmpty()) {
-				throw new NoLicenseAvailableException();
-			}
 		}
-		return license;
+		String stored = sharedPreferencesHandler.licenseToken();
+		if (stored.isEmpty()) {
+			throw new NoLicenseAvailableException();
+		}
+		return stored;
 	}
 
 	private ECPublicKey getPublicKey(String publicKey) throws NoSuchAlgorithmException, InvalidKeySpecException {

presentation/src/main/java/org/cryptomator/presentation/CryptomatorApp.kt

@@ -26,9 +26,11 @@ import org.cryptomator.presentation.service.AutoUploadNotification
 import org.cryptomator.presentation.service.AutoUploadService
 import org.cryptomator.presentation.service.CryptorsService
 import org.cryptomator.presentation.service.IapBillingService
+import org.cryptomator.presentation.service.PendingCallbackQueue
 import org.cryptomator.presentation.service.ProductInfo
 import org.cryptomator.presentation.service.PurchaseRevokedToastObserver
 import org.cryptomator.presentation.service.RestoreOutcome
+import org.cryptomator.presentation.service.RestoreOutcomeDialogObserver
 import org.cryptomator.util.FlavorConfig
 import org.cryptomator.util.NoOpActivityLifecycleCallbacks
 import org.cryptomator.util.SharedPreferencesHandler
@@ -51,21 +53,18 @@ class CryptomatorApp : MultiDexApplication(), HasComponent<ApplicationComponent>
 	@Volatile
 	private var iapBillingServiceBinder: IapBillingService.Binder? = null
 
-	@Volatile
-	var lastRestoreOutcome: RestoreOutcome? = null
-
-	fun consumeLastRestoreOutcome(): RestoreOutcome? {
-		val outcome = lastRestoreOutcome
-		lastRestoreOutcome = null
-		return outcome
+	fun restorePurchasesAndStore() {
+		val handler = SharedPreferencesHandler(applicationContext())
+		restorePurchases { outcome -> handler.setPendingRestoreOutcome(outcome.kind.name) }
 	}
 
-	private val pendingProductDetailsCallbacks = mutableListOf<(List<ProductInfo>) -> Unit>()
+	private val pendingProductDetailsCallbacks = PendingCallbackQueue<List<ProductInfo>>()
 
 	override fun onCreate() {
 		super.onCreate()
 		setupLogging()
 		val sharedPreferencesHandler = SharedPreferencesHandler(applicationContext())
+
 		@Suppress("KotlinConstantConditions") //
 		val flavor = when (BuildConfig.FLAVOR) {
 			"apkstore" -> "APK Store Edition"
@@ -88,6 +87,7 @@ class CryptomatorApp : MultiDexApplication(), HasComponent<ApplicationComponent>
 		registerActivityLifecycleCallbacks(serviceNotifier)
 		if (FlavorConfig.isFreemiumFlavor) {
 			registerActivityLifecycleCallbacks(PurchaseRevokedToastObserver(sharedPreferencesHandler))
+			registerActivityLifecycleCallbacks(RestoreOutcomeDialogObserver(sharedPreferencesHandler))
 		}
 		AppCompatDelegate.setDefaultNightMode(sharedPreferencesHandler.screenStyleMode)
 		cleanupCache()
@@ -165,25 +165,17 @@ class CryptomatorApp : MultiDexApplication(), HasComponent<ApplicationComponent>
 	}
 
 	fun queryProductDetails(callback: (List<ProductInfo>) -> Unit) {
-		if (FlavorConfig.isFreemiumFlavor) {
-			synchronized(pendingProductDetailsCallbacks) {
-				iapBillingServiceBinder?.queryProductDetails(callback) ?: pendingProductDetailsCallbacks.add(callback)
-			}
-		} else {
+		if (!FlavorConfig.isFreemiumFlavor) {
 			callback(emptyList())
+			return
 		}
+		iapBillingServiceBinder?.queryProductDetails(callback) ?: pendingProductDetailsCallbacks.enqueue(callback)
 	}
 
 	private fun drainPendingProductDetailsCallbacks() {
-		synchronized(pendingProductDetailsCallbacks) {
-			if (pendingProductDetailsCallbacks.isEmpty()) {
-				return
-			}
-			val callbacks = ArrayList(pendingProductDetailsCallbacks)
-			pendingProductDetailsCallbacks.clear()
-			iapBillingServiceBinder?.queryProductDetails { products ->
-				callbacks.forEach { it(products) }
-			}
+		val snapshot = pendingProductDetailsCallbacks.drainSnapshot() ?: return
+		iapBillingServiceBinder?.queryProductDetails { products ->
+			snapshot.forEach { it(products) }
 		}
 	}
 

presentation/src/main/java/org/cryptomator/presentation/licensing/LicenseEnforcer.kt

@@ -1,11 +1,9 @@
 package org.cryptomator.presentation.licensing
 
 import android.app.Activity
-import android.content.Context
 import android.content.Intent
 import android.widget.Toast
 import androidx.annotation.StringRes
-import org.cryptomator.domain.di.PerView
 import org.cryptomator.presentation.R
 import org.cryptomator.presentation.intent.Intents
 import org.cryptomator.presentation.model.VaultModel
@@ -17,7 +15,6 @@ import java.util.Date
 import java.util.concurrent.TimeUnit
 import javax.inject.Inject
 
-@PerView
 class LicenseEnforcer @Inject constructor(private val sharedPreferencesHandler: SharedPreferencesHandler) {
 
 	enum class LockedAction(
@@ -56,19 +53,22 @@ class LicenseEnforcer @Inject constructor(private val sharedPreferencesHandler:
 		sharedPreferencesHandler.setTrialExpirationDate(trialExpiration)
 	}
 
-	fun hasActiveTrial(): Boolean {
-		return evaluateTrialState().isActive
-	}
+	fun hasActiveTrial(): Boolean = evaluateTrialState().isActive
 
 	fun evaluateTrialState(): TrialState {
+		val state = readTrialState()
+		if (state.isExpired && !sharedPreferencesHandler.isTrialExpired()) {
+			sharedPreferencesHandler.setTrialExpired(true)
+		}
+		return state
+	}
+
+	private fun readTrialState(): TrialState {
 		val trialExpiration = sharedPreferencesHandler.trialExpirationDate()
 		val now = System.currentTimeMillis()
 		val sticky = sharedPreferencesHandler.isTrialExpired()
 		val active = trialExpiration > 0 && trialExpiration > now && !sticky
 		val expired = trialExpiration > 0 && (trialExpiration <= now || sticky)
-		if (expired && !sticky) {
-			sharedPreferencesHandler.setTrialExpired(true)
-		}
 		val formattedDate = if (active || expired) {
 			DateFormat.getDateInstance().format(Date(trialExpiration))
 		} else null
@@ -82,25 +82,18 @@ class LicenseEnforcer @Inject constructor(private val sharedPreferencesHandler:
 		val hasPaidLicense: Boolean,
 		val hasLifetimeLicense: Boolean,
 		val hasRunningSubscription: Boolean,
-		val trialState: TrialState,
-		val trialExpirationText: String?
+		val trialState: TrialState
 	)
 
-	fun evaluateUiState(context: Context): LicenseUiState {
+	fun evaluateUiState(): LicenseUiState {
 		val trialState = evaluateTrialState()
 		val paidLicense = hasPaidLicense()
-		val lifetimeLicense = sharedPreferencesHandler.licenseToken().isNotEmpty()
-		val runningSubscription = sharedPreferencesHandler.hasRunningSubscription()
-		val expirationText = if (trialState.isActive || trialState.isExpired) {
-			context.getString(R.string.screen_license_check_trial_expiration, trialState.formattedExpirationDate)
-		} else null
 		return LicenseUiState(
 			hasWriteAccess = paidLicense || trialState.isActive,
 			hasPaidLicense = paidLicense,
-			hasLifetimeLicense = lifetimeLicense,
-			hasRunningSubscription = runningSubscription,
-			trialState = trialState,
-			trialExpirationText = expirationText
+			hasLifetimeLicense = sharedPreferencesHandler.licenseToken().isNotEmpty(),
+			hasRunningSubscription = sharedPreferencesHandler.hasRunningSubscription(),
+			trialState = trialState
 		)
 	}
 
@@ -109,10 +102,6 @@ class LicenseEnforcer @Inject constructor(private val sharedPreferencesHandler:
 			return true
 		}
 
-		if (FlavorConfig.isPremiumFlavor) {
-			return false
-		}
-
 		val intent = Intents.licenseCheckIntent()
 			.withLockedAction(action.name)
 			.build(activity as ContextHolder)

presentation/src/main/java/org/cryptomator/presentation/licensing/LicenseStateOrchestrator.kt

@@ -1,23 +1,31 @@
 package org.cryptomator.presentation.licensing
 
-import android.content.Context
 import org.cryptomator.util.FlavorConfig
 import org.cryptomator.util.SharedPreferencesHandler
 import java.util.function.Consumer
 
 class LicenseStateOrchestrator(
 	private val sharedPreferencesHandler: SharedPreferencesHandler,
 	private val licenseEnforcer: LicenseEnforcer,
-	private val contextProvider: () -> Context,
-	private val onStateChanged: (LicenseEnforcer.LicenseUiState) -> Unit,
+	private val callback: Callback,
 	private val priceLoader: (() -> Unit)? = null
 ) {
 
+	interface Callback {
+		fun onLicenseStateChanged(uiState: LicenseEnforcer.LicenseUiState)
+		fun onSubscriptionActivatedFirstTime() {}
+		fun onSubscriptionUpgradedToLifetime() {}
+	}
+
 	private val licenseChangeListener = Consumer<String> { _ -> updateState() }
+	private var wasSubscriptionOnly = false
 
 	fun onResume() {
+		wasSubscriptionOnly = isSubscriptionOnly(
+			hasRunningSubscription = sharedPreferencesHandler.hasRunningSubscription(),
+			hasLifetimeLicense = sharedPreferencesHandler.licenseToken().isNotEmpty()
+		)
 		sharedPreferencesHandler.addLicenseChangedListeners(licenseChangeListener)
-		updateState()
 		if (FlavorConfig.isFreemiumFlavor) {
 			priceLoader?.invoke()
 		}
@@ -28,6 +36,20 @@ class LicenseStateOrchestrator(
 	}
 
 	fun updateState() {
-		onStateChanged(licenseEnforcer.evaluateUiState(contextProvider()))
+		val uiState = licenseEnforcer.evaluateUiState()
+		val nowSubOnly = isSubscriptionOnly(uiState.hasRunningSubscription, uiState.hasLifetimeLicense)
+		val wasSubOnly = wasSubscriptionOnly
+		wasSubscriptionOnly = nowSubOnly
+
+		if (wasSubOnly && uiState.hasLifetimeLicense && uiState.hasRunningSubscription) {
+			callback.onSubscriptionUpgradedToLifetime()
+		}
+		if (!wasSubOnly && nowSubOnly) {
+			callback.onSubscriptionActivatedFirstTime()
+		}
+		callback.onLicenseStateChanged(uiState)
 	}
+
+	private fun isSubscriptionOnly(hasRunningSubscription: Boolean, hasLifetimeLicense: Boolean): Boolean =
+		hasRunningSubscription && !hasLifetimeLicense
 }

presentation/src/main/java/org/cryptomator/presentation/presenter/LicenseCheckPresenter.kt

@@ -2,8 +2,6 @@ package org.cryptomator.presentation.presenter
 
 import android.net.Uri
 import org.cryptomator.domain.usecases.DoLicenseCheckUseCase
-import org.cryptomator.domain.usecases.LicenseCheck
-import org.cryptomator.domain.usecases.NoOpResultHandler
 import org.cryptomator.presentation.exception.ExceptionHandlers
 import org.cryptomator.presentation.ui.activity.view.LicenseView
 import org.cryptomator.presentation.ui.dialog.AppIsObscuredInfoDialog
@@ -12,43 +10,15 @@ import javax.inject.Inject
 
 class LicenseCheckPresenter @Inject internal constructor(
 	exceptionHandlers: ExceptionHandlers,
-	private val doLicenseCheckUseCase: DoLicenseCheckUseCase,
-	private val sharedPreferencesHandler: SharedPreferencesHandler
+	doLicenseCheckUseCase: DoLicenseCheckUseCase,
+	sharedPreferencesHandler: SharedPreferencesHandler
 ) : Presenter<LicenseView>(exceptionHandlers) {
 
-	fun validate(data: Uri?) {
-		data?.let {
-			val license = it.fragment ?: it.lastPathSegment
-			if (license.isNullOrEmpty()) {
-				return
-			}
-			doLicenseCheckUseCase.withLicense(license).run(CheckLicenseStatusSubscriber())
-		}
-	}
+	private val validator = LicenseKeyValidator(doLicenseCheckUseCase, sharedPreferencesHandler, { view }, ::showError)
 
-	fun validateDialogAware(license: String?) {
-		doLicenseCheckUseCase.withLicense(license).run(CheckLicenseStatusSubscriber())
-	}
+	fun validate(data: Uri?) = validator.validate(data)
+	fun validateDialogAware(license: String?) = validator.validateDialogAware(license)
+	fun onFilteredTouchEventForSecurity() = view?.showDialog(AppIsObscuredInfoDialog.newInstance())
 
-	fun onFilteredTouchEventForSecurity() {
-		view?.showDialog(AppIsObscuredInfoDialog.newInstance())
-	}
-
-	private inner class CheckLicenseStatusSubscriber : NoOpResultHandler<LicenseCheck>() {
-		override fun onSuccess(licenseCheck: LicenseCheck) {
-			super.onSuccess(licenseCheck)
-			view?.closeDialog()
-			sharedPreferencesHandler.setMail(licenseCheck.mail())
-			view?.showConfirmationDialog(licenseCheck.mail())
-		}
-
-		override fun onError(t: Throwable) {
-			super.onError(t)
-			showError(t)
-		}
-	}
-
-	init {
-		unsubscribeOnDestroy(doLicenseCheckUseCase)
-	}
+	init { unsubscribeOnDestroy(doLicenseCheckUseCase) }
 }

presentation/src/main/java/org/cryptomator/presentation/presenter/LicenseKeyValidator.kt

@@ -0,0 +1,43 @@
+package org.cryptomator.presentation.presenter
+
+import android.net.Uri
+import org.cryptomator.domain.usecases.DoLicenseCheckUseCase
+import org.cryptomator.domain.usecases.LicenseCheck
+import org.cryptomator.domain.usecases.NoOpResultHandler
+import org.cryptomator.presentation.ui.activity.view.LicenseView
+import org.cryptomator.util.SharedPreferencesHandler
+
+internal class LicenseKeyValidator(
+	private val doLicenseCheckUseCase: DoLicenseCheckUseCase,
+	private val sharedPreferencesHandler: SharedPreferencesHandler,
+	private val getView: () -> LicenseView?
+) {
+	fun validate(data: Uri?, onLicenseExtracted: ((String) -> Unit)? = null) {
+		data?.let {
+			val license = it.fragment ?: it.lastPathSegment
+			if (license.isNullOrEmpty()) {
+				return
+			}
+			onLicenseExtracted?.invoke(license)
+			doLicenseCheckUseCase.withLicense(license).run(subscriber())
+		}
+	}
+
+	fun validateDialogAware(license: String?) {
+		doLicenseCheckUseCase.withLicense(license).run(subscriber())
+	}
+
+	private fun subscriber(): NoOpResultHandler<LicenseCheck> = object : NoOpResultHandler<LicenseCheck>() {
+		override fun onSuccess(licenseCheck: LicenseCheck) {
+			super.onSuccess(licenseCheck)
+			getView()?.closeDialog()
+			sharedPreferencesHandler.setMail(licenseCheck.mail())
+			getView()?.showConfirmationDialog(licenseCheck.mail())
+		}
+
+		override fun onError(t: Throwable) {
+			super.onError(t)
+			onError(t)
+		}
+	}
+}