Fix app crash on app launch with location permissions request

android/engine/src/main/java/org/smartregister/fhircore/engine/util/location/LocationUtils.kt

@@ -34,7 +34,6 @@ object LocationUtils {
 
   fun isLocationEnabled(context: Context): Boolean {
     val locationManager = context.getSystemService(Context.LOCATION_SERVICE) as LocationManager
-
     return locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER) ||
       locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER)
   }

android/engine/src/main/java/org/smartregister/fhircore/engine/util/location/PermissionUtils.kt

@@ -18,63 +18,48 @@
 
 import android.Manifest
 import android.content.Context
-import android.content.Intent
 import android.content.pm.PackageManager
-import androidx.activity.result.ActivityResultLauncher
-import androidx.activity.result.contract.ActivityResultContracts
-import androidx.appcompat.app.AppCompatActivity
 import androidx.core.content.ContextCompat
 
 object PermissionUtils {
 
-  fun checkPermissions(context: Context, permissions: List<String>): Boolean {
-    for (permission in permissions) {
-      if (
-        ContextCompat.checkSelfPermission(context, permission) != PackageManager.PERMISSION_GRANTED
-      ) {
-        return false
-      }
+  fun checkPermissions(context: Context, permissions: List<String>): Boolean =
+    permissions.none {
+      ContextCompat.checkSelfPermission(
+        context,
+        it,
+      ) != PackageManager.PERMISSION_GRANTED
     }
-    return true
-  }
 
   fun getLocationPermissionLauncher(
-    activity: AppCompatActivity,
+    permissions: Map<String, Boolean>,
     onFineLocationPermissionGranted: () -> Unit,
     onCoarseLocationPermissionGranted: () -> Unit,
     onLocationPermissionDenied: () -> Unit,
-  ): ActivityResultLauncher<Array<String>> {
-    return activity.registerForActivityResult(
-      ActivityResultContracts.RequestMultiplePermissions(),
-    ) { permissions ->
-      if (permissions[Manifest.permission.ACCESS_FINE_LOCATION] == true) {
+  ) {
+    when {
+      permissions[Manifest.permission.ACCESS_FINE_LOCATION] == true ->
         onFineLocationPermissionGranted()
-      } else if (permissions[Manifest.permission.ACCESS_COARSE_LOCATION] == true) {
+      permissions[Manifest.permission.ACCESS_COARSE_LOCATION] == true ->
         onCoarseLocationPermissionGranted()
-      } else {
-        onLocationPermissionDenied()
-      }
-    }
-  }
-
-  fun getStartActivityForResultLauncher(
-    activity: AppCompatActivity,
-    onResult: (resultCode: Int, data: Intent?) -> Unit,
-  ): ActivityResultLauncher<Intent> {
-    return activity.registerForActivityResult(
-      ActivityResultContracts.StartActivityForResult(),
-    ) { result ->
-      onResult(result.resultCode, result.data)
+      else -> onLocationPermissionDenied()
     }
   }
 
-  fun hasFineLocationPermissions(context: Context): Boolean {
-    return ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_FINE_LOCATION) ==
+  fun hasFineLocationPermissions(context: Context): Boolean =
+    ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_FINE_LOCATION) ==
       PackageManager.PERMISSION_GRANTED
-  }
 
-  fun hasCoarseLocationPermissions(context: Context): Boolean {
-    return ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_COARSE_LOCATION) ==
+  fun hasCoarseLocationPermissions(context: Context): Boolean =
+    ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_COARSE_LOCATION) ==
       PackageManager.PERMISSION_GRANTED
-  }
+
+  fun hasLocationPermissions(context: Context) =
+    checkPermissions(
+      context,
+      listOf(
+        Manifest.permission.ACCESS_COARSE_LOCATION,
+        Manifest.permission.ACCESS_FINE_LOCATION,
+      ),
+    )
 }

android/engine/src/main/res/values/strings.xml

@@ -150,6 +150,7 @@
     <string name="weeks">Week(s)</string>
     <string name="days">Days(s)</string>
     <string name="initializing">Initializing settings &#8230;</string>
+    <string name="initializing_application">Initializing application &#8230;</string>
     <string name="username_sample" translatable="false">e.g JohnDoe</string>
     <string name="percentage_progress" translatable="false">%1$d%%</string>
     <string name="error_occurred">Something went wrong…</string>

android/quest/src/main/java/org/smartregister/fhircore/quest/ui/main/AppMainActivity.kt

@@ -29,7 +29,6 @@
 import androidx.activity.result.contract.ActivityResultContracts
 import androidx.activity.viewModels
 import androidx.compose.material.ExperimentalMaterialApi
-import androidx.compose.runtime.getValue
 import androidx.lifecycle.lifecycleScope
 import androidx.navigation.findNavController
 import androidx.navigation.fragment.NavHostFragment
@@ -40,6 +39,7 @@
 import io.sentry.android.navigation.SentryNavigationListener
 import java.time.Instant
 import javax.inject.Inject
+import kotlinx.coroutines.async
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import org.hl7.fhir.r4.model.IdType
@@ -62,6 +62,8 @@
 import org.smartregister.fhircore.quest.event.AppEvent
 import org.smartregister.fhircore.quest.event.EventBus
 import org.smartregister.fhircore.quest.ui.questionnaire.QuestionnaireActivity
+import org.smartregister.fhircore.quest.ui.shared.ActivityOnResultType
+import org.smartregister.fhircore.quest.ui.shared.ON_RESULT_TYPE
 import org.smartregister.fhircore.quest.ui.shared.QuestionnaireHandler
 import org.smartregister.fhircore.quest.ui.shared.models.QuestionnaireSubmission
 import timber.log.Timber
@@ -81,13 +83,34 @@
   val appMainViewModel by viewModels<AppMainViewModel>()
   private val sentryNavListener =
     SentryNavigationListener(enableNavigationBreadcrumbs = true, enableNavigationTracing = true)
-  private lateinit var locationPermissionLauncher: ActivityResultLauncher<Array<String>>
-  private lateinit var activityResultLauncher: ActivityResultLauncher<Intent>
+
+  private val locationPermissionLauncher: ActivityResultLauncher<Array<String>> =
+    registerForActivityResult(ActivityResultContracts.RequestMultiplePermissions()) {
+      permissions: Map<String, Boolean> ->
+      PermissionUtils.getLocationPermissionLauncher(
+        permissions = permissions,
+        onFineLocationPermissionGranted = { fetchLocation() },
+        onCoarseLocationPermissionGranted = { fetchLocation() },
+        onLocationPermissionDenied = {
+          showToast(
+            getString(R.string.location_permissions_denied),
+            Toast.LENGTH_SHORT,
+          )
+        },
+      )
+    }
+
   private lateinit var fusedLocationClient: FusedLocationProviderClient
 
   override val startForResult =
-    registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { activityResult ->
-      if (activityResult.resultCode == Activity.RESULT_OK) {
+    registerForActivityResult(ActivityResultContracts.StartActivityForResult()) {
+      activityResult: ActivityResult ->
+      val onResultType = activityResult.data?.extras?.getString(ON_RESULT_TYPE)
+      if (
+        activityResult.resultCode == Activity.RESULT_OK &&
+          !onResultType.isNullOrBlank() &&
+          ActivityOnResultType.valueOf(onResultType) == ActivityOnResultType.QUESTIONNAIRE
+      ) {
         lifecycleScope.launch { onSubmitQuestionnaire(activityResult) }
       }
     }
@@ -127,6 +150,7 @@
         retrieveAppMainUiState()
         withContext(dispatcherProvider.io()) { schedulePeriodicJobs(this@AppMainActivity) }
       }
+
       setupLocationServices()
 
       findViewById<View>(R.id.mainScreenProgressBar).apply { visibility = View.GONE }
@@ -188,92 +212,61 @@
       fusedLocationClient = LocationServices.getFusedLocationProviderClient(this)
 
       if (!LocationUtils.isLocationEnabled(this)) {
-        openLocationServicesSettings()
+        showLocationSettingsDialog(
+          Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS).apply {
+            putExtra(ON_RESULT_TYPE, ActivityOnResultType.LOCATION.name)
+          },
+        )
       }
 
-      if (!hasLocationPermissions()) {
-        launchLocationPermissionsDialog()
+      if (!PermissionUtils.hasLocationPermissions(this)) {
+        locationPermissionLauncher.launch(
+          arrayOf(
+            Manifest.permission.ACCESS_FINE_LOCATION,
+            Manifest.permission.ACCESS_COARSE_LOCATION,
+          ),
+        )
       }
 
-      if (LocationUtils.isLocationEnabled(this) && hasLocationPermissions()) {
+      if (LocationUtils.isLocationEnabled(this) && PermissionUtils.hasLocationPermissions(this)) {
         fetchLocation()
       }
     }
   }
 
-  fun hasLocationPermissions(): Boolean {
-    return PermissionUtils.checkPermissions(
-      this,
-      listOf(
-        Manifest.permission.ACCESS_COARSE_LOCATION,
-        Manifest.permission.ACCESS_FINE_LOCATION,
-      ),
-    )
-  }
-
-  private fun openLocationServicesSettings() {
-    activityResultLauncher =
-      PermissionUtils.getStartActivityForResultLauncher(this) { resultCode, _ ->
-        if (resultCode == RESULT_OK || hasLocationPermissions()) {
-          Timber.d("Location or permissions successfully enabled")
-        }
-      }
-
-    val intent = Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS)
-    showLocationSettingsDialog(intent)
-  }
-
   private fun showLocationSettingsDialog(intent: Intent) {
     AlertDialog.Builder(this)
       .setMessage(getString(R.string.location_services_disabled))
       .setCancelable(true)
-      .setPositiveButton(getString(R.string.yes)) { _, _ -> activityResultLauncher.launch(intent) }
+      .setPositiveButton(getString(R.string.yes)) { _, _ -> startForResult.launch(intent) }
       .setNegativeButton(getString(R.string.no)) { dialog, _ -> dialog.cancel() }
       .show()
   }
 
-  fun launchLocationPermissionsDialog() {
-    locationPermissionLauncher =
-      PermissionUtils.getLocationPermissionLauncher(
-        this,
-        onFineLocationPermissionGranted = { fetchLocation() },
-        onCoarseLocationPermissionGranted = { fetchLocation() },
-        onLocationPermissionDenied = {
-          Toast.makeText(
-              this,
-              getString(R.string.location_permissions_denied),
-              Toast.LENGTH_SHORT,
-            )
-            .show()
-        },
-      )
-
-    locationPermissionLauncher.launch(
-      arrayOf(
-        Manifest.permission.ACCESS_FINE_LOCATION,
-        Manifest.permission.ACCESS_COARSE_LOCATION,
-      ),
-    )
-  }
-
   private fun fetchLocation() {
     val context = this
     lifecycleScope.launch {
       val retrievedLocation =
-        if (PermissionUtils.hasFineLocationPermissions(context)) {
-          LocationUtils.getAccurateLocation(fusedLocationClient)
-        } else if (PermissionUtils.hasCoarseLocationPermissions(context)) {
-          LocationUtils.getApproximateLocation(fusedLocationClient)
-        } else {
-          null
-        }
-      retrievedLocation?.let {
-        protoDataStore.writeLocationCoordinates(
-          LocationCoordinate(it.latitude, it.longitude, it.altitude, Instant.now()),
-        )
-      }
+        async(dispatcherProvider.io()) {
+            when {
+              PermissionUtils.hasFineLocationPermissions(context) ->
+                LocationUtils.getAccurateLocation(fusedLocationClient)
+              PermissionUtils.hasCoarseLocationPermissions(context) ->
+                LocationUtils.getApproximateLocation(fusedLocationClient)
+              else -> null
+            }
+          }
+          .await()
+          ?.also {
+            protoDataStore.writeLocationCoordinates(
+              LocationCoordinate(it.latitude, it.longitude, it.altitude, Instant.now()),
+            )
+          }
+
       if (retrievedLocation == null) {
-        this@AppMainActivity.showToast("Failed to get GPS location", Toast.LENGTH_LONG)
+        withContext(dispatcherProvider.main()) {
+          showToast(getString(R.string.failed_to_get_gps_location), Toast.LENGTH_LONG)
+        }
       }
     }
   }