最近学习了如何在Android 6.0上添加一个系统服务，APP如何通过新增的系统服务访问底层驱动。
在这学习过程中，收获颇多，并结合学习了《Embeded Android》--Karim Yaghmour 一书中的
Appendix B. Adding Support For New Hardware章节，受益匪浅，讲述了如何添加一个完整的系统
服务（app->framework->kernel）。尽管描述的非常详细，但是基于Android 2.3.7描述的。现在把
书中的opersys例子移植到Android 6.0上，虽然说不上复杂，但由于版本差异，难免会出现许多奇奇
怪怪的问题，甚至版本差异造成了bug出现。特以此移植记录分享学习过程。
主要围绕以下几个步骤添加一个完整的系统服务：
(A) 添加circular-char驱动
(B) 添加opersyshw_qemu HAL
(C) 添加com_android_server_opersys_OpersysService JNI
(D) 添加IOpersysService接口
(E) 添加OpersysService
(F) 添加OpersysManager
(G) 添加系统服务
(H) 注册服务
(I) 更新API
(J) 设置权限
(K) 测试服务
(L) 添加测试APP
(A) 添加circular-char驱动
circular-char是一个简单的字符设备驱动，其实现的功能就是一个简单的FIFO，APP可以通过
read、write来进行读写操作实验，即写数据到FIFO，可以从FIFO读出写入的数据。
kernel/drivers/circular-driver/circular-char.c
1 #include <linux/module.h>
2 #include <linux/miscdevice.h>
3 #include <linux/fs.h>
4 #include <asm/uaccess.h>
5
6 #define BUF_SIZE 200
7
8 static char buf[BUF_SIZE];
9 static char *read_ptr;
10 static char *write_ptr;
11
12 static int device_open(struct inode *inode, struct file *file)
13 {
14 printk("device_open called \n");
15
16 return 0;
17 }
18
19 static int device_release(struct inode *inode, struct file *file)
20 {
21 printk("device_release called \n");
22
23 return 0;
24 }
25
26 static ssize_t device_read(struct file *filp, /* see include/linux/fs.h */
27 char *buffer, /* buffer to fill with data */
28 size_t length, /* length of the buffer */
29 loff_t * offset)
30 {
31 int chars_read = 0;
32
33 printk("device_read called \n");
34
35 while(length && *read_ptr && (read_ptr != write_ptr)) {
36 put_user(*(read_ptr++), buffer++);
37
38 printk("Reading %c \n", *read_ptr);
39
40 if(read_ptr >= buf + BUF_SIZE)
41 read_ptr = buf;
42
43 chars_read++;
44 length--;
45 }
46
47 return chars_read;
48 }
49
50 static ssize_t
51 device_write(struct file *filp, const char *buff, size_t len, loff_t * off)
52 {
53 int i;
54
55 printk("device_write called \n");
56
57 for(i = 0; i < len; i++) {
58 get_user(*write_ptr, buff++);
59 printk("Writing %c \n", *write_ptr);
60 write_ptr++;
61 if (write_ptr >= buf + BUF_SIZE)
62 write_ptr = buf;
63 }
64
65 return len;
66 }
67
68 static struct file_operations fops = {
69 .open = device_open,
70 .release = device_release,
71 .read = device_read,
72 .write = device_write,
73 };
74
75 static struct miscdevice circ_char_misc = {
76 .minor = MISC_DYNAMIC_MINOR,
77 .name = "circchar",
78 .fops = &fops,
79 };
80
81 int circ_char_enter(void)
82 {
83 int retval;
84
85 retval = misc_register(&circ_char_misc);
86 printk("CIRC Driver got retval %d\n", retval);
87 printk("mmap is %08X\n", (int) fops.mmap);
88
89 read_ptr = buf;
90 write_ptr = buf;
91
92 return 0;
93 }
94
95 void circ_char_exit(void)
96 {
97 misc_deregister(&circ_char_misc);
98 }
99
100 module_init(circ_char_enter);
101 module_exit(circ_char_exit);
kernel/drivers/circular-driver/Kconfig
1 menuconfig DRIVER_FOR_TEST
2 bool "Drivers for test"
3 help
4 Drivers for test.
5 If unsure, say no.
6
7 if DRIVER_FOR_TEST
8
9 config CIRCULAR_CHAR
10 tristate "circular-char"
11 help
12 circular-char driver.
13
14 endif
kernel/drivers/circular-driver/Makefile
1 obj-$(CONFIG_CIRCULAR_CHAR) += circular-char.o
kernel/drivers/Kconfig
1 ......
2 source "drivers/circular-driver/Kconfig"
3 ......
kernel/drivers/Makefile
1 ......
2 obj-$(CONFIG_DRIVER_FOR_TEST) += circular-driver/
3 ......
kernel/arch/arm/configs/xxx_defconfig
......
CONFIG_DRIVER_FOR_TEST=y
CONFIG_CIRCULAR_CHAR=y
......
驱动已添加到内核，编译烧录到目标板看是否加载成功：
# ls dev/circchar
ls dev/circchar
dev/circchar
#echo hello > dev/circchar
echo hello > dev/circchar
#cat dev/circchar
dev/circchar
hello
如果执行以上命令，输出对应得信息，则说明驱动加载成功。
(B) 添加opersyshw_qemu HAL
这里添加一个opersys的HAL层，使应用和驱动分离，hal主要向应用提供open、read、write等几个
接口。
hardware/libhardware/tests/opersyshw/opersyshw_qemu.c
1 #define LOG_TAG "opersyshw_qemu"
2 #include <cutils/log.h>
3 #include <cutils/sockets.h>
4 #include <sys/types.h>
5 #include <sys/stat.h>
6 #include <fcntl.h>
7 #include <hardware/opersyshw.h>
8 #include <malloc.h>
9
10 #define OPERSYSHW_DEBUG 1
11
12 #if OPERSYSHW_DEBUG
13 # define D(...) ALOGD(__VA_ARGS__)
14 #else
15 # define D(...) ((void)0)
16 #endif
17
18 static int fd = 0;
19
20 static int opersyshw__read(char* buffer, int length)
21 {
22 int retval;
23
24 D("OPERSYS HW - read()for %d bytes called", length);
25
26 retval = read(fd, buffer, length);
27 D("read data from driver: %s", buffer);
28
29 return retval;
30 }
31
32 static int opersyshw__write(char* buffer, int length)
33 {
34 int retval;
35
36 D("OPERSYS HW - write()for %d bytes called", length);
37
38 retval = write(fd, buffer, length);
39 D("write data to driver: %s", buffer);
40
41 return retval;
42 }
43
44 static int opersyshw__close(void)
45 {
46 if (fd != -1) {
47 if (!close(fd)) {
48 return 0;
49 }
50 }
51
52 return -1;
53 }
54
55 static int opersyshw__test(int value)
56 {
57 return value;
58 }
59
60 static int open_opersyshw(const struct hw_module_t* module, char const* name,
61 struct hw_device_t** device)
62 {
63 struct opersyshw_device_t *dev = malloc(sizeof(struct opersyshw_device_t));
64 if (!dev) {
65 D("OPERSYS HW failed to malloc memory !!!");
66 return -1;
67 }
68
69 memset(dev, 0, sizeof(*dev));
70
71 dev->common.tag = HARDWARE_DEVICE_TAG;
72 dev->common.version = 0;
73 dev->common.module = (struct hw_module_t*)module;
74 dev->read = opersyshw__read;
75 dev->write = opersyshw__write;
76 dev->close = opersyshw__close;
77 dev->test = opersyshw__test;
78
79 *device = (struct hw_device_t*) dev;
80
81 fd = open("/dev/circchar", O_RDWR);
82 if (fd < 0) {
83 D("failed to open /dev/circchar!");
84 return 0;
85 }
86
87 D("OPERSYS HW has been initialized");
88
89 return 0;
90 }
91
92 static struct hw_module_methods_t opersyshw_module_methods = {
93 .open = open_opersyshw,
94 };
95
96 struct hw_module_t HAL_MODULE_INFO_SYM = {
97 .tag = HARDWARE_MODULE_TAG,
98 .version_major = 1,
99 .version_minor = 0,
100 .id = OPERSYSHW_HARDWARE_MODULE_ID,
101 .name = "Opersys HW Module",
102 .author = "Opersys inc.",
103 .methods = &opersyshw_module_methods,
104 };
hardware/libhardware/include/hardware/opersyshw.h
1 #ifndef ANDROID_OPERSYSHW_INTERFACE_H
2 #define ANDROID_OPERSYSHW_INTERFACE_H
3
4 #include <stdint.h>
5 #include <sys/cdefs.h>
6 #include <sys/types.h>
7
8 #include <hardware/hardware.h>
9
10 __BEGIN_DECLS
11
12 #define OPERSYSHW_HARDWARE_MODULE_ID "opersyshw"
13
14 struct opersyshw_device_t {
15 struct hw_device_t common;
16
17 int (*read)(char* buffer, int length);
18 int (*write)(char* buffer, int length);
19 int (*close)(void);
20 int (*test)(int value);
21 };
22
23 __END_DECLS
24
25 #endif // ANDROID_OPERSYSHW_INTERFACE_H
hardware/libhardware/tests/opersyshw/Android.mk
1 LOCAL_PATH := $(call my-dir)
2
3 # HAL module implemenation, not prelinked and stored in
4 # hw/<GPS_HARDWARE_MODULE_ID>.<ro.hardware>.so
5 include $(CLEAR_VARS)
6 LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw
7 LOCAL_CFLAGS += $(common_flags)
8 LOCAL_LDLIBS += -llog
9 LOCAL_C_INCLUDES := hardware/libhardware
10 LOCAL_SHARED_LIBRARIES := liblog libcutils libhardware
11 LOCAL_SRC_FILES := opersyshw_qemu.c
12 LOCAL_MODULE := opersyshw.$(TARGET_BOARD_PLATFORM)
13 LOCAL_MODULE_TAGS := optional
14 include $(BUILD_SHARED_LIBRARY)
编译之后看看是否错误，是否生成.so文件，在源码根目录下：
# find ./out/ -name 'opersyshw.*.so'
......
./out/target/product/<project>/system/lib/hw/opersyshw.sc8830.so
......
注意Android.mk中的$(TARGET_BOARD_PLATFORM)，这里是sc8830，不同的平台会有差异
(C) 添加com_android_server_opersys_OpersysService JNI
JNI接口主要是为了Java（app）调用C/C++。
frameworks/base/services/core/jni/com_android_server_opersys_OpersysService.cpp
1 #define LOG_TAG "OpersysServiceJNI"
2
3 #include "jni.h"
4 #include "JNIHelp.h"
5 #include "android_runtime/AndroidRuntime.h"
6
7 #include <utils/misc.h>
8 #include <utils/Log.h>
9 #include <hardware/hardware.h>
10 #include <hardware/opersyshw.h>
11
12 #include <stdio.h>
13
14 namespace android
15 {
16
17 opersyshw_device_t* opersyshw_dev;
18
19 static jint init_native(JNIEnv *env, jobject /* clazz */)
20 {
21 int err;
22 hw_module_t* module;
23 opersyshw_device_t* dev = NULL;
24
25 //ALOGI("init_native()");
26
27 err = hw_get_module(OPERSYSHW_HARDWARE_MODULE_ID, (hw_module_t const**)&module);
28 if (err == 0) {
29 if (module->methods->open(module, "", ((hw_device_t**) &dev)) != 0) {
30 ALOGE("Can't open opersys module!!!");
31 return 0;
32 }
33 } else {
34 ALOGE("Can't get opersys module!!!");
35 return 0;
36 }
37
38 return (jint)dev;
39 }
40
41 static void finalize_native(JNIEnv *env, jobject /* clazz */, int ptr)
42 {
43 opersyshw_device_t* dev = (opersyshw_device_t*)ptr;
44
45 //ALOGI("finalize_native()");
46
47 if (dev == NULL) {
48 return;
49 }
50
51 dev->close();
52
53 free(dev);
54 }
55
56 static int read_native(JNIEnv *env, jobject /* clazz */, int ptr, jbyteArray buffer)
57 {
58 opersyshw_device_t* dev = (opersyshw_device_t*)ptr;
59 jbyte* real_byte_array;
60 int length;
61
62 //ALOGI("read_native()");
63
64 real_byte_array = env->GetByteArrayElements(buffer, NULL);
65
66 if (dev == NULL) {
67 return 0;
68 }
69
70 length = dev->read((char*) real_byte_array, env->GetArrayLength(buffer));
71
72 ALOGI("read data from hal: %s", (char *)real_byte_array);
73
74 env->ReleaseByteArrayElements(buffer, real_byte_array, 0);
75
76 return length;
77 }
78
79 static int write_native(JNIEnv *env, jobject /* clazz */, int ptr, jbyteArray buffer)
80 {
81 opersyshw_device_t* dev = (opersyshw_device_t*)ptr;
82 jbyte* real_byte_array;
83 int length;
84
85 //ALOGI("write_native()");
86
87 real_byte_array = env->GetByteArrayElements(buffer, NULL);
88
89 if (dev == NULL) {
90 return 0;
91 }
92
93 length = dev->write((char*) real_byte_array, env->GetArrayLength(buffer));
94
95 ALOGI("write data to hal: %s", (char *)real_byte_array);
96
97 env->ReleaseByteArrayElements(buffer, real_byte_array, 0);
98
99 return length;
100 }
101
102
103 static int test_native(JNIEnv *env, jobject /* clazz */, int ptr, int value)
104 {
105 opersyshw_device_t* dev = (opersyshw_device_t*)ptr;
106
107 if (dev == NULL) {
108 return 0;
109 }
110
111 ALOGI("test_native()");
112
113 return dev->test(value);
114 }
115
116 static JNINativeMethod method_table[] = {
117 { "init_native", "()I", (void*)init_native },
118 { "finalize_native", "(I)V", (void*)finalize_native },
119 { "read_native", "(I[B)I", (void*)read_native },
120 { "write_native", "(I[B)I", (void*)write_native },
121 { "test_native", "(II)I", (void*)test_native}
122 };
123
124 int register_android_server_opersys_OpersysService(JNIEnv *env)
125 {
126 return jniRegisterNativeMethods(env, "com/android/server/opersys/OpersysService",
127 method_table, NELEM(method_table));
128
129 };
frameworks/base/services/core/jni/onload.cpp
1 ......
2 namespace android {
3 ......
4 int register_android_server_opersys_OpersysService(JNIEnv* env);
5 ......
6 };
7
8 ....
9
10 extern "C" jint JNI_OnLoad(JavaVM* vm, void* /* reserved */)
11 {
12 ......
13 register_android_server_opersys_OpersysService(env);
14 ......
15 }
frameworks/base/services/core/jni/Android.mk
1 ......
2 LOCAL_SRC_FILES += \
3 ......
4 $(LOCAL_REL_DIR)/com_android_server_opersys_OpersysService.cpp \
5 ......
(D) 添加IOpersysService接口
IOpersysService主要用于实现一个进程间通信的接口，其内部机制就是通过Binder实现进程间通信的，
即客户端与服务端(OpersysService)分别处于不同的进程中，客户端和服务端之间不能够直接相互访问，
之间必须通过Binder传递。
frameworks/base/core/java/android/opersys/IOpersysService.aidl
1 interface IOpersysService {
2 /**
3 * {@hide}
4 */
5 String read(int maxLength);
6 int write(String mString);
7 }
frameworks/base/Android.mk
1 ......
2 LOCAL_SRC_FILES += \
3 ......
4 core/java/android/opersys/IOpersysService.aidl \
5 ......
其中，aidl文件主要用于生成同名的.java文件IOpersysService.java，IOpersysService.java主要实现
了一些Binder相关的设置和相关接口。
编译后，会在out目录下生成：
out/target/common/obj/JAVA_LIBRARIES/framework_intermediates/src/core/java/android/opersys/IOpersysService.java
(E) 添加OpersysService
OpersysService主要充当一个服务端（server），直接调用native如：
private static native int init_native();
private static native void finalize_native(int ptr);
private static native int read_native(int ptr, byte[] buffer);
private static native int write_native(int ptr, byte[] buffer);
private static native int test_native(int ptr, int value); 这些方法对应的是frameworks/base/services/core/jni/com_android_server_opersys_OpersysService.cpp
对应的同名函数，视觉上就像Java直接调用了C/C++一样。
frameworks/base/services/core/java/com/android/server/opersys/OpersysService.java
1 package com.android.server.opersys;
2
3 import android.content.Context;
4 import android.os.Handler;
5 import android.opersys.IOpersysService;
6 import android.os.Looper;
7 import android.os.Message;
8 import android.os.Process;
9 import android.util.Slog;
10 import android.os.RemoteException;
11
12 public class OpersysService extends IOpersysService.Stub {
13 private static final String TAG = "OpersysService";
14 private Context mContext;
15 private int mNativePointer;
16
17 public OpersysService(Context context) {
18 super();
19 mContext = context;
20 Slog.i(TAG, "Opersys Service started");
21
22 mNativePointer = init_native();
23
24 Slog.i(TAG, "test() returns " + test_native(mNativePointer, 20));
25 }
26
27 protected void finalize() throws Throwable {
28 finalize_native(mNativePointer);
29 super.finalize();
30 }
31
32 public String read(int maxLength) throws RemoteException
33 {
34 int length;
35 byte[] buffer = new byte[maxLength];
36
37 length = read_native(mNativePointer, buffer);
38
39 try {
40 return new String(buffer, 0, length, "UTF-8");
41 } catch (Exception e) {
42 Slog.e(TAG, "read buffer error!");
43 return null;
44 }
45 }
46
47 public int write(String mString) throws RemoteException
48 {
49 byte[] buffer = mString.getBytes();
50
51 return write_native(mNativePointer, buffer);
52 }
53
54 private static native int init_native();
55 private static native void finalize_native(int ptr);
56 private static native int read_native(int ptr, byte[] buffer);
57 private static native int write_native(int ptr, byte[] buffer);
58 private static native int test_native(int ptr, int value);
59 }
(F) 添加OpersysManager
OpersysManager主要用于管理OpersysService，实例化了IOpersysService，在注册服务的
时候就是实例化了一个OpersysManager，APP(客户端)获取服务getService时也是获得这个对象，通过这个对象，APP就
可以调用该服务的相关接口（API）了
frameworks/base/core/java/android/opersys/OpersysManager.java
1 package android.opersys;
2
3 import android.content.Context;
4 import android.os.RemoteException;
5 import android.opersys.IOpersysService;
6 import android.util.Slog;
7
8 public class OpersysManager
9 {
10 private static final String TAG = "OpersysManager";
11
12 public String read(int maxLength) {
13 try {
14 return mService.read(maxLength);
15 } catch (RemoteException e) {
16 Slog.e(TAG, "read error!");
17 return null;
18 }
19 }
20
21 public int write(String mString) {
22 try {
23 return mService.write(mString);
24 } catch (RemoteException e) {
25 Slog.e(TAG, "write error!");
26 return 0;
27 }
28 }
29
30 public OpersysManager(Context context, IOpersysService service) {
31 mService = service;
32 }
33
34 IOpersysService mService;
35 }
(G) 添加系统服务addService
实现了OpersysService的各种接口之后，需要向SystemServer添加服务
frameworks/base/services/java/com/android/server/SystemServer.java
1 ......
2 import com.android.server.opersys.OpersysService;
3 ......
4 private void startOtherServices() {
5 ......
6 OpersysService opersys = null;
7 ......
8 if (mFactoryTestMode != FactoryTest.FACTORY_TEST_LOW_LEVEL) {
9 ......
10 try {
11 Slog.i(TAG, "Opersys Service");
12 opersys = new OpersysService(context);
13 Slog.i(TAG, "Add Opersys Service");
14 ServiceManager.addService(Context.OPERSYS_SERVICE, opersys);
15 Slog.i(TAG, "Opersys Service Succeed!");
16 } catch (Throwable e) {
17 Slog.e(TAG, "Failure starting OpersysService Service", e);
18 }
19 ......
20 }
21 }
frameworks/base/core/java/android/content/Context.java
1 ......
2 @StringDef({
3 ......
4 OPERSYS_SERVICE,
5 ......
6 })
7 ......
8 /**
9 * Use with {@link #getSystemService} to retrieve a
10 * {@link android.opersys.OpersysManager} for using Opersys Service.
11 *
12 * @see #getSystemService
13 */
14 public static final String OPERSYS_SERVICE = "opersys";
15 ......
(H) 注册服务
frameworks/base/core/java/android/app/SystemServiceRegistry.java
1 ......
2 import android.opersys.OpersysManager;
3 import android.opersys.IOpersysService;
4 ......
5 final class SystemServiceRegistry {
6 ......
7 static {
8 ......
9 registerService(Context.OPERSYS_SERVICE, OpersysManager.class,
10 new CachedServiceFetcher<OpersysManager>() {
11 @Override
12 public OpersysManager createService(ContextImpl ctx) {
13 IBinder b = ServiceManager.getService(Context.OPERSYS_SERVICE);
14 IOpersysService service = IOpersysService.Stub.asInterface(b);
15 if (service == null) {
16 return null;
17 }
18 return new OpersysManager(ctx, service);
19 }});
20 ......
21 }
22 ......
23 }
24 ......
到这里，主要工作都要完成了，貌似可以直接可以编译进行测试了。但是实际上还有些东西需要
设置，如编译设置，SeLinux安全设置等。
(I) 更新API
在前面添加和注册了服务之后，需要更新一下API才能正常编译。
frameworks/data-binding/compiler/src/main/resources/api-versions.xml
1 ......
2 <field name="OPERSYS_SERVICE" />
3 ......
在源码目录下：
# make update-api -j16
编译通过后，会自动更新以下两个文件
frameworks/base/api/current.txt
......
field public static final java.lang.String OPERSYS_SERVICE = "opersys";
......
package android.opersys {
public abstract interface IOpersysService implements android.os.IInterface {
method public abstract int write(java.lang.String) throws android.os.RemoteException;
}
public static abstract class IOpersysService.Stub extends android.os.Binder implements android.opersys.IOpersysService {
ctor public IOpersysService.Stub();
method public android.os.IBinder asBinder();
method public static android.opersys.IOpersysService asInterface(android.os.IBinder);
method public boolean onTransact(int, android.os.Parcel, android.os.Parcel, int) throws android.os.RemoteException;
}
public class OpersysManager {
ctor public OpersysManager(android.content.Context, android.opersys.IOpersysService);
method public java.lang.String read(int);
method public int write(java.lang.String);
}
}
......
frameworks/base/api/system-current.txt更新同上
(J) 设置权限
external/sepolicy/service.te
1 ......
2 type opersys_service, app_api_service, system_server_service, service_manager_type;
3 ......
external/sepolicy/service_contexts
1 ......
2 opersys u:object_r:opersys_service:s0
3 ......
device/<manufacturer>/<chip>/common/sepolicy/device.te
1 ......
2 type circchar_device, dev_type;
3 ......
device/<manufacturer>/<chip>/common/sepolicy/file_contexts
1 ......
2 /dev/circchar u:object_r:circchar_device:s0
3 ......
device/<manufacturer>/<chip>/common/sepolicy/system_server.te
1 ......
2 allow system_server circchar_device:chr_file { open read write ioctl };
3 ......
system/core/rootdir/ueventd.rc
1 ......
2 /dev/circchar 0660 system system
3 ......
(K) 测试服务
完成以上步骤后，全编译一次，烧录后，可先通过命令测试一下服务是否正常启动：
# service check opersys
service check opersys
Service opersys：found
# service list
service list
......
24 opersys: [android.opersys.IOpersysService]
......
# service call opersys 2 s16 "Hello, World!"
service call opersys 2 s16 "Hello, World!"
Result: Parcel(00000000 0000000d '........')
# service call opersys 1 i32 20
service call opersys 1 i32 20
Result: Parcel(
0x00000000: 00000000 0000000d 00650048 006c006c '........H.e.l.l.'
0x00000010: 002c006f 00570020 0072006f 0064006c 'o.,. .W.o.r.l.d.'
0x00000020: 00000021 '!... ') 执行以上命令得到对应的结果后，说明服务启动正常。接下来就可以在APP上使用了。
(L) 添加测试APP
这个APP的功能是，当用户打开APP时，APP会获得OpersysService服务，然后向这个服务发送
“Hello Opersys”，然后从这个服务读回。
packages/apps/HelloOpersysInternal/src/com/opersys/hellointernal/HelloOpersysInternalActivity.java
1 package com.opersys.hellointernal;
2
3 import android.app.Activity;
4 import android.os.Bundle;
5 import android.util.Log;
6 import android.os.ServiceManager; // Will only work in AOSP
7 //import android.opersys.IOpersysService; // Interface "hidden" in SDK
8 import android.opersys.OpersysManager;
9 import android.content.Context;
10
11 public class HelloOpersysInternalActivity extends Activity {
12 private static final String DTAG = "HelloOpersysInternal";
13
14 /** Called when the activity is first created. */
15 @Override
16 public void onCreate(Bundle savedInstanceState) {
17 super.onCreate(savedInstanceState);
18 setContentView(R.layout.main);
19
20 //IOpersysService om = IOpersysService.Stub.asInterface(ServiceManager.getService("opersys"));
21
22 OpersysManager om = (OpersysManager)getSystemService(Context.OPERSYS_SERVICE);
23 try {
24 Log.d(DTAG, "Going to write to the \"opersys\" service");
25 om.write("Hello Opersys");
26 Log.d(DTAG, "Service returned: " + om.read(20));
27 }
28 catch (Exception e) {
29 Log.d(DTAG, "FAILED to call service");
30 e.printStackTrace();
31 }
32 }
33 }
packages/apps/HelloOpersysInternal/res/layout/main.xml
1 <?xml version="1.0" encoding="utf-8"?>
2 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
3 android:layout_width="fill_parent"
4 android:layout_height="fill_parent"
5 android:orientation="vertical" >
6
7 <TextView
8 android:layout_width="fill_parent"
9 android:layout_height="wrap_content"
10 android:text="@string/hello" />
11
12 </LinearLayout>
packages/apps/HelloOpersysInternal/res/values/strings.xml
1 <?xml version="1.0" encoding="utf-8"?>
2 <resources>
3
4 <string name="hello">Hello World, HelloOpersysInternalActivity!</string>
5 <string name="app_name">HelloOpersysInternal</string>
6
7 </resources>
packages/apps/HelloOpersysInternal/AndroidManifest.xml
1 <?xml version="1.0" encoding="utf-8"?>
2 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
3 package="com.opersys.hellointernal"
4 android:versionCode="1"
5 android:versionName="1.0" >
6
7 <uses-sdk android:minSdkVersion="10" />
8
9 <application
10 android:icon="@drawable/ic_launcher"
11 android:label="@string/app_name" >
12 <activity
13 android:label="@string/app_name"
14 android:name=".HelloOpersysInternalActivity" >
15 <intent-filter >
16 <action android:name="android.intent.action.MAIN" />
17
18 <category android:name="android.intent.category.LAUNCHER" />
19 </intent-filter>
20 </activity>
21 </application>
22
23 </manifest>
packages/apps/HelloOpersysInternal/Android.mk
1 LOCAL_PATH:= $(call my-dir)
2 include $(CLEAR_VARS)
3
4 LOCAL_MODULE_TAGS := optional
5
6 LOCAL_SRC_FILES := $(call all-java-files-under, src)
7
8 LOCAL_PACKAGE_NAME := HelloOpersysInternal
9
10 include $(BUILD_PACKAGE)
vendor/sprd/open-source/common_packages.mk
1 PRODUCT_PACKAGES += \
2 ......
3 HelloOpersysInternal
4 ......
到这里，已经完成了所有步骤，全编译烧录之后，打开HelloOpersysInternalAPP，再打开
logcat，可以看到以下信息：
01-01 08:07:56.137 3729 3729 D HelloOpersysInternal: Going to write to the "opersys" service
01-01 08:07:56.140 1272 3082 D opersyshw_qemu: OPERSYS HW - write()for 13 bytes called
01-01 08:07:56.140 1272 3082 D opersyshw_qemu: write data to driver: Hello Opersys
01-01 08:07:56.140 1272 3082 I OpersysServiceJNI: write data to hal: Hello Opersys
01-01 08:07:56.142 1272 3032 D opersyshw_qemu: OPERSYS HW - read()for 20 bytes called
01-01 08:07:56.142 1272 3032 D opersyshw_qemu: read data from driver: Hello Opersys
01-01 08:07:56.142 1272 3032 I OpersysServiceJNI: read data from hal: Hello Opersys
01-01 08:07:56.143 3729 3729 D HelloOpersysInternal: Service returned: Hello Opersys
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
