Ask for notification permission upfront. Keep one notification instead of cancelling and showing a new one as Activities pause/resume.

Author: kaibolay

firebase-appdistribution-api/src/main/java/com/google/firebase/appdistribution/FirebaseAppDistribution.java

@@ -177,7 +177,7 @@ public interface FirebaseAppDistribution {
    * @param screenshot URI to a bitmap containing a screenshot that will be included with the
    *     report, or null to not include a screenshot
    */
-  void startFeedback(@NonNull CharSequence infoText, @Nullable Uri screenshotUri);
+  void startFeedback(@NonNull CharSequence infoText, @Nullable Uri screenshot);
 
   /** Gets the singleton {@link FirebaseAppDistribution} instance. */
   @NonNull

firebase-appdistribution/test-app/src/main/java/com/googletest/firebase/appdistribution/testapp/MainActivity.kt

@@ -13,7 +13,6 @@ import android.widget.ArrayAdapter
 import android.widget.AutoCompleteTextView
 import android.widget.ProgressBar
 import android.widget.TextView
-import androidx.activity.result.ActivityResultLauncher
 import androidx.appcompat.app.AppCompatActivity
 import androidx.appcompat.widget.AppCompatButton
 import androidx.core.widget.doOnTextChanged
@@ -47,7 +46,6 @@ class MainActivity : AppCompatActivity() {
     lateinit var feedbackTriggerMenu: TextInputLayout
 
     var updateTask: Task<Void>? = null
-    var notificationPermissionLauncher: ActivityResultLauncher<String>? = null
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
@@ -67,7 +65,10 @@ class MainActivity : AppCompatActivity() {
         progressPercent = findViewById(R.id.progress_percentage)
         signInStatus = findViewById(R.id.sign_in_status)
         progressBar = findViewById(R.id.progress_bar)
-        notificationPermissionLauncher = NotificationFeedbackTrigger.registerPermissionLauncher(this)
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            NotificationFeedbackTrigger.requestPermission(this)
+        }
 
         // Set up feedback trigger menu
         feedbackTriggerMenu = findViewById(R.id.feedbackTriggerMenu)
@@ -100,7 +101,7 @@ class MainActivity : AppCompatActivity() {
                 FeedbackTrigger.NOTIFICATION.label -> {
                     disableAllFeedbackTriggers()
                     Log.i(TAG, "Enabling notification trigger")
-                    NotificationFeedbackTrigger.enable(this, notificationPermissionLauncher)
+                    NotificationFeedbackTrigger.enable(this)
                 }
             }
         }

firebase-appdistribution/test-app/src/main/java/com/googletest/firebase/appdistribution/testapp/NotificationFeedbackTrigger.kt

@@ -13,8 +13,8 @@ import android.os.Build
 import android.os.Bundle
 import android.util.Log
 import androidx.activity.result.ActivityResultCaller
-import androidx.activity.result.ActivityResultLauncher
 import androidx.activity.result.contract.ActivityResultContracts
+import androidx.annotation.RequiresApi
 import androidx.core.app.NotificationCompat
 import androidx.core.app.NotificationManagerCompat
 import androidx.core.content.ContextCompat
@@ -33,8 +33,16 @@ object NotificationFeedbackTrigger : Application.ActivityLifecycleCallbacks {
 
   private var isEnabled = false
   private var hasRequestedPermission = false
-  private var currentActivity: Activity? = null
-
+  private var currentActivity: Activity? = null // Activity to be used for screenshot
+
+  /**
+   * Initialize the notification trigger for this application.
+   *
+   * This should be called during [Application.onCreate].
+   * [enable] should then be called when you want to actually show the notification.
+   *
+   * @param application the [Application] object
+   */
   fun initialize(application: Application) {
     // Create the NotificationChannel, but only on API 26+ because
     // the NotificationChannel class is new and not in the support library
@@ -43,7 +51,7 @@ object NotificationFeedbackTrigger : Application.ActivityLifecycleCallbacks {
         NotificationChannel(
           FEEBACK_NOTIFICATION_CHANNEL_ID,
           application.getString(R.string.feedback_notification_channel_name),
-          NotificationManager.IMPORTANCE_LOW
+          NotificationManager.IMPORTANCE_HIGH
         )
       channel.description =
         application.getString(R.string.feedback_notification_channel_description)
@@ -54,15 +62,27 @@ object NotificationFeedbackTrigger : Application.ActivityLifecycleCallbacks {
     application.registerActivityLifecycleCallbacks(this)
   }
 
-  fun <T> registerPermissionLauncher(activity: T): ActivityResultLauncher<String>? where
-  T : Activity,
-  T : ActivityResultCaller {
+  /**
+   * Requests permission to show notifications for this application.
+   *
+   * This must be called during [Activity.onCreate].
+   * [enable] should then be called when you want to actually show the notification.
+   *
+   * @param activity the [Activity] object
+   */
+  @RequiresApi(Build.VERSION_CODES.TIRAMISU)
+  fun <T> requestPermission(activity: T) where T : Activity, T : ActivityResultCaller {
+    if (ContextCompat.checkSelfPermission(activity, POST_NOTIFICATIONS) == PERMISSION_GRANTED) {
+      Log.i(TAG, "Already has permission.")
+      return
+    }
+
     if (hasRequestedPermission) {
       Log.i(TAG, "Already request permission; Not trying again.")
-      return null
+      return
     }
 
-    return activity.registerForActivityResult(ActivityResultContracts.RequestPermission()) {
+    val launcher = activity.registerForActivityResult(ActivityResultContracts.RequestPermission()) {
       isGranted: Boolean ->
       if (!isEnabled) {
         Log.w(TAG, "Trigger disabled after permission check. Abandoning notification.")
@@ -76,81 +96,71 @@ object NotificationFeedbackTrigger : Application.ActivityLifecycleCallbacks {
         //   message after each time we try to post a notification.
       }
     }
+
+    if (activity.shouldShowRequestPermissionRationale(POST_NOTIFICATIONS)) {
+      Log.i(TAG, "Showing customer rationale for requesting permission.")
+      AlertDialog.Builder(activity)
+        .setMessage(
+          "Using a notification to initiate feedback to the developer. " +
+                  "To enable this feature, allow the app to post notifications."
+        )
+        .setPositiveButton("OK") { _, _ ->
+          Log.i(TAG, "Launching request for permission.")
+          launcher.launch(POST_NOTIFICATIONS)
+        }
+        .show()
+    } else {
+      Log.i(TAG, "Launching request for permission without rationale.")
+      launcher.launch(POST_NOTIFICATIONS)
+    }
+    hasRequestedPermission = true
   }
 
-  fun enable(activity: Activity? = null, launcher: ActivityResultLauncher<String>? = null) {
+  /**
+   * Show notifications.
+   *
+   * This could be called during [Activity.onCreate].
+   *
+   * @param activity the [Activity] object
+   */
+  fun enable(activity: Activity) {
     currentActivity = activity
     isEnabled = true
-    if (activity != null) {
-      if (hasPermission(activity)) {
-        showNotification(activity)
-      } else {
-        if (launcher != null) {
-          requestPermission(activity, launcher)
-        } else {
-          Log.i(TAG, "Not requesting permission, because of no launcher was provided.")
-        }
-      }
-    }
+    showNotification(activity)
   }
 
+  /** Hide notifications. */
   fun disable() {
-    isEnabled = false
     val activity = currentActivity
-    currentActivity = null
     if (activity != null) {
       cancelNotification(activity)
     }
+    isEnabled = false
+    currentActivity = null
   }
 
-  private fun showNotification(activity: Activity) {
-    val intent = Intent(activity, TakeScreenshotAndTriggerFeedbackActivity::class.java)
+  private fun showNotification(context: Context) {
+    val intent = Intent(context, TakeScreenshotAndTriggerFeedbackActivity::class.java)
     intent.addFlags(Intent.FLAG_ACTIVITY_NO_HISTORY)
     val pendingIntent =
       PendingIntent.getActivity(
-        activity,
+        context,
         /* requestCode = */ 0,
         intent,
         PendingIntent.FLAG_IMMUTABLE
       )
     val builder =
-      NotificationCompat.Builder(activity, FEEBACK_NOTIFICATION_CHANNEL_ID)
+      NotificationCompat.Builder(context, FEEBACK_NOTIFICATION_CHANNEL_ID)
         .setSmallIcon(R.mipmap.ic_launcher)
-        .setContentTitle(activity.getText(R.string.feedback_notification_title))
-        .setContentText(activity.getText(R.string.feedback_notification_text))
-        .setPriority(NotificationCompat.PRIORITY_LOW)
+        .setContentTitle(context.getText(R.string.feedback_notification_title))
+        .setContentText(context.getText(R.string.feedback_notification_text))
+        .setPriority(NotificationCompat.PRIORITY_HIGH)
         .setContentIntent(pendingIntent)
-    val notificationManager = NotificationManagerCompat.from(activity)
+    val notificationManager = NotificationManagerCompat.from(context)
     Log.i(TAG, "Showing notification")
     notificationManager.notify(FEEDBACK_NOTIFICATION_ID, builder.build())
   }
 
-  private fun hasPermission(activity: Activity) =
-    ContextCompat.checkSelfPermission(activity, POST_NOTIFICATIONS) == PERMISSION_GRANTED
-
-  private fun requestPermission(activity: Activity, launcher: ActivityResultLauncher<String>) {
-    if (hasRequestedPermission) {
-      Log.i(TAG, "Already request permission; Not trying again.")
-      return
-    }
-    if (activity.shouldShowRequestPermissionRationale(POST_NOTIFICATIONS)) {
-      Log.i(TAG, "Showing customer rationale for requesting permission.")
-      AlertDialog.Builder(activity)
-        .setMessage(
-          "Using a notification to initiate feedback to the developer. " +
-            "To enable this feature, allow the app to post notifications."
-        )
-        .setPositiveButton("OK") { _, _ ->
-          Log.i(TAG, "Launching request for permission.")
-          launcher.launch(POST_NOTIFICATIONS)
-        }
-        .show()
-    } else {
-      Log.i(TAG, "Launching request for permission without rationale.")
-      launcher.launch(POST_NOTIFICATIONS)
-    }
-    hasRequestedPermission = true
-  }
 
   private fun cancelNotification(context: Context) {
     val notificationManager = NotificationManagerCompat.from(context)
@@ -163,14 +173,10 @@ object NotificationFeedbackTrigger : Application.ActivityLifecycleCallbacks {
       if (activity !is TakeScreenshotAndTriggerFeedbackActivity) {
         Log.d(TAG, "setting current activity")
         currentActivity = activity
-        showNotification(activity)
       }
     }
   }
 
-  override fun onActivityPaused(activity: Activity) {
-    cancelNotification(activity)
-  }
 
   override fun onActivityDestroyed(activity: Activity) {
     if (activity == currentActivity) {
@@ -182,28 +188,28 @@ object NotificationFeedbackTrigger : Application.ActivityLifecycleCallbacks {
   // Other lifecycle methods
   override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {}
   override fun onActivityStarted(activity: Activity) {}
+  override fun onActivityPaused(activity: Activity) {}
   override fun onActivityStopped(activity: Activity) {}
   override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) {}
 
   fun takeScreenshot() {
     val activity = currentActivity
-    if (activity != null) {
-      val view = activity.window.decorView.rootView
-      val bitmap = Bitmap.createBitmap(view.width, view.height, Bitmap.Config.RGB_565)
-      val canvas = Canvas(bitmap)
-      view.draw(canvas)
-      try {
-        activity.openFileOutput(SCREENSHOT_FILE_NAME, Context.MODE_PRIVATE).use { outputStream ->
-          bitmap.compress(Bitmap.CompressFormat.PNG, /* quality = */ 100, outputStream)
-        }
-        Log.i(TAG, "Wrote screenshot to $SCREENSHOT_FILE_NAME")
-      } catch (e: IOException) {
-        Log.e(TAG, "Can't write $SCREENSHOT_FILE_NAME", e)
-      }
-    } else {
+    if (activity == null) {
       Log.e(TAG, "Can't take screenshot because current activity is unknown")
       return
     }
+    val view = activity.window.decorView.rootView
+    val bitmap = Bitmap.createBitmap(view.width, view.height, Bitmap.Config.RGB_565)
+    val canvas = Canvas(bitmap)
+    view.draw(canvas)
+    try {
+      activity.openFileOutput(SCREENSHOT_FILE_NAME, Context.MODE_PRIVATE).use { outputStream ->
+        bitmap.compress(Bitmap.CompressFormat.PNG, /* quality = */ 100, outputStream)
+      }
+      Log.i(TAG, "Wrote screenshot to $SCREENSHOT_FILE_NAME")
+    } catch (e: IOException) {
+      Log.e(TAG, "Can't write $SCREENSHOT_FILE_NAME", e)
+    }
   }
 }