如何让Android中C语言可执行文件依托前台服务稳定运行并通信？

核心思路 #

Android的进程管控机制针对应用进程，独立C可执行文件本质是单独的Native进程，要让它稳定后台运行，必须绑定到前台服务（前台服务进程优先级高，不易被系统回收），同时通过Unix域套接字实现与Activity的跨进程通信。

具体步骤 #

1. 编写Java前台服务，托管Native进程 #

创建前台服务，负责启动、监控C可执行文件，进程终止时自动重启：

• 在onCreate()中启动前台服务：创建符合版本要求的通知（Android 8.0+必须），调用startForeground()提升进程优先级。
• 将编译好的C可执行文件放在/data/data/[包名]/files目录，启动前赋予可执行权限chmod 755。
• 监听Native进程的退出状态，一旦进程终止立即重启，保障可用性。

示例代码片段：

public class NativeDaemonService extends Service {
    private Process nativeProcess;

    @Override
    public void onCreate() {
        super.onCreate();
        // 启动前台服务，创建适配版本的通知
        Notification notification = createForegroundNotification();
        startForeground(1, notification);

        // 启动C可执行文件
        startNativeProcess();
    }

    private void startNativeProcess() {
        try {
            String execPath = getFilesDir() + "/my_c_daemon";
            // 赋予可执行权限
            Runtime.getRuntime().exec("chmod 755 " + execPath).waitFor();
            // 启动Native进程
            nativeProcess = new ProcessBuilder(execPath).start();

            // 监听进程退出，自动重启
            new Thread(() -> {
                try {
                    nativeProcess.waitFor();
                    startNativeProcess();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }).start();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 实现通知创建逻辑，适配不同Android版本
    private Notification createForegroundNotification() {
        // 此处省略通知构建代码，需注意Android 8.0+的NotificationChannel要求
        return notification;
    }

    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }
}

2. 配置Unix域套接字通信 #

• C可执行文件创建Unix域套接字，路径建议放在/data/data/[包名]/socket目录（仅应用拥有读写权限）。
• Activity通过Java的LocalSocket、LocalSocketAddress连接套接字，实现双向通信。

C端套接字示例（简化）：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/un.h>
#include <sys/socket.h>

#define SOCKET_PATH "/data/data/com.your.package/socket/daemon_socket"

int main() {
    int sockfd, connfd;
    struct sockaddr_un addr;

    // 删除旧套接字文件
    unlink(SOCKET_PATH);

    // 创建套接字
    sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
    memset(&addr, 0, sizeof(addr));
    addr.sun_family = AF_UNIX;
    strncpy(addr.sun_path, SOCKET_PATH, sizeof(addr.sun_path)-1);

    // 绑定、监听
    bind(sockfd, (struct sockaddr*)&addr, sizeof(addr));
    listen(sockfd, 5);

    // 循环接收连接并处理通信
    while ((connfd = accept(sockfd, NULL, NULL)) != -1) {
        char buf[1024];
        ssize_t n = read(connfd, buf, sizeof(buf)-1);
        if (n > 0) {
            buf[n] = '\0';
            // 处理数据并回复Activity
            write(connfd, "Received", 8);
        }
        close(connfd);
    }

    close(sockfd);
    unlink(SOCKET_PATH);
    return 0;
}

Java端Activity连接示例：

public class MainActivity extends AppCompatActivity {
    private LocalSocket socket;

    private void connectToNativeDaemon() {
        new Thread(() -> {
            try {
                socket = new LocalSocket();
                LocalSocketAddress address = new LocalSocketAddress(
                    "/data/data/com.your.package/socket/daemon_socket",
                    LocalSocketAddress.Namespace.FILESYSTEM
                );
                socket.connect(address);

                // 发送数据到Native进程
                OutputStream os = socket.getOutputStream();
                os.write("Hello from Activity".getBytes());
                os.flush();

                // 接收Native进程的回复
                InputStream is = socket.getInputStream();
                byte[] buf = new byte[1024];
                int n = is.read(buf);
                if (n > 0) {
                    String response = new String(buf, 0, n);
                    // 切换到主线程更新UI
                    runOnUiThread(() -> Toast.makeText(this, response, Toast.LENGTH_SHORT).show());
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }).start();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        try {
            if (socket != null) socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3. 权限与清单配置 #

• 在AndroidManifest.xml中声明前台服务权限：

  <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
  <!-- Android 12+ 需声明对应类型的前台服务权限，如数据同步类型 -->
  <uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC" />
  

• 注册服务：

  <service
      android:name=".NativeDaemonService"
      android:foregroundServiceType="dataSync"
      android:stopWithTask="false" />
  

  stopWithTask="false"确保用户从最近任务列表划掉应用时，服务不会被停止。

4. 提升存活的额外措施 #

• 引导用户开启自动启动权限：适配不同厂商的定制系统，避免设备重启后服务无法启动。
• 搭配WorkManager：设备重启后，通过WorkManager触发启动前台服务，重新拉起Native进程。
• 降低资源消耗：Native进程尽量减少CPU、内存占用，降低被系统回收的概率。

原理说明 #

Android系统优先回收低优先级后台进程，前台服务所在进程属于前台进程优先级，被杀死的概率极低。通过Java前台服务托管Native进程，相当于给Native进程挂靠了高优先级宿主，再配合进程监控自动重启，就能实现类似常规系统中后台守护进程的稳定运行效果。

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