merge_to_master

app/src/main/java/jp/co/soramitsu/app/root/domain/RootInteractor.kt

@@ -1,5 +1,6 @@
 package jp.co.soramitsu.app.root.domain
 
+import jp.co.soramitsu.common.domain.model.toDomain
 import jp.co.soramitsu.core.updater.UpdateSystem
 import jp.co.soramitsu.core.updater.Updater
 import jp.co.soramitsu.feature_wallet_api.domain.interfaces.WalletRepository
@@ -23,4 +24,6 @@ class RootInteractor(
             walletRepository.updatePhishingAddresses()
         }
     }
+
+    suspend fun getRemoteConfig() = walletRepository.getRemoteConfig().toDomain()
 }

app/src/main/java/jp/co/soramitsu/app/root/navigation/Navigator.kt

@@ -579,6 +579,18 @@ class Navigator :
         navController?.navigate(R.id.open_pincode_check, extras)
     }
 
+    override fun openPincodeCheck() {
+        val action = PinCodeAction.Check(null, ToolbarConfiguration())
+        val bundle = PincodeFragment.getPinCodeBundle(action)
+        navController?.navigate(R.id.open_pincode_check, bundle)
+    }
+
+    override fun openNavGraph() {
+        val action = PinCodeAction.Check(null, ToolbarConfiguration())
+        val bundle = PincodeFragment.getPinCodeBundle(action)
+        navController?.navigate(R.id.root_nav_graph, bundle)
+    }
+
     private fun buildCreatePinBundle(): Bundle {
         val delayedNavigation = NavComponentDelayedNavigation(R.id.action_open_main)
         val action = PinCodeAction.Create(delayedNavigation)

app/src/main/java/jp/co/soramitsu/app/root/presentation/RootActivity.kt

@@ -1,25 +1,44 @@
 package jp.co.soramitsu.app.root.presentation
 
+import android.annotation.SuppressLint
+import android.content.ActivityNotFoundException
 import android.content.Intent
+import android.net.Uri
 import android.os.Bundle
+import android.view.View
+import android.view.animation.Animation
+import android.view.animation.TranslateAnimation
+import androidx.core.view.WindowInsetsCompat
+import androidx.core.view.isVisible
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleObserver
+import androidx.lifecycle.OnLifecycleEvent
+import androidx.lifecycle.ProcessLifecycleOwner
 import androidx.navigation.NavController
 import androidx.navigation.fragment.NavHostFragment
+import javax.inject.Inject
 import jp.co.soramitsu.app.R
 import jp.co.soramitsu.app.root.di.RootApi
 import jp.co.soramitsu.app.root.di.RootComponent
 import jp.co.soramitsu.app.root.navigation.Navigator
+import jp.co.soramitsu.common.PLAY_MARKET_APP_URI
+import jp.co.soramitsu.common.PLAY_MARKET_BROWSER_URI
 import jp.co.soramitsu.common.base.BaseActivity
 import jp.co.soramitsu.common.di.FeatureUtils
 import jp.co.soramitsu.common.utils.EventObserver
-import jp.co.soramitsu.common.utils.setVisible
 import jp.co.soramitsu.common.utils.showToast
 import jp.co.soramitsu.common.utils.updatePadding
+import jp.co.soramitsu.common.view.bottomSheet.AlertBottomSheet
 import jp.co.soramitsu.splash.presentation.SplashBackgroundHolder
 import kotlinx.android.synthetic.main.activity_root.mainView
 import kotlinx.android.synthetic.main.activity_root.rootNetworkBar
-import javax.inject.Inject
 
-class RootActivity : BaseActivity<RootViewModel>(), SplashBackgroundHolder {
+class RootActivity : BaseActivity<RootViewModel>(), SplashBackgroundHolder, LifecycleObserver {
+
+    companion object {
+        private const val ANIM_DURATION = 150L
+        private const val ANIM_START_POSITION = 100f
+    }
 
     @Inject
     lateinit var navigator: Navigator
@@ -41,11 +60,12 @@ class RootActivity : BaseActivity<RootViewModel>(), SplashBackgroundHolder {
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
+        ProcessLifecycleOwner.get().lifecycle.addObserver(this)
 
         navigator.attach(navController, this)
 
         rootNetworkBar.setOnApplyWindowInsetsListener { view, insets ->
-            view.updatePadding(top = insets.systemWindowInsetTop)
+            view.updatePadding(top = WindowInsetsCompat.toWindowInsetsCompat(insets, view).getInsets(WindowInsetsCompat.Type.systemBars()).top)
 
             insets
         }
@@ -71,24 +91,30 @@ class RootActivity : BaseActivity<RootViewModel>(), SplashBackgroundHolder {
         processIntent(intent)
     }
 
+    @SuppressLint("ClickableViewAccessibility")
     override fun initViews() {
+        findViewById<View>(R.id.root_touch_interceptor).setOnTouchListener { v, event ->
+            viewModel.onUserInteractedWithApp()
+            false
+        }
     }
 
-    override fun onStop() {
-        super.onStop()
-
+    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
+    fun onMoveToBackground() {
         viewModel.noticeInBackground()
     }
 
-    override fun onStart() {
-        super.onStart()
-
+    @OnLifecycleEvent(Lifecycle.Event.ON_START)
+    fun onMoveToForeground() {
         viewModel.noticeInForeground()
     }
 
     override fun subscribe(viewModel: RootViewModel) {
         viewModel.showConnectingBarLiveData.observe(this) { show ->
-            rootNetworkBar.setVisible(show)
+            when {
+                show -> showBadConnectionView()
+                else -> hideBadConnectionView()
+            }
         }
 
         viewModel.messageLiveData.observe(
@@ -97,6 +123,83 @@ class RootActivity : BaseActivity<RootViewModel>(), SplashBackgroundHolder {
                 showToast(it)
             }
         )
+
+        viewModel.showUnsupportedAppVersionAlert.observe(
+            this,
+            EventObserver {
+                showUnsupportedAppVersionAlert()
+            }
+        )
+        viewModel.openPlayMarket.observe(
+            this,
+            EventObserver {
+                openPlayMarket()
+            }
+        )
+        viewModel.closeApp.observe(
+            this,
+            EventObserver {
+                finish()
+            }
+        )
+    }
+
+    private fun showUnsupportedAppVersionAlert() {
+        AlertBottomSheet.Builder(this)
+            .setTitle(jp.co.soramitsu.feature_wallet_impl.R.string.common_update_needed)
+            .setMessage(jp.co.soramitsu.feature_wallet_impl.R.string.unsupported_app_version_alert_message)
+            .setButtonText(jp.co.soramitsu.feature_wallet_impl.R.string.common_update)
+            .setCancelable(false)
+            .callback { viewModel.updateAppClicked() }
+            .build()
+            .show()
+    }
+
+    private fun openPlayMarket() {
+        try {
+            startActivity(Intent(Intent.ACTION_VIEW, Uri.parse(PLAY_MARKET_APP_URI)))
+        } catch (e: ActivityNotFoundException) {
+            startActivity(Intent(Intent.ACTION_VIEW, Uri.parse(PLAY_MARKET_BROWSER_URI)))
+        }
+    }
+
+    private fun showBadConnectionView() {
+        if (rootNetworkBar.isVisible) {
+            return
+        }
+
+        val errorColor = getColor(R.color.colorAccent)
+        rootNetworkBar.setText(R.string.network_status_connecting)
+        rootNetworkBar.setBackgroundColor(errorColor)
+        val animation = TranslateAnimation(0f, 0f, -ANIM_START_POSITION, 0f)
+        animation.duration = ANIM_DURATION
+        rootNetworkBar.startAnimation(animation)
+        rootNetworkBar.isVisible = true
+    }
+
+    private fun hideBadConnectionView() {
+        if (!rootNetworkBar.isVisible) {
+            return
+        }
+
+        val successColor = getColor(R.color.green)
+        rootNetworkBar.setText(R.string.network_status_connected)
+        rootNetworkBar.setBackgroundColor(successColor)
+        val animation = TranslateAnimation(0f, 0f, 0f, -ANIM_START_POSITION)
+        animation.duration = ANIM_DURATION
+        animation.startOffset = 500
+        animation.setAnimationListener(object : Animation.AnimationListener {
+            override fun onAnimationRepeat(p0: Animation?) {
+            }
+
+            override fun onAnimationEnd(p0: Animation?) {
+                rootNetworkBar.isVisible = false
+            }
+
+            override fun onAnimationStart(p0: Animation?) {
+            }
+        })
+        rootNetworkBar.startAnimation(animation)
     }
 
     override fun removeSplashBackground() {

app/src/main/java/jp/co/soramitsu/app/root/presentation/RootRouter.kt

@@ -2,4 +2,8 @@ package jp.co.soramitsu.app.root.presentation
 
 interface RootRouter {
     fun returnToWallet()
+
+    fun openPincodeCheck()
+
+    fun openNavGraph()
 }

app/src/main/java/jp/co/soramitsu/app/root/presentation/RootViewModel.kt

@@ -1,37 +1,71 @@
 package jp.co.soramitsu.app.root.presentation
 
+import androidx.lifecycle.LiveData
+import androidx.lifecycle.MutableLiveData
 import androidx.lifecycle.viewModelScope
 import jp.co.soramitsu.app.R
 import jp.co.soramitsu.app.root.domain.RootInteractor
 import jp.co.soramitsu.common.base.BaseViewModel
 import jp.co.soramitsu.common.mixin.api.NetworkStateMixin
 import jp.co.soramitsu.common.mixin.api.NetworkStateUi
 import jp.co.soramitsu.common.resources.ResourceManager
+import jp.co.soramitsu.common.utils.Event
 import jp.co.soramitsu.core.updater.Updater
 import jp.co.soramitsu.runtime.multiNetwork.connection.ChainConnection.ExternalRequirement
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.launch
+import java.util.Date
+import java.util.Timer
+import java.util.TimerTask
+import kotlin.concurrent.timerTask
+import kotlin.time.DurationUnit
+import kotlin.time.toDuration
 
 class RootViewModel(
     private val interactor: RootInteractor,
     private val rootRouter: RootRouter,
     private val externalConnectionRequirementFlow: MutableStateFlow<ExternalRequirement>,
     private val resourceManager: ResourceManager,
-    private val networkStateMixin: NetworkStateMixin
+    private val networkStateMixin: NetworkStateMixin,
 ) : BaseViewModel(), NetworkStateUi by networkStateMixin {
+    companion object {
+        private const val IDLE_MINUTES: Long = 20
+    }
 
     private var willBeClearedForLanguageChange = false
+    private var timeInBackground: Date? = null
+
+    private val _showUnsupportedAppVersionAlert = MutableLiveData<Event<Unit>>()
+    val showUnsupportedAppVersionAlert: LiveData<Event<Unit>> = _showUnsupportedAppVersionAlert
+
+    private val _openPlayMarket = MutableLiveData<Event<Unit>>()
+    val openPlayMarket: LiveData<Event<Unit>> = _openPlayMarket
+
+    private val _closeApp = MutableLiveData<Event<Unit>>()
+    val closeApp: LiveData<Event<Unit>> = _closeApp
+
+    private var timer = Timer()
+    private var timerTask: TimerTask? = null
 
     init {
+        checkAppVersion()
         interactor.runBalancesUpdate()
             .onEach { handleUpdatesSideEffect(it) }
             .launchIn(this)
 
         updatePhishingAddresses()
     }
 
+    private fun checkAppVersion() = viewModelScope.launch {
+        val appConfig = interactor.getRemoteConfig()
+        if (appConfig.isCurrentVersionSupported.not()) {
+            _showUnsupportedAppVersionAlert.value = Event(Unit)
+        }
+    }
+
     private fun handleUpdatesSideEffect(sideEffect: Updater.SideEffect) {
         // pass
         hashCode()
@@ -55,12 +89,24 @@ class RootViewModel(
         if (!willBeClearedForLanguageChange) {
             externalConnectionRequirementFlow.value = ExternalRequirement.STOPPED
         }
+        timeInBackground = Date()
     }
 
     fun noticeInForeground() {
         if (externalConnectionRequirementFlow.value == ExternalRequirement.STOPPED) {
             externalConnectionRequirementFlow.value = ExternalRequirement.ALLOWED
         }
+        timeInBackground?.let {
+            if (idleTimePassedFrom(it)) {
+                timerTask?.cancel()
+                rootRouter.openPincodeCheck()
+            }
+        }
+        timeInBackground = null
+    }
+
+    private fun idleTimePassedFrom(timeInBackground: Date): Boolean {
+        return Date().time - timeInBackground.time >= IDLE_MINUTES.toDuration(DurationUnit.MINUTES).inWholeMilliseconds
     }
 
     fun noticeLanguageLanguage() {
@@ -80,4 +126,22 @@ class RootViewModel(
             showMessage(resourceManager.getString(R.string.buy_completed))
         }
     }
+
+    fun updateAppClicked() {
+        _openPlayMarket.value = Event(Unit)
+        _closeApp.value = Event(Unit)
+    }
+
+    fun onUserInteractedWithApp() {
+        timerTask?.cancel()
+        timerTask = createTimerTask()
+        timer.schedule(timerTask, IDLE_MINUTES.toDuration(DurationUnit.MINUTES).inWholeMilliseconds)
+    }
+
+    private fun createTimerTask() = timerTask {
+        viewModelScope.launch(Dispatchers.Main) {
+            timeInBackground = null
+            rootRouter.openNavGraph()
+        }
+    }
 }

app/src/main/java/jp/co/soramitsu/app/root/presentation/di/RootActivityModule.kt

@@ -35,14 +35,14 @@ class RootActivityModule {
         rootRouter: RootRouter,
         resourceManager: ResourceManager,
         networkStateMixin: NetworkStateMixin,
-        externalRequirementsFlow: MutableStateFlow<ChainConnection.ExternalRequirement>
+        externalRequirementsFlow: MutableStateFlow<ChainConnection.ExternalRequirement>,
     ): ViewModel {
         return RootViewModel(
             interactor,
             rootRouter,
             externalRequirementsFlow,
             resourceManager,
-            networkStateMixin
+            networkStateMixin,
         )
     }
 

app/src/main/java/jp/co/soramitsu/app/root/presentation/main/MainViewModel.kt

@@ -6,7 +6,7 @@ import jp.co.soramitsu.runtime.multiNetwork.connection.ChainConnection
 import kotlinx.coroutines.flow.MutableStateFlow
 
 class MainViewModel(
-    interactor: RootInteractor,
+    private val interactor: RootInteractor,
     externalRequirements: MutableStateFlow<ChainConnection.ExternalRequirement>,
 ) : BaseViewModel() {
 

app/src/main/java/jp/co/soramitsu/app/root/presentation/main/di/MainFragmentModule.kt

@@ -25,7 +25,7 @@ class MainFragmentModule {
     @ViewModelKey(MainViewModel::class)
     fun provideViewModel(
         externalRequirementsFlow: MutableStateFlow<ChainConnection.ExternalRequirement>,
-        interactor: RootInteractor
+        interactor: RootInteractor,
     ): ViewModel {
         return MainViewModel(interactor, externalRequirementsFlow)
     }