Re-introduce location permissions convenience methods

MIGRATION.md

@@ -1,4 +1,6 @@
 # Migration guides
+## 3.11.x to 3.12.x
+-`RadarReceiver` interface has been changed to include `onLocationPermissionStatusUpdated` method.
 
 ## 3.12.x to 3.13.x
 -  The `Radar.trackVerified()` method now returns `token: RadarVerifiedLocationToken`, which includes `user`, `events`, `token,`, `expiresAt`, `expiresIn`, and `passed`. The `Radar.trackVerifiedToken()` method has been removed, since `Radar.trackVerified()` now returns a signed JWT.

example/src/main/java/io/radar/example/MainActivity.kt

@@ -44,19 +44,11 @@ class MainActivity : AppCompatActivity() {
     }
 
     private fun requestForegroundPermission() {
-        if (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
-            ActivityCompat.requestPermissions(this, arrayOf(Manifest.permission.ACCESS_FINE_LOCATION), 1)
-        } else {
-            Log.v("example", "Foreground location permission already granted")
-        }
+        Radar.requestForegroundLocationPermission()
     }
 
     private fun requestBackgroundPermission() {
-        if (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_BACKGROUND_LOCATION) != PackageManager.PERMISSION_GRANTED) {
-            ActivityCompat.requestPermissions(this, arrayOf(Manifest.permission.ACCESS_BACKGROUND_LOCATION), 2)
-        } else {
-            Log.v("example", "Background location permission already granted")
-        }
+        Radar.requestBackgroundLocationPermission()
     }
 
      private fun requestActivityRecognitionPermission() {

example/src/main/java/io/radar/example/MyRadarReceiver.kt

@@ -11,6 +11,8 @@ import io.radar.sdk.Radar
 import io.radar.sdk.RadarReceiver
 import io.radar.sdk.model.RadarEvent
 import io.radar.sdk.model.RadarUser
+import io.radar.sdk.model.RadarLocationPermissionStatus
+import kotlin.random.Random
 
 class MyRadarReceiver : RadarReceiver() {
 
@@ -68,4 +70,13 @@ class MyRadarReceiver : RadarReceiver() {
         notify(context, message)
     }
 
+    override fun onLocationPermissionStatusUpdated(
+        context: Context,
+        status: RadarLocationPermissionStatus
+    ) {
+        val statusString = RadarLocationPermissionStatus.stringForLocationPermissionState(status.status)
+        val body = "Location permission status updated: ${statusString}"
+        notify(context, body)
+    }
+
 }

sdk/build.gradle

@@ -10,7 +10,7 @@ apply plugin: "org.jetbrains.dokka"
 apply plugin: 'io.radar.mvnpublish'
 
 ext {
-    radarVersion = '3.18.0'
+    radarVersion = '3.19.0-beta.2'
 }
 
 String buildNumber = ".${System.currentTimeMillis()}"

sdk/src/main/java/io/radar/sdk/Radar.kt

@@ -471,6 +471,21 @@ object Radar {
     private lateinit var replayBuffer: RadarReplayBuffer
     internal lateinit var batteryManager: RadarBatteryManager
     private lateinit var verificationManager: RadarVerificationManager
+    private lateinit var locationPermissionManager: RadarLocationPermissionManager
+
+    /**
+     * Used by React Native module to setup the activity.
+     */
+    @JvmStatic
+    fun onActivityCreate(activity: Activity, context: Context?) {
+        this.context = context ?: activity;
+        this.activity = activity;
+        val application = this.context as? Application
+        if (!this::locationPermissionManager.isInitialized) {
+            this.locationPermissionManager = RadarLocationPermissionManager(this.context, this.activity)
+            application?.registerActivityLifecycleCallbacks(locationPermissionManager)
+        }
+    }
 
     /**
      * Initializes the Radar SDK. Call this method from the main thread in `Application.onCreate()` before calling any other Radar methods.
@@ -573,6 +588,11 @@ object Radar {
         }
         application?.registerActivityLifecycleCallbacks(RadarActivityLifecycleCallbacks(fraud))
 
+        if (!this::locationPermissionManager.isInitialized) {
+            this.locationPermissionManager = RadarLocationPermissionManager(this.context, this.activity)
+            application?.registerActivityLifecycleCallbacks(locationPermissionManager)
+        }
+
         val sdkConfiguration = RadarSettings.getSdkConfiguration(this.context)
         if (sdkConfiguration.usePersistence) {
             Radar.loadReplayBufferFromSharedPreferences()
@@ -3178,6 +3198,39 @@ object Radar {
             })
         }
     }
+    /**
+     * Requests foreground location permissions.
+     */
+    @JvmStatic
+    fun requestForegroundLocationPermission() {
+        locationPermissionManager.requestForegroundLocationPermission()
+    }
+
+    /**
+     * Requests background location permissions.
+     */
+    @JvmStatic
+    fun requestBackgroundLocationPermission() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            locationPermissionManager.requestBackgroundLocationPermission()
+        }
+    }
+
+    /**
+     * @return A RadarPermissionStatus object with the current location permissions status.
+     */
+    @JvmStatic
+    fun getLocationPermissionStatus():RadarLocationPermissionStatus {
+        return locationPermissionManager.getLocationPermissionStatus()
+    }
+
+    /**
+     * Directs the user to the app settings to enable location permissions.
+     */
+    @JvmStatic
+    fun openAppSettings() {
+        locationPermissionManager.openAppSettings()
+    }
 
     /**
      * Sets the log level for debug logs.
@@ -3528,6 +3581,11 @@ object Radar {
         logger.i("📍️ Radar token updated | passed = ${token.passed}; expiresAt = ${token.expiresAt}; expiresIn = ${token.expiresIn}; token = ${token.token}")
     }
 
+    internal fun sendLocationPermissionStatus(status: RadarLocationPermissionStatus) {
+        receiver?.onLocationPermissionStatusUpdated(context, status)
+
+        logger.i("📍️ Radar location permission updated | status = $status")
+    }
 
     internal fun setLogPersistenceFeatureFlag(enabled: Boolean) {
         this.logBuffer.setPersistentLogFeatureFlag(enabled)

sdk/src/main/java/io/radar/sdk/RadarLocationPermissionManager.kt

@@ -0,0 +1,155 @@
+package io.radar.sdk
+
+import android.Manifest
+import android.app.Activity
+import android.app.Application
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.net.Uri
+import android.os.Build
+import android.os.Bundle
+import android.provider.Settings
+import android.util.Log
+import androidx.activity.ComponentActivity
+import androidx.activity.result.ActivityResultLauncher
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.annotation.RequiresApi
+import androidx.core.app.ActivityCompat
+import io.radar.sdk.model.RadarLocationPermissionStatus
+
+class RadarLocationPermissionManager(private val context: Context, private val activity: Activity?): Application.ActivityLifecycleCallbacks {
+
+    private var danglingSettingsPermissionRequest = false
+    private var danglingForegroundPermissionRequest = false
+    private var danglingBackgroundPermissionRequest = false
+
+    private lateinit var requestForegroundLocationPermissionLauncher: ActivityResultLauncher<String>
+
+    private lateinit var requestBackgroundLocationPermissionLauncher: ActivityResultLauncher<String>
+
+    init {
+        if (activity is ComponentActivity) {
+            Log.d("LocPermissionManager", "Activity is a ComponentActivity")
+            requestForegroundLocationPermissionLauncher = activity.registerForActivityResult(
+                ActivityResultContracts.RequestPermission()
+            ) { isGranted: Boolean ->
+                if (!isGranted) {
+                    RadarLocationPermissionStatus.savePreviouslyDeniedForeground(context,true)
+                }
+                Radar.sendLocationPermissionStatus(RadarLocationPermissionStatus.initWithStatus(context, activity))
+                // TODO: sync the user's permissions status here
+            }
+
+            requestBackgroundLocationPermissionLauncher = activity.registerForActivityResult(
+                ActivityResultContracts.RequestPermission()
+            ) { isGranted: Boolean ->
+                if (!isGranted) {
+                    RadarLocationPermissionStatus.savePreviouslyDeniedBackground(context, true)
+                }
+                Radar.sendLocationPermissionStatus(RadarLocationPermissionStatus.initWithStatus(context, activity))
+                // TODO: sync the user's permissions status here
+            }
+        } else {
+            Log.d("LocPermissionManager", "Activity is not a ComponentActivity")
+        }
+    }
+
+    @RequiresApi(Build.VERSION_CODES.Q)
+    fun requestBackgroundLocationPermission() {
+        Log.d("LocPermissionManager", "requesting background")
+        if (activity is ComponentActivity) {
+            Log.d("LocPermissionManager", "calling activity")
+            context.getSharedPreferences("RadarSDK", Context.MODE_PRIVATE).getString("x_platform_sdk_type",null)?.let {
+                if (it != null) {
+                    Log.d("LocPermissionManager", "x platform side channel")
+                    danglingBackgroundPermissionRequest = true
+                }
+            }
+            requestBackgroundLocationPermissionLauncher.launch(Manifest.permission.ACCESS_BACKGROUND_LOCATION)
+            // TODO: sync the user's location permissions action with the their permissions status here
+        }
+    }
+
+    fun requestForegroundLocationPermission() {
+        Log.d("LocPermissionManager", "requesting foreground")
+        if (activity is ComponentActivity) {
+            Log.d("LocPermissionManager", "calling activity")
+            context.getSharedPreferences("RadarSDK", Context.MODE_PRIVATE).getString("x_platform_sdk_type",null)?.let {
+                if (it != null) {
+                    Log.d("LocPermissionManager", "x platform side channel")
+                    danglingForegroundPermissionRequest = true
+                }
+            }
+            Radar.sendLocationPermissionStatus(RadarLocationPermissionStatus.initWithStatus(context,activity,true))
+            requestForegroundLocationPermissionLauncher.launch(Manifest.permission.ACCESS_FINE_LOCATION)
+
+            // TODO: sync the user's location permissions action with the their permissions status here
+        }
+    }
+
+    fun openAppSettings() {
+        danglingSettingsPermissionRequest = true
+        val intent = Intent().apply {
+            action = Settings.ACTION_APPLICATION_DETAILS_SETTINGS
+            val uri = Uri.fromParts("package", context.packageName, null)
+            data = uri
+            flags = Intent.FLAG_ACTIVITY_NEW_TASK
+        }
+        context.startActivity(intent)
+    }
+
+    fun getLocationPermissionStatus(): RadarLocationPermissionStatus {
+        if (activity is ComponentActivity) {
+            return RadarLocationPermissionStatus.initWithStatus(context, activity)
+        }
+        return RadarLocationPermissionStatus()
+    }
+
+    override fun onActivityPaused(activity: Activity) {
+        // do nothing
+    }
+
+    override fun onActivityStopped(p0: Activity) {
+        // do nothing
+    }
+
+    override fun onActivitySaveInstanceState(p0: Activity, p1: Bundle) {
+        // do nothing
+    }
+
+    override fun onActivityDestroyed(p0: Activity) {
+        // do nothing
+    }
+
+    override fun onActivityCreated(p0: Activity, p1: Bundle?) {
+        // do nothing
+    }
+
+    override fun onActivityStarted(p0: Activity) {
+        // do nothing
+    }
+
+    override fun onActivityResumed(activity: Activity) {
+        if (danglingSettingsPermissionRequest) {
+            Radar.sendLocationPermissionStatus(RadarLocationPermissionStatus.initWithStatus(context,activity))
+            // TODO: sync the user's location permissions action with the their permissions status here
+        }
+        if (danglingForegroundPermissionRequest) {
+            if (ActivityCompat.checkSelfPermission(context, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED){
+                RadarLocationPermissionStatus.savePreviouslyDeniedForeground(context,true)
+            }
+            Radar.sendLocationPermissionStatus(RadarLocationPermissionStatus.initWithStatus(context,activity))
+        }
+        if (danglingBackgroundPermissionRequest) {
+            if (ActivityCompat.checkSelfPermission(context, Manifest.permission.ACCESS_BACKGROUND_LOCATION) != PackageManager.PERMISSION_GRANTED){
+                RadarLocationPermissionStatus.savePreviouslyDeniedBackground(context,true)
+            }
+            Radar.sendLocationPermissionStatus(RadarLocationPermissionStatus.initWithStatus(context,activity))
+        }
+        danglingSettingsPermissionRequest = false
+        danglingBackgroundPermissionRequest = false
+        danglingForegroundPermissionRequest = false
+    }
+
+}

sdk/src/main/java/io/radar/sdk/RadarReceiver.kt

@@ -4,6 +4,7 @@ import android.content.Context
 import android.location.Location
 import io.radar.sdk.Radar.RadarStatus
 import io.radar.sdk.model.RadarEvent
+import io.radar.sdk.model.RadarLocationPermissionStatus
 import io.radar.sdk.model.RadarUser
 
 /**
@@ -56,5 +57,12 @@ abstract class RadarReceiver {
      */
     abstract fun onLog(context: Context, message: String)
 
+    /**
+     * Tells the reciever that the location permissions status was updated.
+     *
+     * @param[context] The context.
+     * @param[status] The location permissions status.
+     */
+    abstract fun onLocationPermissionStatusUpdated(context: Context, status: RadarLocationPermissionStatus)
 
 }