Android 14（API 34）下持久Socket连接服务的替代方案咨询

针对Android 14（API 34）对Foreground Service的限制，以下几种方案可用于维持与服务器的持久Socket连接：

1. WorkManager + 心跳重连机制 #

WorkManager能在后台周期性执行任务，适合定期检查Socket连接状态，断开时自动重建。该方案无法实现永久持续的连接，但通过合理设置心跳周期（需平衡电量消耗），可尽可能维持在线状态。

示例代码 #

定义Socket连接Worker

class SocketKeepAliveWorker(
    context: Context,
    params: WorkerParameters
) : CoroutineWorker(context, params) {

    private val host = "你的服务器地址"
    private val port = 你的端口号
    private var socket: Socket? = null
    private var reader: BufferedReader? = null
    private const val BUFFER_SIZE = 1024

    override suspend fun doWork(): Result {
        return try {
            if (socket?.isConnected != true) {
                // 重建Socket连接
                socket = Socket().apply {
                    connect(InetSocketAddress(InetAddress.getByName(host), port), 30 * 1000)
                }
                reader = BufferedReader(InputStreamReader(socket?.inputStream), 8 * 1024)
                
                // 读取服务器数据
                val buffer = CharArray(BUFFER_SIZE)
                var n: Int
                while ((reader?.read(buffer)?.also { n = it } ?: -1) != -1) {
                    val data = String(buffer, 0, n)
                    // 处理接收到的数据
                    processReceivedData(data)
                }
            }
            // 任务完成后调度下一次检查
            Result.retry()
        } catch (e: Exception) {
            e.printStackTrace()
            // 连接失败，延迟重试
            Result.retry()
        } finally {
            // 关闭资源
            reader?.close()
            socket?.close()
        }
    }

    private fun processReceivedData(data: String) {
        // 实现数据处理逻辑
    }
}

调度Worker

// 在Activity或Application中启动Worker
val constraints = Constraints.Builder()
    .setRequiredNetworkType(NetworkType.CONNECTED)
    .build()

val request = PeriodicWorkRequestBuilder<SocketKeepAliveWorker>(15, TimeUnit.MINUTES)
    .setConstraints(constraints)
    .build()

WorkManager.getInstance(context).enqueueUniquePeriodicWork(
    "SocketKeepAlive",
    ExistingPeriodicWorkPolicy.REPLACE,
    request
)

2. Accessibility Service（辅助功能服务） #

Accessibility Service后台优先级高，系统不会轻易终止，适合长期运行的任务。但需要用户手动开启辅助功能权限，且不可滥用（否则可能被Google Play拒审）。

示例代码 #

配置Accessibility Service（AndroidManifest.xml）

<service
    android:name=".SocketAccessibilityService"
    android:permission="android.permission.BIND_ACCESSIBILITY_SERVICE">
    <intent-filter>
        <action android:name="android.accessibilityservice.AccessibilityService" />
    </intent-filter>
    <meta-data
        android:name="android.accessibilityservice"
        android:resource="@xml/accessibility_service_config" />
</service>

辅助服务配置文件（res/xml/accessibility_service_config.xml）

<?xml version="1.0" encoding="utf-8"?>
<accessibility-service xmlns:android="http://schemas.android.com/apk/res/android"
    android:accessibilityEventTypes="typeAllMask"
    android:accessibilityFeedbackType="feedbackAllMask"
    android:accessibilityFlags="flagDefault"
    android:description="@string/accessibility_service_description" />

实现Accessibility Service

class SocketAccessibilityService : AccessibilityService() {
    private val host = "你的服务器地址"
    private val port = 你的端口号
    private var socketThread: Thread? = null
    private var socket: Socket? = null
    private var reader: BufferedReader? = null
    private const val BUFFER_SIZE = 1024

    override fun onServiceConnected() {
        super.onServiceConnected()
        // 启动Socket连接线程
        socketThread = Thread {
            try {
                socket = Socket().apply {
                    connect(InetSocketAddress(InetAddress.getByName(host), port), 30 * 1000)
                }
                reader = BufferedReader(InputStreamReader(socket?.inputStream), 8 * 1024)
                
                val buffer = CharArray(BUFFER_SIZE)
                var n: Int
                while (!Thread.currentThread().isInterrupted && (reader?.read(buffer)?.also { n = it } ?: -1) != -1) {
                    val data = String(buffer, 0, n)
                    // 处理数据
                    processReceivedData(data)
                }
            } catch (e: Exception) {
                e.printStackTrace()
                // 连接断开后重试
                Thread.sleep(5000)
                restartSocketConnection()
            } finally {
                reader?.close()
                socket?.close()
            }
        }
        socketThread?.start()
    }

    private fun processReceivedData(data: String) {
        // 数据处理逻辑
    }

    private fun restartSocketConnection() {
        socketThread?.interrupt()
        onServiceConnected()
    }

    override fun onInterrupt() {
        socketThread?.interrupt()
        reader?.close()
        socket?.close()
    }
}

3. 利用前台服务的允许场景（补充方案） #

如果你的业务场景属于Android 14允许使用Foreground Service的范畴（如媒体播放、实时位置追踪、语音交互等），可继续使用Foreground Service，但必须遵循系统要求：显示通知、声明对应权限。

原Socket连接代码（中文注释版） #

Socket socket = new Socket();
// 连接服务器，超时时间30秒
socket.connect(new InetSocketAddress(InetAddress.getByName("你的服务器地址"), 你的端口号), 30 * 1000);
// 创建输入流读取器，缓冲区8KB
reader = new BufferedReader(new InputStreamReader(socket.getInputStream()), 8 * 1024);
char[] buffer = new char[BUFFER_SIZE];
int n;
// 循环读取服务器发送的数据，直到连接断开
while ((n = reader.read(buffer)) != -1) {
  Writer writer = new StringWriter();
  writer.write(buffer, 0, n);
  String data = writer.toString();
  // 处理接收到的数据
}

内容的提问来源于stack exchange，提问作者almisoft