Merge "Set up demo mode repository for mobile icons" into tm-qpr-dev am: a2c6879a83 (f7e551d8) · Commits · e / os / android_frameworks_base

packages/SystemUI/src/com/android/systemui/statusbar/pipeline/dagger/StatusBarPipelineModule.kt

+2 −2

Original line number	Diff line number	Diff line
		@@ -25,7 +25,7 @@ import com.android.systemui.statusbar.pipeline.airplane.data.repository.Airplane
		import com.android.systemui.statusbar.pipeline.airplane.ui.viewmodel.AirplaneModeViewModel
		import com.android.systemui.statusbar.pipeline.airplane.ui.viewmodel.AirplaneModeViewModelImpl
		import com.android.systemui.statusbar.pipeline.mobile.data.repository.MobileConnectionsRepository
		import com.android.systemui.statusbar.pipeline.mobile.data.repository.MobileConnectionsRepositoryImpl
		import com.android.systemui.statusbar.pipeline.mobile.data.repository.MobileRepositorySwitcher
		import com.android.systemui.statusbar.pipeline.mobile.data.repository.UserSetupRepository
		import com.android.systemui.statusbar.pipeline.mobile.data.repository.UserSetupRepositoryImpl
		import com.android.systemui.statusbar.pipeline.mobile.domain.interactor.MobileIconsInteractor
		@@ -63,7 +63,7 @@ abstract class StatusBarPipelineModule {

		@Binds
		abstract fun mobileConnectionsRepository(
		impl: MobileConnectionsRepositoryImpl
		impl: MobileRepositorySwitcher
		): MobileConnectionsRepository

		@Binds abstract fun userSetupRepository(impl: UserSetupRepositoryImpl): UserSetupRepository

packages/SystemUI/src/com/android/systemui/statusbar/pipeline/mobile/data/repository/MobileConnectionRepository.kt

+0 −211

Original line number	Diff line number	Diff line
		@@ -16,44 +16,13 @@

		package com.android.systemui.statusbar.pipeline.mobile.data.repository

		import android.content.Context
		import android.database.ContentObserver
		import android.provider.Settings.Global
		import android.telephony.CellSignalStrength
		import android.telephony.CellSignalStrengthCdma
		import android.telephony.ServiceState
		import android.telephony.SignalStrength
		import android.telephony.SubscriptionInfo
		import android.telephony.SubscriptionManager
		import android.telephony.TelephonyCallback
		import android.telephony.TelephonyDisplayInfo
		import android.telephony.TelephonyDisplayInfo.OVERRIDE_NETWORK_TYPE_NONE
		import android.telephony.TelephonyManager
		import com.android.systemui.common.coroutine.ConflatedCallbackFlow.conflatedCallbackFlow
		import com.android.systemui.dagger.qualifiers.Application
		import com.android.systemui.dagger.qualifiers.Background
		import com.android.systemui.statusbar.pipeline.mobile.data.model.DefaultNetworkType
		import com.android.systemui.statusbar.pipeline.mobile.data.model.MobileSubscriptionModel
		import com.android.systemui.statusbar.pipeline.mobile.data.model.OverrideNetworkType
		import com.android.systemui.statusbar.pipeline.mobile.data.model.toDataConnectionType
		import com.android.systemui.statusbar.pipeline.shared.ConnectivityPipelineLogger
		import com.android.systemui.statusbar.pipeline.shared.ConnectivityPipelineLogger.Companion.logOutputChange
		import com.android.systemui.util.settings.GlobalSettings
		import java.lang.IllegalStateException
		import javax.inject.Inject
		import kotlinx.coroutines.CoroutineDispatcher
		import kotlinx.coroutines.CoroutineScope
		import kotlinx.coroutines.ExperimentalCoroutinesApi
		import kotlinx.coroutines.asExecutor
		import kotlinx.coroutines.channels.awaitClose
		import kotlinx.coroutines.flow.Flow
		import kotlinx.coroutines.flow.MutableSharedFlow
		import kotlinx.coroutines.flow.SharingStarted
		import kotlinx.coroutines.flow.StateFlow
		import kotlinx.coroutines.flow.mapLatest
		import kotlinx.coroutines.flow.merge
		import kotlinx.coroutines.flow.onEach
		import kotlinx.coroutines.flow.stateIn

		/**
		* Every mobile line of service can be identified via a [SubscriptionInfo] object. We set up a
		@@ -80,183 +49,3 @@ interface MobileConnectionRepository {
		*/
		val isDefaultDataSubscription: StateFlow<Boolean>
		}

		@Suppress("EXPERIMENTAL_IS_NOT_ENABLED")
		@OptIn(ExperimentalCoroutinesApi::class)
		class MobileConnectionRepositoryImpl(
		private val context: Context,
		private val subId: Int,
		private val telephonyManager: TelephonyManager,
		private val globalSettings: GlobalSettings,
		defaultDataSubId: StateFlow<Int>,
		globalMobileDataSettingChangedEvent: Flow<Unit>,
		bgDispatcher: CoroutineDispatcher,
		logger: ConnectivityPipelineLogger,
		scope: CoroutineScope,
		) : MobileConnectionRepository {
		init {
		if (telephonyManager.subscriptionId != subId) {
		throw IllegalStateException(
		"TelephonyManager should be created with subId($subId). " +
		"Found ${telephonyManager.subscriptionId} instead."
		)
		}
		}

		private val telephonyCallbackEvent = MutableSharedFlow<Unit>(extraBufferCapacity = 1)

		override val subscriptionModelFlow: StateFlow<MobileSubscriptionModel> = run {
		var state = MobileSubscriptionModel()
		conflatedCallbackFlow {
		// TODO (b/240569788): log all of these into the connectivity logger
		val callback =
		object :
		TelephonyCallback(),
		TelephonyCallback.ServiceStateListener,
		TelephonyCallback.SignalStrengthsListener,
		TelephonyCallback.DataConnectionStateListener,
		TelephonyCallback.DataActivityListener,
		TelephonyCallback.CarrierNetworkListener,
		TelephonyCallback.DisplayInfoListener {
		override fun onServiceStateChanged(serviceState: ServiceState) {
		state = state.copy(isEmergencyOnly = serviceState.isEmergencyOnly)
		trySend(state)
		}

		override fun onSignalStrengthsChanged(signalStrength: SignalStrength) {
		val cdmaLevel =
		signalStrength
		.getCellSignalStrengths(CellSignalStrengthCdma::class.java)
		.let { strengths ->
		if (!strengths.isEmpty()) {
		strengths[0].level
		} else {
		CellSignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN
		}
		}

		val primaryLevel = signalStrength.level

		state =
		state.copy(
		cdmaLevel = cdmaLevel,
		primaryLevel = primaryLevel,
		isGsm = signalStrength.isGsm,
		)
		trySend(state)
		}

		override fun onDataConnectionStateChanged(
		dataState: Int,
		networkType: Int
		) {
		state =
		state.copy(dataConnectionState = dataState.toDataConnectionType())
		trySend(state)
		}

		override fun onDataActivity(direction: Int) {
		state = state.copy(dataActivityDirection = direction)
		trySend(state)
		}

		override fun onCarrierNetworkChange(active: Boolean) {
		state = state.copy(carrierNetworkChangeActive = active)
		trySend(state)
		}

		override fun onDisplayInfoChanged(
		telephonyDisplayInfo: TelephonyDisplayInfo
		) {
		val networkType =
		if (
		telephonyDisplayInfo.overrideNetworkType ==
		OVERRIDE_NETWORK_TYPE_NONE
		) {
		DefaultNetworkType(telephonyDisplayInfo.networkType)
		} else {
		OverrideNetworkType(telephonyDisplayInfo.overrideNetworkType)
		}
		state = state.copy(resolvedNetworkType = networkType)
		trySend(state)
		}
		}
		telephonyManager.registerTelephonyCallback(bgDispatcher.asExecutor(), callback)
		awaitClose { telephonyManager.unregisterTelephonyCallback(callback) }
		}
		.onEach { telephonyCallbackEvent.tryEmit(Unit) }
		.logOutputChange(logger, "MobileSubscriptionModel")
		.stateIn(scope, SharingStarted.WhileSubscribed(), state)
		}

		/** Produces whenever the mobile data setting changes for this subId */
		private val localMobileDataSettingChangedEvent: Flow<Unit> = conflatedCallbackFlow {
		val observer =
		object : ContentObserver(null) {
		override fun onChange(selfChange: Boolean) {
		trySend(Unit)
		}
		}

		globalSettings.registerContentObserver(
		globalSettings.getUriFor("${Global.MOBILE_DATA}$subId"),
		/* notifyForDescendants */ true,
		observer
		)

		awaitClose { context.contentResolver.unregisterContentObserver(observer) }
		}

		/**
		* There are a few cases where we will need to poll [TelephonyManager] so we can update some
		* internal state where callbacks aren't provided. Any of those events should be merged into
		* this flow, which can be used to trigger the polling.
		*/
		private val telephonyPollingEvent: Flow<Unit> =
		merge(
		telephonyCallbackEvent,
		localMobileDataSettingChangedEvent,
		globalMobileDataSettingChangedEvent,
		)

		override val dataEnabled: StateFlow<Boolean> =
		telephonyPollingEvent
		.mapLatest { dataConnectionAllowed() }
		.stateIn(scope, SharingStarted.WhileSubscribed(), dataConnectionAllowed())

		private fun dataConnectionAllowed(): Boolean = telephonyManager.isDataConnectionAllowed

		override val isDefaultDataSubscription: StateFlow<Boolean> =
		defaultDataSubId
		.mapLatest { it == subId }
		.stateIn(scope, SharingStarted.WhileSubscribed(), defaultDataSubId.value == subId)

		class Factory
		@Inject
		constructor(
		private val context: Context,
		private val telephonyManager: TelephonyManager,
		private val logger: ConnectivityPipelineLogger,
		private val globalSettings: GlobalSettings,
		@Background private val bgDispatcher: CoroutineDispatcher,
		@Application private val scope: CoroutineScope,
		) {
		fun build(
		subId: Int,
		defaultDataSubId: StateFlow<Int>,
		globalMobileDataSettingChangedEvent: Flow<Unit>,
		): MobileConnectionRepository {
		return MobileConnectionRepositoryImpl(
		context,
		subId,
		telephonyManager.createForSubscriptionId(subId),
		globalSettings,
		defaultDataSubId,
		globalMobileDataSettingChangedEvent,
		bgDispatcher,
		logger,
		scope,
		)
		}
		}
		}

packages/SystemUI/src/com/android/systemui/statusbar/pipeline/mobile/data/repository/MobileConnectionsRepository.kt

+0 −238

Original line number	Diff line number	Diff line
		@@ -16,53 +16,14 @@

		package com.android.systemui.statusbar.pipeline.mobile.data.repository

		import android.annotation.SuppressLint
		import android.content.Context
		import android.content.IntentFilter
		import android.database.ContentObserver
		import android.net.ConnectivityManager
		import android.net.ConnectivityManager.NetworkCallback
		import android.net.Network
		import android.net.NetworkCapabilities
		import android.net.NetworkCapabilities.NET_CAPABILITY_VALIDATED
		import android.net.NetworkCapabilities.TRANSPORT_CELLULAR
		import android.provider.Settings
		import android.provider.Settings.Global.MOBILE_DATA
		import android.telephony.CarrierConfigManager
		import android.telephony.SubscriptionInfo
		import android.telephony.SubscriptionManager
		import android.telephony.SubscriptionManager.INVALID_SUBSCRIPTION_ID
		import android.telephony.TelephonyCallback
		import android.telephony.TelephonyCallback.ActiveDataSubscriptionIdListener
		import android.telephony.TelephonyManager
		import androidx.annotation.VisibleForTesting
		import com.android.internal.telephony.PhoneConstants
		import com.android.settingslib.mobile.MobileMappings
		import com.android.settingslib.mobile.MobileMappings.Config
		import com.android.systemui.broadcast.BroadcastDispatcher
		import com.android.systemui.common.coroutine.ConflatedCallbackFlow.conflatedCallbackFlow
		import com.android.systemui.dagger.SysUISingleton
		import com.android.systemui.dagger.qualifiers.Application
		import com.android.systemui.dagger.qualifiers.Background
		import com.android.systemui.statusbar.pipeline.mobile.data.model.MobileConnectivityModel
		import com.android.systemui.statusbar.pipeline.shared.ConnectivityPipelineLogger
		import com.android.systemui.util.settings.GlobalSettings
		import javax.inject.Inject
		import kotlinx.coroutines.CoroutineDispatcher
		import kotlinx.coroutines.CoroutineScope
		import kotlinx.coroutines.ExperimentalCoroutinesApi
		import kotlinx.coroutines.asExecutor
		import kotlinx.coroutines.channels.awaitClose
		import kotlinx.coroutines.flow.Flow
		import kotlinx.coroutines.flow.MutableSharedFlow
		import kotlinx.coroutines.flow.SharingStarted
		import kotlinx.coroutines.flow.StateFlow
		import kotlinx.coroutines.flow.distinctUntilChanged
		import kotlinx.coroutines.flow.mapLatest
		import kotlinx.coroutines.flow.merge
		import kotlinx.coroutines.flow.onEach
		import kotlinx.coroutines.flow.stateIn
		import kotlinx.coroutines.withContext

		/**
		* Repo for monitoring the complete active subscription info list, to be consumed and filtered based
		@@ -90,202 +51,3 @@ interface MobileConnectionsRepository {
		/** Observe changes to the [Settings.Global.MOBILE_DATA] setting */
		val globalMobileDataSettingChangedEvent: Flow<Unit>
		}

		@Suppress("EXPERIMENTAL_IS_NOT_ENABLED")
		@OptIn(ExperimentalCoroutinesApi::class)
		@SysUISingleton
		class MobileConnectionsRepositoryImpl
		@Inject
		constructor(
		private val connectivityManager: ConnectivityManager,
		private val subscriptionManager: SubscriptionManager,
		private val telephonyManager: TelephonyManager,
		private val logger: ConnectivityPipelineLogger,
		broadcastDispatcher: BroadcastDispatcher,
		private val globalSettings: GlobalSettings,
		private val context: Context,
		@Background private val bgDispatcher: CoroutineDispatcher,
		@Application private val scope: CoroutineScope,
		private val mobileConnectionRepositoryFactory: MobileConnectionRepositoryImpl.Factory
		) : MobileConnectionsRepository {
		private val subIdRepositoryCache: MutableMap<Int, MobileConnectionRepository> = mutableMapOf()

		/**
		* State flow that emits the set of mobile data subscriptions, each represented by its own
		* [SubscriptionInfo]. We probably only need the [SubscriptionInfo.getSubscriptionId] of each
		* info object, but for now we keep track of the infos themselves.
		*/
		override val subscriptionsFlow: StateFlow<List<SubscriptionInfo>> =
		conflatedCallbackFlow {
		val callback =
		object : SubscriptionManager.OnSubscriptionsChangedListener() {
		override fun onSubscriptionsChanged() {
		trySend(Unit)
		}
		}

		subscriptionManager.addOnSubscriptionsChangedListener(
		bgDispatcher.asExecutor(),
		callback,
		)

		awaitClose { subscriptionManager.removeOnSubscriptionsChangedListener(callback) }
		}
		.mapLatest { fetchSubscriptionsList() }
		.onEach { infos -> dropUnusedReposFromCache(infos) }
		.stateIn(scope, started = SharingStarted.WhileSubscribed(), listOf())

		/** StateFlow that keeps track of the current active mobile data subscription */
		override val activeMobileDataSubscriptionId: StateFlow<Int> =
		conflatedCallbackFlow {
		val callback =
		object : TelephonyCallback(), ActiveDataSubscriptionIdListener {
		override fun onActiveDataSubscriptionIdChanged(subId: Int) {
		trySend(subId)
		}
		}

		telephonyManager.registerTelephonyCallback(bgDispatcher.asExecutor(), callback)
		awaitClose { telephonyManager.unregisterTelephonyCallback(callback) }
		}
		.stateIn(scope, started = SharingStarted.WhileSubscribed(), INVALID_SUBSCRIPTION_ID)

		private val defaultDataSubIdChangeEvent: MutableSharedFlow<Unit> =
		MutableSharedFlow(extraBufferCapacity = 1)

		override val defaultDataSubId: StateFlow<Int> =
		broadcastDispatcher
		.broadcastFlow(
		IntentFilter(TelephonyManager.ACTION_DEFAULT_DATA_SUBSCRIPTION_CHANGED)
		) { intent, _ ->
		intent.getIntExtra(PhoneConstants.SUBSCRIPTION_KEY, INVALID_SUBSCRIPTION_ID)
		}
		.distinctUntilChanged()
		.onEach { defaultDataSubIdChangeEvent.tryEmit(Unit) }
		.stateIn(
		scope,
		SharingStarted.WhileSubscribed(),
		SubscriptionManager.getDefaultDataSubscriptionId()
		)

		private val carrierConfigChangedEvent =
		broadcastDispatcher.broadcastFlow(
		IntentFilter(CarrierConfigManager.ACTION_CARRIER_CONFIG_CHANGED)
		)

		/**
		* [Config] is an object that tracks relevant configuration flags for a given subscription ID.
		* In the case of [MobileMappings], it's hard-coded to check the default data subscription's
		* config, so this will apply to every icon that we care about.
		*
		* Relevant bits in the config are things like
		* [CarrierConfigManager.KEY_SHOW_4G_FOR_LTE_DATA_ICON_BOOL]
		*
		* This flow will produce whenever the default data subscription or the carrier config changes.
		*/
		override val defaultDataSubRatConfig: StateFlow<Config> =
		merge(defaultDataSubIdChangeEvent, carrierConfigChangedEvent)
		.mapLatest { Config.readConfig(context) }
		.stateIn(
		scope,
		SharingStarted.WhileSubscribed(),
		initialValue = Config.readConfig(context)
		)

		override fun getRepoForSubId(subId: Int): MobileConnectionRepository {
		if (!isValidSubId(subId)) {
		throw IllegalArgumentException(
		"subscriptionId $subId is not in the list of valid subscriptions"
		)
		}

		return subIdRepositoryCache[subId]
		?: createRepositoryForSubId(subId).also { subIdRepositoryCache[subId] = it }
		}

		/**
		* In single-SIM devices, the [MOBILE_DATA] setting is phone-wide. For multi-SIM, the individual
		* connection repositories also observe the URI for [MOBILE_DATA] + subId.
		*/
		override val globalMobileDataSettingChangedEvent: Flow<Unit> = conflatedCallbackFlow {
		val observer =
		object : ContentObserver(null) {
		override fun onChange(selfChange: Boolean) {
		trySend(Unit)
		}
		}

		globalSettings.registerContentObserver(
		globalSettings.getUriFor(MOBILE_DATA),
		true,
		observer
		)

		awaitClose { context.contentResolver.unregisterContentObserver(observer) }
		}

		@SuppressLint("MissingPermission")
		override val defaultMobileNetworkConnectivity: StateFlow<MobileConnectivityModel> =
		conflatedCallbackFlow {
		val callback =
		object : NetworkCallback(FLAG_INCLUDE_LOCATION_INFO) {
		override fun onLost(network: Network) {
		// Send a disconnected model when lost. Maybe should create a sealed
		// type or null here?
		trySend(MobileConnectivityModel())
		}

		override fun onCapabilitiesChanged(
		network: Network,
		caps: NetworkCapabilities
		) {
		trySend(
		MobileConnectivityModel(
		isConnected = caps.hasTransport(TRANSPORT_CELLULAR),
		isValidated = caps.hasCapability(NET_CAPABILITY_VALIDATED),
		)
		)
		}
		}

		connectivityManager.registerDefaultNetworkCallback(callback)

		awaitClose { connectivityManager.unregisterNetworkCallback(callback) }
		}
		.stateIn(scope, SharingStarted.WhileSubscribed(), MobileConnectivityModel())

		private fun isValidSubId(subId: Int): Boolean {
		subscriptionsFlow.value.forEach {
		if (it.subscriptionId == subId) {
		return true
		}
		}

		return false
		}

		@VisibleForTesting fun getSubIdRepoCache() = subIdRepositoryCache

		private fun createRepositoryForSubId(subId: Int): MobileConnectionRepository {
		return mobileConnectionRepositoryFactory.build(
		subId,
		defaultDataSubId,
		globalMobileDataSettingChangedEvent,
		)
		}

		private fun dropUnusedReposFromCache(newInfos: List<SubscriptionInfo>) {
		// Remove any connection repository from the cache that isn't in the new set of IDs. They
		// will get garbage collected once their subscribers go away
		val currentValidSubscriptionIds = newInfos.map { it.subscriptionId }

		subIdRepositoryCache.keys.forEach {
		if (!currentValidSubscriptionIds.contains(it)) {
		subIdRepositoryCache.remove(it)
		}
		}
		}

		private suspend fun fetchSubscriptionsList(): List<SubscriptionInfo> =
		withContext(bgDispatcher) { subscriptionManager.completeActiveSubscriptionInfoList }
		}

packages/SystemUI/src/com/android/systemui/statusbar/pipeline/mobile/data/repository/MobileRepositorySwitcher.kt

0 → 100644

+162 −0

File added.

Preview size limit exceeded, changes collapsed.

packages/SystemUI/src/com/android/systemui/statusbar/pipeline/mobile/data/repository/demo/DemoMobileConnectionsRepository.kt

0 → 100644

+277 −0

File added.

Preview size limit exceeded, changes collapsed.