Add hotspot management functionality

moemoeq · moemoeq · commit e0b4d3f0bbe1 · 2025-05-19T10:58:22.000+09:00
- Introduced HotspotHelper class for managing Wi-Fi hotspot operations on Android 11 (API 30) using TetheringManager
- Integrated hotspot commands into MessagingManager, allowing for enabling and disabling the hotspot via notifications.
- Added a new string resource for missing write settings permission notification.
diff --git a/app/src/main/kotlin/io/homeassistant/companion/android/notifications/MessagingManager.kt b/app/src/main/kotlin/io/homeassistant/companion/android/notifications/MessagingManager.kt
@@ -78,6 +78,7 @@ import io.homeassistant.companion.android.sensors.NotificationSensorManager
 import io.homeassistant.companion.android.sensors.SensorReceiver
 import io.homeassistant.companion.android.settings.SettingsActivity
 import io.homeassistant.companion.android.util.FlashlightHelper
+import io.homeassistant.companion.android.util.HotspotHelper
 import io.homeassistant.companion.android.util.PermissionRequestMediator
 import io.homeassistant.companion.android.util.UrlUtil
 import io.homeassistant.companion.android.vehicle.HaCarAppService
@@ -115,6 +116,7 @@ class MessagingManager @Inject constructor(
     private val settingsDao: SettingsDao,
     private val textToSpeechClient: TextToSpeechClient,
     private val flashlightHelper: FlashlightHelper,
+    private val hotspotHelper: HotspotHelper,
     private val permissionRequestMediator: PermissionRequestMediator
 ) {
     companion object {
@@ -177,6 +179,7 @@ class MessagingManager @Inject constructor(
         const val COMMAND_SCREEN_BRIGHTNESS_LEVEL = "command_screen_brightness_level"
         const val COMMAND_SCREEN_OFF_TIMEOUT = "command_screen_off_timeout"
         const val COMMAND_FLASHLIGHT = "command_flashlight"
+        const val COMMAND_HOTSPOT = "command_hotspot"
 
         // DND commands
         const val DND_PRIORITY_ONLY = "priority_only"
@@ -232,7 +235,8 @@ class MessagingManager @Inject constructor(
             COMMAND_AUTO_SCREEN_BRIGHTNESS,
             COMMAND_SCREEN_BRIGHTNESS_LEVEL,
             COMMAND_SCREEN_OFF_TIMEOUT,
-            COMMAND_FLASHLIGHT
+            COMMAND_FLASHLIGHT,
+            COMMAND_HOTSPOT
         )
         val DND_COMMANDS = listOf(DND_ALARMS_ONLY, DND_ALL, DND_NONE, DND_PRIORITY_ONLY)
         val RM_COMMANDS = listOf(RM_NORMAL, RM_SILENT, RM_VIBRATE)
@@ -546,6 +550,15 @@ class MessagingManager @Inject constructor(
                                 sendNotification(jsonData)
                             }
                         }
+                        COMMAND_HOTSPOT -> {
+                            val command = jsonData[NotificationData.COMMAND]
+                            if (command in DeviceCommandData.ENABLE_COMMANDS && Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                                handleDeviceCommands(jsonData)
+                            } else {
+                                Timber.d("Invalid hotspot command received, posting notification to device")
+                                sendNotification(jsonData)
+                            }
+                        }
                         else -> Timber.d("No command received")
                     }
                 }
@@ -802,6 +815,22 @@ class MessagingManager @Inject constructor(
                     requestCameraPermission()
                 }
             }
+            COMMAND_HOTSPOT -> {
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+                    if (Settings.System.canWrite(context)) {
+                        // API 30+ AND PERMISSION GRANTED
+                        when (command) {
+                            DeviceCommandData.TURN_OFF -> hotspotHelper.turnOffHotspot()
+                            DeviceCommandData.TURN_ON -> hotspotHelper.turnOnHotspot()
+                        }
+                    } else {
+                        Handler(Looper.getMainLooper()).post {
+                            Toast.makeText(context, commonR.string.missing_write_settings_permission, Toast.LENGTH_LONG).show()
+                        }
+                        requestWriteSystemPermission()
+                    }
+                }
+            }
             else -> Timber.d("No command received")
         }
     }
diff --git a/app/src/main/kotlin/io/homeassistant/companion/android/util/HotspotHelper.kt b/app/src/main/kotlin/io/homeassistant/companion/android/util/HotspotHelper.kt
@@ -0,0 +1,214 @@
+package io.homeassistant.companion.android.util
+
+import android.content.Context
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import androidx.annotation.RequiresApi
+import dagger.hilt.android.qualifiers.ApplicationContext
+import javax.inject.Inject
+import timber.log.Timber
+import java.util.concurrent.Executor
+
+/**
+ * Helper class for managing Wi-Fi hotspot functionality.
+ * Only supported on Android 11 (API 30) and above.
+ */
+class HotspotHelper @Inject constructor(
+    @ApplicationContext private val context: Context
+) {
+    companion object {
+        private const val TETHERING_WIFI = 0
+        private const val METHOD_TETHERING_MANAGER = "TetheringManager"
+        // private const val METHOD_CONNECTIVITY_MANAGER = "ConnectivityManager"
+    }
+    
+    // Executor implementation to run on the main thread
+    private val mainExecutor = Executor { command -> Handler(Looper.getMainLooper()).post(command) }
+
+    /**
+     * Enables the Wi-Fi hotspot.
+     * Only works on Android 11+.
+     * 
+     * @return true if operation was successful
+     */
+    fun turnOnHotspot(): Boolean {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
+            Timber.i("Hotspot control not supported on Android versions below 11 (API 30)")
+            return false
+        }
+
+        try {
+            return enableHotspot()
+        } catch (e: Exception) {
+            Timber.e(e, "Failed to turn on hotspot")
+            return false
+        }
+    }
+
+    /**
+     * Disables the Wi-Fi hotspot.
+     * Only works on Android 11+.
+     * 
+     * @return true if operation was successful
+     */
+    fun turnOffHotspot(): Boolean {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
+            Timber.i("Hotspot control not supported on Android versions below 11 (API 30)")
+            return false
+        }
+        
+        try {
+            return disableHotspot()
+        } catch (e: Exception) {
+            Timber.e(e, "Failed to turn off hotspot")
+            return false
+        }
+    }
+
+    // API 30+ needed for TetheringManager
+    @RequiresApi(Build.VERSION_CODES.R)
+    private fun enableHotspot(): Boolean {
+        // Try TetheringManager
+        // Support least Android 11(API 30) Code.R
+        if (enableHotspotWithTetheringManager()) {
+            Timber.i("Hotspot enabled successfully using $METHOD_TETHERING_MANAGER")
+            return true
+        }
+
+        // TODO: implement using ConnectivityManager as fallback
+
+        Timber.e("Failed to enable hotspot: no viable method found")
+        return false
+    }
+
+    @RequiresApi(Build.VERSION_CODES.R)
+    private fun disableHotspot(): Boolean {
+        // Try TetheringManager
+        // Support least Android 11(API 30) Code.R
+        if (disableHotspotWithTetheringManager()) {
+            Timber.i("Hotspot disabled successfully using $METHOD_TETHERING_MANAGER")
+            return true
+        }
+
+        // TODO: implement using ConnectivityManager as fallback
+        
+        Timber.e("Failed to disable hotspot: no viable method found")
+        return false
+    }
+
+    /**
+     * Attempts to enable hotspot using TetheringManager via reflection.
+     */
+    @RequiresApi(Build.VERSION_CODES.R)
+    private fun enableHotspotWithTetheringManager(): Boolean {
+        try {
+            val tetheringManagerClass = Class.forName("android.net.TetheringManager")
+            val tetheringManager = context.getSystemService(tetheringManagerClass) ?: return false
+            
+            // Look for appropriate method
+            for (method in tetheringManager.javaClass.methods) {
+                if (method.name == "startTethering") {
+                    try {
+                        val callbackClass = Class.forName("android.net.TetheringManager\$StartTetheringCallback")
+                        
+                        // Try with TetheringRequest (preferred on newer devices)
+                        val tetheringRequestClass = Class.forName("android.net.TetheringManager\$TetheringRequest")
+                        val builderClass = Class.forName("android.net.TetheringManager\$TetheringRequest\$Builder")
+                        val builder = builderClass.getConstructor(Int::class.java).newInstance(TETHERING_WIFI)
+                        val request = builderClass.getMethod("build").invoke(builder)
+
+                        val startMethod = tetheringManager.javaClass.getMethod(
+                            "startTethering",
+                            tetheringRequestClass,
+                            Executor::class.java,
+                            callbackClass
+                        )
+
+                        val callbackInstance = createCallbackInstance(callbackClass)
+
+                        Timber.d("Enabling hotspot with TetheringRequest approach")
+                        startMethod.invoke(tetheringManager, request, mainExecutor, callbackInstance)
+                        return true
+                    }
+                    catch (e: Exception) {
+                        Timber.e(e, "Error invoking TetheringManager.startTethering")
+                    }
+                }
+            }
+            Timber.w("No suitable TetheringManager.startTethering method found")
+            return false
+        } catch (e: Exception) {
+            Timber.e(e, "Error accessing TetheringManager")
+            return false
+        }
+    }
+    
+    /**
+     * Creates appropriate callback instance through reflection.
+     * Handles both interface and abstract class scenarios.
+     */
+    private fun createCallbackInstance(callbackClass: Class<*>): Any {
+        try {
+            if (callbackClass.isInterface) {
+                // For interfaces, use Proxy
+                return java.lang.reflect.Proxy.newProxyInstance(
+                    callbackClass.classLoader,
+                    arrayOf(callbackClass)
+                ) { _, method, _ ->
+                    when (method.name) {
+                        "onTetheringStarted" -> {
+                            Timber.d("Callback: Tethering started successfully")
+                            null
+                        }
+                        // this also causes when tethering already started
+                        "onTetheringFailed" -> {
+                            Timber.e("Callback: Tethering failed to start")
+                            null
+                        }
+                        else -> null
+                    }
+                }
+            } else {
+                // For abstract classes, create instance via constructor
+                val constructor = callbackClass.getDeclaredConstructor()
+                constructor.isAccessible = true
+                return constructor.newInstance()
+            }
+        } catch (e: Exception) {
+            Timber.e(e, "Failed to create callback instance")
+            throw e
+        }
+    }
+
+    /**
+     * Attempts to disable hotspot using TetheringManager via reflection.
+     */
+    @RequiresApi(Build.VERSION_CODES.R)
+    private fun disableHotspotWithTetheringManager(): Boolean {
+        try {
+            val tetheringManagerClass = Class.forName("android.net.TetheringManager")
+            val tetheringManager = context.getSystemService(tetheringManagerClass) ?: return false
+            
+            // Look for stopTethering method
+            for (method in tetheringManager.javaClass.methods) {
+                if (method.name == "stopTethering" && 
+                    method.parameterTypes.size == 1 && 
+                    method.parameterTypes[0] == Int::class.java) {
+                    try {
+                        Timber.d("Disabling hotspot with TetheringManager.stopTethering")
+                        method.invoke(tetheringManager, TETHERING_WIFI)
+                        return true
+                    } catch (e: Exception) {
+                        Timber.e(e, "Error invoking TetheringManager.stopTethering")
+                    }
+                }
+            }
+            Timber.w("No suitable TetheringManager.stopTethering method found")
+            return false
+        } catch (e: Exception) {
+            Timber.e(e, "Error accessing TetheringManager")
+            return false
+        }
+    }
+}
diff --git a/common/src/main/res/values/strings.xml b/common/src/main/res/values/strings.xml
@@ -1129,6 +1129,7 @@
     <string name="sensor_update_type_info_location">For more information about location updates, please check the documentation.</string>
     <string name="sensor_update_type_info_custom">This sensor updates on a non-standard schedule, please check the documentation.</string>
     <string name="missing_camera_permission">\'Camera\' permission required</string>
+    <string name="missing_write_settings_permission">Please grant permission to modify system settings</string>
     <string name="missing_phone_permission">Please grant Phone permission to make a phone call</string>
     <string name="missing_bluetooth_permission">Please grant Nearby devices permission to control Bluetooth</string>
     <string name="notification_channels_description">Notification channels allow you to control the look and feel of a certain type of notification. You can create notification channels by sending a notification with the channel parameter, refer to the help icon in the upper right hand corner to learn more. Below is a list of all notification channels created by your server and the app. Select the edit icon to adjust channel settings like the notification sound and Do Not Disturb override. Select the delete icon to remove the channel from this list.\n\nDeleting a channel does not reset channel settings, if a notification is received with the same channel name then it will re-use its previous settings. You can only delete channels created by your server.</string>
