Merge remote-tracking branch 'origin/feature/add_backgr_loc_option_hi…

…nt' into hotfix/v0.3.1

app/src/main/java/com/hypertrack/android/interactors/PermissionsInteractor.kt

@@ -10,11 +10,13 @@ import com.hypertrack.android.utils.MyApplication
 import com.judemanutd.autostarter.AutoStartPermissionHelper
 
 interface PermissionsInteractor {
-    fun checkPermissionState(activity: Activity): PermissionState
-    fun isWhitelistingGranted(): Boolean
+    fun checkPermissionsState(activity: Activity): PermissionsState
     fun requestWhitelisting(activity: Activity)
     fun requestRequiredPermissions(activity: Activity)
     fun requestBackgroundLocationPermission(activity: Activity)
+    fun isWhitelistingGranted(): Boolean
+    fun isBackgroundLocationGranted(): Boolean
+    fun isBasePermissionsGranted(): Boolean
 }
 
 class PermissionsInteractorImpl(
@@ -23,20 +25,11 @@ class PermissionsInteractorImpl(
 
     private val autostarter = AutoStartPermissionHelper.getInstance()
 
-    override fun checkPermissionState(activity: Activity): PermissionState {
-        return PermissionState(
-            activityTrackingGranted = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-                hasPermission(Manifest.permission.ACTIVITY_RECOGNITION)
-            } else {
-                true
-            },
+    override fun checkPermissionsState(activity: Activity): PermissionsState {
+        return PermissionsState(
+            activityTrackingGranted = isActivityGranted(),
             foregroundLocationGranted = hasPermission(Manifest.permission.ACCESS_FINE_LOCATION),
-            backgroundLocationGranted = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-                hasPermission(Manifest.permission.ACCESS_BACKGROUND_LOCATION)
-            } else {
-                true
-            },
-            whitelistingGranted = isWhitelistingGranted(),
+            backgroundLocationGranted = isBackgroundLocationGranted(),
         )
     }
 
@@ -45,6 +38,27 @@ class PermissionsInteractorImpl(
         return !applicable || (applicable && accountRepository.wasWhitelisted)
     }
 
+    override fun isBasePermissionsGranted(): Boolean {
+        return isActivityGranted() && hasPermission(Manifest.permission.ACCESS_FINE_LOCATION)
+    }
+
+    private fun isActivityGranted(): Boolean {
+        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            hasPermission(Manifest.permission.ACTIVITY_RECOGNITION)
+        } else {
+            true
+        }
+    }
+
+    override fun isBackgroundLocationGranted(): Boolean {
+        //we don't need ACCESS_BACKGROUND_LOCATION for Q
+        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+            hasPermission(Manifest.permission.ACCESS_BACKGROUND_LOCATION)
+        } else {
+            true
+        }
+    }
+
     override fun requestWhitelisting(activity: Activity) {
         val granted = AutoStartPermissionHelper.getInstance().getAutoStartPermission(activity)
 //        Log.d(PermissionRequestViewModel.TAG, "AutoStart granted value is $granted")
@@ -78,22 +92,20 @@ class PermissionsInteractorImpl(
 
 }
 
-class PermissionState(
+class PermissionsState(
     val activityTrackingGranted: Boolean,
     val foregroundLocationGranted: Boolean,
     val backgroundLocationGranted: Boolean,
-    val whitelistingGranted: Boolean
 ) {
-    fun getDestination(): PermissionDestination {
+    fun getNextPermissionRequest(): PermissionDestination {
         return when {
             !foregroundLocationGranted || !activityTrackingGranted -> PermissionDestination.FOREGROUND_AND_TRACKING
-            !whitelistingGranted -> PermissionDestination.WHITELISTING
-//            !backgroundLocationGranted -> PermissionDestination.BACKGROUND todo
+            !backgroundLocationGranted -> PermissionDestination.BACKGROUND
             else -> PermissionDestination.PASS
         }
     }
 }
 
 enum class PermissionDestination {
-    PASS, FOREGROUND_AND_TRACKING, BACKGROUND, WHITELISTING
+    PASS, FOREGROUND_AND_TRACKING, BACKGROUND
 }

app/src/main/java/com/hypertrack/android/ui/screens/background_permissions/BackgroundPermissionsFragment.kt

@@ -1,16 +1,24 @@
 package com.hypertrack.android.ui.screens.background_permissions
 
+import android.content.pm.PackageManager
+import android.graphics.Typeface
+import android.os.Build
 import android.os.Bundle
+import android.text.Spannable
+import android.text.SpannableStringBuilder
+import android.text.style.StyleSpan
 import android.view.View
 import androidx.fragment.app.viewModels
 import androidx.navigation.fragment.findNavController
 import com.hypertrack.android.ui.MainActivity
 import com.hypertrack.android.ui.base.BaseFragment
+import com.hypertrack.android.ui.common.hide
 import com.hypertrack.android.utils.MyApplication
 import com.hypertrack.logistics.android.github.R
 import kotlinx.android.synthetic.main.fragment_background_permission.*
 
-class BackgroundPermissionsFragment : BaseFragment<MainActivity>(R.layout.fragment_background_permission) {
+class BackgroundPermissionsFragment :
+    BaseFragment<MainActivity>(R.layout.fragment_background_permission) {
 
     private val vm: BackgroundPermissionsViewModel by viewModels {
         MyApplication.injector.provideViewModelFactory(MyApplication.context)
@@ -19,6 +27,22 @@ class BackgroundPermissionsFragment : BaseFragment<MainActivity>(R.layout.fragme
     override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
         super.onViewCreated(view, savedInstanceState)
 
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+            val hint = getString(R.string.background_location_permission_option_hint)
+            val sb =
+                SpannableStringBuilder(hint + "\n" + MyApplication.context.packageManager.backgroundPermissionOptionLabel)
+
+            sb.setSpan(
+                StyleSpan(Typeface.BOLD),
+                hint.length,
+                sb.length,
+                Spannable.SPAN_INCLUSIVE_INCLUSIVE
+            ); // make first 4 characters Bold
+            tvOptionHint.text = sb
+        } else {
+            tvOptionHint.hide()
+        }
+
         vm.destination.observe(viewLifecycleOwner, {
             findNavController().navigate(it)
         })
@@ -29,9 +53,9 @@ class BackgroundPermissionsFragment : BaseFragment<MainActivity>(R.layout.fragme
     }
 
     override fun onRequestPermissionsResult(
-            requestCode: Int,
-            permissions: Array<out String>,
-            grantResults: IntArray
+        requestCode: Int,
+        permissions: Array<out String>,
+        grantResults: IntArray
     ) {
         super.onRequestPermissionsResult(requestCode, permissions, grantResults)
         vm.onPermissionResult(mainActivity())

app/src/main/java/com/hypertrack/android/ui/screens/background_permissions/BackgroundPermissionsViewModel.kt

@@ -6,7 +6,6 @@ import androidx.lifecycle.ViewModel
 import androidx.navigation.NavDirections
 import com.hypertrack.android.interactors.PermissionDestination
 import com.hypertrack.android.interactors.PermissionsInteractor
-import com.hypertrack.android.ui.MainActivity
 
 class BackgroundPermissionsViewModel(
         private val permissionsInteractor: PermissionsInteractor
@@ -19,18 +18,15 @@ class BackgroundPermissionsViewModel(
     }
 
     fun onPermissionResult(activity: Activity) {
-        when (permissionsInteractor.checkPermissionState(activity).getDestination()) {
+        when (permissionsInteractor.checkPermissionsState(activity).getNextPermissionRequest()) {
             PermissionDestination.PASS -> {
-                destination.postValue(BackgroundPermissionsFragmentDirections.actionBackgroundPermissionsFragmentToPermissionRequestFragment())
+                destination.postValue(BackgroundPermissionsFragmentDirections.actionBackgroundPermissionsFragmentToVisitManagementFragment())
             }
             PermissionDestination.FOREGROUND_AND_TRACKING -> {
-                destination.postValue(BackgroundPermissionsFragmentDirections.actionBackgroundPermissionsFragmentToVisitManagementFragment())
+                destination.postValue(BackgroundPermissionsFragmentDirections.actionBackgroundPermissionsFragmentToPermissionRequestFragment())
             }
             PermissionDestination.BACKGROUND -> {
-                //todo should we let user proceed?
-            }
-            PermissionDestination.WHITELISTING -> {
-                destination.postValue(BackgroundPermissionsFragmentDirections.actionBackgroundPermissionsFragmentToPermissionRequestFragment())
+                destination.postValue(BackgroundPermissionsFragmentDirections.actionBackgroundPermissionsFragmentToVisitManagementFragment())
             }
         }
 

app/src/main/java/com/hypertrack/android/ui/screens/driver_id_input/DriverLoginViewModel.kt

@@ -24,16 +24,14 @@ class DriverLoginViewModel(
             // Log.d(TAG, "Proceeding with Driver Id $driverId")
             hyperTrackService.driverId = driverId
             driverRepository.driverId = driverId
-            when (permissionsInteractor.checkPermissionState(activity).getDestination()) {
+            when (permissionsInteractor.checkPermissionsState(activity)
+                .getNextPermissionRequest()) {
                 PermissionDestination.PASS -> {
                     destination.postValue(DriverIdInputFragmentDirections.actionDriverIdInputFragmentToVisitManagementFragment())
                 }
                 PermissionDestination.FOREGROUND_AND_TRACKING,
-                PermissionDestination.WHITELISTING -> {
-                    destination.postValue(DriverIdInputFragmentDirections.actionDriverIdInputFragmentToPermissionRequestFragment())
-                }
                 PermissionDestination.BACKGROUND -> {
-                    destination.postValue(DriverIdInputFragmentDirections.actionDriverIdInputFragmentToBackgroundPermissionsFragment())
+                    destination.postValue(DriverIdInputFragmentDirections.actionDriverIdInputFragmentToPermissionRequestFragment())
                 }
             }
 

app/src/main/java/com/hypertrack/android/ui/screens/permission_request/PermissionRequestFragment.kt

@@ -1,8 +1,6 @@
 package com.hypertrack.android.ui.screens.permission_request
 
-import android.content.Intent
 import android.os.Bundle
-import android.util.Log
 import android.view.View
 import androidx.fragment.app.viewModels
 import androidx.navigation.fragment.findNavController
@@ -25,17 +23,24 @@ class PermissionRequestFragment : ProgressDialogFragment(R.layout.fragment_permi
             findNavController().navigate(it)
         })
 
-        vm.whitelistingRequired.observe(viewLifecycleOwner) { visible ->
+        vm.showSkipButton.observe(viewLifecycleOwner) { visible ->
+            btnSkip.setGoneState(!visible)
+        }
+
+
+        vm.showWhitelistingButton.observe(viewLifecycleOwner) { visible ->
             listOf<View>(btnWhitelisting, whitelistingMessage)
                 .forEach { it.setGoneState(!visible) }
         }
 
         vm.showPermissionsButton.observe(viewLifecycleOwner) { show ->
-            listOf<View>(btnContinue, permissionRationalMessage)
-                    .forEach { it.setGoneState(!show) }
+            listOf<View>(btnAllow, permissionRationalMessage)
+                .forEach { it.setGoneState(!show) }
         }
 
-        btnContinue.setOnClickListener { vm.requestPermissions(mainActivity()) }
+        btnSkip.setOnClickListener { vm.onSkipClicked() }
+
+        btnAllow.setOnClickListener { vm.requestPermissions(mainActivity()) }
 
         btnWhitelisting.setOnClickListener {
             vm.requestWhitelisting(mainActivity())

app/src/main/java/com/hypertrack/android/ui/screens/permission_request/PermissionRequestViewModel.kt

@@ -1,7 +1,6 @@
 package com.hypertrack.android.ui.screens.permission_request
 
 import android.app.Activity
-import android.util.Log
 import androidx.lifecycle.MutableLiveData
 import androidx.lifecycle.ViewModel
 import androidx.navigation.NavDirections
@@ -14,36 +13,49 @@ class PermissionRequestViewModel(
     private val hyperTrackService: HyperTrackService
 ) : ViewModel() {
 
-    val whitelistingRequired = MutableLiveData<Boolean>(!permissionsInteractor.isWhitelistingGranted())
+    val showWhitelistingButton =
+        MutableLiveData<Boolean>(!permissionsInteractor.isWhitelistingGranted())
     val showPermissionsButton = MutableLiveData<Boolean>(true)
+    val showSkipButton = MutableLiveData<Boolean>(false)
 
     val destination = MutableLiveData<NavDirections>()
 
     fun requestWhitelisting(activity: Activity) {
         permissionsInteractor.requestWhitelisting(activity)
-        whitelistingRequired.postValue(!permissionsInteractor.isWhitelistingGranted())
+        showWhitelistingButton.postValue(!permissionsInteractor.isWhitelistingGranted())
     }
 
     private fun onPermissionResult(activity: Activity) {
-        when (permissionsInteractor.checkPermissionState(activity).getDestination()) {
-            PermissionDestination.PASS -> {
-                syncDeviceSettings()
-                destination.postValue(PermissionRequestFragmentDirections.actionPermissionRequestFragmentToVisitManagementFragment())
-            }
-            PermissionDestination.FOREGROUND_AND_TRACKING -> {
-                showPermissionsButton.postValue(true)
-            }
-            PermissionDestination.BACKGROUND -> {
-                syncDeviceSettings()
-                destination.postValue(PermissionRequestFragmentDirections.actionPermissionRequestFragmentToBackgroundPermissionsFragment())
-            }
-            PermissionDestination.WHITELISTING -> {
-                syncDeviceSettings()
-                showPermissionsButton.postValue(false)
+        permissionsInteractor.checkPermissionsState(activity).let {
+            when (permissionsInteractor.checkPermissionsState(activity)
+                .getNextPermissionRequest()) {
+                PermissionDestination.FOREGROUND_AND_TRACKING -> {
+                    showPermissionsButton.postValue(true)
+                }
+                PermissionDestination.BACKGROUND -> {
+                    syncDeviceSettings()
+                    destination.postValue(PermissionRequestFragmentDirections.actionPermissionRequestFragmentToBackgroundPermissionsFragment())
+                }
+                PermissionDestination.PASS -> {
+                    syncDeviceSettings()
+                    if (permissionsInteractor.isWhitelistingGranted()) {
+                        destination.postValue(PermissionRequestFragmentDirections.actionPermissionRequestFragmentToVisitManagementFragment())
+                    }
+                }
             }
+
+            showPermissionsButton.postValue(!permissionsInteractor.isBasePermissionsGranted())
+            showWhitelistingButton.postValue(!permissionsInteractor.isWhitelistingGranted())
+            showSkipButton.postValue(it.foregroundLocationGranted)
         }
+    }
 
-        whitelistingRequired.postValue(!permissionsInteractor.isWhitelistingGranted())
+    fun onSkipClicked() {
+        if (permissionsInteractor.isBackgroundLocationGranted()) {
+            destination.postValue(PermissionRequestFragmentDirections.actionGlobalVisitManagementFragment())
+        } else {
+            destination.postValue(PermissionRequestFragmentDirections.actionPermissionRequestFragmentToBackgroundPermissionsFragment())
+        }
     }
 
 

app/src/main/java/com/hypertrack/android/ui/screens/splash_screen/SplashScreenViewModel.kt

@@ -28,16 +28,14 @@ class SplashScreenViewModel(
         driverRepository.hasDriverId -> {
             // already logged in
             crashReportsProvider.setUserIdentifier(driverRepository.driverId)
-            when (permissionsInteractor.checkPermissionState(activity).getDestination()) {
+            when (permissionsInteractor.checkPermissionsState(activity)
+                .getNextPermissionRequest()) {
                 PermissionDestination.PASS -> {
                     destination.postValue(SplashScreenFragmentDirections.actionGlobalVisitManagementFragment())
                 }
                 PermissionDestination.FOREGROUND_AND_TRACKING,
-                PermissionDestination.WHITELISTING -> {
-                    destination.postValue(SplashScreenFragmentDirections.actionSplashScreenFragmentToPermissionRequestFragment())
-                }
                 PermissionDestination.BACKGROUND -> {
-                    destination.postValue(SplashScreenFragmentDirections.actionSplashScreenFragmentToBackgroundPermissionsFragment())
+                    destination.postValue(SplashScreenFragmentDirections.actionSplashScreenFragmentToPermissionRequestFragment())
                 }
             }
         }