react-native-audio-api 0.13.4 → 0.13.6

package/android/src/main/java/com/swmansion/audioapi/system/notification/NotificationRegistry.kt

@@ -1,5 +1,6 @@
 package com.swmansion.audioapi.system.notification
 
+import android.annotation.SuppressLint
 import android.app.Notification
 import android.util.Log
 import androidx.annotation.RequiresPermission
@@ -8,6 +9,7 @@ import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReadableMap
 import com.swmansion.audioapi.system.ForegroundServiceManager
 import java.lang.ref.WeakReference
+import java.util.concurrent.ConcurrentHashMap
 
 /**
  * Central notification registry that manages multiple notification instances.
@@ -20,8 +22,9 @@ class NotificationRegistry(
   companion object {
     private const val TAG = "NotificationRegistry"
 
-    // Store last built notifications for foreground service access
-    private val builtNotifications = mutableMapOf<Int, Notification>()
+    // Store last built notifications for foreground service access. Concurrent because
+    // CentralizedForegroundService reads it on its main thread, outside the registry monitor.
+    private val builtNotifications = ConcurrentHashMap<Int, Notification>()
 
     fun getBuiltNotification(notificationId: Int): Notification? = builtNotifications[notificationId]
   }
@@ -39,6 +42,7 @@ class NotificationRegistry(
    * @param type The type of notification (only used for first creation)
    * @param options Configuration options from JavaScript
    */
+  @Synchronized
   @RequiresPermission(android.Manifest.permission.POST_NOTIFICATIONS)
   fun showNotification(
     key: String,
@@ -76,11 +80,7 @@ class NotificationRegistry(
     }
   }
 
-  /**
-   * Hide a notification.
-   *
-   * @param key The unique identifier of the notification
-   */
+  @Synchronized
   fun hideNotification(key: String) {
     val notification = notifications[key]
     if (notification == null) {
@@ -88,23 +88,46 @@ class NotificationRegistry(
       return
     }
 
-    try {
-      // Only hide if currently active
-      if (activeNotifications.getOrDefault(key, false)) {
-        cancelNotification(notification.getNotificationId())
-        notification.hide()
-        activeNotifications[key] = false
-
-        // Unsubscribe from foreground service
-        ForegroundServiceManager.unsubscribe(notification)
+    // Only hide if currently active
+    if (!activeNotifications.getOrDefault(key, false)) {
+      return
+    }
 
-        Log.d(TAG, "Hiding notification: $key (unsubscribed from foreground service)")
-      }
+    try {
+      cancelNotification(notification.getNotificationId())
+      notification.hide()
     } catch (e: Exception) {
       Log.e(TAG, "Error hiding notification $key: ${e.message}", e)
+    } finally {
+      activeNotifications[key] = false
+      ForegroundServiceManager.unsubscribe(notification)
     }
   }
 
+  @Synchronized
+  fun hideNotification(id: Int) {
+    notifications.entries
+      .firstOrNull { it.value.getNotificationId() == id }
+      ?.let { hideNotification(it.key) }
+  }
+
+  /**
+   * Rebuild and re-post the recording notification with a new paused state.
+   */
+  @Synchronized
+  @SuppressLint("MissingPermission")
+  fun updateRecordingNotificationPausedState(paused: Boolean) {
+    val entry =
+      notifications.entries.firstOrNull {
+        it.value.getNotificationId() == RecordingNotification.ID
+      } ?: return
+    if (!activeNotifications.getOrDefault(entry.key, false)) {
+      return
+    }
+    val recordingNotification = entry.value as? RecordingNotification ?: return
+    displayNotification(RecordingNotification.ID, recordingNotification.rebuildWithPausedState(paused))
+  }
+
   /**
    * Create a notification instance.
    *
@@ -149,6 +172,7 @@ class NotificationRegistry(
    *
    * @param key The unique identifier of the notification
    */
+  @Synchronized
   fun destroyNotification(key: String) {
     hideNotification(key)
     notifications.remove(key)
@@ -159,16 +183,19 @@ class NotificationRegistry(
   /**
    * Check if a notification is currently active.
    */
+  @Synchronized
   fun isNotificationActive(key: String): Boolean = activeNotifications.getOrDefault(key, false)
 
   /**
    * Get all registered notification keys.
    */
+  @Synchronized
   fun getRegisteredKeys(): Set<String> = notifications.keys.toSet()
 
   /**
    * Cleanup all notifications.
    */
+  @Synchronized
   fun cleanup() {
     notifications.keys.toList().forEach { key ->
       hideNotification(key)
@@ -202,9 +229,10 @@ class NotificationRegistry(
   }
 
   private fun cancelNotification(id: Int) {
+    // Drop the stored notification first so the foreground service can no longer pick
+    // it up, even when the released React context prevents the system-side cancel.
+    builtNotifications.remove(id)
     val context = reactContext.get() ?: return
     NotificationManagerCompat.from(context).cancel(id)
-    // Clean up stored notification
-    builtNotifications.remove(id)
   }
 }

package/android/src/main/java/com/swmansion/audioapi/system/notification/RecordingNotification.kt

@@ -4,23 +4,18 @@ import android.app.Notification
 import android.app.NotificationChannel
 import android.app.NotificationManager
 import android.app.PendingIntent
-import android.content.ComponentCallbacks
 import android.content.Context
 import android.content.Intent
 import android.content.IntentFilter
-import android.content.res.Configuration
-import android.graphics.Color
 import android.graphics.drawable.Icon
+import android.net.Uri
 import android.os.Build
 import android.util.Log
-import android.widget.RemoteViews
-import androidx.annotation.RequiresApi
 import androidx.core.app.NotificationCompat
 import androidx.core.content.ContextCompat
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReadableMap
 import com.swmansion.audioapi.AudioAPIModule
-import com.swmansion.audioapi.R
 import com.swmansion.audioapi.system.notification.state.RecordingNotificationState
 import java.lang.ref.WeakReference
 
@@ -29,196 +24,242 @@ class RecordingNotification(
   private val audioAPIModule: WeakReference<AudioAPIModule>,
   private val notificationId: Int,
   private val channelId: String,
-) : BaseNotification,
-  ComponentCallbacks {
+) : BaseNotification {
   companion object {
     private const val TAG = "RecordingNotification"
     const val ID = 200
+
+    private const val REQUEST_CODE_CONTENT = 2000
+    private const val REQUEST_CODE_PAUSE = 2001
+    private const val REQUEST_CODE_RESUME = 2002
+    private const val REQUEST_CODE_STOP = 2003
+    private const val REQUEST_CODE_DISMISSED = 2004
   }
 
-  private var state: RecordingNotificationState =
-    RecordingNotificationState(
-      darkTheme =
-        reactContext
-          .get()!!
-          .resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK == Configuration.UI_MODE_NIGHT_YES,
-      initialized = false,
-    )
+  private val state = RecordingNotificationState()
 
   private fun initializeNotification() {
     val context = reactContext.get() ?: throw IllegalStateException("React context is null")
-    if (!state.initialized) {
-      context.registerComponentCallbacks(this)
-      createNotificationChannel(context)
-      state.receiver =
-        RecordingNotificationReceiver(audioAPIModule.get()!!)
-      val filter =
-        IntentFilter().apply {
-          addAction(RecordingNotificationReceiver.NOTIFICATION_RECORDING_STOPPED)
-          addAction(RecordingNotificationReceiver.NOTIFICATION_RECORDING_RESUMED)
-        }
-      ContextCompat.registerReceiver(
-        context,
-        state.receiver,
-        filter,
-        ContextCompat.RECEIVER_NOT_EXPORTED,
-      )
-
-      state.pauseIntent =
-        Intent(RecordingNotificationReceiver.NOTIFICATION_RECORDING_STOPPED).apply {
-          `package` = context.packageName
-        }
-
-      state.resumeIntent =
-        Intent(RecordingNotificationReceiver.NOTIFICATION_RECORDING_RESUMED).apply {
-          `package` = context.packageName
-        }
-      state.darkTheme = context.resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK == Configuration.UI_MODE_NIGHT_YES
-      state.initialized = true
+    if (state.initialized) {
+      return
     }
+
+    createNotificationChannel(context)
+    state.receiver = RecordingNotificationReceiver(audioAPIModule.get()!!)
+    val filter =
+      IntentFilter().apply {
+        addAction(RecordingNotificationReceiver.ACTION_PAUSE)
+        addAction(RecordingNotificationReceiver.ACTION_RESUME)
+        addAction(RecordingNotificationReceiver.ACTION_STOP)
+        addAction(RecordingNotificationReceiver.ACTION_DISMISSED)
+      }
+    ContextCompat.registerReceiver(
+      context,
+      state.receiver,
+      filter,
+      ContextCompat.RECEIVER_NOT_EXPORTED,
+    )
+    state.initialized = true
   }
 
   override fun show(options: ReadableMap?): Notification {
     initializeNotification()
     val context = reactContext.get() ?: throw IllegalStateException("React context is null")
-    if (options != state.cachedRNOptions) {
+    if (options !== state.cachedRNOptions) {
       state.cachedRNOptions = options
       parseMapFromRN(options)
     }
-    val builder = getBuilder()
+    return buildNotification(context)
+  }
 
-    if (state.smallIconResourceName != null) {
-      builder.setSmallIcon(context.resources.getIdentifier(state.smallIconResourceName, "drawable", context.packageName))
-    }
+  /**
+   * Rebuilds with an updated paused flag, leaving the sticky RN options untouched.
+   */
+  fun rebuildWithPausedState(paused: Boolean): Notification {
+    val context = reactContext.get() ?: throw IllegalStateException("React context is null")
+    state.paused = paused
+    return buildNotification(context)
+  }
 
-    if (state.largeIconResourceName != null) {
-      val icon =
-        Icon.createWithResource(
-          context,
-          context.resources.getIdentifier(state.largeIconResourceName, "drawable", context.packageName),
+  private fun buildNotification(context: ReactApplicationContext): Notification {
+    val builder =
+      NotificationCompat
+        .Builder(context, channelId)
+        .setOngoing(!state.dismissible)
+        .setOnlyAlertOnce(true)
+        .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
+        .setContentTitle(state.title)
+        .setContentText(state.contentText)
+        .setSmallIcon(
+          resolveDrawable(context, state.smallIconResourceName) ?: android.R.drawable.ic_btn_speak_now,
         )
-      builder.setLargeIcon(icon)
-    }
 
-    if (state.backgroundColor != null) {
-      builder.setColor(state.backgroundColor!!)
+    resolveDrawable(context, state.largeIconResourceName)?.let {
+      builder.setLargeIcon(Icon.createWithResource(context, it))
     }
+    state.backgroundColor?.let { builder.setColor(it) }
 
-    val collapsedView = RemoteViews(context.packageName, R.layout.notification_collapsed)
-    val expandedView = RemoteViews(context.packageName, R.layout.notification_expanded)
+    setupContentIntent(context, builder)
+    setupActions(context, builder)
+    setupDeleteIntent(context, builder)
+    setupChronometer(builder)
 
-    val (pauseResumePendingIntent, iconId) = setupPauseResumeIntent(context)
+    return builder.build()
+  }
 
-    setupRemoteView(listOf(collapsedView, expandedView), pauseResumePendingIntent, iconId)
+  private fun setupContentIntent(
+    context: Context,
+    builder: NotificationCompat.Builder,
+  ) {
+    val launchIntent = context.packageManager.getLaunchIntentForPackage(context.packageName) ?: return
+    state.deepLinkUri?.let {
+      launchIntent.action = Intent.ACTION_VIEW
+      launchIntent.removeCategory(Intent.CATEGORY_LAUNCHER)
+      launchIntent.data = Uri.parse(it)
+    }
+    builder.setContentIntent(
+      PendingIntent.getActivity(
+        context,
+        REQUEST_CODE_CONTENT,
+        launchIntent,
+        PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
+      ),
+    )
+  }
 
-    builder
-      .setStyle(NotificationCompat.DecoratedCustomViewStyle())
-      .setCustomContentView(collapsedView)
-      .setCustomBigContentView(expandedView)
-      .setContentTitle(state.title)
-      .setContentText(state.contentText)
+  private fun setupActions(
+    context: Context,
+    builder: NotificationCompat.Builder,
+  ) {
+    if (state.paused) {
+      builder.addAction(
+        createAction(
+          context,
+          RecordingNotificationReceiver.ACTION_RESUME,
+          REQUEST_CODE_RESUME,
+          state.resumeActionTitle ?: "Resume",
+        ),
+      )
+    } else {
+      builder.addAction(
+        createAction(
+          context,
+          RecordingNotificationReceiver.ACTION_PAUSE,
+          REQUEST_CODE_PAUSE,
+          state.pauseActionTitle ?: "Pause",
+        ),
+      )
+    }
 
-    if (state.backgroundColor != null) {
-      builder.setColor(state.backgroundColor!!)
+    if (state.showStopAction) {
+      builder.addAction(
+        createAction(
+          context,
+          RecordingNotificationReceiver.ACTION_STOP,
+          REQUEST_CODE_STOP,
+          state.stopActionTitle ?: "Stop",
+        ),
+      )
     }
+  }
 
-    return builder.build()
+  private fun setupDeleteIntent(
+    context: Context,
+    builder: NotificationCompat.Builder,
+  ) {
+    val dismissed =
+      Intent(RecordingNotificationReceiver.ACTION_DISMISSED)
+        .putExtra(RecordingNotificationReceiver.EXTRA_DISMISS_STOPS_RECORDING, state.dismissible)
+    builder.setDeleteIntent(createBroadcast(context, dismissed, REQUEST_CODE_DISMISSED))
   }
 
-  private fun setupPauseResumeIntent(context: Context): Pair<PendingIntent, Int> {
-    val pauseResumeIntent =
-      if (state.paused) {
-        state.resumeIntent
-      } else {
-        state.pauseIntent
-      }
+  private fun createAction(
+    context: Context,
+    action: String,
+    requestCode: Int,
+    title: String,
+  ): NotificationCompat.Action = NotificationCompat.Action(null, title, createBroadcast(context, Intent(action), requestCode))
 
-    val pauseResumePendingIntent =
-      PendingIntent.getBroadcast(
-        context,
-        0,
-        pauseResumeIntent!!,
-        PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
-      )
+  private fun createBroadcast(
+    context: Context,
+    intent: Intent,
+    requestCode: Int,
+  ): PendingIntent =
+    PendingIntent.getBroadcast(
+      context,
+      requestCode,
+      intent.apply { `package` = context.packageName },
+      PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
+    )
+
+  // The system chronometer always ticks against wall time, so the recording's paused
+  // spans are carved out by shifting the base (`startedAtMs`) forward on each resume.
+  private fun setupChronometer(builder: NotificationCompat.Builder) {
+    val now = System.currentTimeMillis()
 
-    val pauseId =
-      if (state.pauseIconResourceName != null) {
-        context.resources.getIdentifier(state.pauseIconResourceName, "drawable", context.packageName)
-      } else {
-        android.R.drawable.ic_media_pause
+    if (state.usesChronometer && !state.paused) {
+      if (state.startedAtMs == null) {
+        state.startedAtMs = now
       }
-    val resumeId =
-      if (state.resumeIconResourceName != null) {
-        context.resources.getIdentifier(state.resumeIconResourceName, "drawable", context.packageName)
-      } else {
-        android.R.drawable.ic_media_play
+      state.pausedAtMs?.let { pausedAt ->
+        state.startedAtMs = state.startedAtMs!! + (now - pausedAt)
+        state.pausedAtMs = null
       }
-
-    val iconId = if (state.paused) resumeId else pauseId
-    return pauseResumePendingIntent to iconId
+      builder
+        .setWhen(state.startedAtMs!!)
+        .setShowWhen(true)
+        .setUsesChronometer(true)
+    } else {
+      if (state.usesChronometer && state.paused && state.pausedAtMs == null) {
+        state.pausedAtMs = now
+      }
+      builder
+        .setUsesChronometer(false)
+        .setShowWhen(false)
+    }
   }
 
-  private fun setupRemoteView(
-    views: List<RemoteViews>,
-    pauseResumePendingIntent: PendingIntent,
-    iconId: Int,
-  ) {
-    val iconColor =
-      if (state.darkTheme) {
-        Color.WHITE // Dark Mode -> White Icon
-      } else {
-        Color.BLACK // Light Mode -> Black Icon
-      }
-    for (view in views) {
-      view.setTextViewText(R.id.notification_title, state.title)
-      view.setTextViewText(R.id.notification_content, state.contentText)
-      view.setImageViewResource(R.id.notification_action_btn, iconId)
-      view.setInt(R.id.notification_action_btn, "setColorFilter", iconColor)
-      view.setOnClickPendingIntent(R.id.notification_action_btn, pauseResumePendingIntent)
+  private fun resolveDrawable(
+    context: Context,
+    resourceName: String?,
+  ): Int? {
+    if (resourceName == null) {
+      return null
     }
+    val resourceId = context.resources.getIdentifier(resourceName, "drawable", context.packageName)
+    return if (resourceId != 0) resourceId else null
   }
 
-// not used currently, left for future reference
-//  private fun loadBitmapFromUri(
-//    context: Context,
-//    uriString: String?,
-//  ): Bitmap? =
-//    try {
-//      val uri = android.net.Uri.parse(uriString)
-//      val inputStream: InputStream
-//      if (uri.scheme == "http" || uri.scheme == "https") {
-//        // web URL
-//        val connection = java.net.URL(uriString).openConnection()
-//        connection.doInput = true
-//        connection.connect()
-//        inputStream = connection.inputStream
-//      } else {
-//        // local files
-//        inputStream = context.contentResolver.openInputStream(uri)!!
-//      }
-//      android.graphics.BitmapFactory.decodeStream(inputStream)
-//    } catch (e: Exception) {
-//      Log.e(TAG, "Failed to load bitmap from URI: $uriString", e)
-//      null
-//    }
+  private fun parseMapFromRN(options: ReadableMap?) {
+    state.title = options.stringOr("title", state.title ?: "Recording Audio")
+    state.contentText = options.stringOr("contentText", state.contentText ?: "Audio recording is in progress/paused")
+    state.smallIconResourceName = options.stringOr("smallIconResourceName", state.smallIconResourceName)
+    state.largeIconResourceName = options.stringOr("largeIconResourceName", state.largeIconResourceName)
+    state.backgroundColor = options.intOr("color", state.backgroundColor)
+    state.showStopAction = options.boolOr("showStopAction", state.showStopAction)
+    state.dismissible = options.boolOr("dismissible", state.dismissible)
+    state.pauseActionTitle = options.stringOr("pauseActionTitle", state.pauseActionTitle)
+    state.resumeActionTitle = options.stringOr("resumeActionTitle", state.resumeActionTitle)
+    state.stopActionTitle = options.stringOr("stopActionTitle", state.stopActionTitle)
+    state.deepLinkUri = options.stringOr("deepLinkUri", state.deepLinkUri)
+    state.usesChronometer = options.boolOr("usesChronometer", state.usesChronometer)
+    state.paused = options.boolOr("paused", state.paused)
+  }
 
-  private fun getBuilder(): NotificationCompat.Builder {
-    val context = reactContext.get() ?: throw IllegalStateException("React context is null")
-    if (state.builder == null) {
-      val openAppIntent = context.packageManager.getLaunchIntentForPackage(context.packageName)
-      val pendingIntent = PendingIntent.getActivity(context, 0, openAppIntent, PendingIntent.FLAG_IMMUTABLE)
+  private fun ReadableMap?.stringOr(
+    key: String,
+    fallback: String?,
+  ): String? = if (this?.hasKey(key) == true) getString(key) else fallback
 
-      state.builder =
-        NotificationCompat
-          .Builder(context, channelId)
-          .setOngoing(true)
-          .setContentIntent(pendingIntent)
-    }
-    if (state.smallIconResourceName == null) {
-      state.builder!!.setSmallIcon(android.R.drawable.ic_btn_speak_now)
-    }
-    return state.builder!!
-  }
+  private fun ReadableMap?.boolOr(
+    key: String,
+    fallback: Boolean,
+  ): Boolean = if (this?.hasKey(key) == true) getBoolean(key) else fallback
+
+  private fun ReadableMap?.intOr(
+    key: String,
+    fallback: Int?,
+  ): Int? = if (this?.hasKey(key) == true) getInt(key) else fallback
 
   private fun createNotificationChannel(context: ReactApplicationContext) {
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
@@ -238,84 +279,37 @@ class RecordingNotification(
     Log.d(TAG, "Notification channel created: $channelId")
   }
 
-  private fun parseMapFromRN(options: ReadableMap?) {
-    state.title = if (options?.hasKey("title") == true) options.getString("title") else state.title ?: "Recording Audio"
-    state.contentText =
-      if (options?.hasKey("contentText") == true) {
-        options.getString("contentText")
-      } else {
-        state.contentText ?: "Audio recording is in progress/paused"
-      }
-    state.smallIconResourceName =
-      if (options?.hasKey("smallIconResourceName") ==
-        true
-      ) {
-        options.getString("smallIconResourceName")
-      } else {
-        state.smallIconResourceName ?: null
-      }
-    state.largeIconResourceName =
-      if (options?.hasKey("largeIconResourceName") ==
-        true
-      ) {
-        options.getString("largeIconResourceName")
-      } else {
-        state.largeIconResourceName ?: null
-      }
-    state.pauseIconResourceName =
-      if (options?.hasKey("pauseIconResourceName") ==
-        true
-      ) {
-        options.getString("pauseIconResourceName")
-      } else {
-        state.pauseIconResourceName ?: null
-      }
-    state.resumeIconResourceName =
-      if (options?.hasKey("resumeIconResourceName") ==
-        true
-      ) {
-        options.getString("resumeIconResourceName")
-      } else {
-        state.resumeIconResourceName ?: null
-      }
-    state.backgroundColor = if (options?.hasKey("color") == true) options.getInt("color") else state.backgroundColor ?: null
-    state.paused = if (options?.hasKey("paused") == true) options.getBoolean("paused") else false
-  }
-
   override fun hide() {
-    val context = reactContext.get() ?: throw IllegalStateException("React context is null")
-    if (state.receiver != null) {
-      context.unregisterReceiver(state.receiver)
-      context.unregisterComponentCallbacks(this)
-      state.receiver = null
+    try {
+      val context = reactContext.get() ?: throw IllegalStateException("React context is null")
+      state.receiver?.let {
+        context.unregisterReceiver(it)
+        state.receiver = null
+      }
+      val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+      notificationManager.cancel(notificationId)
+    } finally {
+      state.initialized = false
+      state.cachedRNOptions = null
+      state.title = null
+      state.contentText = null
+      state.smallIconResourceName = null
+      state.largeIconResourceName = null
+      state.backgroundColor = null
+      state.showStopAction = false
+      state.dismissible = false
+      state.pauseActionTitle = null
+      state.resumeActionTitle = null
+      state.stopActionTitle = null
+      state.deepLinkUri = null
+      state.usesChronometer = false
+      state.startedAtMs = null
+      state.pausedAtMs = null
+      state.paused = false
     }
-    val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-    notificationManager.cancel(notificationId)
-    state.initialized = false
-    state.builder = null
   }
 
   override fun getNotificationId(): Int = notificationId
 
   override fun getChannelId(): String = channelId
-
-  @RequiresApi(Build.VERSION_CODES.O)
-  override fun onConfigurationChanged(newConfig: Configuration) {
-    val currentNightMode = newConfig.uiMode and Configuration.UI_MODE_NIGHT_MASK == Configuration.UI_MODE_NIGHT_YES
-    if (currentNightMode != state.darkTheme) {
-      // Theme changed, rebuild notification
-      state.darkTheme = currentNightMode
-      val notification = show(state.cachedRNOptions)
-      val context = reactContext.get()
-      if (context != null) {
-        val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-        notificationManager.notify(notificationId, notification)
-      }
-    }
-  }
-
-  @Deprecated("Deprecated in Java")
-  override fun onLowMemory() {
-    // left to listen for ui mode changes
-  }
 }