Work around rare crashes that can happen when fragments are not attached to a context

grote · mar-v-in · commit a808476b7df4 · 2021-10-30T20:48:40.000+02:00
while co-routines are still executing but requiring a context

Change-Id: Ie6c7cee50014b59c25384d3bf9a122081b9917fc
diff --git a/play-services-core/src/main/kotlin/org/microg/gms/ui/DeviceRegistrationFragment.kt b/play-services-core/src/main/kotlin/org/microg/gms/ui/DeviceRegistrationFragment.kt
@@ -31,10 +31,11 @@ class DeviceRegistrationFragment : Fragment(R.layout.device_registration_fragmen
     }
 
     fun setEnabled(newStatus: Boolean) {
+        val appContext = requireContext().applicationContext
         lifecycleScope.launchWhenResumed {
-            val info = getCheckinServiceInfo(requireContext())
+            val info = getCheckinServiceInfo(appContext)
             val newConfiguration = info.configuration.copy(enabled = newStatus)
-            setCheckinServiceConfiguration(requireContext(), newConfiguration)
+            setCheckinServiceConfiguration(appContext, newConfiguration)
             displayServiceInfo(info.copy(configuration = newConfiguration))
         }
     }
@@ -45,8 +46,9 @@ class DeviceRegistrationFragment : Fragment(R.layout.device_registration_fragmen
 
     override fun onResume() {
         super.onResume()
+        val appContext = requireContext().applicationContext
         lifecycleScope.launchWhenResumed {
-            displayServiceInfo(getCheckinServiceInfo(requireContext()))
+            displayServiceInfo(getCheckinServiceInfo(appContext))
         }
     }
 }
diff --git a/play-services-core/src/main/kotlin/org/microg/gms/ui/DeviceRegistrationPreferencesFragment.kt b/play-services-core/src/main/kotlin/org/microg/gms/ui/DeviceRegistrationPreferencesFragment.kt
@@ -44,8 +44,9 @@ class DeviceRegistrationPreferencesFragment : PreferenceFragmentCompat() {
 
     private fun updateStatus() {
         handler.postDelayed(updateRunnable, UPDATE_INTERVAL)
+        val appContext = requireContext().applicationContext
         lifecycleScope.launchWhenResumed {
-            val serviceInfo = getCheckinServiceInfo(requireContext())
+            val serviceInfo = getCheckinServiceInfo(appContext)
             statusCategory.isVisible = serviceInfo.configuration.enabled
             if (serviceInfo.lastCheckin > 0) {
                 status.summary = getString(R.string.checkin_last_registration, DateUtils.getRelativeTimeSpanString(serviceInfo.lastCheckin, System.currentTimeMillis(), 0))
diff --git a/play-services-core/src/main/kotlin/org/microg/gms/ui/PushNotificationAdvancedFragment.kt b/play-services-core/src/main/kotlin/org/microg/gms/ui/PushNotificationAdvancedFragment.kt
@@ -32,45 +32,50 @@ class PushNotificationAdvancedFragment : PreferenceFragmentCompat() {
         networkOther = preferenceScreen.findPreference(GcmPrefs.PREF_NETWORK_OTHER) ?: networkOther
 
         confirmNewApps.onPreferenceChangeListener = Preference.OnPreferenceChangeListener { _, newValue ->
+            val appContext = requireContext().applicationContext
             lifecycleScope.launchWhenResumed {
                 if (newValue is Boolean) {
-                    setGcmServiceConfiguration(requireContext(), getGcmServiceInfo(requireContext()).configuration.copy(confirmNewApps = newValue))
+                    setGcmServiceConfiguration(appContext, getGcmServiceInfo(appContext).configuration.copy(confirmNewApps = newValue))
                 }
                 updateContent()
             }
             true
         }
         networkMobile.onPreferenceChangeListener = Preference.OnPreferenceChangeListener { _, newValue ->
+            val appContext = requireContext().applicationContext
             lifecycleScope.launchWhenResumed {
                 (newValue as? String)?.toIntOrNull()?.let {
-                    setGcmServiceConfiguration(requireContext(), getGcmServiceInfo(requireContext()).configuration.copy(mobile = it))
+                    setGcmServiceConfiguration(appContext, getGcmServiceInfo(appContext).configuration.copy(mobile = it))
                 }
                 updateContent()
             }
             true
         }
         networkWifi.onPreferenceChangeListener = Preference.OnPreferenceChangeListener { _, newValue ->
+            val appContext = requireContext().applicationContext
             lifecycleScope.launchWhenResumed {
                 (newValue as? String)?.toIntOrNull()?.let {
-                    setGcmServiceConfiguration(requireContext(), getGcmServiceInfo(requireContext()).configuration.copy(wifi = it))
+                    setGcmServiceConfiguration(appContext, getGcmServiceInfo(appContext).configuration.copy(wifi = it))
                 }
                 updateContent()
             }
             true
         }
         networkRoaming.onPreferenceChangeListener = Preference.OnPreferenceChangeListener { _, newValue ->
+            val appContext = requireContext().applicationContext
             lifecycleScope.launchWhenResumed {
                 (newValue as? String)?.toIntOrNull()?.let {
-                    setGcmServiceConfiguration(requireContext(), getGcmServiceInfo(requireContext()).configuration.copy(roaming = it))
+                    setGcmServiceConfiguration(appContext, getGcmServiceInfo(appContext).configuration.copy(roaming = it))
                 }
                 updateContent()
             }
             true
         }
         networkOther.onPreferenceChangeListener = Preference.OnPreferenceChangeListener { _, newValue ->
+            val appContext = requireContext().applicationContext
             lifecycleScope.launchWhenResumed {
                 (newValue as? String)?.toIntOrNull()?.let {
-                    setGcmServiceConfiguration(requireContext(), getGcmServiceInfo(requireContext()).configuration.copy(other = it))
+                    setGcmServiceConfiguration(appContext, getGcmServiceInfo(appContext).configuration.copy(other = it))
                 }
                 updateContent()
             }
@@ -84,8 +89,9 @@ class PushNotificationAdvancedFragment : PreferenceFragmentCompat() {
     }
 
     private fun updateContent() {
+        val appContext = requireContext().applicationContext
         lifecycleScope.launchWhenResumed {
-            val serviceInfo = getGcmServiceInfo(requireContext())
+            val serviceInfo = getGcmServiceInfo(appContext)
             confirmNewApps.isChecked = serviceInfo.configuration.confirmNewApps
             networkMobile.value = serviceInfo.configuration.mobile.toString()
             networkMobile.summary = getSummaryString(serviceInfo.configuration.mobile, serviceInfo.learntMobileInterval)
diff --git a/play-services-core/src/main/kotlin/org/microg/gms/ui/PushNotificationAllAppsFragment.kt b/play-services-core/src/main/kotlin/org/microg/gms/ui/PushNotificationAllAppsFragment.kt
@@ -52,8 +52,8 @@ class PushNotificationAllAppsFragment : PreferenceFragmentCompat() {
     }
 
     private fun updateContent() {
+        val context = requireContext().applicationContext
         lifecycleScope.launchWhenResumed {
-            val context = requireContext()
             val apps = withContext(Dispatchers.IO) {
                 val res = database.appList.map { app ->
                     app to context.packageManager.getApplicationInfoIfExists(app.packageName)
diff --git a/play-services-core/src/main/kotlin/org/microg/gms/ui/PushNotificationAppFragment.kt b/play-services-core/src/main/kotlin/org/microg/gms/ui/PushNotificationAppFragment.kt
@@ -46,12 +46,13 @@ class PushNotificationAppFragment : Fragment(R.layout.push_notification_fragment
 
     override fun onResume() {
         super.onResume()
+        val appContext = requireContext().applicationContext
         lifecycleScope.launchWhenResumed {
-            val pm = requireContext().packageManager
+            val pm = appContext.packageManager
             val applicationInfo = pm.getApplicationInfoIfExists(packageName)
             binding.appName = applicationInfo?.loadLabel(pm)?.toString() ?: packageName
             binding.appIcon = applicationInfo?.loadIcon(pm)
-                    ?: AppCompatResources.getDrawable(requireContext(), android.R.mipmap.sym_def_app_icon)
+                    ?: AppCompatResources.getDrawable(appContext, android.R.mipmap.sym_def_app_icon)
         }
     }
 }
diff --git a/play-services-core/src/main/kotlin/org/microg/gms/ui/PushNotificationFragment.kt b/play-services-core/src/main/kotlin/org/microg/gms/ui/PushNotificationFragment.kt
@@ -30,10 +30,11 @@ class PushNotificationFragment : Fragment(R.layout.push_notification_fragment) {
     }
 
     fun setEnabled(newStatus: Boolean) {
+        val appContext = requireContext().applicationContext
         lifecycleScope.launchWhenResumed {
-            val info = getGcmServiceInfo(requireContext())
+            val info = getGcmServiceInfo(appContext)
             val newConfiguration = info.configuration.copy(enabled = newStatus)
-            setGcmServiceConfiguration(requireContext(), newConfiguration)
+            setGcmServiceConfiguration(appContext, newConfiguration)
             displayServiceInfo(info.copy(configuration = newConfiguration))
         }
     }
@@ -44,9 +45,10 @@ class PushNotificationFragment : Fragment(R.layout.push_notification_fragment) {
 
     override fun onResume() {
         super.onResume()
+        val appContext = requireContext().applicationContext
         lifecycleScope.launchWhenResumed {
-            displayServiceInfo(getGcmServiceInfo(requireContext()))
-            binding.checkinEnabled = getCheckinServiceInfo(requireContext()).configuration.enabled
+            displayServiceInfo(getGcmServiceInfo(appContext))
+            binding.checkinEnabled = getCheckinServiceInfo(appContext).configuration.enabled
         }
     }
 
diff --git a/play-services-core/src/main/kotlin/org/microg/gms/ui/SafetyNetFragment.kt b/play-services-core/src/main/kotlin/org/microg/gms/ui/SafetyNetFragment.kt
@@ -32,10 +32,11 @@ class SafetyNetFragment : Fragment(R.layout.safety_net_fragment) {
     }
 
     fun setEnabled(newStatus: Boolean) {
+        val appContext = requireContext().applicationContext
         lifecycleScope.launchWhenResumed {
-            val info = getSafetyNetServiceInfo(requireContext())
+            val info = getSafetyNetServiceInfo(appContext)
             val newConfiguration = info.configuration.copy(enabled = newStatus)
-            displayServiceInfo(setSafetyNetServiceConfiguration(requireContext(), newConfiguration))
+            displayServiceInfo(setSafetyNetServiceConfiguration(appContext, newConfiguration))
         }
     }
 
@@ -45,9 +46,10 @@ class SafetyNetFragment : Fragment(R.layout.safety_net_fragment) {
 
     override fun onResume() {
         super.onResume()
+        val appContext = requireContext().applicationContext
         lifecycleScope.launchWhenResumed {
-            binding.checkinEnabled = getCheckinServiceInfo(requireContext()).configuration.enabled
-            displayServiceInfo(getSafetyNetServiceInfo(requireContext()))
+            binding.checkinEnabled = getCheckinServiceInfo(appContext).configuration.enabled
+            displayServiceInfo(getSafetyNetServiceInfo(appContext))
         }
     }
 
diff --git a/play-services-core/src/main/kotlin/org/microg/gms/ui/SettingsFragment.kt b/play-services-core/src/main/kotlin/org/microg/gms/ui/SettingsFragment.kt
@@ -5,6 +5,7 @@
 
 package org.microg.gms.ui
 
+import android.content.Context
 import android.os.Bundle
 import androidx.lifecycle.lifecycleScope
 import androidx.navigation.fragment.findNavController
@@ -50,12 +51,13 @@ class SettingsFragment : ResourceSettingsFragment() {
 
     override fun onResume() {
         super.onResume()
+        val appContext = requireContext().applicationContext
         lifecycleScope.launchWhenResumed {
-            updateDetails()
+            updateDetails(appContext)
         }
     }
 
-    private suspend fun updateDetails() {
+    private suspend fun updateDetails(context: Context) {
         if (getGcmServiceInfo(requireContext()).configuration.enabled) {
             val database = GcmDatabase(context)
             val regCount = database.registrationList.size
@@ -68,7 +70,7 @@ class SettingsFragment : ResourceSettingsFragment() {
         findPreference<Preference>(PREF_CHECKIN)!!.setSummary(if (getCheckinServiceInfo(requireContext()).configuration.enabled) R.string.service_status_enabled_short else R.string.service_status_disabled_short)
         findPreference<Preference>(PREF_SNET)!!.setSummary(if (getSafetyNetServiceInfo(requireContext()).configuration.enabled) R.string.service_status_enabled_short else R.string.service_status_disabled_short)
 
-        val backendCount = UnifiedLocationClient[requireContext()].getLocationBackends().size + UnifiedLocationClient[requireContext()].getGeocoderBackends().size
+        val backendCount = UnifiedLocationClient[context].getLocationBackends().size + UnifiedLocationClient[requireContext()].getGeocoderBackends().size
         findPreference<Preference>(PREF_UNIFIEDNLP)!!.summary = resources.getQuantityString(R.plurals.pref_unifiednlp_summary, backendCount, backendCount);
 
         findPreference<Preference>(PREF_EXPOSURE)?.isVisible = NearbyPreferencesIntegration.isAvailable
diff --git a/play-services-nearby-core-ui/src/main/kotlin/org/microg/gms/nearby/core/ui/ExposureNotificationsAppFragment.kt b/play-services-nearby-core-ui/src/main/kotlin/org/microg/gms/nearby/core/ui/ExposureNotificationsAppFragment.kt
@@ -40,12 +40,13 @@ class ExposureNotificationsAppFragment : Fragment(R.layout.exposure_notification
 
     override fun onResume() {
         super.onResume()
+        val appContext = requireContext().applicationContext
         lifecycleScope.launchWhenResumed {
-            val pm = requireContext().packageManager
+            val pm = appContext.packageManager
             val applicationInfo = pm.getApplicationInfoIfExists(packageName)
             binding.appName = applicationInfo?.loadLabel(pm)?.toString() ?: packageName
             binding.appIcon = applicationInfo?.loadIcon(pm)
-                    ?: AppCompatResources.getDrawable(requireContext(), android.R.mipmap.sym_def_app_icon)
+                    ?: AppCompatResources.getDrawable(appContext, android.R.mipmap.sym_def_app_icon)
         }
     }
 }
diff --git a/play-services-nearby-core-ui/src/main/kotlin/org/microg/gms/nearby/core/ui/ExposureNotificationsFragment.kt b/play-services-nearby-core-ui/src/main/kotlin/org/microg/gms/nearby/core/ui/ExposureNotificationsFragment.kt
@@ -32,10 +32,11 @@ class ExposureNotificationsFragment : Fragment(R.layout.exposure_notifications_f
     }
 
     fun setEnabled(newStatus: Boolean) {
+        val appContext = requireContext().applicationContext
         lifecycleScope.launchWhenResumed {
-            val info = getExposureNotificationsServiceInfo(requireContext())
+            val info = getExposureNotificationsServiceInfo(appContext)
             val newConfiguration = info.configuration.copy(enabled = newStatus)
-            setExposureNotificationsServiceConfiguration(requireContext(), newConfiguration)
+            setExposureNotificationsServiceConfiguration(appContext, newConfiguration)
             displayServiceInfo(info.copy(configuration = newConfiguration))
         }
     }
@@ -46,8 +47,9 @@ class ExposureNotificationsFragment : Fragment(R.layout.exposure_notifications_f
 
     override fun onResume() {
         super.onResume()
+        val appContext = requireContext().applicationContext
         lifecycleScope.launchWhenResumed {
-            displayServiceInfo(getExposureNotificationsServiceInfo(requireContext()))
+            displayServiceInfo(getExposureNotificationsServiceInfo(appContext))
         }
     }
 }
diff --git a/play-services-nearby-core-ui/src/main/kotlin/org/microg/gms/nearby/core/ui/ExposureNotificationsPreferencesFragment.kt b/play-services-nearby-core-ui/src/main/kotlin/org/microg/gms/nearby/core/ui/ExposureNotificationsPreferencesFragment.kt
@@ -101,15 +101,16 @@ class ExposureNotificationsPreferencesFragment : PreferenceFragmentCompat() {
     }
 
     private fun updateStatus() {
+        val appContext = requireContext().applicationContext
         lifecycleScope.launchWhenResumed {
             handler.postDelayed(updateStatusRunnable, UPDATE_STATUS_INTERVAL)
-            val enabled = getExposureNotificationsServiceInfo(requireContext()).configuration.enabled
+            val enabled = getExposureNotificationsServiceInfo(appContext).configuration.enabled
             exposureEnableInfo.isVisible = !enabled
 
-            val bluetoothSupported = ScannerService.isSupported(requireContext())
-            val advertisingSupported = if (bluetoothSupported == true) AdvertiserService.isSupported(requireContext()) else bluetoothSupported
+            val bluetoothSupported = ScannerService.isSupported(appContext)
+            val advertisingSupported = if (bluetoothSupported == true) AdvertiserService.isSupported(appContext) else bluetoothSupported
 
-            exposureLocationOff.isVisible = enabled && bluetoothSupported != false && !LocationManagerCompat.isLocationEnabled(requireContext().getSystemService(LOCATION_SERVICE) as LocationManager)
+            exposureLocationOff.isVisible = enabled && bluetoothSupported != false && !LocationManagerCompat.isLocationEnabled(appContext.getSystemService(LOCATION_SERVICE) as LocationManager)
             exposureBluetoothOff.isVisible = enabled && bluetoothSupported == null && !turningBluetoothOn
             exposureBluetoothUnsupported.isVisible = enabled && bluetoothSupported == false
             exposureBluetoothNoAdvertisement.isVisible = enabled && bluetoothSupported == true && advertisingSupported != true
@@ -119,9 +120,9 @@ class ExposureNotificationsPreferencesFragment : PreferenceFragmentCompat() {
     }
 
     private fun updateContent() {
+        val context = requireContext().applicationContext
         lifecycleScope.launchWhenResumed {
             handler.postDelayed(updateContentRunnable, UPDATE_CONTENT_INTERVAL)
-            val context = requireContext()
             val (apps, lastHourKeys, currentId) = ExposureDatabase.with(context) { database ->
                 val apps = database.appList.map { packageName ->
                     context.packageManager.getApplicationInfoIfExists(packageName)
diff --git a/play-services-nearby-core-ui/src/main/kotlin/org/microg/gms/nearby/core/ui/ExposureNotificationsRpisFragment.kt b/play-services-nearby-core-ui/src/main/kotlin/org/microg/gms/nearby/core/ui/ExposureNotificationsRpisFragment.kt
@@ -72,8 +72,9 @@ class ExposureNotificationsRpisFragment : PreferenceFragmentCompat() {
     }
 
     fun updateChart() {
+        val appContext = requireContext().applicationContext
         lifecycleScope.launchWhenResumed {
-            val rpiHourHistogram = ExposureDatabase.with(requireContext()) { database -> database.rpiHourHistogram }
+            val rpiHourHistogram = ExposureDatabase.with(appContext) { database -> database.rpiHourHistogram }
             val totalRpiCount = rpiHourHistogram.map { it.rpis }.sum()
             deleteAll.isEnabled = totalRpiCount > 0
             histogramCategory.title = getString(R.string.prefcat_exposure_rpis_histogram_title, totalRpiCount)

Original file line number	Diff line number	Diff line change
`@@ -31,10 +31,11 @@ class DeviceRegistrationFragment : Fragment(R.layout.device_registration_fragmen`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`fun setEnabled(newStatus: Boolean) {`
	`34`	`+ val appContext = requireContext().applicationContext`
`34`	`35`	`lifecycleScope.launchWhenResumed {`
`35`		`- val info = getCheckinServiceInfo(requireContext())`
	`36`	`+ val info = getCheckinServiceInfo(appContext)`
`36`	`37`	`val newConfiguration = info.configuration.copy(enabled = newStatus)`
`37`		`- setCheckinServiceConfiguration(requireContext(), newConfiguration)`
	`38`	`+ setCheckinServiceConfiguration(appContext, newConfiguration)`
`38`	`39`	`displayServiceInfo(info.copy(configuration = newConfiguration))`
`39`	`40`	`}`
`40`	`41`	`}`
`@@ -45,8 +46,9 @@ class DeviceRegistrationFragment : Fragment(R.layout.device_registration_fragmen`
`45`	`46`
`46`	`47`	`override fun onResume() {`
`47`	`48`	`super.onResume()`
	`49`	`+ val appContext = requireContext().applicationContext`
`48`	`50`	`lifecycleScope.launchWhenResumed {`
`49`		`- displayServiceInfo(getCheckinServiceInfo(requireContext()))`
	`51`	`+ displayServiceInfo(getCheckinServiceInfo(appContext))`
`50`	`52`	`}`
`51`	`53`	`}`
`52`	`54`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,45 +32,50 @@ class PushNotificationAdvancedFragment : PreferenceFragmentCompat() {`
`32`	`32`	`networkOther = preferenceScreen.findPreference(GcmPrefs.PREF_NETWORK_OTHER) ?: networkOther`
`33`	`33`
`34`	`34`	`confirmNewApps.onPreferenceChangeListener = Preference.OnPreferenceChangeListener { _, newValue ->`
	`35`	`+ val appContext = requireContext().applicationContext`
`35`	`36`	`lifecycleScope.launchWhenResumed {`
`36`	`37`	`if (newValue is Boolean) {`
`37`		`- setGcmServiceConfiguration(requireContext(), getGcmServiceInfo(requireContext()).configuration.copy(confirmNewApps = newValue))`
	`38`	`+ setGcmServiceConfiguration(appContext, getGcmServiceInfo(appContext).configuration.copy(confirmNewApps = newValue))`
`38`	`39`	`}`
`39`	`40`	`updateContent()`
`40`	`41`	`}`
`41`	`42`	`true`
`42`	`43`	`}`
`43`	`44`	`networkMobile.onPreferenceChangeListener = Preference.OnPreferenceChangeListener { _, newValue ->`
	`45`	`+ val appContext = requireContext().applicationContext`
`44`	`46`	`lifecycleScope.launchWhenResumed {`
`45`	`47`	`(newValue as? String)?.toIntOrNull()?.let {`
`46`		`- setGcmServiceConfiguration(requireContext(), getGcmServiceInfo(requireContext()).configuration.copy(mobile = it))`
	`48`	`+ setGcmServiceConfiguration(appContext, getGcmServiceInfo(appContext).configuration.copy(mobile = it))`
`47`	`49`	`}`
`48`	`50`	`updateContent()`
`49`	`51`	`}`
`50`	`52`	`true`
`51`	`53`	`}`
`52`	`54`	`networkWifi.onPreferenceChangeListener = Preference.OnPreferenceChangeListener { _, newValue ->`
	`55`	`+ val appContext = requireContext().applicationContext`
`53`	`56`	`lifecycleScope.launchWhenResumed {`
`54`	`57`	`(newValue as? String)?.toIntOrNull()?.let {`
`55`		`- setGcmServiceConfiguration(requireContext(), getGcmServiceInfo(requireContext()).configuration.copy(wifi = it))`
	`58`	`+ setGcmServiceConfiguration(appContext, getGcmServiceInfo(appContext).configuration.copy(wifi = it))`
`56`	`59`	`}`
`57`	`60`	`updateContent()`
`58`	`61`	`}`
`59`	`62`	`true`
`60`	`63`	`}`
`61`	`64`	`networkRoaming.onPreferenceChangeListener = Preference.OnPreferenceChangeListener { _, newValue ->`
	`65`	`+ val appContext = requireContext().applicationContext`
`62`	`66`	`lifecycleScope.launchWhenResumed {`
`63`	`67`	`(newValue as? String)?.toIntOrNull()?.let {`
`64`		`- setGcmServiceConfiguration(requireContext(), getGcmServiceInfo(requireContext()).configuration.copy(roaming = it))`
	`68`	`+ setGcmServiceConfiguration(appContext, getGcmServiceInfo(appContext).configuration.copy(roaming = it))`
`65`	`69`	`}`
`66`	`70`	`updateContent()`
`67`	`71`	`}`
`68`	`72`	`true`
`69`	`73`	`}`
`70`	`74`	`networkOther.onPreferenceChangeListener = Preference.OnPreferenceChangeListener { _, newValue ->`
	`75`	`+ val appContext = requireContext().applicationContext`
`71`	`76`	`lifecycleScope.launchWhenResumed {`
`72`	`77`	`(newValue as? String)?.toIntOrNull()?.let {`
`73`		`- setGcmServiceConfiguration(requireContext(), getGcmServiceInfo(requireContext()).configuration.copy(other = it))`
	`78`	`+ setGcmServiceConfiguration(appContext, getGcmServiceInfo(appContext).configuration.copy(other = it))`
`74`	`79`	`}`
`75`	`80`	`updateContent()`
`76`	`81`	`}`
`@@ -84,8 +89,9 @@ class PushNotificationAdvancedFragment : PreferenceFragmentCompat() {`
`84`	`89`	`}`
`85`	`90`
`86`	`91`	`private fun updateContent() {`
	`92`	`+ val appContext = requireContext().applicationContext`
`87`	`93`	`lifecycleScope.launchWhenResumed {`
`88`		`- val serviceInfo = getGcmServiceInfo(requireContext())`
	`94`	`+ val serviceInfo = getGcmServiceInfo(appContext)`
`89`	`95`	`confirmNewApps.isChecked = serviceInfo.configuration.confirmNewApps`
`90`	`96`	`networkMobile.value = serviceInfo.configuration.mobile.toString()`
`91`	`97`	`networkMobile.summary = getSummaryString(serviceInfo.configuration.mobile, serviceInfo.learntMobileInterval)`
Original file line number	Diff line number	Diff line change
`@@ -52,8 +52,8 @@ class PushNotificationAllAppsFragment : PreferenceFragmentCompat() {`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`private fun updateContent() {`
	`55`	`+ val context = requireContext().applicationContext`
`55`	`56`	`lifecycleScope.launchWhenResumed {`
`56`		`- val context = requireContext()`
`57`	`57`	`val apps = withContext(Dispatchers.IO) {`
`58`	`58`	`val res = database.appList.map { app ->`
`59`	`59`	`app to context.packageManager.getApplicationInfoIfExists(app.packageName)`
Original file line number	Diff line number	Diff line change
`@@ -46,12 +46,13 @@ class PushNotificationAppFragment : Fragment(R.layout.push_notification_fragment`
`46`	`46`
`47`	`47`	`override fun onResume() {`
`48`	`48`	`super.onResume()`
	`49`	`+ val appContext = requireContext().applicationContext`
`49`	`50`	`lifecycleScope.launchWhenResumed {`
`50`		`- val pm = requireContext().packageManager`
	`51`	`+ val pm = appContext.packageManager`
`51`	`52`	`val applicationInfo = pm.getApplicationInfoIfExists(packageName)`
`52`	`53`	`binding.appName = applicationInfo?.loadLabel(pm)?.toString() ?: packageName`
`53`	`54`	`binding.appIcon = applicationInfo?.loadIcon(pm)`
`54`		`- ?: AppCompatResources.getDrawable(requireContext(), android.R.mipmap.sym_def_app_icon)`
	`55`	`+ ?: AppCompatResources.getDrawable(appContext, android.R.mipmap.sym_def_app_icon)`
`55`	`56`	`}`
`56`	`57`	`}`
`57`	`58`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,10 +30,11 @@ class PushNotificationFragment : Fragment(R.layout.push_notification_fragment) {`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`fun setEnabled(newStatus: Boolean) {`
	`33`	`+ val appContext = requireContext().applicationContext`
`33`	`34`	`lifecycleScope.launchWhenResumed {`
`34`		`- val info = getGcmServiceInfo(requireContext())`
	`35`	`+ val info = getGcmServiceInfo(appContext)`
`35`	`36`	`val newConfiguration = info.configuration.copy(enabled = newStatus)`
`36`		`- setGcmServiceConfiguration(requireContext(), newConfiguration)`
	`37`	`+ setGcmServiceConfiguration(appContext, newConfiguration)`
`37`	`38`	`displayServiceInfo(info.copy(configuration = newConfiguration))`
`38`	`39`	`}`
`39`	`40`	`}`
`@@ -44,9 +45,10 @@ class PushNotificationFragment : Fragment(R.layout.push_notification_fragment) {`
`44`	`45`
`45`	`46`	`override fun onResume() {`
`46`	`47`	`super.onResume()`
	`48`	`+ val appContext = requireContext().applicationContext`
`47`	`49`	`lifecycleScope.launchWhenResumed {`
`48`		`- displayServiceInfo(getGcmServiceInfo(requireContext()))`
`49`		`- binding.checkinEnabled = getCheckinServiceInfo(requireContext()).configuration.enabled`
	`50`	`+ displayServiceInfo(getGcmServiceInfo(appContext))`
	`51`	`+ binding.checkinEnabled = getCheckinServiceInfo(appContext).configuration.enabled`
`50`	`52`	`}`
`51`	`53`	`}`
`52`	`54`
Original file line number	Diff line number	Diff line change
`@@ -32,10 +32,11 @@ class SafetyNetFragment : Fragment(R.layout.safety_net_fragment) {`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`fun setEnabled(newStatus: Boolean) {`
	`35`	`+ val appContext = requireContext().applicationContext`
`35`	`36`	`lifecycleScope.launchWhenResumed {`
`36`		`- val info = getSafetyNetServiceInfo(requireContext())`
	`37`	`+ val info = getSafetyNetServiceInfo(appContext)`
`37`	`38`	`val newConfiguration = info.configuration.copy(enabled = newStatus)`
`38`		`- displayServiceInfo(setSafetyNetServiceConfiguration(requireContext(), newConfiguration))`
	`39`	`+ displayServiceInfo(setSafetyNetServiceConfiguration(appContext, newConfiguration))`
`39`	`40`	`}`
`40`	`41`	`}`
`41`	`42`
`@@ -45,9 +46,10 @@ class SafetyNetFragment : Fragment(R.layout.safety_net_fragment) {`
`45`	`46`
`46`	`47`	`override fun onResume() {`
`47`	`48`	`super.onResume()`
	`49`	`+ val appContext = requireContext().applicationContext`
`48`	`50`	`lifecycleScope.launchWhenResumed {`
`49`		`- binding.checkinEnabled = getCheckinServiceInfo(requireContext()).configuration.enabled`
`50`		`- displayServiceInfo(getSafetyNetServiceInfo(requireContext()))`
	`51`	`+ binding.checkinEnabled = getCheckinServiceInfo(appContext).configuration.enabled`
	`52`	`+ displayServiceInfo(getSafetyNetServiceInfo(appContext))`
`51`	`53`	`}`
`52`	`54`	`}`
`53`	`55`
Original file line number	Diff line number	Diff line change
`@@ -40,12 +40,13 @@ class ExposureNotificationsAppFragment : Fragment(R.layout.exposure_notification`
`40`	`40`
`41`	`41`	`override fun onResume() {`
`42`	`42`	`super.onResume()`
	`43`	`+ val appContext = requireContext().applicationContext`
`43`	`44`	`lifecycleScope.launchWhenResumed {`
`44`		`- val pm = requireContext().packageManager`
	`45`	`+ val pm = appContext.packageManager`
`45`	`46`	`val applicationInfo = pm.getApplicationInfoIfExists(packageName)`
`46`	`47`	`binding.appName = applicationInfo?.loadLabel(pm)?.toString() ?: packageName`
`47`	`48`	`binding.appIcon = applicationInfo?.loadIcon(pm)`
`48`		`- ?: AppCompatResources.getDrawable(requireContext(), android.R.mipmap.sym_def_app_icon)`
	`49`	`+ ?: AppCompatResources.getDrawable(appContext, android.R.mipmap.sym_def_app_icon)`
`49`	`50`	`}`
`50`	`51`	`}`
`51`	`52`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,10 +32,11 @@ class ExposureNotificationsFragment : Fragment(R.layout.exposure_notifications_f`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`fun setEnabled(newStatus: Boolean) {`
	`35`	`+ val appContext = requireContext().applicationContext`
`35`	`36`	`lifecycleScope.launchWhenResumed {`
`36`		`- val info = getExposureNotificationsServiceInfo(requireContext())`
	`37`	`+ val info = getExposureNotificationsServiceInfo(appContext)`
`37`	`38`	`val newConfiguration = info.configuration.copy(enabled = newStatus)`
`38`		`- setExposureNotificationsServiceConfiguration(requireContext(), newConfiguration)`
	`39`	`+ setExposureNotificationsServiceConfiguration(appContext, newConfiguration)`
`39`	`40`	`displayServiceInfo(info.copy(configuration = newConfiguration))`
`40`	`41`	`}`
`41`	`42`	`}`
`@@ -46,8 +47,9 @@ class ExposureNotificationsFragment : Fragment(R.layout.exposure_notifications_f`
`46`	`47`
`47`	`48`	`override fun onResume() {`
`48`	`49`	`super.onResume()`
	`50`	`+ val appContext = requireContext().applicationContext`
`49`	`51`	`lifecycleScope.launchWhenResumed {`
`50`		`- displayServiceInfo(getExposureNotificationsServiceInfo(requireContext()))`
	`52`	`+ displayServiceInfo(getExposureNotificationsServiceInfo(appContext))`
`51`	`53`	`}`
`52`	`54`	`}`
`53`	`55`	`}`