service/src/AutoOnFeature.kt - LeafOS-Project/android_packages_modules_Bluetooth - Gitiles

 /*
  * Copyright 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.
  */

 @file:JvmName("AutoOnFeature")

 package com.android.server.bluetooth

 import android.bluetooth.BluetoothAdapter.STATE_ON
 import android.content.BroadcastReceiver
 import android.content.ContentResolver
 import android.content.Context
 import android.content.Intent
 import android.content.IntentFilter
 import android.database.ContentObserver
 import android.os.Handler
 import android.os.Looper
 import android.provider.Settings
 import androidx.annotation.VisibleForTesting
 import com.android.modules.expresslog.Counter
 import com.android.server.bluetooth.airplane.hasUserToggledApm as hasUserToggledApm
 import com.android.server.bluetooth.airplane.isOn as isAirplaneModeOn
 import com.android.server.bluetooth.satellite.isOn as isSatelliteModeOn
 import java.time.LocalDateTime
 import java.time.LocalTime
 import java.time.temporal.ChronoUnit
 import kotlin.time.Duration
 import kotlin.time.DurationUnit
 import kotlin.time.toDuration

 private const val TAG = "AutoOnFeature"

 public fun resetAutoOnTimerForUser(
     looper: Looper,
     context: Context,
     state: BluetoothAdapterState,
     callback_on: () -> Unit
 ) {
     // Remove any previous timer
     timer?.cancel()
     timer = null

     if (!isFeatureEnabledForUser(context.contentResolver)) {
         Log.d(TAG, "Not Enabled for current user: ${context.getUser()}")
         return
     }
     if (state.oneOf(STATE_ON)) {
         Log.d(TAG, "Bluetooth already in ${state}, no need for timer")
         return
     }
     if (isSatelliteModeOn) {
         Log.d(TAG, "Satellite prevent feature activation")
         return
     }
     if (isAirplaneModeOn) {
         if (!hasUserToggledApm(context)) {
             Log.d(TAG, "Airplane prevent feature activation")
             return
         }
         Log.d(TAG, "Airplane bypassed as airplane enhanced mode has been activated previously")
     }

     val receiver =
         object : BroadcastReceiver() {
             override fun onReceive(ctx: Context, intent: Intent) {
                 Log.i(TAG, "Received ${intent.action} that trigger a new alarm scheduling")
                 pause()
                 resetAutoOnTimerForUser(looper, context, state, callback_on)
             }
         }

     timer = Timer.start(looper, context, receiver, callback_on)
 }

 public fun pause() {
     timer?.pause()
     timer = null
 }

 public fun notifyBluetoothOn(resolver: ContentResolver) {
     timer?.cancel()
     timer = null

     if (!isFeatureSupportedForUser(resolver)) {
         val defaultFeatureValue = true
         Log.i(TAG, "Feature was set to its default value ${defaultFeatureValue}")
         setFeatureEnabledForUserUnchecked(resolver, defaultFeatureValue)
     }
 }

 public fun isUserSupported(resolver: ContentResolver) = isFeatureSupportedForUser(resolver)

 public fun isUserEnabled(context: Context): Boolean {
     if (!isUserSupported(context.contentResolver)) {
         throw IllegalStateException("AutoOnFeature not supported for user: ${context.getUser()}")
     }
     return isFeatureEnabledForUser(context.contentResolver)
 }

 public fun setUserEnabled(
     looper: Looper,
     context: Context,
     state: BluetoothAdapterState,
     status: Boolean,
     callback_on: () -> Unit,
 ) {
     if (!isUserSupported(context.contentResolver)) {
         throw IllegalStateException("AutoOnFeature not supported for user: ${context.getUser()}")
     }
     setFeatureEnabledForUserUnchecked(context.contentResolver, status)
     Counter.logIncrement(
         if (status) "bluetooth.value_auto_on_enabled" else "bluetooth.value_auto_on_disabled"
     )
     resetAutoOnTimerForUser(looper, context, state, callback_on)
 }

 // Listener is needed because code should be actionable prior to V API release
 public fun registerHiddenApiListener(
     looper: Looper,
     context: Context,
     state: BluetoothAdapterState,
     callback_on: () -> Unit
 ) {
     HiddenApiListener.registerUser(looper, context, state, callback_on)
 }

 ////////////////////////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////// PRIVATE METHODS /////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////////////////////////

 @VisibleForTesting internal var timer: Timer? = null

 @VisibleForTesting
 internal class Timer
 private constructor(
     looper: Looper,
     private val context: Context,
     private val receiver: BroadcastReceiver,
     callback_on: () -> Unit,
     private val now: LocalDateTime,
     private val target: LocalDateTime,
     private val timeToSleep: Duration
 ) {
     private val handler = Handler(looper)

     init {
         writeDateToStorage(target, context.contentResolver)
         handler.postDelayed(
             {
                 Log.i(TAG, "[${this}]: Bluetooth restarting now")
                 callback_on()
                 cancel()
                 // Set global instance to null to prevent further action. Job is done here
                 timer = null
             },
             timeToSleep.inWholeMilliseconds
         )
         Log.i(TAG, "[${this}]: Scheduling next Bluetooth restart")

         context.registerReceiver(
             receiver,
             IntentFilter().apply {
                 addAction(Intent.ACTION_DATE_CHANGED)
                 addAction(Intent.ACTION_TIMEZONE_CHANGED)
                 addAction(Intent.ACTION_TIME_CHANGED)
             },
             null,
             handler
         )
     }

     companion object {
         @VisibleForTesting internal val STORAGE_KEY = "bluetooth_internal_automatic_turn_on_timer"

         private fun writeDateToStorage(date: LocalDateTime, resolver: ContentResolver): Boolean {
             return Settings.Secure.putString(resolver, STORAGE_KEY, date.toString())
         }

         private fun getDateFromStorage(resolver: ContentResolver): LocalDateTime? {
             val date = Settings.Secure.getString(resolver, STORAGE_KEY)
             return date?.let { LocalDateTime.parse(it) }
         }

         private fun resetStorage(resolver: ContentResolver) {
             Settings.Secure.putString(resolver, STORAGE_KEY, null)
         }

         fun start(
             looper: Looper,
             context: Context,
             receiver: BroadcastReceiver,
             callback_on: () -> Unit
         ): Timer? {
             val now = LocalDateTime.now()
             val target = getDateFromStorage(context.contentResolver) ?: nextTimeout(now)
             val timeToSleep =
                 now.until(target, ChronoUnit.NANOS).toDuration(DurationUnit.NANOSECONDS)

             if (timeToSleep.isNegative()) {
                 Log.i(TAG, "Starting now (${now}) as it was scheduled for ${target}")
                 callback_on()
                 resetStorage(context.contentResolver)
                 return null
             }

             return Timer(looper, context, receiver, callback_on, now, target, timeToSleep)
         }

         /** Return a LocalDateTime for tomorrow 5 am */
         private fun nextTimeout(now: LocalDateTime) =
             LocalDateTime.of(now.toLocalDate(), LocalTime.of(5, 0)).plusDays(1)
     }

     /** Save timer to storage and stop it */
     internal fun pause() {
         Log.i(TAG, "[${this}]: Pausing timer")
         context.unregisterReceiver(receiver)
         handler.removeCallbacksAndMessages(null)
     }

     /** Stop timer and reset storage */
     @VisibleForTesting
     internal fun cancel() {
         Log.i(TAG, "[${this}]: Cancelling timer")
         context.unregisterReceiver(receiver)
         handler.removeCallbacksAndMessages(null)
         resetStorage(context.contentResolver)
     }

     override fun toString() = "Timer scheduled ${now} for target=${target} (=${timeToSleep} delay)."
 }

 @VisibleForTesting internal val USER_SETTINGS_KEY = "bluetooth_automatic_turn_on"

 /**
  * *Do not use outside of this file to avoid async issues*
  *
  * @return whether the auto on feature is enabled for this user
  */
 private fun isFeatureEnabledForUser(resolver: ContentResolver): Boolean {
     return Settings.Secure.getInt(resolver, USER_SETTINGS_KEY, 0) == 1
 }

 /**
  * *Do not use outside of this file to avoid async issues*
  *
  * @return whether the auto on feature is supported for the user
  */
 private fun isFeatureSupportedForUser(resolver: ContentResolver): Boolean {
     return Settings.Secure.getInt(resolver, USER_SETTINGS_KEY, -1) != -1
 }

 /**
  * *Do not use outside of this file to avoid async issues*
  *
  * @return whether the auto on feature is enabled for this user
  */
 private fun setFeatureEnabledForUserUnchecked(resolver: ContentResolver, status: Boolean) {
     Settings.Secure.putInt(resolver, USER_SETTINGS_KEY, if (status) 1 else 0)
 }

 // Listener is needed because code should be actionable prior to V API release
 @VisibleForTesting
 internal class HiddenApiListener
 private constructor(
     looper: Looper,
     private val context: Context,
     state: BluetoothAdapterState,
     callback_on: () -> Unit
 ) {
     companion object {
         @VisibleForTesting internal var listener: HiddenApiListener? = null

         fun registerUser(
             looper: Looper,
             context: Context,
             state: BluetoothAdapterState,
             callback_on: () -> Unit
         ) {
             // Remove observer on previous user
             listener?.remove()
             listener = HiddenApiListener(looper, context, state, callback_on)
         }
     }

     private val handler = Handler(looper)

     private val observer =
         object : ContentObserver(handler) {
             override fun onChange(selfChange: Boolean) {
                 var previousState = featureState
                 var newState =
                     Settings.Secure.getInt(context.contentResolver, USER_SETTINGS_KEY, -1)
                 featureState = newState

                 if (previousState == newState) {
                     Log.d(TAG, "HiddenApi: State is unchanged: ${newState}")
                     return
                 }

                 if (previousState == -1) {
                     Log.d(TAG, "HiddenApi: Feature default state got setup to ${newState}")
                     return
                 }

                 Log.d(TAG, "HiddenApi: Feature state change from ${previousState} to ${newState}")

                 Counter.logIncrement("bluetooth.value_auto_on_hidden_usage")
                 Counter.logIncrement(
                     if (newState == 1) "bluetooth.value_auto_on_enabled"
                     else "bluetooth.value_auto_on_disabled"
                 )

                 resetAutoOnTimerForUser(looper, context, state, callback_on)
             }
         }

     private var featureState =
         Settings.Secure.getInt(context.contentResolver, USER_SETTINGS_KEY, -1)

     init {
         val notifyForDescendants = false

         context.contentResolver.registerContentObserver(
             Settings.Secure.getUriFor(USER_SETTINGS_KEY),
             notifyForDescendants,
             observer
         )
     }

     @VisibleForTesting
     internal fun remove() {
         context.contentResolver.unregisterContentObserver(observer)
         handler.removeCallbacksAndMessages(null)
     }
 }
	/*
	* Copyright 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.
	*/

	@file:JvmName("AutoOnFeature")

	package com.android.server.bluetooth

	import android.bluetooth.BluetoothAdapter.STATE_ON
	import android.content.BroadcastReceiver
	import android.content.ContentResolver
	import android.content.Context
	import android.content.Intent
	import android.content.IntentFilter
	import android.database.ContentObserver
	import android.os.Handler
	import android.os.Looper
	import android.provider.Settings
	import androidx.annotation.VisibleForTesting
	import com.android.modules.expresslog.Counter
	import com.android.server.bluetooth.airplane.hasUserToggledApm as hasUserToggledApm
	import com.android.server.bluetooth.airplane.isOn as isAirplaneModeOn
	import com.android.server.bluetooth.satellite.isOn as isSatelliteModeOn
	import java.time.LocalDateTime
	import java.time.LocalTime
	import java.time.temporal.ChronoUnit
	import kotlin.time.Duration
	import kotlin.time.DurationUnit
	import kotlin.time.toDuration

	private const val TAG = "AutoOnFeature"

	public fun resetAutoOnTimerForUser(
	looper: Looper,
	context: Context,
	state: BluetoothAdapterState,
	callback_on: () -> Unit
	) {
	// Remove any previous timer
	timer?.cancel()
	timer = null

	if (!isFeatureEnabledForUser(context.contentResolver)) {
	Log.d(TAG, "Not Enabled for current user: ${context.getUser()}")
	return
	}
	if (state.oneOf(STATE_ON)) {
	Log.d(TAG, "Bluetooth already in ${state}, no need for timer")
	return
	}
	if (isSatelliteModeOn) {
	Log.d(TAG, "Satellite prevent feature activation")
	return
	}
	if (isAirplaneModeOn) {
	if (!hasUserToggledApm(context)) {
	Log.d(TAG, "Airplane prevent feature activation")
	return
	}
	Log.d(TAG, "Airplane bypassed as airplane enhanced mode has been activated previously")
	}

	val receiver =
	object : BroadcastReceiver() {
	override fun onReceive(ctx: Context, intent: Intent) {
	Log.i(TAG, "Received ${intent.action} that trigger a new alarm scheduling")
	pause()
	resetAutoOnTimerForUser(looper, context, state, callback_on)
	}
	}

	timer = Timer.start(looper, context, receiver, callback_on)
	}

	public fun pause() {
	timer?.pause()
	timer = null
	}

	public fun notifyBluetoothOn(resolver: ContentResolver) {
	timer?.cancel()
	timer = null

	if (!isFeatureSupportedForUser(resolver)) {
	val defaultFeatureValue = true
	Log.i(TAG, "Feature was set to its default value ${defaultFeatureValue}")
	setFeatureEnabledForUserUnchecked(resolver, defaultFeatureValue)
	}
	}

	public fun isUserSupported(resolver: ContentResolver) = isFeatureSupportedForUser(resolver)

	public fun isUserEnabled(context: Context): Boolean {
	if (!isUserSupported(context.contentResolver)) {
	throw IllegalStateException("AutoOnFeature not supported for user: ${context.getUser()}")
	}
	return isFeatureEnabledForUser(context.contentResolver)
	}

	public fun setUserEnabled(
	looper: Looper,
	context: Context,
	state: BluetoothAdapterState,
	status: Boolean,
	callback_on: () -> Unit,
	) {
	if (!isUserSupported(context.contentResolver)) {
	throw IllegalStateException("AutoOnFeature not supported for user: ${context.getUser()}")
	}
	setFeatureEnabledForUserUnchecked(context.contentResolver, status)
	Counter.logIncrement(
	if (status) "bluetooth.value_auto_on_enabled" else "bluetooth.value_auto_on_disabled"
	)
	resetAutoOnTimerForUser(looper, context, state, callback_on)
	}

	// Listener is needed because code should be actionable prior to V API release
	public fun registerHiddenApiListener(
	looper: Looper,
	context: Context,
	state: BluetoothAdapterState,
	callback_on: () -> Unit
	) {
	HiddenApiListener.registerUser(looper, context, state, callback_on)
	}

	////////////////////////////////////////////////////////////////////////////////////////////////////
	////////////////////////////////////////// PRIVATE METHODS /////////////////////////////////////////
	////////////////////////////////////////////////////////////////////////////////////////////////////

	@VisibleForTesting internal var timer: Timer? = null

	@VisibleForTesting
	internal class Timer
	private constructor(
	looper: Looper,
	private val context: Context,
	private val receiver: BroadcastReceiver,
	callback_on: () -> Unit,
	private val now: LocalDateTime,
	private val target: LocalDateTime,
	private val timeToSleep: Duration
	) {
	private val handler = Handler(looper)

	init {
	writeDateToStorage(target, context.contentResolver)
	handler.postDelayed(
	{
	Log.i(TAG, "[${this}]: Bluetooth restarting now")
	callback_on()
	cancel()
	// Set global instance to null to prevent further action. Job is done here
	timer = null
	},
	timeToSleep.inWholeMilliseconds
	)
	Log.i(TAG, "[${this}]: Scheduling next Bluetooth restart")

	context.registerReceiver(
	receiver,
	IntentFilter().apply {
	addAction(Intent.ACTION_DATE_CHANGED)
	addAction(Intent.ACTION_TIMEZONE_CHANGED)
	addAction(Intent.ACTION_TIME_CHANGED)
	},
	null,
	handler
	)
	}

	companion object {
	@VisibleForTesting internal val STORAGE_KEY = "bluetooth_internal_automatic_turn_on_timer"

	private fun writeDateToStorage(date: LocalDateTime, resolver: ContentResolver): Boolean {
	return Settings.Secure.putString(resolver, STORAGE_KEY, date.toString())
	}

	private fun getDateFromStorage(resolver: ContentResolver): LocalDateTime? {
	val date = Settings.Secure.getString(resolver, STORAGE_KEY)
	return date?.let { LocalDateTime.parse(it) }
	}

	private fun resetStorage(resolver: ContentResolver) {
	Settings.Secure.putString(resolver, STORAGE_KEY, null)
	}

	fun start(
	looper: Looper,
	context: Context,
	receiver: BroadcastReceiver,
	callback_on: () -> Unit
	): Timer? {
	val now = LocalDateTime.now()
	val target = getDateFromStorage(context.contentResolver) ?: nextTimeout(now)
	val timeToSleep =
	now.until(target, ChronoUnit.NANOS).toDuration(DurationUnit.NANOSECONDS)

	if (timeToSleep.isNegative()) {
	Log.i(TAG, "Starting now (${now}) as it was scheduled for ${target}")
	callback_on()
	resetStorage(context.contentResolver)
	return null
	}

	return Timer(looper, context, receiver, callback_on, now, target, timeToSleep)
	}

	/** Return a LocalDateTime for tomorrow 5 am */
	private fun nextTimeout(now: LocalDateTime) =
	LocalDateTime.of(now.toLocalDate(), LocalTime.of(5, 0)).plusDays(1)
	}

	/** Save timer to storage and stop it */
	internal fun pause() {
	Log.i(TAG, "[${this}]: Pausing timer")
	context.unregisterReceiver(receiver)
	handler.removeCallbacksAndMessages(null)
	}

	/** Stop timer and reset storage */
	@VisibleForTesting
	internal fun cancel() {
	Log.i(TAG, "[${this}]: Cancelling timer")
	context.unregisterReceiver(receiver)
	handler.removeCallbacksAndMessages(null)
	resetStorage(context.contentResolver)
	}

	override fun toString() = "Timer scheduled ${now} for target=${target} (=${timeToSleep} delay)."
	}

	@VisibleForTesting internal val USER_SETTINGS_KEY = "bluetooth_automatic_turn_on"

	/**
	* Do not use outside of this file to avoid async issues
	*
	* @return whether the auto on feature is enabled for this user
	*/
	private fun isFeatureEnabledForUser(resolver: ContentResolver): Boolean {
	return Settings.Secure.getInt(resolver, USER_SETTINGS_KEY, 0) == 1
	}

	/**
	* Do not use outside of this file to avoid async issues
	*
	* @return whether the auto on feature is supported for the user
	*/
	private fun isFeatureSupportedForUser(resolver: ContentResolver): Boolean {
	return Settings.Secure.getInt(resolver, USER_SETTINGS_KEY, -1) != -1
	}

	/**
	* Do not use outside of this file to avoid async issues
	*
	* @return whether the auto on feature is enabled for this user
	*/
	private fun setFeatureEnabledForUserUnchecked(resolver: ContentResolver, status: Boolean) {
	Settings.Secure.putInt(resolver, USER_SETTINGS_KEY, if (status) 1 else 0)
	}

	// Listener is needed because code should be actionable prior to V API release
	@VisibleForTesting
	internal class HiddenApiListener
	private constructor(
	looper: Looper,
	private val context: Context,
	state: BluetoothAdapterState,
	callback_on: () -> Unit
	) {
	companion object {
	@VisibleForTesting internal var listener: HiddenApiListener? = null

	fun registerUser(
	looper: Looper,
	context: Context,
	state: BluetoothAdapterState,
	callback_on: () -> Unit
	) {
	// Remove observer on previous user
	listener?.remove()
	listener = HiddenApiListener(looper, context, state, callback_on)
	}
	}

	private val handler = Handler(looper)

	private val observer =
	object : ContentObserver(handler) {
	override fun onChange(selfChange: Boolean) {
	var previousState = featureState
	var newState =
	Settings.Secure.getInt(context.contentResolver, USER_SETTINGS_KEY, -1)
	featureState = newState

	if (previousState == newState) {
	Log.d(TAG, "HiddenApi: State is unchanged: ${newState}")
	return
	}

	if (previousState == -1) {
	Log.d(TAG, "HiddenApi: Feature default state got setup to ${newState}")
	return
	}

	Log.d(TAG, "HiddenApi: Feature state change from ${previousState} to ${newState}")

	Counter.logIncrement("bluetooth.value_auto_on_hidden_usage")
	Counter.logIncrement(
	if (newState == 1) "bluetooth.value_auto_on_enabled"
	else "bluetooth.value_auto_on_disabled"
	)

	resetAutoOnTimerForUser(looper, context, state, callback_on)
	}
	}

	private var featureState =
	Settings.Secure.getInt(context.contentResolver, USER_SETTINGS_KEY, -1)

	init {
	val notifyForDescendants = false

	context.contentResolver.registerContentObserver(
	Settings.Secure.getUriFor(USER_SETTINGS_KEY),
	notifyForDescendants,
	observer
	)
	}

	@VisibleForTesting
	internal fun remove() {
	context.contentResolver.unregisterContentObserver(observer)
	handler.removeCallbacksAndMessages(null)
	}
	}