Refresh DataUsageSummaryPreferenceController

When re-enter the page contains it.

Fix: 341234382
Test: manual - on Data usage
Test: unit test
Change-Id: Ib6a4624e11b60d703c35cea07232cc24f1516389

src/com/android/settings/datausage/DataUsageSummaryPreferenceController.kt

@@ -21,20 +21,18 @@ import android.net.NetworkPolicy
 import android.net.NetworkTemplate
 import android.text.TextUtils
 import android.util.Log
-import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.LifecycleOwner
-import androidx.lifecycle.lifecycleScope
-import androidx.lifecycle.repeatOnLifecycle
 import androidx.preference.PreferenceScreen
 import com.android.settings.R
 import com.android.settings.datausage.lib.DataUsageLib.getMobileTemplate
 import com.android.settings.datausage.lib.INetworkCycleDataRepository
 import com.android.settings.datausage.lib.NetworkCycleDataRepository
 import com.android.settings.network.ProxySubscriptionManager
+import com.android.settings.network.policy.NetworkPolicyRepository
 import com.android.settings.network.telephony.TelephonyBasePreferenceController
+import com.android.settingslib.spa.framework.util.collectLatestWithLifecycle
 import kotlin.math.max
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 
 /**
@@ -47,6 +45,7 @@ open class DataUsageSummaryPreferenceController @JvmOverloads constructor(
     subId: Int,
     private val proxySubscriptionManager: ProxySubscriptionManager =
         ProxySubscriptionManager.getInstance(context),
+    private val networkPolicyRepository: NetworkPolicyRepository = NetworkPolicyRepository(context),
     private val networkCycleDataRepositoryFactory: (
         template: NetworkTemplate,
     ) -> INetworkCycleDataRepository = { NetworkCycleDataRepository(context, it) },
@@ -64,37 +63,37 @@ open class DataUsageSummaryPreferenceController @JvmOverloads constructor(
             proxySubscriptionManager.getAccessibleSubscriptionInfo(mSubId)
         } else null
     }
+
+    private val networkTemplate by lazy { getMobileTemplate(mContext, mSubId) }
+
     private val networkCycleDataRepository by lazy {
-        networkCycleDataRepositoryFactory(getMobileTemplate(mContext, mSubId))
+        networkCycleDataRepositoryFactory(networkTemplate)
     }
-    private val policy by lazy { networkCycleDataRepository.getPolicy() }
+
     private lateinit var preference: DataUsageSummaryPreference
 
     override fun getAvailabilityStatus(subId: Int) =
-        if (subInfo != null && policy != null) AVAILABLE else CONDITIONALLY_UNAVAILABLE
+        if (subInfo != null) AVAILABLE else CONDITIONALLY_UNAVAILABLE
 
     override fun displayPreference(screen: PreferenceScreen) {
         super.displayPreference(screen)
         preference = screen.findPreference(preferenceKey)!!
-        policy?.let {
-            preference.setLimitInfo(it.getLimitInfo())
-            val dataBarSize = max(it.limitBytes, it.warningBytes)
-            if (dataBarSize > NetworkPolicy.WARNING_DISABLED) {
-                setDataBarSize(dataBarSize)
-            }
-        }
     }
 
     override fun onViewCreated(viewLifecycleOwner: LifecycleOwner) {
-        viewLifecycleOwner.lifecycleScope.launch {
-            viewLifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
-                update()
+        networkPolicyRepository.networkPolicyFlow(networkTemplate)
+            .collectLatestWithLifecycle(viewLifecycleOwner) { policy ->
+                preference.isVisible = subInfo != null && policy != null
+                if (policy != null) update(policy)
             }
-        }
     }
 
-    private suspend fun update() {
-        val policy = policy ?: return
+    private suspend fun update(policy: NetworkPolicy) {
+        preference.setLimitInfo(policy.getLimitInfo())
+        val dataBarSize = max(policy.limitBytes, policy.warningBytes)
+        if (dataBarSize > NetworkPolicy.WARNING_DISABLED) {
+            setDataBarSize(dataBarSize)
+        }
         val dataPlanInfo = withContext(Dispatchers.Default) {
             dataPlanRepositoryFactory(networkCycleDataRepository).getDataPlanInfo(
                 policy = policy,

src/com/android/settings/network/policy/NetworkPolicyRepository.kt

@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.settings.network.policy
+
+import android.content.Context
+import android.net.NetworkPolicy
+import android.net.NetworkPolicyManager
+import android.net.NetworkTemplate
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.flowOn
+
+class NetworkPolicyRepository(context: Context) {
+    private val networkPolicyManager = context.getSystemService(NetworkPolicyManager::class.java)!!
+
+    fun getNetworkPolicy(networkTemplate: NetworkTemplate): NetworkPolicy? =
+        networkPolicyManager.networkPolicies.find { policy -> policy.template == networkTemplate }
+
+    fun networkPolicyFlow(networkTemplate: NetworkTemplate): Flow<NetworkPolicy?> = flow {
+        emit(getNetworkPolicy(networkTemplate))
+    }.flowOn(Dispatchers.Default)
+}