Use single queryDetailsForDevice if possible

To improve performance. Since queryDetailsForDevice() also aggregated the uids into one, the apps list in DataUsageList still needs another separated api call. Fix: 315449973 Test: manual - on DataUsageList page Test: unit tests Change-Id: I96c23dd7d0d40ecd183e0fb0f61329db42dae1ab
2023-12-15 16:36:05 +08:00
parent cb9870b087
commit 51fc4bef49
14 changed files with 405 additions and 196 deletions
--- a/src/com/android/settings/datausage/ChartDataUsagePreferenceController.kt
+++ b/src/com/android/settings/datausage/ChartDataUsagePreferenceController.kt
@@ -18,39 +18,22 @@ package com.android.settings.datausage

 import android.content.Context
 import android.net.NetworkTemplate
-import androidx.annotation.OpenForTesting
-import androidx.annotation.VisibleForTesting
-import androidx.lifecycle.LifecycleCoroutineScope
-import androidx.lifecycle.LifecycleOwner
-import androidx.lifecycle.lifecycleScope
 import androidx.preference.PreferenceScreen
 import com.android.settings.core.BasePreferenceController
 import com.android.settings.datausage.lib.INetworkCycleDataRepository
 import com.android.settings.datausage.lib.NetworkCycleChartData
 import com.android.settings.datausage.lib.NetworkCycleDataRepository
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext

-@OpenForTesting
-open class ChartDataUsagePreferenceController(context: Context, preferenceKey: String) :
+class ChartDataUsagePreferenceController(context: Context, preferenceKey: String) :
    BasePreferenceController(context, preferenceKey) {

    private lateinit var repository: INetworkCycleDataRepository
    private lateinit var preference: ChartDataUsagePreference
-    private lateinit var lifecycleScope: LifecycleCoroutineScope
-    private var lastStartTime: Long? = null
-    private var lastEndTime: Long? = null

-    open fun init(template: NetworkTemplate) {
+    fun init(template: NetworkTemplate) {
        this.repository = NetworkCycleDataRepository(mContext, template)
    }

-    @VisibleForTesting
-    fun init(repository: INetworkCycleDataRepository) {
-        this.repository = repository
-    }
-
    override fun getAvailabilityStatus() = AVAILABLE

    override fun displayPreference(screen: PreferenceScreen) {
@@ -58,33 +41,20 @@ open class ChartDataUsagePreferenceController(context: Context, preferenceKey: S
        preference = screen.findPreference(preferenceKey)!!
    }

-    override fun onViewCreated(viewLifecycleOwner: LifecycleOwner) {
-        lifecycleScope = viewLifecycleOwner.lifecycleScope
-    }
-
    /**
     * Sets whether billing cycle modifiable.
     *
     * Don't bind warning / limit sweeps if not modifiable.
     */
-    open fun setBillingCycleModifiable(isModifiable: Boolean) {
+    fun setBillingCycleModifiable(isModifiable: Boolean) {
        preference.setNetworkPolicy(
            if (isModifiable) repository.getPolicy() else null
        )
    }

-    fun update(startTime: Long, endTime: Long) {
-        if (lastStartTime == startTime && lastEndTime == endTime) return
-        lastStartTime = startTime
-        lastEndTime = endTime
-
-        preference.setTime(startTime, endTime)
-        preference.setNetworkCycleData(NetworkCycleChartData.AllZero)
-        lifecycleScope.launch {
-            val chartData = withContext(Dispatchers.Default) {
-                repository.queryChartData(startTime, endTime)
-            }
-            preference.setNetworkCycleData(chartData)
-        }
+    /** Updates chart to show selected cycle. */
+    fun update(chartData: NetworkCycleChartData) {
+        preference.setTime(chartData.total.startTime, chartData.total.endTime)
+        preference.setNetworkCycleData(chartData)
    }
 }
--- a/src/com/android/settings/datausage/DataUsageList.kt
+++ b/src/com/android/settings/datausage/DataUsageList.kt
@@ -27,6 +27,7 @@ import android.util.Log
 import android.view.View
 import androidx.annotation.OpenForTesting
 import androidx.annotation.VisibleForTesting
+import androidx.fragment.app.viewModels
 import androidx.preference.Preference
 import com.android.settings.R
 import com.android.settings.datausage.lib.BillingCycleRepository
@@ -59,6 +60,8 @@ open class DataUsageList : DataUsageBaseFragment() {
    private lateinit var chartDataUsagePreferenceController: ChartDataUsagePreferenceController
    private lateinit var billingCycleRepository: BillingCycleRepository

+    private val viewModel: DataUsageListViewModel by viewModels()
+
    @VisibleForTesting
    var dataUsageListHeaderController: DataUsageListHeaderController? = null

@@ -104,14 +107,21 @@ open class DataUsageList : DataUsageBaseFragment() {
            .collectLatestWithLifecycle(viewLifecycleOwner) { updatePolicy() }

        val template = template ?: return
+        viewModel.templateFlow.value = template
        dataUsageListHeaderController = DataUsageListHeaderController(
            setPinnedHeaderView(R.layout.apps_filter_spinner),
            template,
            metricsCategory,
            viewLifecycleOwner,
-            ::onCyclesLoad,
+            viewModel.cyclesFlow,
            ::updateSelectedCycle,
        )
+        viewModel.cyclesFlow.collectLatestWithLifecycle(viewLifecycleOwner) { cycles ->
+            dataUsageListAppsController.updateCycles(cycles)
+        }
+        viewModel.chartDataFlow.collectLatestWithLifecycle(viewLifecycleOwner) { chartData ->
+            chartDataUsagePreferenceController.update(chartData)
+        }
    }

    override fun getPreferenceScreenResId() = R.xml.data_usage_list
@@ -158,10 +168,6 @@ open class DataUsageList : DataUsageBaseFragment() {
                .getActiveSubscriptionInfo(subId) != null)
    }

-    private fun onCyclesLoad(networkUsageData: List<NetworkUsageData>) {
-        dataUsageListAppsController.updateCycles(networkUsageData)
-    }
-
    /**
     * Updates the chart and detail data when initial loaded or selected cycle changed.
     */
@@ -169,19 +175,11 @@ open class DataUsageList : DataUsageBaseFragment() {
        Log.d(TAG, "showing cycle $usageData")

        usageAmount.title = usageData.getDataUsedString(requireContext())
+        viewModel.selectedCycleFlow.value = usageData

-        updateChart(usageData)
        updateApps(usageData)
    }

-    /** Updates chart to show selected cycle. */
-    private fun updateChart(usageData: NetworkUsageData) {
-        chartDataUsagePreferenceController.update(
-            startTime = usageData.startTime,
-            endTime = usageData.endTime,
-        )
-    }
-
    /** Updates applications data usage. */
    private fun updateApps(usageData: NetworkUsageData) {
        dataUsageListAppsController.update(
--- a/src/com/android/settings/datausage/DataUsageListHeaderController.kt
+++ b/src/com/android/settings/datausage/DataUsageListHeaderController.kt
@@ -24,19 +24,13 @@ import android.view.accessibility.AccessibilityEvent
 import android.widget.AdapterView
 import android.widget.Spinner
 import androidx.annotation.OpenForTesting
-import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.LifecycleOwner
-import androidx.lifecycle.lifecycleScope
-import androidx.lifecycle.repeatOnLifecycle
 import com.android.settings.R
 import com.android.settings.core.SubSettingLauncher
 import com.android.settings.datausage.CycleAdapter.SpinnerInterface
-import com.android.settings.datausage.lib.INetworkCycleDataRepository
-import com.android.settings.datausage.lib.NetworkCycleDataRepository
 import com.android.settings.datausage.lib.NetworkUsageData
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
+import com.android.settingslib.spa.framework.util.collectLatestWithLifecycle
+import kotlinx.coroutines.flow.Flow

@OpenForTesting
 open class DataUsageListHeaderController(
@@ -44,10 +38,8 @@ open class DataUsageListHeaderController(
    template: NetworkTemplate,
    sourceMetricsCategory: Int,
    viewLifecycleOwner: LifecycleOwner,
-    private val onCyclesLoad: (usageDataList: List<NetworkUsageData>) -> Unit,
+    cyclesFlow: Flow<List<NetworkUsageData>>,
    private val updateSelectedCycle: (usageData: NetworkUsageData) -> Unit,
-    private val repository: INetworkCycleDataRepository =
-        NetworkCycleDataRepository(header.context, template),
 ) {
    private val context = header.context

@@ -104,13 +96,9 @@ open class DataUsageListHeaderController(
            }
        }

-        viewLifecycleOwner.lifecycleScope.launch {
-            viewLifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
-                cycles = withContext(Dispatchers.Default) {
-                    repository.loadCycles()
-                }
-                updateCycleData()
-            }
+        cyclesFlow.collectLatestWithLifecycle(viewLifecycleOwner) {
+            cycles = it
+            updateCycleData()
        }
    }

@@ -121,7 +109,6 @@ open class DataUsageListHeaderController(
    private fun updateCycleData() {
        cycleAdapter.updateCycleList(cycles.map { Range(it.startTime, it.endTime) })
        cycleSpinner.visibility = View.VISIBLE
-        onCyclesLoad(cycles)
    }

    private fun setSelectedCycle(position: Int) {
--- a/src/com/android/settings/datausage/DataUsageListViewModel.kt
+++ b/src/com/android/settings/datausage/DataUsageListViewModel.kt
@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2023 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.datausage
+
+import android.app.Application
+import android.net.NetworkTemplate
+import androidx.lifecycle.AndroidViewModel
+import androidx.lifecycle.viewModelScope
+import com.android.settings.datausage.lib.NetworkCycleBucketRepository
+import com.android.settings.datausage.lib.NetworkStatsRepository
+import com.android.settings.datausage.lib.NetworkStatsRepository.Companion.Bucket
+import com.android.settings.datausage.lib.NetworkStatsRepository.Companion.filterTime
+import com.android.settings.datausage.lib.NetworkUsageData
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.filterNotNull
+import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.plus
+
+data class SelectedBuckets(
+    val selectedCycle: NetworkUsageData,
+    val buckets: List<Bucket>,
+)
+
+class DataUsageListViewModel(application: Application) : AndroidViewModel(application) {
+    private val scope = viewModelScope + Dispatchers.Default
+
+    val templateFlow = MutableStateFlow<NetworkTemplate?>(null)
+
+    private val bucketsFlow = templateFlow.filterNotNull().map { template ->
+        NetworkStatsRepository(getApplication(), template).queryDetailsForDevice()
+    }.stateIn(scope, SharingStarted.WhileSubscribed(), emptyList())
+
+    val cyclesFlow = combine(templateFlow.filterNotNull(), bucketsFlow) { template, buckets ->
+        NetworkCycleBucketRepository(application, template, buckets).loadCycles()
+    }.flowOn(Dispatchers.Default)
+
+    val selectedCycleFlow = MutableStateFlow<NetworkUsageData?>(null)
+
+    private val selectedBucketsFlow =
+        combine(selectedCycleFlow.filterNotNull(), bucketsFlow) { selectedCycle, buckets ->
+            SelectedBuckets(
+                selectedCycle = selectedCycle,
+                buckets = buckets.filterTime(selectedCycle.startTime, selectedCycle.endTime),
+            )
+        }.flowOn(Dispatchers.Default)
+
+    val chartDataFlow =
+        combine(templateFlow.filterNotNull(), selectedBucketsFlow) { template, selectedBuckets ->
+            NetworkCycleBucketRepository(application, template, selectedBuckets.buckets)
+                .queryChartData(selectedBuckets.selectedCycle)
+        }.flowOn(Dispatchers.Default)
+}
--- a/src/com/android/settings/datausage/lib/NetworkCycleBucketRepository.kt
+++ b/src/com/android/settings/datausage/lib/NetworkCycleBucketRepository.kt
@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2023 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.datausage.lib
+
+import android.content.Context
+import android.net.NetworkTemplate
+import android.text.format.DateUtils
+import android.util.Range
+import com.android.settings.datausage.lib.NetworkCycleDataRepository.Companion.bucketRange
+import com.android.settings.datausage.lib.NetworkCycleDataRepository.Companion.reverseBucketRange
+import com.android.settings.datausage.lib.NetworkStatsRepository.Companion.Bucket
+import com.android.settings.datausage.lib.NetworkStatsRepository.Companion.aggregate
+import com.android.settings.datausage.lib.NetworkStatsRepository.Companion.filterTime
+
+class NetworkCycleBucketRepository(
+    context: Context,
+    networkTemplate: NetworkTemplate,
+    private val buckets: List<Bucket>,
+    private val networkCycleDataRepository: NetworkCycleDataRepository =
+        NetworkCycleDataRepository(context, networkTemplate)
+) {
+
+    fun loadCycles(): List<NetworkUsageData> =
+        getCycles().map { aggregateUsage(it) }.filter { it.usage > 0 }
+
+    private fun getCycles(): List<Range<Long>> {
+        val policy = networkCycleDataRepository.getPolicy() ?: return queryCyclesAsFourWeeks()
+        return policy.cycleIterator().asSequence().map {
+            Range(it.lower.toInstant().toEpochMilli(), it.upper.toInstant().toEpochMilli())
+        }.toList()
+    }
+
+    private fun queryCyclesAsFourWeeks(): List<Range<Long>> {
+        val timeRange = buckets.aggregate()?.timeRange ?: return emptyList()
+        return reverseBucketRange(
+            startTime = timeRange.lower,
+            endTime = timeRange.upper,
+            step = DateUtils.WEEK_IN_MILLIS * 4,
+        )
+    }
+
+    fun queryChartData(usageData: NetworkUsageData) = NetworkCycleChartData(
+        total = usageData,
+        dailyUsage = bucketRange(
+            startTime = usageData.startTime,
+            endTime = usageData.endTime,
+            step = NetworkCycleChartData.BUCKET_DURATION.inWholeMilliseconds,
+        ).map { aggregateUsage(it) },
+    )
+
+    private fun aggregateUsage(range: Range<Long>) = NetworkUsageData(
+        startTime = range.lower,
+        endTime = range.upper,
+        usage = buckets.filterTime(range.lower, range.upper).aggregate()?.usage ?: 0,
+    )
+}
--- a/src/com/android/settings/datausage/lib/NetworkCycleChartData.kt
+++ b/src/com/android/settings/datausage/lib/NetworkCycleChartData.kt
@@ -26,11 +26,6 @@ data class NetworkCycleChartData(
    val dailyUsage: List<NetworkUsageData>,
 ) {
    companion object {
-        val AllZero = NetworkCycleChartData(
-            total = NetworkUsageData.AllZero,
-            dailyUsage = emptyList(),
-        )
-
        val BUCKET_DURATION = 1.days
    }
 }
--- a/src/com/android/settings/datausage/lib/NetworkCycleDataRepository.kt
+++ b/src/com/android/settings/datausage/lib/NetworkCycleDataRepository.kt
@@ -23,13 +23,10 @@ import android.net.NetworkTemplate
 import android.text.format.DateUtils
 import android.util.Range
 import com.android.settingslib.NetworkPolicyEditor
-import com.android.settingslib.spa.framework.util.asyncMap

 interface INetworkCycleDataRepository {
-    suspend fun loadCycles(): List<NetworkUsageData>
    fun getCycles(): List<Range<Long>>
    fun getPolicy(): NetworkPolicy?
-    suspend fun queryChartData(startTime: Long, endTime: Long): NetworkCycleChartData?
 }

 class NetworkCycleDataRepository(
@@ -41,9 +38,6 @@ class NetworkCycleDataRepository(

    private val policyManager = context.getSystemService(NetworkPolicyManager::class.java)!!

-    override suspend fun loadCycles(): List<NetworkUsageData> =
-        getCycles().queryUsage().filter { it.usage > 0 }
-
    fun loadFirstCycle(): NetworkUsageData? = getCycles().firstOrNull()?.let { queryUsage(it) }

    override fun getCycles(): List<Range<Long>> {
@@ -68,23 +62,6 @@ class NetworkCycleDataRepository(
            getPolicy(networkTemplate)
        }

-    override suspend fun queryChartData(startTime: Long, endTime: Long): NetworkCycleChartData? {
-        val usage = networkStatsRepository.querySummaryForDevice(startTime, endTime)
-        if (usage > 0L) {
-            return NetworkCycleChartData(
-                total = NetworkUsageData(startTime, endTime, usage),
-                dailyUsage = bucketRange(
-                    startTime = startTime,
-                    endTime = endTime,
-                    step = NetworkCycleChartData.BUCKET_DURATION.inWholeMilliseconds,
-                ).queryUsage(),
-            )
-        }
-        return null
-    }
-
-    private suspend fun List<Range<Long>>.queryUsage(): List<NetworkUsageData> =
-        asyncMap { queryUsage(it) }

    fun queryUsage(range: Range<Long>) = NetworkUsageData(
        startTime = range.lower,
@@ -92,10 +69,12 @@ class NetworkCycleDataRepository(
        usage = networkStatsRepository.querySummaryForDevice(range.lower, range.upper),
    )

-    private fun bucketRange(startTime: Long, endTime: Long, step: Long): List<Range<Long>> =
-        (startTime..endTime step step).zipWithNext(::Range)
+    companion object {
+        fun bucketRange(startTime: Long, endTime: Long, step: Long): List<Range<Long>> =
+            (startTime..endTime step step).zipWithNext(::Range)

-    private fun reverseBucketRange(startTime: Long, endTime: Long, step: Long): List<Range<Long>> =
-        (endTime downTo (startTime - step + 1) step step)
-            .zipWithNext { bucketEnd, bucketStart -> Range(bucketStart, bucketEnd) }
+        fun reverseBucketRange(startTime: Long, endTime: Long, step: Long): List<Range<Long>> =
+            (endTime downTo (startTime - step + 1) step step)
+                .zipWithNext { bucketEnd, bucketStart -> Range(bucketStart, bucketEnd) }
+    }
 }
--- a/src/com/android/settings/datausage/lib/NetworkStatsRepository.kt
+++ b/src/com/android/settings/datausage/lib/NetworkStatsRepository.kt
@@ -33,20 +33,22 @@ class NetworkStatsRepository(context: Context, private val template: NetworkTemp
    ): NetworkUsageData? = try {
        networkStatsManager.queryDetailsForUidTagState(
            template, range.lower, range.upper, uid, NetworkStats.Bucket.TAG_NONE, state,
-        ).aggregate()
+        ).convertToBuckets().aggregate()
    } catch (e: Exception) {
        Log.e(TAG, "Exception queryDetailsForUidTagState", e)
        null
    }

-    fun getTimeRange(): Range<Long>? = try {
+    fun queryDetailsForDevice(): List<Bucket> = try {
        networkStatsManager.queryDetailsForDevice(template, Long.MIN_VALUE, Long.MAX_VALUE)
-            .aggregate()?.timeRange
+            .convertToBuckets()
    } catch (e: Exception) {
        Log.e(TAG, "Exception queryDetailsForDevice", e)
-        null
+        emptyList()
    }

+    fun getTimeRange(): Range<Long>? = queryDetailsForDevice().aggregate()?.timeRange
+
    fun querySummaryForDevice(startTime: Long, endTime: Long): Long = try {
        networkStatsManager.querySummaryForDevice(template, startTime, endTime).bytes
    } catch (e: Exception) {
@@ -70,33 +72,38 @@ class NetworkStatsRepository(context: Context, private val template: NetworkTemp
            val uid: Int,
            val bytes: Long,
            val state: Int = NetworkStats.Bucket.STATE_ALL,
+            val startTimeStamp: Long,
+            val endTimeStamp: Long,
        )

+        fun List<Bucket>.aggregate(): NetworkUsageData? = when {
+            isEmpty() -> null
+            else -> NetworkUsageData(
+                startTime = minOf { it.startTimeStamp },
+                endTime = maxOf { it.endTimeStamp },
+                usage = sumOf { it.bytes },
+            )
+        }
+
+        fun List<Bucket>.filterTime(startTime: Long, endTime: Long): List<Bucket> = filter {
+            it.startTimeStamp >= startTime && it.endTimeStamp <= endTime
+        }
+
        private fun NetworkStats.convertToBuckets(): List<Bucket> = use {
            val buckets = mutableListOf<Bucket>()
            val bucket = NetworkStats.Bucket()
            while (getNextBucket(bucket)) {
-                buckets += Bucket(uid = bucket.uid, bytes = bucket.bytes, state = bucket.state)
+                buckets += Bucket(
+                    uid = bucket.uid,
+                    bytes = bucket.bytes,
+                    state = bucket.state,
+                    startTimeStamp = bucket.startTimeStamp,
+                    endTimeStamp = bucket.endTimeStamp,
+                )
            }
            buckets
        }

-        private fun NetworkStats.aggregate(): NetworkUsageData? = use {
-            var startTime = Long.MAX_VALUE
-            var endTime = Long.MIN_VALUE
-            var usage = 0L
-            val bucket = NetworkStats.Bucket()
-            while (getNextBucket(bucket)) {
-                startTime = startTime.coerceAtMost(bucket.startTimeStamp)
-                endTime = endTime.coerceAtLeast(bucket.endTimeStamp)
-                usage += bucket.bytes
-            }
-            when {
-                startTime > endTime -> null
-                else -> NetworkUsageData(startTime, endTime, usage)
-            }
-        }
-
        private val NetworkStats.Bucket.bytes: Long
            get() = rxBytes + txBytes
    }