• Android开启HTTP服务

    需求：通过手机给设备升级固件，设备有WIFI

    方案：升级包放到APP可以访问的目录，手机开热点并启动一个HTTP服务，设备连接手机热点，另外，设备端开启一个 telnet 服务，手机通过 telnet 登录到设备系统（Android系统热点的默认IP地址是192.168.43.1，APP可以遍历192.168.43这个IP段的IP以及固定的端口），通过指令下载固件，完成升级。

    1. 用到的第三方库

    1. implementation 'commons-net:commons-net:3.9.0' // telnet
    2. implementation 'org.nanohttpd:nanohttpd:2.3.1' // NanoHttpd
    3. implementation 'org.apache.commons:commons-compress:1.23.0'//解压缩文件
    4. implementation 'com.github.junrar:junrar:7.5.4'//解压rar
    5. implementation 'org.tukaani:xz:1.9'//解压.7z文件需要
    6. implementation 'com.sparkjava:spark-core:2.9.4'// sparkjava

    2. 添加权限

    1.     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
    2.     <uses-permission android:name="android.permission.INTERNET" />
    3.     <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
    4.     <uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />
    5.     <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />
    6.     <uses-permission android:name="android.permission.WRITE_SETTINGS" />
    7.     <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
    8.     
    9.     
    10.     <uses-permission
    11.         android:name="android.permission.NEARBY_WIFI_DEVICES"
    12.         android:usesPermissionFlags="neverForLocation"
    13.         tools:targetApi="s" />
    14.     
    15.     
    16.     <uses-permission
    17.         android:name="android.permission.ACCESS_FINE_LOCATION"
    18.         android:maxSdkVersion="32" />
    19.     <uses-permission
    20.         android:name="android.permission.READ_EXTERNAL_STORAGE"
    21.         android:maxSdkVersion="32" />

    3. 开启热点 

    APUtil.kt

    1. import android.Manifest
    2. import android.content.ActivityNotFoundException
    3. import android.content.ComponentName
    4. import android.content.Context
    5. import android.content.Intent
    6. import android.content.pm.PackageManager
    7. import android.net.wifi.SoftApConfiguration
    8. import android.net.wifi.WifiManager
    9. import android.os.Build
    10. import android.util.Log
    11. import androidx.annotation.RequiresApi
    12. import androidx.core.app.ActivityCompat
    13. import java.lang.reflect.Field
    14. import java.lang.reflect.Method
    15.  
    16.  
    17. class APUtil(private val context: Context) {
    18.     val wifiManager = context.getSystemService(Context.WIFI_SERVICE) as WifiManager
    19.  
    20.  
    21.     private fun securityTypeString(securityType: Int): String {
    22.         return when (securityType) {
    23.             SoftApConfiguration.SECURITY_TYPE_OPEN -> "OPEN"
    24.             SoftApConfiguration.SECURITY_TYPE_WPA2_PSK -> "WPA2_PSK"
    25.             SoftApConfiguration.SECURITY_TYPE_WPA3_OWE -> "WPA3_OWE"
    26.             SoftApConfiguration.SECURITY_TYPE_WPA3_SAE -> "WPA3_SAE"
    27.             SoftApConfiguration.SECURITY_TYPE_WPA3_OWE_TRANSITION -> "WPA3_OWE_TRANSITION"
    28.             SoftApConfiguration.SECURITY_TYPE_WPA3_SAE_TRANSITION -> "WPA3_SAE_TRANSITION"
    29.             else -> "Unknown security type: $securityType"
    30.         }
    31.     }
    32.  
    33.     @RequiresApi(Build.VERSION_CODES.O)
    34.     private val localOnlyHotspotCallback = object : WifiManager.LocalOnlyHotspotCallback() {
    35.         override fun onStarted(reservation: WifiManager.LocalOnlyHotspotReservation?) {
    36.             super.onStarted(reservation)
    37.             if (Build.VERSION.SDK_INT >= 30) {
    38.                 reservation?.softApConfiguration?.let { config ->
    39.                     Log.i(TAG, "-------------------------- softApConfiguration --------------------------")
    40.                     if (Build.VERSION.SDK_INT >= 33) {
    41.                         Log.i(TAG, "热点名称: ${config.wifiSsid}")
    42.                     } else {
    43.                         Log.i(TAG, "热点名称: ${config.ssid}")
    44.                     }
    45.                     Log.i(TAG, "热点密码: ${config.passphrase}")
    46.                     Log.i(TAG, "securityType=${securityTypeString(config.securityType)}")
    47.                     Log.i(TAG, "mac=${config.bssid}")
    48.                 }
    49.             } else {
    50.                 reservation?.wifiConfiguration?.let { config ->
    51.                     Log.i(TAG, "-------------------------- wifiConfiguration --------------------------")
    52.                     Log.i(TAG, "热点名称: ${config.SSID}")
    53.                     Log.i(TAG, "热点密码: ${config.preSharedKey}")
    54.                     Log.i(TAG, "mac=${config.BSSID}")
    55.                     Log.i(TAG, "status=${config.status}")
    56.                     config.httpProxy?.let { httpProxy ->
    57.                         Log.i(TAG, "http://${httpProxy.host}:${httpProxy.port}")
    58.                     }
    59.                 }
    60.             }
    61.         }
    62.  
    63.         override fun onStopped() {
    64.             super.onStopped()
    65.             Log.e(TAG, "onStopped()")
    66.         }
    67.  
    68.         override fun onFailed(reason: Int) {
    69.             super.onFailed(reason)
    70.             Log.e(TAG, "onFailed() - reason=$reason")
    71.         }
    72.     }
    73.  
    74.  
    75.     fun startHotspot() {
    76.         if (Build.VERSION.SDK_INT >= 26) {
    77.             if (ActivityCompat.checkSelfPermission(
    78.                     context,
    79.                     Manifest.permission.ACCESS_FINE_LOCATION
    80.                 ) != PackageManager.PERMISSION_GRANTED || ActivityCompat.checkSelfPermission(
    81.                     context,
    82.                     Manifest.permission.NEARBY_WIFI_DEVICES
    83.                 ) != PackageManager.PERMISSION_GRANTED
    84.             ) {
    85.                 return
    86.             }
    87.             // 官方文档
    88.             // https://developer.android.google.cn/reference/android/net/wifi/WifiManager#startLocalOnlyHotspot(android.net.wifi.WifiManager.LocalOnlyHotspotCallback,%20android.os.Handler)
    89.             wifiManager.startLocalOnlyHotspot(localOnlyHotspotCallback, null)
    90.         }
    91.     }
    92.  
    93.  
    94.     fun printHotSpotState() {
    95.         Log.i(TAG, "热点是否已经打开：方式1 ${isHotSpotApOpen(context)} 方式2 ${isHotSpotApOpen2(context)}")
    96.         Log.i(TAG, "手机型号：${Build.MANUFACTURER} ${Build.MODEL}")
    97.     }
    98.  
    99.  
    100.     companion object {
    101.  
    102.         private const val TAG = "APUtil"
    103.  
    104.         //获取热点是否打开方式1
    105.         fun isHotSpotApOpen(context: Context): Boolean {
    106.             var isAPEnable = false
    107.             try {
    108.                 val wifiManager = context.getSystemService(Context.WIFI_SERVICE) as WifiManager
    109.                 val method: Method = wifiManager.javaClass.getDeclaredMethod("getWifiApState")
    110.                 val state = method.invoke(wifiManager) as Int
    111.                 val field: Field = wifiManager.javaClass.getDeclaredField("WIFI_AP_STATE_ENABLED")
    112.                 val value = field.get(wifiManager) as Int
    113.                 isAPEnable = state == value
    114.                 Log.i(TAG, "state=$state, value=$value")
    115.             } catch (e: Exception) {
    116.                 e.printStackTrace()
    117.             }
    118.             return isAPEnable
    119.         }
    120.  
    121.  
    122.         //获取热点是否打开方式2
    123.         fun isHotSpotApOpen2(context: Context): Boolean {
    124.             var isAPEnable = false
    125.             try {
    126.                 val wifiManager = context.getSystemService(Context.WIFI_SERVICE) as WifiManager
    127.                 val method: Method = wifiManager.javaClass.getDeclaredMethod("isWifiApEnabled")
    128.                 method.isAccessible = true
    129.                 isAPEnable = method.invoke(wifiManager) as Boolean
    130.             } catch (e: Exception) {
    131.                 e.printStackTrace()
    132.             }
    133.             return isAPEnable
    134.         }
    135.  
    136.         /**
    137.          * 打开设置热点的页面
    138.          */
    139.         fun openSettings(context: Context) {
    140.             val intent = Intent()
    141.             intent.addCategory(Intent.CATEGORY_DEFAULT)
    142.             intent.action = "android.intent.action.MAIN"
    143.             val cn = ComponentName(
    144.                 "com.android.settings",
    145.                 "com.android.settings.Settings\$WirelessSettingsActivity"
    146.             )
    147.             intent.component = cn
    148.             try {
    149.                 context.startActivity(intent)
    150.             } catch (ex: ActivityNotFoundException) {
    151.                 intent.component = ComponentName(
    152.                     "com.android.settings",
    153.                     "com.android.settings.Settings\$TetherSettingsActivity"
    154.                 )
    155.                 context.startActivity(intent)
    156.             }
    157.         }
    158.     }
    159. }

    4. 开启HTTP服务

    使用 nanohttpd 实现

     HttpFileServer.kt

    1. import android.content.Context
    2. import android.util.Log
    3. import fi.iki.elonen.NanoHTTPD
    4. import org.json.JSONObject
    5. import java.io.FileInputStream
    6. import java.io.FileNotFoundException
    7. import java.io.IOException
    8. import java.util.stream.Collectors
    9.  
    10. /**
    11.  * 手机开热点时使用的IP
    12.  */
    13. const val SERVER_IP = "192.168.43.1"
    14. const val SERVER_PORT = 8080
    15.  
    16. private const val TAG = "HttpFileServer"
    17.  
    18. // HFS
    19. class HttpFileServer(context: Context, ipAddress: String) : NanoHTTPD(ipAddress, SERVER_PORT) {
    20.  
    21.     init {
    22.         rootDir = context.getExternalFilesDir("OTA")!!.absolutePath
    23.         Log.i(TAG, "rootDir=$rootDir")
    24.     }
    25.  
    26.     override fun serve(session: IHTTPSession): Response? {
    27.         val params = session.parameters
    28.         Log.e(TAG, String.format("uri=%s", session.uri))
    29.         for (entry in params.entries) {
    30.             Log.e(TAG, String.format("%s=%s", entry.key, entry.value.stream().collect(Collectors.joining(", "))))
    31.         }
    32.         return responseFile(session)
    33.     }
    34.  
    35.     private fun responseFile(session: IHTTPSession): Response? {
    36.         //目前使用的是 http://192.168.43.1:8080/filename
    37.         val uri = session.uri
    38.         val filename = uri.substring(uri.lastIndexOf('/') + 1)
    39.         return try {
    40.             //文件输入流
    41.             val fis = FileInputStream("$rootDir/${filename}")
    42.             newFixedLengthResponse(Response.Status.OK, "application/octet-stream", fis, fis.available().toLong())
    43.         } catch (e: FileNotFoundException) {
    44.             Log.e(TAG, "$filename 文件不存在！", e)
    45.             val jsonObj = JSONObject()
    46.             jsonObj.put("message", "$filename 文件不存在！")
    47.             Log.e(TAG, jsonObj.toString(2))
    48.             newFixedLengthResponse(Response.Status.NOT_FOUND, "application/json", jsonObj.toString(2))
    49.         } catch (e: IOException) {
    50.             e.printStackTrace()
    51.             newFixedLengthResponse(session.uri + " 异常 " + e)
    52.         }
    53.     }
    54.  
    55.     companion object {
    56.         var rootDir: String = ""
    57.     }
    58. }

    使用 sparkjava 实现 

     注意：使用的是sparkjava，而不是大数据分析的那个Spark！

    1. // http://192.168.43.1:8080/download?filename=dog.jpg
    2. Spark.port(8080)        
    3. Spark.get("download") { req, res ->
    4.     val filename = req.queryParams("filename")
    5.     println("thread ${Thread.currentThread().id} - $filename")
    6.  
    7.     res.status(200)
    8.     res.header("Content-Type", "application/octet-stream")
    9.     res.header("Content-disposition", "attachment; filename=$filename")
    10.  
    11.     context.assets.open(filename).use { istream ->
    12.         istream.copyTo(res.raw().outputStream)
    13.     }
    14.     res
    15. }

    5. 使用 telnet

    WifiUtil.kt

    telnet 主要用到了 WifiUtil 的一个属性：network

    1. import android.content.Context
    2. import android.net.ConnectivityManager
    3. import android.net.Network
    4. import android.net.NetworkCapabilities
    5. import android.net.NetworkRequest
    6. import android.net.wifi.WifiInfo
    7. import android.net.wifi.WifiManager
    8. import android.net.wifi.WifiNetworkSpecifier
    9. import android.os.Build
    10. import android.os.PatternMatcher
    11. import android.util.Log
    12. import androidx.annotation.RequiresApi
    13. import site.feiyuliuxing.wifitest.toIPAddress
    14.  
    15. class WifiUtil(context: Context) {
    16.     private val mNetworkCallback: ConnectivityManager.NetworkCallback
    17.     private val mConnectivityManager: ConnectivityManager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
    18.     private val wifiManager: WifiManager = context.getSystemService(Context.WIFI_SERVICE) as WifiManager
    19.     private var mNetwork: Network? = null
    20.  
    21.     //Android系统热点的默认IP地址是192.168.43.1
    22.     var hostIP = "192.168.43.1"
    23.         private set
    24.     val network: Network?
    25.         get() = mNetwork
    26.     val targetIP: String
    27.         get() {
    28.             val arr = hostIP.split(".").toMutableList()
    29.             arr[arr.lastIndex] = "1"
    30.             return arr.joinToString(".")
    31.         }
    32.  
    33.     init {
    34.         if (Build.VERSION.SDK_INT < 29) {
    35.             //Android10以下系统
    36.             mNetworkCallback = object : ConnectivityManager.NetworkCallback() {
    37.                 override fun onAvailable(network: Network) {
    38.                     callbackAvailable(network)
    39.                 }
    40.  
    41.                 override fun onLost(network: Network) {
    42.                     callbackLost(network)
    43.                 }
    44.             }
    45.         } else if (Build.VERSION.SDK_INT < 31) {
    46.             //Android10 Android11
    47.             mNetworkCallback = object : ConnectivityManager.NetworkCallback() {
    48.                 override fun onAvailable(network: Network) {
    49.                     callbackAvailable(network)
    50.                 }
    51.  
    52.                 override fun onLost(network: Network) {
    53.                     callbackLost(network)
    54.                 }
    55.  
    56.                 @RequiresApi(Build.VERSION_CODES.Q)
    57.                 override fun onCapabilitiesChanged(network: Network, networkCapabilities: NetworkCapabilities) {
    58.                     // Android10才支持该回调方法
    59.                     callbackCapabilitiesChanged(network, networkCapabilities)
    60.                 }
    61.             }
    62.         } else {
    63.             //Android12获取 SSID 需要 FLAG_INCLUDE_LOCATION_INFO 并获得 ACCESS_FINE_LOCATION 权限
    64.             mNetworkCallback = object : ConnectivityManager.NetworkCallback(FLAG_INCLUDE_LOCATION_INFO) {
    65.                 override fun onAvailable(network: Network) {
    66.                     callbackAvailable(network)
    67.                 }
    68.  
    69.                 override fun onLost(network: Network) {
    70.                     callbackLost(network)
    71.                 }
    72.  
    73.                 @RequiresApi(Build.VERSION_CODES.Q)
    74.                 override fun onCapabilitiesChanged(network: Network, networkCapabilities: NetworkCapabilities) {
    75.                     // Android10才支持该回调方法
    76.                     callbackCapabilitiesChanged(network, networkCapabilities)
    77.                 }
    78.             }
    79.         }
    80.     }
    81.     
    82.     private fun callbackAvailable(network: Network) {
    83.         mNetwork = network
    84.         hostIP = getIP(network)
    85.     }
    86.  
    87.     private fun callbackLost(network: Network) {
    88.         mNetwork = null
    89.     }
    90.  
    91.     @RequiresApi(Build.VERSION_CODES.Q)
    92.     private fun callbackCapabilitiesChanged(network: Network, networkCapabilities: NetworkCapabilities) {
    93.         val wifiInfo = networkCapabilities.transportInfo as WifiInfo?
    94.         if (wifiInfo != null) {
    95.             println("onCapabilitiesChanged() - SSID=${wifiInfo.ssid}, IP=${wifiInfo.ipAddress.toIP()}")
    96.         }
    97.     }
    98.  
    99.     private val networkRequest: NetworkRequest
    100.         get() = NetworkRequest.Builder()
    101.             .addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
    102.             .removeCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
    103.             .apply {
    104.                 if (Build.VERSION.SDK_INT >= 29) {
    105.                     val wifiNetworkSpecifier = WifiNetworkSpecifier.Builder()
    106. //                        .setBand(ScanResult.WIFI_BAND_24_GHZ)//Android12 但是设置这个参数后无法连接
    107.                         .setSsidPattern(PatternMatcher("ZS[0-9a-fA-F]{8}", PatternMatcher.PATTERN_ADVANCED_GLOB))
    108. //                        .setSsid("ZS3755a0e2")
    109.                         .setWpa2Passphrase("12345678")
    110.                         .build()
    111.  
    112.                     setNetworkSpecifier(wifiNetworkSpecifier)
    113.                 }
    114.             }
    115.             .build()
    116.  
    117.     fun requestConnectWIFI() {
    118.         mConnectivityManager.requestNetwork(networkRequest, mNetworkCallback)
    119.     }
    120.  
    121.     fun close() {
    122.         mConnectivityManager.unregisterNetworkCallback(mNetworkCallback)
    123.     }
    124.  
    125.     //无需运行时申请权限
    126.     fun getGatewayIP(): String {
    127.         if (Build.VERSION.SDK_INT < 32) {
    128.             /*This method was deprecated in API level 31.
    129.                 Use the methods on LinkProperties which can be obtained either via
    130.                 NetworkCallback#onLinkPropertiesChanged(Network, LinkProperties) or
    131.                 ConnectivityManager#getLinkProperties(Network).*/
    132.             val dhcpInfo = wifiManager.dhcpInfo
    133.  
    134.             // 网关IP地址是一个整数，需要转换为可读的IP地址格式
    135.             val gatewayIpAddress: String = dhcpInfo.gateway.toIPAddress()
    136.             println("Gateway IP: $gatewayIpAddress")
    137.             return gatewayIpAddress
    138.         } else {
    139.             var addr = ""
    140.             mConnectivityManager.activeNetwork?.let { network ->
    141.                 mConnectivityManager.getLinkProperties(network)?.let { linkProperties ->
    142.                     linkProperties.dhcpServerAddress?.let { inet4Address ->
    143.                         addr = inet4Address.hostAddress ?: ""
    144.                     }
    145.                 }
    146.             }
    147.             println("网关IP: $addr")
    148.             return addr
    149.         }
    150.     }
    151.     
    152.     private fun getIP(network: Network): String {
    153.         mConnectivityManager.getLinkProperties(network)?.linkAddresses?.let { linkAddresses ->
    154.             linkAddresses.forEach { linkAddress ->
    155.                 // hostAddress: the IP address string in textual presentation.
    156.                 linkAddress.address.hostAddress?.let { hostAddress ->
    157.                     if (hostAddress.isValidIP) {
    158.                         println("手机IP：${hostAddress}")
    159.                         return hostAddress
    160.                     }
    161.                 }
    162.             }
    163.         }
    164.         return ""
    165.     }
    166.  
    167.     private val ipRegex = """\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}""".toRegex()
    168.  
    169.     private val String.isValidIP: Boolean
    170.         get() = ipRegex.matches(this)
    171.  
    172.     private fun Int.toIP(): String {
    173.         return "${this.and(0xff)}" +
    174.                 ".${this.shr(8).and(0xff)}" +
    175.                 ".${this.shr(16).and(0xff)}" +
    176.                 ".${this.shr(24).and(0xff)}"
    177.     }
    178. }

    TelnetUtil.kt

    1. import android.net.Network
    2. import org.apache.commons.net.telnet.EchoOptionHandler
    3. import org.apache.commons.net.telnet.SuppressGAOptionHandler
    4. import org.apache.commons.net.telnet.TelnetClient
    5. import org.apache.commons.net.telnet.TerminalTypeOptionHandler
    6.  
    7. class TelnetUtil {
    8.     private val telnetClient = TelnetClient()
    9.  
    10.     private fun connectServer(ip: String, network: Network?): Boolean {
    11.         try {
    12.             if (network != null) {
    13.                 telnetClient.setSocketFactory(network.socketFactory)
    14.             }
    15.  
    16.             /*val ttopt = TerminalTypeOptionHandler("VT220", false, false, true, false)
    17.             val echoopt = EchoOptionHandler(true, false, true, false)
    18.             val gaopt = SuppressGAOptionHandler(true, true, true, true)
    19.             telnetClient.addOptionHandler(ttopt)
    20.             telnetClient.addOptionHandler(echoopt)
    21.             telnetClient.addOptionHandler(gaopt)*/
    22.  
    23.             telnetClient.connect(ip, 23)
    24.             if (telnetClient.isConnected) {
    25.                 println("端口可用 $ip")
    26.                 return true
    27.             }
    28.  
    29.         } catch (ex: Exception) {
    30.             ex.printStackTrace()
    31.         }
    32.         return false
    33.     }
    34.  
    35.     fun readUntil(match: String, timeout: Long = 10_000): Boolean {
    36.         val sb = StringBuilder()
    37.         val startTime = System.currentTimeMillis()
    38.         while (true) {
    39.             if ((System.currentTimeMillis() - startTime) >= timeout) {
    40.                 //超时
    41.                 break
    42.             }
    43.             var len = telnetClient.inputStream.available()
    44.             while (len > 0) {
    45.                 val ch = telnetClient.inputStream.read()
    46.                 if (ch != -1) {
    47.                     sb.append(ch.toChar())
    48.                     print(ch.toChar())
    49.                     if (ch == 0x0D || ch == 0x0A) {
    50.                         System.out.flush()
    51.                     }
    52.                     if (sb.contains(match)) {
    53.                         println(sb.toString())
    54.                         return true
    55.                     }
    56.                 }
    57.                 len--
    58.             }
    59.         }
    60.         println(sb.toString())
    61.         return false
    62.     }
    63.  
    64.     fun send(msg: String) {
    65.         telnetClient.outputStream.apply {
    66.             write(msg.toByteArray(Charsets.UTF_8))
    67.             flush()
    68.         }
    69.     }
    70. }

    6. 解压缩文件

    参考这篇文章：Android解压 zip rar 7z 文件

  • 相关阅读:
    直播倒计时 1 天｜SOFAChannel#35《SOFABoot 4.0 — 迈向 JDK 17 新时代》
    【牛客刷题】带你在牛客刷题第五弹（简单排序）
    vue入门
    Linux 程序开发流程 / 基本开发工具 / Vim / GCC工具链 / Make 工具 / Makefile 模板
    PostgreSQL数据库统计信息——acquire_sample_rows采样函数
    Chrome添加扩展程序
    springMVC基础技术使用
    Idea同时切换多个项目的分支
    A-level成绩BBB能申英国哪些大学？
    LAMMPS实操系列（四）: 高熵合金FCC-CoCrCuFeNi的退火模拟
  • 原文地址：https://blog.csdn.net/jjf19891208/article/details/139710406