Android网络编程基础 #

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.myapp">

    <!-- 网络访问权限 -->
    <uses-permission android:name="android.permission.INTERNET" />
    
    <!-- 网络状态权限 -->
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
    
    <!-- WiFi状态权限 -->
    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />

</manifest>

fun isNetworkAvailable(context: Context): Boolean {
    val connectivityManager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
    
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        val network = connectivityManager.activeNetwork ?: return false
        val capabilities = connectivityManager.getNetworkCapabilities(network) ?: return false
        
        return capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET) &&
               capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)
    } else {
        val networkInfo = connectivityManager.activeNetworkInfo
        return networkInfo?.isConnected == true
    }
}

fun isWifiConnected(context: Context): Boolean {
    val connectivityManager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
    
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        val network = connectivityManager.activeNetwork ?: return false
        val capabilities = connectivityManager.getNetworkCapabilities(network) ?: return false
        return capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)
    } else {
        val networkInfo = connectivityManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI)
        return networkInfo?.isConnected == true
    }
}

val headers = mapOf(
    "Content-Type" to "application/json",
    "Accept" to "application/json",
    "Authorization" to "Bearer token",
    "User-Agent" to "MyApp/1.0",
    "Cache-Control" to "no-cache"
)

<!-- res/xml/network_security_config.xml -->
<?xml version="1.0" encoding="utf-8"?>
<network-security-config>
    <!-- 允许明文传输（仅用于开发环境） -->
    <base-config cleartextTrafficPermitted="true">
        <trust-anchors>
            <certificates src="system" />
        </trust-anchors>
    </base-config>
    
    <!-- 限制特定域名 -->
    <domain-config cleartextTrafficPermitted="false">
        <domain includeSubdomains="true">example.com</domain>
        <trust-anchors>
            <certificates src="system" />
        </trust-anchors>
    </domain-config>
    
    <!-- 自定义证书 -->
    <domain-config>
        <domain includeSubdomains="true">secure.example.com</domain>
        <trust-anchors>
            <certificates src="@raw/my_cert" />
        </trust-anchors>
    </domain-config>
</network-security-config>

<application
    android:networkSecurityConfig="@xml/network_security_config"
    ...>
</application>

<network-security-config>
    <base-config cleartextTrafficPermitted="true">
        <trust-anchors>
            <certificates src="system" />
        </trust-anchors>
    </base-config>
</network-security-config>

fun httpGet(urlString: String): String {
    var connection: HttpURLConnection? = null
    try {
        val url = URL(urlString)
        connection = url.openConnection() as HttpURLConnection
        connection.requestMethod = "GET"
        connection.connectTimeout = 10000
        connection.readTimeout = 10000
        
        val responseCode = connection.responseCode
        if (responseCode == HttpURLConnection.HTTP_OK) {
            return connection.inputStream.bufferedReader().readText()
        } else {
            throw Exception("HTTP Error: $responseCode")
        }
    } finally {
        connection?.disconnect()
    }
}

fun httpPost(urlString: String, jsonBody: String): String {
    var connection: HttpURLConnection? = null
    try {
        val url = URL(urlString)
        connection = url.openConnection() as HttpURLConnection
        connection.requestMethod = "POST"
        connection.connectTimeout = 10000
        connection.readTimeout = 10000
        connection.doOutput = true
        connection.setRequestProperty("Content-Type", "application/json")
        
        connection.outputStream.use { output ->
            output.write(jsonBody.toByteArray())
        }
        
        val responseCode = connection.responseCode
        if (responseCode == HttpURLConnection.HTTP_OK) {
            return connection.inputStream.bufferedReader().readText()
        } else {
            throw Exception("HTTP Error: $responseCode")
        }
    } finally {
        connection?.disconnect()
    }
}

class NetworkRepository {
    
    suspend fun fetchData(url: String): String = withContext(Dispatchers.IO) {
        httpGet(url)
    }
    
    suspend fun postData(url: String, body: String): String = withContext(Dispatchers.IO) {
        httpPost(url, body)
    }
}

class NetworkCallback : ConnectivityManager.NetworkCallback() {
    
    override fun onAvailable(network: Network) {
        Log.d("Network", "网络可用")
    }
    
    override fun onLost(network: Network) {
        Log.d("Network", "网络丢失")
    }
    
    override fun onCapabilitiesChanged(network: Network, capabilities: NetworkCapabilities) {
        val isWifi = capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)
        val isCellular = capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)
        Log.d("Network", "WiFi: $isWifi, Cellular: $isCellular")
    }
}

// 注册
val connectivityManager = getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
val networkRequest = NetworkRequest.Builder()
    .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
    .build()
connectivityManager.registerNetworkCallback(networkRequest, NetworkCallback())

// 注销
connectivityManager.unregisterNetworkCallback(networkCallback)

class NetworkLiveData(private val context: Context) : LiveData<Boolean>() {
    
    private val connectivityManager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
    
    private val networkCallback = object : ConnectivityManager.NetworkCallback() {
        override fun onAvailable(network: Network) {
            postValue(true)
        }
        
        override fun onLost(network: Network) {
            postValue(false)
        }
    }
    
    override fun onActive() {
        super.onActive()
        val networkRequest = NetworkRequest.Builder()
            .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
            .build()
        connectivityManager.registerNetworkCallback(networkRequest, networkCallback)
        
        value = isNetworkAvailable(context)
    }
    
    override fun onInactive() {
        super.onInactive()
        connectivityManager.unregisterNetworkCallback(networkCallback)
    }
}

class MainViewModel : ViewModel() {
    
    private val repository = NetworkRepository()
    
    private val _result = MutableLiveData<Result<String>>()
    val result: LiveData<Result<String>> = _result
    
    fun fetchData(url: String) {
        viewModelScope.launch {
            _result.value = Result.loading()
            try {
                val data = repository.fetchData(url)
                _result.value = Result.success(data)
            } catch (e: Exception) {
                _result.value = Result.error(e.message ?: "Unknown error")
            }
        }
    }
}

suspend fun <T> retryIO(times: Int = 3, block: suspend () -> T): T {
    var currentAttempt = 0
    var lastException: Exception? = null
    
    while (currentAttempt < times) {
        try {
            return block()
        } catch (e: IOException) {
            lastException = e
            currentAttempt++
            delay(1000L * currentAttempt)
        }
    }
    
    throw lastException ?: Exception("Unknown error")
}

// 使用
val result = retryIO {
    repository.fetchData(url)
}

class CacheManager(private val context: Context) {
    
    private val cacheDir = File(context.cacheDir, "network_cache")
    
    fun saveCache(key: String, data: String) {
        File(cacheDir, key).writeText(data)
    }
    
    fun getCache(key: String): String? {
        val file = File(cacheDir, key)
        return if (file.exists()) file.readText() else null
    }
    
    fun clearCache() {
        cacheDir.deleteRecursively()
    }
}