Android个层次调用流程概述

一时失言乱红尘 2022-09-20 15:09 101阅读 0赞

Android的硬件抽象层:

简单来说，就是对Linux内核驱动程序的封装，向上提供接口，屏蔽低层的实现细节。

也就是说，把对硬件的支持分成了两层，

一层放在用户空间（User Space），(硬件抽象层)

一层放在内核空间（Kernel Space），(Linux内核驱动程序)

下面这个图阐述了硬件抽象层在Android系统中的位置，以及它和其它层的关系：

![cd38a20a19d8bc3efba3927f828ba61ea9d34511.jpg][]

二，简单的总结

进入到Android源代码工程的external目录，创建hello目录:

cd external

mkdir hello

在hello目录中新建Android.mk文件：

LOCAL\_PATH := $(call my-dir)

include $(CLEAR\_VARS)

LOCAL\_MODULE\_TAGS := optional

LOCAL\_MODULE := hello

LOCAL\_SRC\_FILES := $(call all-subdir-c-files)

include $(BUILD\_EXECUTABLE)

注意，BUILD\_EXECUTABLE表示我们要编译的是可执行程序。

使用mmm命令进行编译：

mmm ./external/hello

编译成功后，就可以在out/target/product/gerneric/system/bin目录下，看到可执行文件hello了。

重新打包Android系统文件system.img：

make snod

这样，重新打包后的system.img文件就包含刚才编译好的hello可执行文件了。

七. 运行模拟器，使用/system/bin/hello可执行程序来访问Linux内核驱动程序。

emulator -kernel ./kernel/common/arch/arm/boot/zImage &

adb shell

cd system/bin

./hello

------------ ------------ ------------ ------------ ------------ ------------ ------------ ------------ ------------ ------------ ------------ ------------

三，编写硬件抽象层

进入到在hardware/libhardware/include/hardware目录，新建hello.h文件：

cd hardware/libhardware/include/hardware

vi hello.h

hello.h文件的内容如下：

\#ifndef ANDROID\_HELLO\_INTERFACE\_H

\#define ANDROID\_HELLO\_INTERFACE\_H

\#include <hardware/hardware.h>

\_\_BEGIN\_DECLS

/\*定义模块ID\*/

\#define HELLO\_HARDWARE\_MODULE\_ID  "hello"

/\*硬件模块结构体\*/

struct hello\_module\_t \{

struct   hw\_module\_t   common;

\};

/\*硬件接口结构体\*/

struct hello\_device\_t \{

struct hw\_device\_t   common;

int fd;         // 设备文件描述符

int (\*set\_val)(struct hello\_device\_t\* dev, int val);        // 为该HAL对上提供的函数接口

int (\*get\_val)(struct hello\_device\_t\* dev, int\* val);

\};

\_\_END\_DECLS

\#endif

进入到hardware/libhardware/modules目录，新建hello目录，并添加hello.c文件。 hello.c的内容较多，我们分段来看。

首先是包含相关头文件和定义相关结构：

\#define LOG\_TAG "HelloStub"

\#include <hardware/hardware.h>

\#include <hardware/hello.h>

\#include <fcntl.h>

\#include <errno.h>

\#include <cutils/log.h>

\#include <cutils/atomic.h>

\#define DEVICE\_NAME            "/dev/hello"

\#define MODULE\_NAME          "Hello"

\#define MODULE\_AUTHOR     "shyluo@gmail.com"

/\*设备打开和关闭接口\*/

static int hello\_device\_open(const struct hw\_module\_t\* module, const char\* name, struct hw\_device\_t\*\* device);

static int hello\_device\_close(struct hw\_device\_t\* device);

/\*设备访问接口\*/

static int hello\_set\_val(struct hello\_device\_t\* dev, int val);

static int hello\_get\_val(struct hello\_device\_t\* dev, int\* val);

/\*模块方法表\*/

static struct    hw\_module\_methods\_t    hello\_module\_methods = \{

open: hello\_device\_open

\};

/\*模块实例变量\*/

struct   hello\_module\_t    HAL\_MODULE\_INFO\_SYM = \{

common: \{

tag: HARDWARE\_MODULE\_TAG,

version\_major: 1,

version\_minor: 0,

id: HELLO\_HARDWARE\_MODULE\_ID,

name: MODULE\_NAME,

author: MODULE\_AUTHOR,

methods: &hello\_module\_methods,

\};

<Android硬件抽象层规范规定>

实例变量名必须为HAL\_MODULE\_INFO\_SYM，

tag也必须为HARDWARE\_MODULE\_TAG。

定义hello\_device\_open函数：

static int  hello\_device\_open ( const struct hw\_module\_t\* module,   const char\* name,   struct hw\_device\_t\*\* device ) \{

struct hello\_device\_t \* dev;

dev  =  (struct hello\_device\_t\*)malloc(sizeof(struct hello\_device\_t));

if(!dev) \{

LOGE("Hello Stub: failed to alloc space");

return -EFAULT;

memset(dev, 0, sizeof(struct hello\_device\_t));

dev->common.tag             = HARDWARE\_DEVICE\_TAG;

dev->common.version      = 0;

dev->common.module      = (hw\_module\_t\*)module;

dev->common.close         = hello\_device\_close;

dev->set\_val                    = hello\_set\_val;

dev->get\_val                    = hello\_get\_val;

if((dev->fd = open(DEVICE\_NAME, O\_RDWR)) == -1) \{

LOGE("Hello Stub: failed to open /dev/hello -- %s.", strerror(errno));free(dev);

return -EFAULT;

\*device = &(dev->common);

LOGI("Hello Stub: open /dev/hello successfully.");

return 0;

定义hello\_device\_close、hello\_set\_val和hello\_get\_val这三个函数：

static int   hello\_device\_close (struct hw\_device\_t\* device) \{

struct hello\_device\_t \*  hello\_device = (struct hello\_device\_t\*)device;

if(hello\_device) \{

close(hello\_device->fd);

free(hello\_device);

return 0;

static int  hello\_set\_val(struct hello\_device\_t\* dev, int val) \{

LOGI("Hello Stub: set value %d to device.", val);

write(dev->fd, &val, sizeof(val));

return 0;

static int hello\_get\_val(struct hello\_device\_t\* dev, int\* val) \{

if(!val) \{

LOGE("Hello Stub: error val pointer");

return -EFAULT;

read(dev->fd, val, sizeof(\*val));

LOGI("Hello Stub: get value %d from device", \*val);

return 0;

继续在hello目录下新建Android.mk文件：

LOCAL\_PATH := $(call my-dir)

include $(CLEAR\_VARS)

LOCAL\_MODULE\_TAGS := optional

LOCAL\_PRELINK\_MODULE := false

LOCAL\_MODULE\_PATH := $(TARGET\_OUT\_SHARED\_LIBRARIES)/hw

LOCAL\_SHARED\_LIBRARIES := liblog

LOCAL\_SRC\_FILES := hello.c

LOCAL\_MODULE := hello.default

include $(BUILD\_SHARED\_LIBRARY)

注意，LOCAL\_MODULE的定义规则，hello后面跟有default，hello.default能够保证我们的模块总能被硬象抽象层加载到。

编译：

mmm hardware/libhardware/modules/hello

编译成功后，就可以在out/target/product/generic/system/lib/hw目录下看到hello.default.so文件了。

重新打包Android系统镜像system.img：

make snod

重新打包后，system.img就包含我们定义的硬件抽象层模块hello.default了。

虽然我们在Android系统为我们自己的硬件增加了一个硬件抽象层模块，但是现在Java应用程序还不能访问到我们的硬件。

我们还必须编写JNI方法和在Android的Application Frameworks层增加API接口，才能让上层Application访问我们的硬件。

------------ ------------ ------------ ------------ ------------ ------------ ------------ ------------ ------------ ------------ ------------ ------------

四：JNI方法

如何为Android硬件抽象层接口编写JNI方法，以便使得上层的Java应用程序能够使用下层提供的硬件服务。

一. 确保Android系统镜像文件system.img已经包含hello.default模块。

二. 进入到frameworks/base/services/jni目录，新建com\_android\_server\_HelloService.cpp文件：

cd frameworks/base/services/jni

vi com\_android\_server\_HelloService.cpp

com\_android\_server前缀表示的是包名，表示硬件服务HelloService是放在frameworks/base/services/java目录下的com/android/server目录的，即存在一个命令为com.android.server.HelloService的类。

首先是包含相应的头文件：

\#define LOG\_TAG "HelloService"

\#include "jni.h"

\#include "JNIHelp.h"

\#include "android\_runtime/AndroidRuntime.h"

\#include <utils/misc.h>

\#include <utils/Log.h>

\#include <hardware/hardware.h>

\#include <hardware/hello.h>

\#include <stdio.h>

/\* 接着定义hello\_init、hello\_getVal和hello\_setVal三个JNI方法：\*/

namespace android

/\*在硬件抽象层中定义的硬件访问结构体，参考<hardware/hello.h>\*/

struct hello\_device\_t\*  hello\_device = NULL;

/\*通过硬件抽象层定义的硬件访问接口设置硬件寄存器val的值\*/

static void hello\_setVal (JNIEnv\* env,   jobject clazz,   jint value) \{

int val = value;

LOGI("Hello JNI: set value %d to device.", val);

if(!hello\_device) \{

LOGI("Hello JNI: device is not open.");

return;

hello\_device->set\_val(hello\_device, val);          // 在抽象层的open中定义

/\*通过硬件抽象层定义的硬件访问接口读取硬件寄存器val的值\*/

static jint hello\_getVal(JNIEnv\* env,   jobject clazz) \{

int val = 0;

if(!hello\_device) \{

LOGI("Hello JNI: device is not open.");

return val;

hello\_device->get\_val(hello\_device, &val);

LOGI("Hello JNI: get value %d from device.", val);

return val;

/\*通过硬件抽象层定义的硬件模块打开接口  打开硬件设备\*/

static inline int  hello\_device\_open (const hw\_module\_t\* module, struct hello\_device\_t\*\* device) \{

return  module->methods->open(module, HELLO\_HARDWARE\_MODULE\_ID, (struct hw\_device\_t\*\*)device);

/\*通过硬件模块ID来加载指定的硬件抽象层模块并打开硬件\*/

static jboolean  hello\_init (JNIEnv\* env, jclass clazz) \{

hello\_module\_t\* module;

LOGI("Hello JNI: initializing......");

/\* 加载模块ID为HELLO\_HARDWARE\_MODULE\_ID的硬件抽象层模块,  Android硬件抽象层会根据HELLO\_HARDWARE\_MODULE\_ID的值

\* 在Android系统的/system/lib/hw目录中找到相应的模块，然后加载起来，并且返回hw\_module\_t接口给调用者使用。

\*/

if ( hw\_get\_module ( HELLO\_HARDWARE\_MODULE\_ID,   (const struct hw\_module\_t\*\*)&module ) == 0 )  \{

LOGI("Hello JNI: hello Stub found.");

if(hello\_device\_open(&(module->common), &hello\_device) == 0) \{

LOGI("Hello JNI: hello device is open.");

return 0;

LOGE("Hello JNI: failed to open hello device.");

return -1;

LOGE("Hello JNI: failed to get hello stub module.");

return -1;

/\*JNI方法表\*/

static const   JNINativeMethod   method\_table\[ \] = \{

\{"init\_native",           "()Z",          (void\*)hello\_init\},

\{"setVal\_native",     "(I)V",         (void\*)hello\_setVal\},

\{"getVal\_native",      "()I",          (void\*)hello\_getVal\},

\};

/\*注册JNI方法\*/

int  register\_android\_server\_HelloService(JNIEnv \*env) \{

return  jniRegisterNativeMethods(env,   "com/android/server/HelloService",   method\_table,   NELEM(method\_table) );

// 必须对应HelloService所在的包的路径

\};

在Android系统初始化时，使其自动加载该JNI方法调用表

\----------------------------------------------------------------------------

修改同目录下的onload.cpp文件，

（1）在namespace android增加 register\_android\_server\_HelloService函数声明：

namespace android \{

..............................................................................................

int  register\_android\_server\_HelloService(JNIEnv \*env);

\};

（2）在JNI\_onLoad 增加 register\_android\_server\_HelloService函数调用：

extern "C" jint JNI\_onLoad(JavaVM\* vm, void\* reserved)

.................................................................................................

（3）修改同目录下的Android.mk文件，在 LOCAL\_SRC\_FILES变量 中增加一行：

LOCAL\_SRC\_FILES:= \\

com\_android\_server\_AlarmManagerService.cpp \\

com\_android\_server\_BatteryService.cpp \\

com\_android\_server\_InputManager.cpp \\

com\_android\_server\_LightsService.cpp \\

com\_android\_server\_PowerManagerService.cpp \\

com\_android\_server\_SystemServer.cpp \\

com\_android\_server\_UsbService.cpp \\

com\_android\_server\_VibratorService.cpp \\

com\_android\_server\_location\_GpsLocationProvider.cpp \\

com\_android\_server\_HelloService.cpp /

onload.cpp

最后编译

mmm frameworks/base/services/jni

make snod

这样，重新打包的system.img镜像文件就包含我们刚才编写的JNI方法了，

我们可以通过Android系统的Application Frameworks层提供的硬件服务HelloService来调用这些JNI方法，进而调用低层的硬件抽象层接口去访问硬件了。

五：提供Java访问硬件服务接口

Linux内核层、硬件抽象层和运行时库层提供的自定义硬件服务接口，这些接口都是通过C或者C++语言来实现的。

以下，我们将介绍如何在Android系统的Application Frameworks层提供Java接口的硬件服务。

（为什么用代理？）

在Android系统中，硬件服务一般是运行在一个独立的进程中为各种应用程序提供服务。因此，调用这些硬件服务的应用程序与这些硬件服务之间的通信需要通过代理来进行。为此，我们要先定义好通信接口。

（1）进入到frameworks/base/core/java/android/os目录，新增IHelloService.aidl接口定义文件：

cd   frameworks/base/core/java/android/os

vi    IHelloService.aidl

IHelloService.aidl定义了IHelloService接口：

package android.os;

interface  IHelloService\{

void setVal (int val);

int    getVal ( );

该接口主要提供了设备获取硬件寄存器val的值的功能，分别通过setVal和getVal两个函数来实现。

（2）返回到frameworks/base目录，打开Android.mk文件，修改LOCAL\_SRC\_FILES变量的值，增加IHelloService.aidl源文件：

core/java/android/os/IHelloService.aidl /

（3）编译IHelloService.aidl接口：

mmm frameworks/base

这样，就会根据IHelloService.aidl生成相应的IHelloService.Stub接口。

（4）进入到frameworks/base/services/java/com/android/server目录，新增HelloService.java文件：

package com.android.server;

import android.content.Context;

import android.os.IHelloService;

import android.util.Slog;

public class HelloService extends  IHelloService . Stub \{

private static final String TAG = "HelloService";

HelloService() \{

init\_native();

public void  setVal(int val) \{

setVal\_native(val);

public int  getVal() \{

return getVal\_native();

/\* HelloService主要是通过调用JNI方法init\_native、setVal\_native和getVal\_native来提供硬件服务 \*/

private static native boolean   init\_native();

private static native void         setVal\_native(int val);

private static native int            getVal\_native();

\};

(5)  修改同目录的SystemServer.java文件，在ServerThread::run函数中增加加载HelloService的代码：

@Override

public void run() \{

....................................................................................

try \{

Slog.i(TAG, "Hello Service");

ServiceManager. addService("hello", new HelloService());

\} catch (Throwable e) \{

Slog.e(TAG, "Failure starting Hello Service", e);

......................................................................................

（6）编译HelloService和重新打包system.img：

mmm frameworks/base/services/java

make snod

这样，重新打包后的system.img系统镜像文件就在Application Frameworks层中包含了我们自定义的硬件服务HelloService了，并且会在系统启动的时候，自动加载HelloService。

这时，应用程序就可以通过Java接口来访问Hello硬件服务了。

------------ ------------ ------------ ------------ ------------ ------------ ------------ ------------ ------------ ------------ ------------ ------------

六：Java调用实例

public class Hello extends Activityimplements OnClickListener \{

private final static String LOG\_TAG ="shy.luo.renju.Hello";

private IHelloService helloService = null;

private EditText valueText = null;

private Button readButton = null;

private Button writeButton = null;

private Button clearButton = null;

/\*\* Called when the activity is first created. \*/

@Override

public void onCreate(Bundle savedInstanceState) \{

super.onCreate(savedInstanceState);