守护进程通信之Socket
前置文章
《创建Android守护进程（底层服务） 》
前言
在文章 《创建Android守护进程（底层服务） 》 中，学习了如何创建一个 Android 守护进程，但是这个进程还没有做任何有价值的事情。因此，在此篇文章中，来学习如何利用 Android 守护进程做一些事情。
在本文中，将讲述一个上层的 Android APP 如何和 Android 守护进程建立通信，传输数据，完成某项功能。本文将以 APP 读取 Android 设备 CPU 频率为例，APP 与守护进程通过建立 socket 通信，守护进程通过 socket 通道，把 CPU 频率上报到 APP 显示。
注：本文承接 《创建Android守护进程（底层服务） 》 一文中的内容。采用 MTK Android 8.0 的基带平台代码
本文涉及的主要代码，已经上传到 Github：
- nativeservice - 守护进程
- SocketConnectNative - APP
添加Socket配置
在开机启动配置文件中添加创建 socket，如下代码的 socket…部分，其它代码和文章《创建Android守护进程（底层服务） 》是相同的。
service nativeservice /system/bin/nativeservice
class main #main类，属于main的服务会开机被运行，且死掉会重启
group system #属于 system 组
#user system #以system用户启动，不设置以root用户启动
seclabel u:r:nativeservice:s0 #SeAndroid SContext，domain是nativeservice
restorecon nativeservice
socket nativeservice stream 0666 root root #创建nativeservice socket，用户为 root
write /proc/bootprof "start nativeservice"代码路径：system/core/rootdir/init.rc
添加 SeAndroid 权限
承接文章《创建Android守护进程（底层服务） 》中的内容，修改或者添加部分内容。
声明 socket 通道文件的角色
type nativeservice_socket, file_type;在文件 device/mediatek/sepolicy/basic/non_plat/file.te 中添加。
声明 socket 通道文件的安全上下文
/dev/socket/nativeservice u:object_r:nativeservice_socket:s0在文件 device/mediatek/sepolicy/basic/non_plat/file_contexts 中添加。
因为用的 socket 命名空间是 RESERVED，因此，socket 通道会在 /dev/socket/ 地下，详情可以查阅文件frameworks/base/core/java/android/net/LocalSocketAddress.java。
配置使用者权限
以上两个声明文件的角色和安全上下文，后面就是给某个进程赋予该角色被操作的权限。本文中，采用 System app 来和守护进程建立 socket 连接，因此，添加如下代码
allow system_app nativeservice_socket:sock_file { write append };
allow system_app nativeservice:unix_stream_socket { connectto };在文件 device/mediatek/sepolicy/basic/non_plat/system_app.te 中添加。
proc 文件权限
守护进程需要打开和读取 /proc/ 底下的 CPU 频率文件，因此给守护进程 nativeservice 授予如下权限
allow nativeservice proc:file { open read };在文件 device/mediatek/sepolicy/basic/non_plat/nativeservice.te 中添加。
编写守护进程代码
先看一下现在守护进程代码的目录架构，比文章 《创建Android守护进程（底层服务） 》 中多了 NativeServiceListener.cpp 和 NativeServiceListener.h 两个文件，修改了 native_main.cpp 文件。
native_main.cpp 代码
//
// Created familyyuan.
//
#include 代码文件 system/core/nativeservice/native_main.cpp
NativeServiceListener.h 文件
声明继承 SocketListener.h 的头文件，当 socket 建立连接收到数据，会回调 onDataAvailable() 函数。
/* Copyright (C) 2016 Tcl Corporation Limited */
#ifndef _NATIVESERVICESOCKETLISTENER_H
#define _NATIVESERVICESOCKETLISTENER_H
#include "SocketListener.h"
class SocketClient;
class NativeServiceListener : public SocketListener {
public:
static const int CMD_ARGS_MAX = 26;
static const int CMD_BUF_SIZE = 1024;
/* 1 out of errorRate will be dropped */
int errorRate;
protected:
bool onDataAvailable(SocketClient *c);
public:
NativeServiceListener(const char *socketName);
NativeServiceListener(const char *socketName, bool withSeq);
NativeServiceListener(int sock);
virtual ~NativeServiceListener() {}
private:
void init(const char *socketName, bool withSeq);
};
#endif代码文件 system/core/nativeservice/NativeServiceListener.h。
NativeServiceListener.cpp 文件
这个文件就是 SocketListener 的实现类，在 onDataAvailable() 函数中做事情。
/* Copyright (C) 2016 Tcl Corporation Limited */
#define LOG_TAG "NativeServiceListener"
#include 代码文件 system/core/nativeservice/NativeServiceListener.cpp。
小结
至此，底层的代码就编写完毕了，以上代码编译开机，在 /dev/socket/ 下创建了 nativeservice socket 文件，如下图
守护进程接收到 socket 连接后打印的 log
编写 APP 代码
APP 实现的功能是与 Nativeservice 建立 socket 连接，读取 socket 返回的 cpu 频率数据，显示在屏幕上。如下图所示，有一个 Activity 界面，启动一个 Service，Service 和 nativeservcie 建立 socket 连接，每隔 1 秒拿一次 cpu 频率数据，显示在一个浮动 view 上。
如下是 Service 的代码，更多代码请看 Github - SocketConnectNative。
package yuan.family.com.socketconnectnative;
public class SocketConnNativeService extends Service {
final String TAG = SocketConnNativeService.class.getSimpleName();
private WindowManager mWindowManager;
private WindowManager.LayoutParams wmParams;
private LocalSocket mSocket;
private InputStream mIn;
private OutputStream mOut;
private Handler mHandler;
private Handler mThreadHandler;
private HandlerThread mHandlerThread;
private final int CONN_SOCKET = 101;
private final int SOCKET_RESULT = 101;
private TextView mCpuFreqTV;
public SocketConnNativeService() {
}
@Override
public IBinder onBind(Intent intent) {
// TODO: Return the communication channel to the service.
throw new UnsupportedOperationException("Not yet implemented");
}
/**
* 浮动窗口的 window 和 view 配置
*/
private void initWindowParams() {
mWindowManager = (WindowManager) getApplication().getSystemService(getApplication().WINDOW_SERVICE);
wmParams = new WindowManager.LayoutParams();
wmParams.type = WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY;
wmParams.format = PixelFormat.TRANSLUCENT;
wmParams.flags = WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE;
wmParams.gravity = Gravity.LEFT | Gravity.TOP;
wmParams.width = WindowManager.LayoutParams.MATCH_PARENT;
wmParams.height = WindowManager.LayoutParams.WRAP_CONTENT;
}
/**
* 引入 view，实例化组件，把 view 显示出来
*/
private void initView() {
initWindowParams();
View dialogView = LayoutInflater.from(this).inflate(R.layout.cpu_freq_view, null);
mCpuFreqTV = dialogView.findViewById(R.id.cpu_freq);
dialogView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
mWindowManager.removeViewImmediate(v);
stopSelf();
}
});
mWindowManager.addView(dialogView, wmParams);
}
/**
* 由于使用的是 Android 8.0 需要把 service 推到前台，不然被系统杀掉
*/
private Notification getNotification(){
NotificationManager mNotiManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
NotificationChannel mChannel = new NotificationChannel("socket_native_conn", "socket_native_conn", NotificationManager.IMPORTANCE_DEFAULT);
mNotiManager.createNotificationChannel(mChannel);
Notification.Builder mBuilder = new Notification.Builder(this);
mBuilder.setShowWhen(false);
mBuilder.setAutoCancel(false);
mBuilder.setSmallIcon(R.mipmap.ic_launcher);
mBuilder.setContentText("SocketConnNative keep");
mBuilder.setContentTitle("SocketConnNative keep");
mBuilder.setChannelId("socket_native_conn");
return mBuilder.build();
}
/**
* 与 socket 建立连接，获取输入输出流
*/
private boolean connect() {
if (mSocket != null && mSocket.isConnected()) {
return true;
}
try {
// a non-server socket
mSocket = new LocalSocket();
// LocalSocketAddress.Namespace.RESERVED keep namespace
LocalSocketAddress address = new LocalSocketAddress("nativeservice", LocalSocketAddress.Namespace.RESERVED);
mSocket.connect(address);
mIn = mSocket.getInputStream();
mOut = mSocket.getOutputStream();
} catch (Exception ex) {
ex.printStackTrace();
//disconnect();
return false;
}
return true;
}
public void disconnect() {
try {
if (mSocket != null) {
mSocket.shutdownInput();
mSocket.shutdownOutput();
mSocket.close();
}
} catch (Exception ex) {
ex.printStackTrace();
}
try {
if (mIn != null) {
mIn.close();
}
} catch (IOException ex) {
ex.printStackTrace();
}
try {
if (mOut != null) {
mOut.close();
}
} catch (IOException ex) {
ex.printStackTrace();
}
mSocket = null;
mIn = null;
mOut = null;
}
protected boolean sendCommand(byte[] cmd) {
try {
String prefixCmd = "0 traceability ";
byte fullCmd[] = new byte[prefixCmd.length() + cmd.length];
System.arraycopy(prefixCmd.getBytes(), 0, fullCmd, 0, prefixCmd.length());
System.arraycopy(cmd, 0, fullCmd, prefixCmd.length(), cmd.length);
if (mOut != null) {
mOut.write(fullCmd, 0, fullCmd.length);
}
} catch (Exception ex) {
Log.e(TAG, "write error");
return false;
}
return true;
}
public String connSocketNative(byte[] cmd) {
byte[] result = new byte[128];
StringBuilder stringBuilder = new StringBuilder();
if (!connect()) {
Log.d(TAG, "Connecting nativeservice proxy fail!");
mThreadHandler.sendEmptyMessage(CONN_SOCKET);
} else if (!sendCommand(cmd)) {
Log.d(TAG, "Send command to nativeservice proxy fail!");
mThreadHandler.sendEmptyMessage(CONN_SOCKET);
} else {
BufferedReader br = null;
try {
//读取 nativeservice 返回的 cpu 频率数据
br = new BufferedReader(new InputStreamReader(mIn, "UTF-8"));
String resultStr = br.readLine();
while (!TextUtils.isEmpty(resultStr)) {
stringBuilder.append(resultStr);
resultStr = br.readLine();
}
} catch (IOException ex) {
ex.printStackTrace();
}
}
disconnect();
return stringBuilder.toString().replace("[?]", "").trim();
}
@Override
public void onCreate() {
super.onCreate();
startForeground(1, getNotification());
mHandler = new MainHandler(Looper.getMainLooper());
mHandlerThread = new HandlerThread("thread", Thread.MAX_PRIORITY);
mHandlerThread.start();
mThreadHandler = new ThreadHandler(mHandlerThread.getLooper());
initView();
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
mThreadHandler.sendEmptyMessage(CONN_SOCKET);
return super.onStartCommand(intent, flags, startId);
}
@Override
public void onDestroy() {
super.onDestroy();
stopForeground(true);
}
/**
* socket 连接是耗时操作，需要在子线程完成
*/
private class ThreadHandler extends Handler {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case CONN_SOCKET:
String result = connSocketNative(new byte[]{'A'});
Gson gson = new Gson();
CpuInfo cpuInfo = gson.fromJson(result, CpuInfo.class);
//获取成功，将 cpu 频率数据发给 UI 线程
if (cpuInfo != null && cpuInfo.getCode() == 200) {
mHandler.sendMessage(Message.obtain(mHandler, SOCKET_RESULT, cpuInfo.getCpu()));
}
break;
default:
break;
}
}
public ThreadHandler(Looper looper) {
super(looper);
}
}
/**
* UI 线程获取到数据后，显示在 TextView 上
* 每隔 1 秒钟获取一次
*/
private class MainHandler extends Handler {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case SOCKET_RESULT:
mCpuFreqTV.setText(msg.obj.toString());
mThreadHandler.sendEmptyMessageDelayed(CONN_SOCKET, 1000);
break;
default:
break;
}
}
public MainHandler(Looper looper) {
super(looper);
}
}
}总结
守护进程在文章 《创建Android守护进程（底层服务） 》 的基础上，没有太多的修改和添加，主要三点，一是配置 SeAndroid 权限，二是增加加载 CPU 频率的代码，三是添加 Socket 监听器。上层 APP 是纯新的代码，但是代码都比较简单，核心代码就在 SocketConnNativeService.java 文件中。守护进程通过 socket 上报给 APP 的数据基于 Json 数据格式，便于 APP 解析，本文中使用 Google 的 Json 数据处理框架 Gson。