This commit is contained in:
2026-10-29 13:29:14 +06:00
parent a7111060a5
commit 0c1adbb198
113 changed files with 10412 additions and 0 deletions

View File

@@ -0,0 +1,316 @@
package com.example.netshareecohub.routing
import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.content.IntentFilter
import android.content.pm.PackageManager
import android.net.TetheringManager
import android.os.Build
import android.os.Handler
import android.os.Looper
import android.provider.Settings
import android.widget.Toast
import com.example.netshareecohub.R
import com.example.netshareecohub.data.logging.Logger
import kotlinx.coroutines.suspendCancellableCoroutine
import java.util.concurrent.atomic.AtomicBoolean
import kotlin.coroutines.resume
/**
* Tethering controller for ordinary app builds.
*
* Android's tethering service enforces the caller's real permissions. This class deliberately
* does not use root commands, hidden-API reflection, or Settings-screen automation.
*/
class SystemTetheringManager {
private val tag = "SystemTetheringManager"
private val mainHandler = Handler(Looper.getMainLooper())
private val startInProgress = AtomicBoolean(false)
private val startedByThisInstance = AtomicBoolean(false)
fun openSystemTetheringSettings(context: Context): Boolean {
// Keep all app flows in-app. A normal APK cannot grant itself privileged tethering access.
Toast.makeText(
context,
context.getString(R.string.tethering_settings_not_opened),
Toast.LENGTH_LONG
).show()
Logger.info(tag, "Settings navigation intentionally disabled; no external screen was opened.")
return false
}
fun isTetheringSupported(context: Context): Boolean {
val sdkCanAttempt = Build.VERSION.SDK_INT in Build.VERSION_CODES.R..35
return sdkCanAttempt && hasControlPermission(context)
}
private fun hasControlPermission(context: Context): Boolean {
val privileged = context.checkSelfPermission(PERMISSION_TETHER_PRIVILEGED) ==
PackageManager.PERMISSION_GRANTED
return privileged || Settings.System.canWrite(context)
}
private fun permissionMessage(context: Context): String =
context.getString(R.string.tethering_permission_missing)
/**
* Attempts the Android tethering request on Android 11–15 where the platform implementation
* has this request path. The OS callback, not the button press, determines the result.
* Android 16's public SDK only exposes a normal-app request configuration for Wi-Fi, so this
* class does not pretend that it can request Ethernet tethering there.
*/
fun startTethering(
context: Context,
tetheringType: Int = TETHERING_ETHERNET,
onResult: (Boolean, String?) -> Unit
) {
if (tetheringType != TETHERING_ETHERNET) {
onResult(false, context.getString(R.string.tethering_only_ethernet_supported))
return
}
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
onResult(false, context.getString(R.string.tethering_api_unavailable))
return
}
if (Build.VERSION.SDK_INT >= 36) {
onResult(false, context.getString(R.string.tethering_android16_limit))
return
}
if (!hasControlPermission(context)) {
onResult(false, permissionMessage(context))
return
}
if (startedByThisInstance.get()) {
onResult(true, context.getString(R.string.tethering_already_started))
return
}
if (!startInProgress.compareAndSet(false, true)) {
onResult(false, context.getString(R.string.tethering_request_in_progress))
return
}
val manager = context.getSystemService(TetheringManager::class.java)
if (manager == null) {
startInProgress.set(false)
onResult(false, context.getString(R.string.tethering_service_unavailable))
return
}
val completed = AtomicBoolean(false)
val timeout = Runnable {
if (completed.compareAndSet(false, true)) {
startInProgress.set(false)
onResult(false, context.getString(R.string.tethering_start_timeout))
}
}
mainHandler.postDelayed(timeout, START_TIMEOUT_MS)
try {
// Ethernet's AOSP tethering type is 5. The OS still enforces access permissions.
val request = TetheringManager.TetheringRequest.Builder(TETHERING_ETHERNET).build()
manager.startTethering(
request,
context.mainExecutor,
object : TetheringManager.StartTetheringCallback {
override fun onTetheringStarted() {
if (!completed.compareAndSet(false, true)) return
mainHandler.removeCallbacks(timeout)
startInProgress.set(false)
startedByThisInstance.set(true)
val message = context.getString(R.string.tethering_start_confirmed)
Logger.info(tag, message)
onResult(true, message)
}
override fun onTetheringFailed(error: Int) {
if (!completed.compareAndSet(false, true)) return
mainHandler.removeCallbacks(timeout)
startInProgress.set(false)
val message = context.getString(
R.string.tethering_start_failed_code,
error,
explainTetheringError(error, context)
)
Logger.warn(tag, message)
onResult(false, message)
}
}
)
} catch (e: SecurityException) {
mainHandler.removeCallbacks(timeout)
if (completed.compareAndSet(false, true)) {
startInProgress.set(false)
val message = context.getString(R.string.tethering_permission_denied)
Logger.warn(tag, "$message ${e.message.orEmpty()}")
onResult(false, message)
}
} catch (e: IllegalArgumentException) {
mainHandler.removeCallbacks(timeout)
if (completed.compareAndSet(false, true)) {
startInProgress.set(false)
val message = context.getString(R.string.tethering_type_not_supported)
Logger.warn(tag, "$message ${e.message.orEmpty()}")
onResult(false, message)
}
} catch (e: LinkageError) {
mainHandler.removeCallbacks(timeout)
if (completed.compareAndSet(false, true)) {
startInProgress.set(false)
onResult(false, context.getString(R.string.tethering_api_unavailable))
}
} catch (e: Exception) {
mainHandler.removeCallbacks(timeout)
if (completed.compareAndSet(false, true)) {
startInProgress.set(false)
val message = context.getString(
R.string.tethering_start_exception,
e.localizedMessage ?: e.javaClass.simpleName
)
Logger.error(tag, message, e)
onResult(false, message)
}
}
}
suspend fun startTetheringAwait(
context: Context,
tetheringType: Int = TETHERING_ETHERNET
): Pair<Boolean, String?> = suspendCancellableCoroutine { continuation ->
startTethering(context, tetheringType) { success, message ->
if (continuation.isActive) continuation.resume(success to message)
}
}
/**
* Stop only a session this controller successfully started in this process. On Android 11–15
* stopTethering has no completion callback, so we listen for the legacy state-change broadcast
* and report failure if Android never confirms that Ethernet is no longer tethered.
*/
fun stopTethering(
context: Context,
tetheringType: Int = TETHERING_ETHERNET,
onResult: (Boolean, String?) -> Unit
) {
if (tetheringType != TETHERING_ETHERNET) {
onResult(false, context.getString(R.string.tethering_only_ethernet_supported))
return
}
if (!startedByThisInstance.get()) {
onResult(false, context.getString(R.string.tethering_no_owned_session))
return
}
if (Build.VERSION.SDK_INT >= 36) {
onResult(false, context.getString(R.string.tethering_android16_limit))
return
}
if (!hasControlPermission(context)) {
onResult(false, permissionMessage(context))
return
}
val manager = context.getSystemService(TetheringManager::class.java)
if (manager == null) {
onResult(false, context.getString(R.string.tethering_service_unavailable))
return
}
val appContext = context.applicationContext
val finished = AtomicBoolean(false)
lateinit var receiver: BroadcastReceiver
lateinit var timeout: Runnable
fun finish(success: Boolean, message: String) {
if (!finished.compareAndSet(false, true)) return
mainHandler.removeCallbacks(timeout)
try {
appContext.unregisterReceiver(receiver)
} catch (_: Exception) {
// Receiver may already have been removed by the system/lifecycle.
}
if (success) startedByThisInstance.set(false)
Logger.info(tag, message)
onResult(success, message)
}
receiver = object : BroadcastReceiver() {
override fun onReceive(receiveContext: Context?, intent: Intent?) {
if (intent?.action != TetheringManager.ACTION_TETHER_STATE_CHANGED) return
if (!intent.hasExtra(TetheringManager.EXTRA_ACTIVE_TETHER)) return
val active = intent.getStringArrayListExtra(TetheringManager.EXTRA_ACTIVE_TETHER)
?.toList()
?: intent.getStringArrayExtra(TetheringManager.EXTRA_ACTIVE_TETHER)?.toList()
?: return
val ethernetStillActive = active.any(::looksLikeEthernetInterface)
if (!ethernetStillActive) {
finish(true, appContext.getString(R.string.tethering_stop_confirmed))
}
}
}
timeout = Runnable {
finish(false, appContext.getString(R.string.tethering_stop_unverified))
}
try {
val filter = IntentFilter(TetheringManager.ACTION_TETHER_STATE_CHANGED)
if (Build.VERSION.SDK_INT >= 33) {
appContext.registerReceiver(receiver, filter, Context.RECEIVER_NOT_EXPORTED)
} else {
@Suppress("DEPRECATION")
appContext.registerReceiver(receiver, filter)
}
manager.stopTethering(tetheringType)
mainHandler.postDelayed(timeout, STOP_TIMEOUT_MS)
} catch (e: SecurityException) {
finish(false, appContext.getString(R.string.tethering_permission_denied))
} catch (e: LinkageError) {
finish(false, appContext.getString(R.string.tethering_api_unavailable))
} catch (e: Exception) {
finish(
false,
appContext.getString(
R.string.tethering_stop_exception,
e.localizedMessage ?: e.javaClass.simpleName
)
)
}
}
suspend fun stopTetheringAwait(
context: Context,
tetheringType: Int = TETHERING_ETHERNET
): Pair<Boolean, String?> = suspendCancellableCoroutine { continuation ->
stopTethering(context, tetheringType) { success, message ->
if (continuation.isActive) continuation.resume(success to message)
}
}
private fun looksLikeEthernetInterface(name: String): Boolean {
val value = name.lowercase()
return value.startsWith("eth") || value.startsWith("enx") || value.startsWith("enp") ||
value.startsWith("usb") || value.startsWith("rndis") || value.startsWith("ncm") ||
value.startsWith("lan")
}
private fun explainTetheringError(code: Int, context: Context): String = when (code) {
1 -> context.getString(R.string.tethering_error_unknown_interface)
2 -> context.getString(R.string.tethering_error_service_unavailable)
3 -> context.getString(R.string.tethering_error_unsupported)
4 -> context.getString(R.string.tethering_error_interface_unavailable)
11 -> context.getString(R.string.tethering_error_provisioning)
12 -> context.getString(R.string.tethering_error_dhcp)
13 -> context.getString(R.string.tethering_error_entitlement)
14, 15 -> context.getString(R.string.tethering_error_permission)
else -> context.getString(R.string.tethering_error_generic)
}
companion object {
const val TETHERING_WIFI = 0
const val TETHERING_USB = 1
const val TETHERING_BLUETOOTH = 2
const val TETHERING_ETHERNET = 5
private const val PERMISSION_TETHER_PRIVILEGED = "android.permission.TETHER_PRIVILEGED"
private const val START_TIMEOUT_MS = 30_000L
private const val STOP_TIMEOUT_MS = 5_000L
}
}