Android驱动模型(kernel-hal-framework-app)

最新推荐文章于 2024-06-04 17:47:09 发布
置顶 最新推荐文章于 2024-06-04 17:47:09 发布
阅读量2.2k 收藏 19
点赞数 6
分类专栏： android系统架构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chunerlaogong/article/details/78307228
版权

读书的时候有写博客的习惯，后面就再也没写过了，发现很多知识点整理在电脑上容易丢失，也不能共享，所以今天又拿起笔开始写博客了,这篇文章的内容是基于兆芯平台的Android架构，实现了一个APP调用hal层来控制导光板的灯光效果。
Android上层平台和底层通信有两种模型: 1.NDK模型(不常用); 2.框架模型
Android驱动开发模型
Android系统使用JNI的原因有：
1、代码保护，Java程序很容易被反编译，C/C++反汇编难度大
2、可以很方便的使用开源库，大部分开源库都是C/C++编写的
3、执行效率的问题，将高执行效率的代码段用C/C++编写
4、Java在文件操作方面,找不到相应的API

1、NDK模型

由内核级别的驱动程序和APP组成，内核级别的驱动程序对外的接口是ioctl，而APP是由JAVA语言写的，JAVA语言并没有（或者并不支持）ioctl接口，所以内核级别的驱动程序和APP是不能直接连接（数据交换），那么就在中间增加了一层C/C++，这层C/C++支持ioctl接口，可以和内核级别的驱动程序连接，而APP的JAVA程序又可以调用C/C++，这样就连接起来了，JAVA通过JNI调用C/C++（JNI：java native interface是专门给java程序调用c/c++提供一种程序调用方法）。通过NDK这个工具将APP和第三方的一些库（C/C++）打包成apk安装包。存在问题：内核级别的驱动程序需要遵循GPL协议，而GPL协议需要开源，但是有些厂家的内核由于包含商业信息，故不完全开源，即一部分开源，一部分不开源，这样就有了框架模型。
Android驱动模型1-NDK驱动模型
NDK驱动程序设计步骤

2、框架模型

开源的一部分是需要遵循GPL协议的，放在内核里面，不开源的一部分就不能放在内核里面，故放在Android系统里面，即HAL，硬件抽象层，与硬件相关的代码，是不想开源的。 在硬件抽象层上面又加了一层硬件服务层，把封装好的硬件服务注册到Android系统中，那么APP通过service manager找到硬件服务层，硬件服务层找到硬件抽象层，硬件抽象层找到驱动程序。
Android驱动模型2-框架模型
框架设计模型设计总共分为4步：

  1. 第一步：是内核级的驱动开发，就是封装Linux驱动方法供hal层调用。
  2. 第二步：设计硬件抽象层HAL程序，下图是设计步骤

框架模型设计步骤

下面是具体的实现代码：
  • sn3199_hal.c (相对android源码路径：hardware/libhardware/modules/sn3199/)
#include <cutils/log.h>
#include <stdint.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
#include <pthread.h>
#include <sys/types.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/ioctl.h>
#include <linux/i2c.h>
#include <linux/i2c-dev.h>
#include <hardware/sn3199_hal.h>
#define LOG_TAG "sn3199_hal_default"

//全局变量
uchar s,t1,t2,flag,N;
uchar mode=2;
int i2c_fd = -1;
const unsigned char PWM64[64]=
{
        0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,
        0x08,0x09,0x0b,0x0d,0x0f,0x11,0x13,0x16,
        0x1a,0x1c,0x1d,0x1f,0x22,0x25,0x28,0x2e,
        0x34,0x38,0x3c,0x40,0x44,0x48,0x4b,0x4f,  
        0x55,0x5a,0x5f,0x64,0x69,0x6d,0x72,0x77,
        0x7d,0x80,0x88,0x8d,0x94,0x9a,0xa0,0xa7,
        0xac,0xb0,0xb9,0xbf,0xc6,0xcb,0xcf,0xd6,
        0xe1,0xe9,0xed,0xf1,0xf6,0xfa,0xfe,0xff
};
//adau1761单字节写入函数
void single_world_write(unsigned char chip_addr, int i2c_fd, unsigned short reg, unsigned char val)
{
        struct i2c_rdwr_ioctl_data light_guide_plate_data;
        light_guide_plate_data.msgs = (struct i2c_msg *)calloc(1, sizeof(struct i2c_msg));
        if(!light_guide_plate_data.msgs)
        {
                perror("light_guide_plate_data.msgs calloc error:\n");
                return;
        }
        //构造写入到adau1761单个寄存器中的消息
        light_guide_plate_data.nmsgs = 1;
        (light_guide_plate_data.msgs[0]).len = 2; //写入数据的长度为3
        (light_guide_plate_data.msgs[0]).addr = chip_addr;
        (light_guide_plate_data.msgs[0]).flags = 0;
        (light_guide_plate_data.msgs[0]).buf = (unsigned char *)calloc(1,2);
        (light_guide_plate_data.msgs[0]).buf[0] = reg;
        (light_guide_plate_data.msgs[0]).buf[1] = val;
        //使用ioctl写入数据
        ioctl(i2c_fd, I2C_RDWR, (unsigned long)&light_guide_plate_data);
        return;
}
//adau1761多字节写入函数
void burst_model_write(unsigned char chip_addr, int i2c_fd, unsigned short reg, unsigned char *data, unsigned int data_len)
{
        int i;
        struct i2c_rdwr_ioctl_data light_guide_plate_data;
        light_guide_plate_data.msgs = (struct i2c_msg *)calloc(1, sizeof(struct i2c_msg));
        if(!light_guide_plate_data.msgs)
        {
                perror("light_guide_plate_data.msgs calloc error:\n");
                exit(-1);
        }
        light_guide_plate_data.nmsgs = 1;
        (light_guide_plate_data.msgs[0]).len = data_len + 2; //写入数据的长度为3
        (light_guide_plate_data.msgs[0]).addr = chip_addr;
        (light_guide_plate_data.msgs[0]).flags = 0;
        (light_guide_plate_data.msgs[0]).buf = (unsigned char *)calloc(1,data_len + 1);
        (light_guide_plate_data.msgs[0]).buf[0] = reg;
        for(i = 0; i < data_len; i++)
        {
                (light_guide_plate_data.msgs[0]).buf[i + 1] = data[i];
        }
        //使用ioctl写入数据
        ioctl(i2c_fd, I2C_RDWR, (unsigned long)&light_guide_plate_data);
        return;
}
//adau1761单字节读出函数
unsigned char single_world_read(unsigned char chip_addr, int i2c_fd, unsigned short reg)
{

        struct i2c_rdwr_ioctl_data light_guide_plate_data;
        light_guide_plate_data.msgs = (struct i2c_msg *)calloc(2, sizeof(struct i2c_msg));
        if(!light_guide_plate_data.msgs)
        {
                perror("light_guide_plate_data.msgs calloc error:\n");
                exit(-1);
        }
        //构造从adau1761单个寄存器读数据的消息
        //先写偏移地址
        light_guide_plate_data.nmsgs = 2;
        (light_guide_plate_data.msgs[0]).len = 1;
        (light_guide_plate_data.msgs[0]).addr = chip_addr;
        (light_guide_plate_data.msgs[0]).flags = 0x0;
        (light_guide_plate_data.msgs[0]).buf = (unsigned char *)calloc(1,1);
        (light_guide_plate_data.msgs[0]).buf[0] = reg;
        (light_guide_plate_data.msgs[1]).len = 1;
        (light_guide_plate_data.msgs[1]).addr = chip_addr;
        (light_guide_plate_data.msgs[1]).flags = I2C_M_RD;
        (light_guide_plate_data.msgs[1]).buf = (unsigned char *)calloc(1,2);
        //使用ioctl读取数据
        ioctl(i2c_fd, I2C_RDWR, (unsigned long)&light_guide_plate_data);
        printf("buf[0] = 0x%x\n",(light_guide_plate_data.msgs[1]).buf[0]);
        return (light_guide_plate_data.msgs[1]).buf[0];
}
//adau1761多字节读出函数
unsigned char * burst_model_read(unsigned char chip_addr, int i2c_fd, unsigned short reg, unsigned int data_len)
{
        struct i2c_rdwr_ioctl_data light_guide_plate_data;
        light_guide_plate_data.msgs = (struct i2c_msg *)calloc(2, sizeof(struct i2c_msg));
        if(!light_guide_plate_data.msgs)
        {
                perror("light_guide_plate_data.msgs calloc error:\n");
                exit(-1);
        }
        //构造从adau1761单个寄存器读数据的消息
        //先写偏移地址
        light_guide_plate_data.nmsgs = 2;
        (light_guide_plate_data.msgs[0]).len = 2;
        (light_guide_plate_data.msgs[0]).addr = chip_addr;
        (light_guide_plate_data.msgs[0]).flags = 0x0;
        (light_guide_plate_data.msgs[0]).buf = (unsigned char *)calloc(1,1);
        (light_guide_plate_data.msgs[0]).buf[0] = reg;
        (light_guide_plate_data.msgs[1]).len = data_len;
        (light_guide_plate_data.msgs[1]).addr = chip_addr;
        (light_guide_plate_data.msgs[1]).flags = I2C_M_RD;
        (light_guide_plate_data.msgs[1]).buf = (unsigned char *)calloc(1,data_len);
        //使用ioctl读取数据
        ioctl(i2c_fd, I2C_RDWR, (unsigned long)&light_guide_plate_data);
        return (light_guide_plate_data.msgs[1]).buf;
}

int reset()
{

        single_world_write(CHIP_ADDR1, i2c_fd, 0xff,0xff);
        single_world_write(CHIP_ADDR1, i2c_fd, 0x00,0x01);         //enable sd chip1
        single_world_write(CHIP_ADDR1, i2c_fd, 0x01,0x77);
        single_world_write(CHIP_ADDR1, i2c_fd, 0x02,0x07);
        single_world_write(CHIP_ADDR1, i2c_fd, 0x04,0x00);



        single_world_write(CHIP_ADDR2, i2c_fd, 0xff,0xff);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x00,0x01);         //enable sd chip1
        single_world_write(CHIP_ADDR2, i2c_fd, 0x01,0x77);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x02,0x07);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x04,0x00);

        return 0;
}

/************************************************/
//设置LED 电流大小
//0= 20mA , 1 = 15mA, 2= 10mA, 3=5mA, 4= 40mA, 5= 35mA, 6=30mA,7=25mA
/*************************************************/
void Led_SetCurrent(unsigned char level)
{

        if ( level > 7 ) return;

        g_LedEffect |= level<<4;

        single_world_write(CHIP_ADDR1, i2c_fd, SN3216_REG_LED_EFFECT, g_LedEffect);
        single_world_write(CHIP_ADDR2, i2c_fd, SN3216_REG_LED_EFFECT, g_LedEffect);

}
/*****************正常工作（音箱本身喇叭不工作）-常亮白色********************
   *i2c_fd:i2c文件操作描述符
 *
 ***********************************************************************/
int normally_bright_white()
{
        single_world_write(CHIP_ADDR1, i2c_fd, 0x03, 0x0); //pwm mode
        single_world_write(CHIP_ADDR2, i2c_fd, 0x03, 0x0); //pwm mode
        single_world_write(CHIP_ADDR1, i2c_fd, 0x07,0xff); //紫色
        single_world_write(CHIP_ADDR1, i2c_fd, 0x08,0xff);
        single_world_write(CHIP_ADDR1, i2c_fd, 0x09,0xff);
        single_world_write(CHIP_ADDR1, i2c_fd, 0x0a,0xff);
        single_world_write(CHIP_ADDR1, i2c_fd, 0x0b,0xff);
        single_world_write(CHIP_ADDR1, i2c_fd, 0x0c,0xff);
        single_world_write(CHIP_ADDR1, i2c_fd, 0x0d,0xff);
        single_world_write(CHIP_ADDR1, i2c_fd, 0x0e,0xff);
        single_world_write(CHIP_ADDR1, i2c_fd, 0x0f,0xff);
        single_world_write(CHIP_ADDR1, i2c_fd, 0x10,0xff);

        single_world_write(CHIP_ADDR2, i2c_fd, 0x07,0xff); //紫色
        single_world_write(CHIP_ADDR2, i2c_fd, 0x08,0xff);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x09,0xff);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x0a,0xff);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x0b,0xff);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x0c,0xff);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x0d,0xff);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x0e,0xff);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x0f,0xff);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x10,0xff);
        ALOGD("normally_bright_white:i2c_cfd = %d\n", i2c_fd);
        return 0;

}
/*****************待机-白色呼吸灯效果********************
 *
 ******************************************************/
int standby_mode() //RGB单色呼吸
{

        single_world_write(CHIP_ADDR1, i2c_fd, 0x03,0x70); //One shot mode
        single_world_write(CHIP_ADDR1, i2c_fd, 0x06,0x10); //INTB  OUT1
        single_world_write(CHIP_ADDR1, i2c_fd, 0x04,0x80);  //从模式
        single_world_write(CHIP_ADDR1, i2c_fd, 0x1a,0x81); //T1~T3;  T3=2T1=2*260*2ms,T2=260
        single_world_write(CHIP_ADDR1, i2c_fd, 0x1b,0x81);
        single_world_write(CHIP_ADDR1, i2c_fd, 0x1c,0x81);

        single_world_write(CHIP_ADDR1, i2c_fd, 0x1d,0x01); //T4=2*260ms
        single_world_write(CHIP_ADDR1, i2c_fd, 0x1e,0x01);
        single_world_write(CHIP_ADDR1, i2c_fd, 0x1f,0x01);

        single_world_write(CHIP_ADDR1, i2c_fd, 0x20,0x01);
        single_world_write(CHIP_ADDR1, i2c_fd, 0x21,0x01);
        single_world_write(CHIP_ADDR1, i2c_fd, 0x22,0x01);

        single_world_write(CHIP_ADDR1, i2c_fd, 0x23,0x01);
        single_world_write(CHIP_ADDR1, i2c_fd, 0x24,0x01);
        single_world_write(CHIP_ADDR1, i2c_fd, 0x25,0x01);
        single_world_write(CHIP_ADDR1, i2c_fd, 0x26,0xff);
        single_world_write(CHIP_ADDR1, i2c_fd, 0x10,0xff);

 
        single_world_write(CHIP_ADDR1, i2c_fd, 0x07,0xff);     //雪白
        single_world_write(CHIP_ADDR1, i2c_fd, 0x08,0xfa);
        single_world_write(CHIP_ADDR1, i2c_fd, 0x09,0xfa);

        single_world_write(CHIP_ADDR1, i2c_fd, 0x0a,0xff);
        single_world_write(CHIP_ADDR1, i2c_fd, 0x0b,0xfa);
        single_world_write(CHIP_ADDR1, i2c_fd, 0x0c,0xfa);

        single_world_write(CHIP_ADDR1, i2c_fd, 0x0d,0xff);
        single_world_write(CHIP_ADDR1, i2c_fd, 0x0e,0xfa);
        single_world_write(CHIP_ADDR1, i2c_fd, 0x0f,0xfa);
        single_world_write(CHIP_ADDR1, i2c_fd, 0x10,0xff);





        single_world_write(CHIP_ADDR2, i2c_fd, 0x03,0x70); //One shot mode
        single_world_write(CHIP_ADDR2, i2c_fd, 0x06,0x0); //INTB  OUT1
        single_world_write(CHIP_ADDR2, i2c_fd, 0x04,0x0);  //主模式
        single_world_write(CHIP_ADDR2, i2c_fd, 0x1a,0x81); //T1~T3;  T3=2T1=2*260*2ms,T2=260
        single_world_write(CHIP_ADDR2, i2c_fd, 0x1b,0x81);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x1c,0x81);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x1d,0x01); //T4=2*260ms
        single_world_write(CHIP_ADDR2, i2c_fd, 0x1e,0x01);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x1f,0x01);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x20,0x01);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x21,0x01);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x22,0x01);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x23,0x01);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x24,0x01);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x25,0x01);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x26,0xff);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x10,0xff);

        single_world_write(CHIP_ADDR2, i2c_fd, 0x07,0xff);         //雪白
        single_world_write(CHIP_ADDR2, i2c_fd, 0x08,0xfa);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x09,0xfa);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x0a,0xff);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x0b,0xfa);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x0c,0xfa);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x0d,0xff);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x0e,0xfa);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x0f,0xfa);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x10,0xff);
        ALOGD("standby_mode:i2c_cfd = %d\n", i2c_fd);
        return 0;
}
/*****************正在开机-蓝色呼吸灯********************
 * 
 *
 ****************************************************/
 int boot_system_state() //RGB单色呼吸
 {
 
         single_world_write(CHIP_ADDR1, i2c_fd, 0x03,0x70); //One shot mode
         single_world_write(CHIP_ADDR1, i2c_fd, 0x06,0x10); //INTB  OUT1
         single_world_write(CHIP_ADDR1, i2c_fd, 0x04,0x80);  //从模式
         single_world_write(CHIP_ADDR1, i2c_fd, 0x1a,0x81); //T1~T3;  T3=2T1=2*260*2ms,T2=260
         single_world_write(CHIP_ADDR1, i2c_fd, 0x1b,0x81);
         single_world_write(CHIP_ADDR1, i2c_fd, 0x1c,0x81);
 
         single_world_write(CHIP_ADDR1, i2c_fd, 0x1d,0x01); //T4=2*260ms
         single_world_write(CHIP_ADDR1, i2c_fd, 0x1e,0x01);
         single_world_write(CHIP_ADDR1, i2c_fd, 0x1f,0x01);
 
         single_world_write(CHIP_ADDR1, i2c_fd, 0x20,0x01);
         single_world_write(CHIP_ADDR1, i2c_fd, 0x21,0x01);
         single_world_write(CHIP_ADDR1, i2c_fd, 0x22,0x01);
 
         single_world_write(CHIP_ADDR1, i2c_fd, 0x23,0x01);
         single_world_write(CHIP_ADDR1, i2c_fd, 0x24,0x01);
         single_world_write(CHIP_ADDR1, i2c_fd, 0x25,0x01);
         single_world_write(CHIP_ADDR1, i2c_fd, 0x26,0xff);
         single_world_write(CHIP_ADDR1, i2c_fd, 0x10,0xff);
 
  
         single_world_write(CHIP_ADDR1, i2c_fd, 0x07,0x0);     //雪白
         single_world_write(CHIP_ADDR1, i2c_fd, 0x08,0x0);
         single_world_write(CHIP_ADDR1, i2c_fd, 0x09,0xff);
 
         single_world_write(CHIP_ADDR1, i2c_fd, 0x0a,0x0);
         single_world_write(CHIP_ADDR1, i2c_fd, 0x0b,0x0);
         single_world_write(CHIP_ADDR1, i2c_fd, 0x0c,0xff);
 
         single_world_write(CHIP_ADDR1, i2c_fd, 0x0d,0x0);
         single_world_write(CHIP_ADDR1, i2c_fd, 0x0e,0x0);
         single_world_write(CHIP_ADDR1, i2c_fd, 0x0f,0xff);
         single_world_write(CHIP_ADDR1, i2c_fd, 0x10,0xff);
 
 
 
 
 
         single_world_write(CHIP_ADDR2, i2c_fd, 0x03,0x70); //One shot mode
         single_world_write(CHIP_ADDR2, i2c_fd, 0x06,0x0); //INTB  OUT1
         single_world_write(CHIP_ADDR2, i2c_fd, 0x04,0x0);  //主模式
         single_world_write(CHIP_ADDR2, i2c_fd, 0x1a,0x81); //T1~T3;  T3=2T1=2*260*2ms,T2=260
         single_world_write(CHIP_ADDR2, i2c_fd, 0x1b,0x81);
         single_world_write(CHIP_ADDR2, i2c_fd, 0x1c,0x81);
         single_world_write(CHIP_ADDR2, i2c_fd, 0x1d,0x01); //T4=2*260ms
         single_world_write(CHIP_ADDR2, i2c_fd, 0x1e,0x01);
         single_world_write(CHIP_ADDR2, i2c_fd, 0x1f,0x01);
         single_world_write(CHIP_ADDR2, i2c_fd, 0x20,0x01);
         single_world_write(CHIP_ADDR2, i2c_fd, 0x21,0x01);
         single_world_write(CHIP_ADDR2, i2c_fd, 0x22,0x01);
         single_world_write(CHIP_ADDR2, i2c_fd, 0x23,0x01);
         single_world_write(CHIP_ADDR2, i2c_fd, 0x24,0x01);
         single_world_write(CHIP_ADDR2, i2c_fd, 0x25,0x01);
         single_world_write(CHIP_ADDR2, i2c_fd, 0x26,0xff);
         single_world_write(CHIP_ADDR2, i2c_fd, 0x10,0xff);
 
 
         single_world_write(CHIP_ADDR2, i2c_fd, 0x07,0x0);         //雪白
         single_world_write(CHIP_ADDR2, i2c_fd, 0x08,0x0);
         single_world_write(CHIP_ADDR2, i2c_fd, 0x09,0xff);
         single_world_write(CHIP_ADDR2, i2c_fd, 0x0a,0x0);
         single_world_write(CHIP_ADDR2, i2c_fd, 0x0b,0x0);
         single_world_write(CHIP_ADDR2, i2c_fd, 0x0c,0xff);
         single_world_write(CHIP_ADDR2, i2c_fd, 0x0d,0x0);
         single_world_write(CHIP_ADDR2, i2c_fd, 0x0e,0x0);
         single_world_write(CHIP_ADDR2, i2c_fd, 0x0f,0xff);
         single_world_write(CHIP_ADDR2, i2c_fd, 0x10,0xff);
         ALOGD("boot_system_state:i2c_cfd = %d\n", i2c_fd);
         return 0;
 }
/*****************网络异常状态-常亮红色********************
 * 
 *
 ****************************************************/
 int network_anomaly_state()
 {
        single_world_write(CHIP_ADDR1, i2c_fd, 0x03, 0x0); //pwm mode
        single_world_write(CHIP_ADDR2, i2c_fd, 0x03, 0x0); //pwm mode

        single_world_write(CHIP_ADDR1, i2c_fd, 0x07,0xff); //红色
        single_world_write(CHIP_ADDR1, i2c_fd, 0x08,0x0);
        single_world_write(CHIP_ADDR1, i2c_fd, 0x09,0x0);
        single_world_write(CHIP_ADDR1, i2c_fd, 0xa,0xff); //红色
        single_world_write(CHIP_ADDR1, i2c_fd, 0xb,0x0);
        single_world_write(CHIP_ADDR1, i2c_fd, 0xc,0x0);
        single_world_write(CHIP_ADDR1, i2c_fd, 0xd,0xff); //红色
        single_world_write(CHIP_ADDR1, i2c_fd, 0xe,0x0);
        single_world_write(CHIP_ADDR1, i2c_fd, 0xf,0x0);
        single_world_write(CHIP_ADDR1, i2c_fd, 0x10,0xff); //更新数据到各PWM寄存器里面

        single_world_write(CHIP_ADDR2, i2c_fd, 0x07,0xff);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x08,0x0);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x09,0x0);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x0a,0xff);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x0b,0x0);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x0c,0x0);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x0d,0xff);     //
        single_world_write(CHIP_ADDR2, i2c_fd, 0x0e,0x0);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x0f,0x0);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x10,0xff); //更新数据到各PWM寄存器里面  
        ALOGD("network_anomaly_state:i2c_cfd = %d\n", i2c_fd);
        return 0; 
 }
/*****************程序系统异常状态-红色闪烁********************
 *  seconds:红色闪烁状态间隔时间
 *
 ****************************************************/
int abnormal_state(unsigned int seconds)
{
        single_world_write(CHIP_ADDR1, i2c_fd, 0x03, 0x0); //pwm mode
        single_world_write(CHIP_ADDR2, i2c_fd, 0x03, 0x0); //pwm mode
        while(1)
        {
                single_world_write(CHIP_ADDR1, i2c_fd, 0x07,0xff); //红色
                single_world_write(CHIP_ADDR1, i2c_fd, 0x08,0x0);
                single_world_write(CHIP_ADDR1, i2c_fd, 0x09,0x0);
                single_world_write(CHIP_ADDR1, i2c_fd, 0xa,0xff); //红色
                single_world_write(CHIP_ADDR1, i2c_fd, 0xb,0x0);
                single_world_write(CHIP_ADDR1, i2c_fd, 0xc,0x0);
                single_world_write(CHIP_ADDR1, i2c_fd, 0xd,0xff); //红色
                single_world_write(CHIP_ADDR1, i2c_fd, 0xe,0x0);
                single_world_write(CHIP_ADDR1, i2c_fd, 0xf,0x0);
                single_world_write(CHIP_ADDR1, i2c_fd, 0x10,0xff); //更新数据到各PWM寄存器里面

                single_world_write(CHIP_ADDR2, i2c_fd, 0x07,0xff);     //红色
                single_world_write(CHIP_ADDR2, i2c_fd, 0x08,0x0);
                single_world_write(CHIP_ADDR2, i2c_fd, 0x09,0x0);
                single_world_write(CHIP_ADDR2, i2c_fd, 0x0a,0xff);     //红色
                single_world_write(CHIP_ADDR2, i2c_fd, 0x0b,0x0);
                single_world_write(CHIP_ADDR2, i2c_fd, 0x0c,0x0);
                single_world_write(CHIP_ADDR2, i2c_fd, 0x0d,0xff);     //红色
                single_world_write(CHIP_ADDR2, i2c_fd, 0x0e,0x0);
                single_world_write(CHIP_ADDR2, i2c_fd, 0x0f,0x0);
                single_world_write(CHIP_ADDR2, i2c_fd, 0x10,0xff); //更新数据到各PWM寄存器里面

                sleep(seconds);

                single_world_write(CHIP_ADDR1, i2c_fd, 0x07,0x0); //黑色
                single_world_write(CHIP_ADDR1, i2c_fd, 0x08,0x0);
                single_world_write(CHIP_ADDR1, i2c_fd, 0x09,0x0);
                single_world_write(CHIP_ADDR1, i2c_fd, 0xa,0x0); //黑色
                single_world_write(CHIP_ADDR1, i2c_fd, 0xb,0x0);
                single_world_write(CHIP_ADDR1, i2c_fd, 0xc,0x0);
                single_world_write(CHIP_ADDR1, i2c_fd, 0xd,0x0); //黑色
                single_world_write(CHIP_ADDR1, i2c_fd, 0xe,0x0);
                single_world_write(CHIP_ADDR1, i2c_fd, 0xf,0x0);
                single_world_write(CHIP_ADDR1, i2c_fd, 0x10,0xff); //更新数据到各PWM寄存器里面

                single_world_write(CHIP_ADDR2, i2c_fd, 0x07,0x0);
                single_world_write(CHIP_ADDR2, i2c_fd, 0x08,0x0);
                single_world_write(CHIP_ADDR2, i2c_fd, 0x09,0x0);
                single_world_write(CHIP_ADDR2, i2c_fd, 0x0a,0x0);
                single_world_write(CHIP_ADDR2, i2c_fd, 0x0b,0x0);
                single_world_write(CHIP_ADDR2, i2c_fd, 0x0c,0x0);
                single_world_write(CHIP_ADDR2, i2c_fd, 0x0d,0x0);     //
                single_world_write(CHIP_ADDR2, i2c_fd, 0x0e,0x0);
                single_world_write(CHIP_ADDR2, i2c_fd, 0x0f,0x0);
                single_world_write(CHIP_ADDR2, i2c_fd, 0x10,0xff); //更新数据到各PWM寄存器里面

                sleep(seconds);
        }
        abnormal_state_thread = -1;
        pthread_exit(0);
        ALOGD("abnormal_state:i2c_cfd = %d\n", i2c_fd);

        return 0;
}
/***************跟随音乐跳动状态**********************
 *
 *
 ****************************************************/
int audio_mode() //Audio mode
{
        single_world_write(CHIP_ADDR1, i2c_fd, 0x03, 0x04); //PWM mode; AE AGC
        single_world_write(CHIP_ADDR1, i2c_fd, 0x04, 0x6); //5mA, 18dB
        single_world_write(CHIP_ADDR2, i2c_fd, 0x03, 0x04); //PWM mode; AE AGC
        single_world_write(CHIP_ADDR2, i2c_fd, 0x04, 0x6); //5mA, 18dB

        single_world_write(CHIP_ADDR1, i2c_fd, 0x07,0xff);
        single_world_write(CHIP_ADDR1, i2c_fd, 0x08,0x0);
        single_world_write(CHIP_ADDR1, i2c_fd, 0x09,0x0);
        single_world_write(CHIP_ADDR1, i2c_fd, 0xa,0xff);
        single_world_write(CHIP_ADDR1, i2c_fd, 0xb,0xff);
        single_world_write(CHIP_ADDR1, i2c_fd, 0xc,0xff);
        single_world_write(CHIP_ADDR1, i2c_fd, 0xd,0xff);
        single_world_write(CHIP_ADDR1, i2c_fd, 0xe,0xff);
        single_world_write(CHIP_ADDR1, i2c_fd, 0xf,0x0);

        single_world_write(CHIP_ADDR1, i2c_fd, 0x10,0xff); //更新数据到各PWM寄存器里面

        single_world_write(CHIP_ADDR2, i2c_fd, 0x07,0x0);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x08,0xff);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x09,0x0);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x0a,0x0);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x0b,0x0);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x0c,0xff);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x0d,0x0);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x0e,0xff);
        single_world_write(CHIP_ADDR2, i2c_fd, 0x0f,0xff);

        single_world_write(CHIP_ADDR2, i2c_fd, 0x10,0xff); //更新数据到各PWM寄存器里面
        ALOGD("audio_mode:i2c_cfd = %d\n", i2c_fd);
        return 0;
}
int sn3199_init()
{
        //打开通用设备驱动文件
        i2c_fd = open("/dev/i2c-1", O_RDWR);
        if(i2c_fd < 0)
        {
                ALOGD("Open /dev/i2c-1 error:\n");
                return -1;
        }
        ALOGD("sn3199_init:i2c_cfd = %d\n", i2c_fd);
        return 0;
}
static struct sn3199_device_t sn3199_dev = 
{
        .sn3199_device = 
        {
                .tag = HARDWARE_DEVICE_TAG,
                .close = sn3199_close,
        },
        .set_light_state = set_light_state,
};
//logcat -s "SN3199_HAL"
//实现open函数
static int open_sn3199_hal(const struct hw_module_t* module, char const* id, struct hw_device_t** device)
{
    ALOGD("open_sn3199 exec.....");
    sn3199_init();   //获取i2c设备符
   /* struct sn3199_device_t *dev = calloc(1, sizeof(struct sn3199_device_t));
    dev->sn3199_device.tag = HARDWARE_DEVICE_TAG;
    dev->sn3199_device.close = (int (*)(struct hw_device_t *))sn3199_close;
    dev->set_light_state = set_light_state;
    *device = (struct hw_device_t*)dev;*/
    *device = &sn3199_dev;
    return 0;
}
int set_light_state(struct sn3199_device_t *dev, int state)
{

    ALOGD("set_light_state exec....");
    g_Flag = 0;
    reset();
    switch (state) {
    case 1:
            ALOGD("standby_mode....");
            standby_mode();
            break;
    case 2:
            ALOGD("normally_bright_white....");
            normally_bright_white();
            break;
    case 3:
            ALOGD("abnormal_state");
            pthread_create(&abnormal_state_thread, NULL, (void *)&abnormal_state, (void *)1);
            g_Flag = 1;
            //pthread_join(abnormal_state_thread, NULL);
            break;
    case 4:
            ALOGD("audio_mode");
            audio_mode();
            break;
    case 5:
            ALOGD("network_anomaly_state");
            network_anomaly_state();
            break;

    case 6:
            ALOGD(" boot_system_state");
            boot_system_state();
            break;
    default:
            break;
    }
    return 0;
}
static int sn3199_close(struct sn3199_device_t *dev)
{
    if(i2c_fd > 0)
    {
        close(i2c_fd);
        i2c_cfd = -1;   
    } 
    if(dev)
        free(dev);
    
    g_Flag = -1;
    return 0;
}

//定义HAL_MODULE_INFO_SYM，并对其进行初始化
static hw_module_methods_t sn3199_methods =
{
    .open = open_sn3199_hal,
};

struct hw_module_t HAL_MODULE_INFO_SYM =
{
    .tag = HARDWARE_MODULE_TAG,
    .id = **SN3199_HARDWARE_MODULE_ID**,     //该id起到了承上启下的作用，硬件服务层会匹配该id,一般这里使用宏定义(VIBRATOR_HARDWARE_MODULE_ID)，不然可能会出错
    .author = "yjd",     
    .methods = &sn3199_methods,
};
  • sn3199_hal.h(相对android源码路径：hardware/libhardware/include/hardware/)
#ifndef _SN3199_HAL_H_
#define _SN3199_HAL_H_

#include <hardware/hardware.h>
#include <pthread.h>
#define	SN3216_REG_LED_EFFECT 		0x04

void single_world_write(unsigned char chip_addr, int i2c_fd, unsigned short reg, unsigned char val);
void burst_model_write(unsigned char chip_addr, int i2c_fd, unsigned short reg, unsigned char *data, unsigned int data_len);
unsigned char single_world_read(unsigned char chip_addr, int i2c_fd, unsigned short reg);
unsigned char * burst_model_read(unsigned char chip_addr, int i2c_fd, unsigned short reg, unsigned int data_len);
int reset();
int normally_bright_white();
int standby_mode();
int boot_system_state(); //RGB单色呼吸
int network_anomaly_state();
int abnormal_state(unsigned int seconds);
int audio_mode(); //Audio mode
static unsigned char g_Ledctrl1=0,g_Ledctrl2=0,g_LedEffect = 0;
static unsigned char g_Flag = 0;
pthread_t abnormal_state_thread = -1;
#define CHIP_ADDR1 0x64
#define CHIP_ADDR2 0x67
#define uchar unsigned char
#define uint unsigned int
#define SN3199_HARDWARE_MODULE_ID "sn3199"
//自定义一个对外的结构体
struct sn3199_device_t
{
    struct hw_device_t sn3199_device;
    int (*set_light_state)(struct sn3199_device_t *dev, int state);
};
static int sn3199_close(struct sn3199_device_t *dev);
int set_light_state(struct sn3199_device_t *dev, int state);

#endif


LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)

LOCAL_MODULE := sn3199.default    #sn3199_hal_default.so

# HAL module implementation stored in
# hw/<VIBRATOR_HARDWARE_MODULE_ID>.default.so
LOCAL_MODULE_RELATIVE_PATH := hw    #/system/lib/hw/
LOCAL_C_INCLUDES := hardware/libhardware
LOCAL_SRC_FILES := sn3199_hal.c
LOCAL_SHARED_LIBRARIES := liblog
LOCAL_MODULE_TAGS := optional

include $(BUILD_SHARED_LIBRARY)

以上就是hal的代码，通过mm命令最后生成sn3199.default.so

第三步：硬件访问服务程序设计（解决上层访问硬件冲突）
硬件服务流程
下面是具体的代码实现

  • ISn3199Service.aidl(Android源码目录的相对路径：frameworks/base/core/java/android/os/)
package android.os;

/** {@hide} */
interface ISn3199Service
{
    int sn3199Open();    //打开sn3199
    int setLightState(int state);  //设置sn3199灯光状态
}

该文件最后会生成实现Stub类方法的文件ISn3199Service.java(生成文件相对Android源码路径：out/target/common/obj/JAVA_LIBRARIES/framework_intermediates/src/core/java/android/os)

  • Android.mk(相对Android源码相对路径：frameworks/base)
		.
		.
		.
		core/java/android/os/IVibratorService.aidl \
       + core/java/android/os/ISn3199Service.aidl
       .
       .
       .

Sn3199Service.java（相对Android路径：frameworks/base/services/core/java/com/android/server/）

package com.android.server;
import android.util.Slog;
import android.os.ISn3199Service;
public class Sn3199Service extends ISn3199Service.Stub {
    private static final String TAG = "Sn3199Service";
    public Sn3199Service()
    {
        Slog.d(TAG, "Sn3199Service");
    }
    //打开sn3199
    public int sn3199Open() throws android.os.RemoteException    
    {
        return nativeSn3199Open();
    }
    //设置sn3199灯光状态
    public int setLightState(int state) throws android.os.RemoteException 
    {
        return nativeSetLightState(state);
    }

    //声明本地函数
    public static native int nativeSn3199Open();
    public static native int nativeSetLightState(int state);
}

服务层调用hal层通过JNI
这里写图片描述

  • 将硬件服务注册到ServiceManager中去
    SystemServer.java(相对Android源码路径：frameworks/base/services/java/com/android/server/)
 ......
 VibratorService vibrator = null;
 +Sn3199Service sn3199 = null;
 IAlarmManager alarm = null;
 .......


  Slog.i(TAG, "Vibrator Service");
  vibrator = new VibratorService(context);
  ServiceManager.addService("vibrator", vibrator);

  +Slog.i(TAG, "Sn3199 Service");
  +sn3199 = new Sn3199Service();   //我们的构造函数是无参数构造函数，所以这里为空
  +ServiceManager.addService("sn3199", sn3199);

实现jni调用

  • com_android_server_Sn3199Service.cpp(相对Android源码目录：frameworks/base/services/core/jni/)
#define LOG_TAG "Sn3199Service"

#include "jni.h"
#include "JNIHelp.h"
#include "android_runtime/AndroidRuntime.h"

#include <utils/misc.h>
#include <utils/Log.h>
#include <hardware/sn3199_hal.h>

#include <stdio.h>
struct sn3199_device_t *sn3199_dev;
namespace android
{
//JNI调用
static jint sn3199Open(JNIEnv *env, jobject clazz)
{
    hw_module_t* module;
    hw_device_t* device;
    jint err;
    err = hw_get_module(SN3199_HARDWARE_MODULE_ID , (hw_module_t const**)&module);     //获取到对应的hal中的modules对象，第一个参数为hal层中的id
    if(err == 0)
    {
        ALOGD("module->methods->open");
        module->methods->open(module, NULL, &device); //获取到hal中的device信息
        sn3199_dev = (struct sn3199_device_t* )device;
        return 0;
    }
    else
    {
        ALOGD("hw_get_module exec error");
    }
    return -1;
}
static jint setLightState(JNIEnv *env, jobject clazz, int state)   //前面了两个参数是系统带的一定要有的，后面的是用户自定参数
{
    sn3199_dev->set_light_state(sn3199_dev, state);
    return 0;
}
static JNINativeMethod method_table[] = {
    { "nativeSn3199Open", "()I", (void*)sn3199Open },    //第二个参数()参数个数，I-返回值类型
    { "nativeSetLightState", "(I)I", (void*)setLightState }
};

int register_android_server_Sn3199Service(JNIEnv *env)
{
    return jniRegisterNativeMethods(env, "com/android/server/Sn3199Service",
            method_table, NELEM(method_table));
}

};

加载cpp文件到Android.mk中(相对Android源码目录：frameworks/base/services/core/jni)

 $(LOCAL_REL_DIR)/com_android_server_VibratorService.cpp \
 +$(LOCAL_REL_DIR)/com_android_server_Sn3199Service.cpp \

调用register_android_server_Sn3199Service函数

  • onload.cpp(相对Android源码目录：frameworks/base/services/core/jni/)
.......
int register_android_server_VibratorService(JNIEnv* env);
//and by yjd
 1. int register_android_server_Sn3199Service(JNIEnv *env);   //定义
//end
.....
register_android_server_VibratorService(env);
 //and by yjd
 2. register_android_server_Sn3199Service(env);   //调用
 //end
register_android_server_SystemServer(env);
...

hal层问题编译总结：第一个是，自己编写的hal层源码怎么添加进Android的默认编译中去，也就是说在根目录执行make时，自己编写hal源码也会被编译。第二个问题是，编译完成后还要自动安装在指定的系统目录lib/hw下。刚开始时不太了解，总是需要使用mmm来进行编译安装，但是打包之后再编译这是不现实的。为此需要添加到默认中
解决方法：
在写好hardware/libhardware/modules/sn3199工程文件时，要将sn3199目录加到modules的Android.mk中，hardware_modules变量中添加sn3199文件夹的名字即可，这样在默认中就会自动编译这个sn3199的文件，这样虽然可以编译了，但是不会自动安装，如果在源码根目录下编译安装sn3199，还需修改device/s3graphics/zx2000/zx2000.mk这个文件中的PRODUCT_PACKAGES变量，在文件中添加PRODUCT_PACKAGES += sn3199.default代码即可

这样上图中的stub、Java、JNI都完成了(已经凌晨1点了，挺住写完再睡)
在framework/base/目录下执行mm命令进行编译

接下来就是编写APP进行测试了，测试之前要将刚编译框架层中的classes.jar（相对Android源码路径：out/target/common/obj/JAVA_LIBRARIES/framework_intermediates）拷贝出来供APP使用，直接上代码，APP只是测试用，所以就随便写了

  • MainActivity.java
package com.example.yjd.sn3199interfacetest;

import android.os.Bundle;
import android.os.ISn3199Service;
import android.os.RemoteException;
import android.os.ServiceManager;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;

public class MainActivity extends AppCompatActivity implements View.OnClickListener {
    private ISn3199Service iSn3199Service = null;
    private Button[] btnState = new Button[6];
    Toast toast;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        iSn3199Service = ISn3199Service.Stub.asInterface(ServiceManager.getService("sn3199"));
        if(null != iSn3199Service) {
            try {
                iSn3199Service.sn3199Open();
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
        btnState[0] = (Button) findViewById(R.id.state1);
        btnState[1] = (Button) findViewById(R.id.state2);
        btnState[2] = (Button) findViewById(R.id.state3);
        btnState[3] = (Button) findViewById(R.id.state4);
        btnState[4] = (Button) findViewById(R.id.state5);
        btnState[5] = (Button) findViewById(R.id.state6);
        for (int i = 0; i < 6; i++) {
           btnState[i].setOnClickListener(this);
        }
    }
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.state1:    //待机-白色呼吸灯效果
                try{
                    iSn3199Service.setLightState(1);
                }catch(RemoteException e) {
                    e.printStackTrace();
                }
                toast = Toast.makeText(this, "待机-白色呼吸灯效果设置成功", Toast.LENGTH_SHORT);
                toast.show();
                break;
            case R.id.state2:   //正常工作（音箱本身喇叭不工作）-常亮白色
                try{
                    iSn3199Service.setLightState(2);
                }catch(RemoteException e)
                {
                    e.printStackTrace();
                }
                toast = Toast.makeText(this, "待机-白色呼吸灯效果设置成功", Toast.LENGTH_SHORT);
                toast.show();
                break;
            case R.id.state3:   //程序系统异常状态-红色闪烁
                try{
                    iSn3199Service.setLightState(3);
                }catch(RemoteException e)
                {
                    e.printStackTrace();
                }
                toast = Toast.makeText(this, "程序系统异常状态-红色闪烁设置成功", Toast.LENGTH_SHORT);
                toast.show();
                break;
            case R.id.state4:    //跟随音乐跳动状态
                try{
                    iSn3199Service.setLightState(4);
                }catch(RemoteException e)
                {
                    e.printStackTrace();
                }
                toast = Toast.makeText(this, "跟随音乐跳动状态设置成功", Toast.LENGTH_SHORT);
                toast.show();
                break;
            case R.id.state5:   //网络异常状态-常亮红色
                try{
                    iSn3199Service.setLightState(5);
                }catch(RemoteException e)
                {
                    e.printStackTrace();
                }
                toast = Toast.makeText(this, "网络异常状态-常亮红色设置成功", Toast.LENGTH_SHORT);
                toast.show();
                break;
            case R.id.state6:     //正在开机-蓝色呼吸灯
                try{
                    iSn3199Service.setLightState(6);
                }catch(RemoteException e)
                {
                    e.printStackTrace();
                }
                toast = Toast.makeText(this, "正在开机-蓝色呼吸灯设置成功", Toast.LENGTH_SHORT);
                toast.show();
                break;
            default:
                break;
        }
    }
}
  • activity_main.xml
<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="com.example.yjd.sn3199interfacetest.MainActivity">

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="vertical">
        <Button
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="State1"
            android:id="@+id/state1"/>
        <Button
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="State2"
            android:id="@+id/state2"/>
        <Button
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="State3"
            android:id="@+id/state3"/>
        <Button
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="State4"
            android:id="@+id/state4"/>
        <Button
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="State5"
            android:id="@+id/state5"/>
        <Button
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="State6"
            android:id="@+id/state6"/>

    </LinearLayout>

</android.support.constraint.ConstraintLayout>

编译的时候可能会遇到方法超过64K的错误，这里添加两行代码完美解决
这里写图片描述
这里写图片描述
OK，终于写完了，至于怎么添加classes.jar包到Android项目中应该就很简单了，还是贴张图吧
这里写图片描述
这里添加依赖选第3个选模块依赖：ModuleDependency
这里写图片描述

在此特别注意的时候，在调试底层代码的时候，多看main log， 用logcat -v time -b main 命令

如果有什么疑问可以加QQ：1308418494一起讨论学习，欢迎大神指点

yujd
关注
  • 6
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android HAL到Framework
Linux驱动相关内容及Android开发
05-20 918
本文主要对Android的整体架构，从底层到上层一个完整链路的梳理，帮助大家进一步理解
Android Framework，HAL，Kernel调用关系
w2064004678的博客
01-22 2395
1 . JNI技术: 1）JNI技术简单的说就是在本地Java语言声明本地方法和加载动态链接库(.so文件) 2）动态链接库(.so文件)是由NDK编译C/C++文件而成的。 2 . HAL层开发： 1）HAL是Hardware Abstraction Layer的简称。也称为硬件抽象层。 2）硬件访问服务是在Framework层实现的。 3）硬件访问服务是用Java语言实现的，硬件抽象层是用C++语言编写的。因此硬件访问服务必须通过JNI技术调用硬件抽象层的接口。 4）硬件抽象层调用Linux Ker.
Android内核和驱动篇-Android内核介绍
最新发布
2401_85122678的博客
06-04 725
Android化呢?除了要移植前面提到的驱动之外，就是如何配置你的Kernel来支持Android平台，这可以参考Goldfish的内核配置文件 - arch/arm/configs/goldfish_defconfig。Android是基于Linux的，对于一个新的设备，我们首先要编译一个支持Android的Kernel，那么如何使你的Kernel。配置好后，就可以用Toolchain来编译内核了。Android内核配置。一般需要支持的内核选项。
app应用--->framework层---->hal硬件抽象层---->kernel driver
无法支撑我那丰满的欲望和消瘦的理想
08-23 1971
一：android系统整体框架 二：关于各个层次之间如何打通任督二脉(android系统如何从最上层ui一直调用到最低层)   jni open打开/dev/xxx设备文件 整体思路：application------------------------------调用框架层的java接口------------------------------------调用硬件抽象层hal---
基于问题学习安卓系统架构
qq_19903753的博客
08-12 1420
基于问题学习安卓系统架构 文章目录基于问题学习安卓系统架构1 原理1.1 什么是安卓系统架构APP层Framework层Native/ArtNative: C/C++ArtHAL层Kernal层1.2 Android8源码与系统架构的关系源码目录结构源码目录描述1.3 为什么安卓系统架构要这么设计 1 原理 本节要了解、弄懂安卓系统架构的原理，首先将安卓系统架构完全分析清楚，再根据下载好的Android8的源码，将源码目录中的内容与系统架构联合在一起，最后总结为什么安卓系统架构要这么设计。 1.1 什么是安
Android Camera从App层到framework层到HAL层的初始化过程
xiaowang_lj的博客
07-21 1345
Camera2.0首先启动的是CameraActivity，而它继承自QuickActivity，在代码中你会发现没有重写OnCreate等生命周期方法，因为此处采用的是模板方法的设计模式，在QuickActivity中的onCreate方法调用的是onCreateTasks等方法，所以要看onCreate方法就只须看onCreateTasks方法即可。该方法又调用mm_camera_channel.c的mm_channel_init方法，进入mm_camera_channel.c的该方法;
Android中framework,HAL,vhal
sun007700的专栏
11-23 1312
framework
Android Camera : 从 Framework 到 HAL，Kernel 的 buf 管理探究
技术杂谈
01-30 3923
本文来自作者 海角之南 在 GitChat 上分享 「Android Camera : 从 Framework 到 HAL，Kernel 的 buf 管理探究」，「阅读原文」查看交流实录。「文末高能」编辑 | 哈比Android Camera Buf liVePhone Camera 的功能可谓日新月异且富有趣味，除了硬件功能强大，软件逻辑也很重要，Buf 管理是软件逻辑里非常重要的一环，弄懂它的
android5.0 android-21 源码
03-10
5. **权限管理**：探究Android的权限模型，如如何在Android 5.0中实现运行时权限。 6. **安全机制**：分析沙箱机制、权限控制、数据加密等安全措施。 7. **编译与构建**：掌握AOSP（Android Open Source Project）...
Android10-全志R818-自定义按键开发指南 - 代码已验证有效
09-02
首先，我们要理解自定义按键开发涉及的两个主要部分：内核（Kernel）和Android框架（Framework）。 1. **内核部分**： 内核主要负责硬件层面的适配和按键事件的上报。对于全志R818平台，这通常涉及到GPIO矩阵按键...
【eoe+Android特刊】10-17期
06-28
16期的“底层驱动原理”可能涉及Android系统级别的驱动开发，包括硬件接口、HAL层、Kernel与Android Framework之间的交互等。这部分内容对有志于进行系统级开发或优化的工程师尤其有用，能够帮助他们理解Android如何...
Android4.0.3-源代码
01-01
2. **Kernel（内核）**：基于Linux，Android的内核负责处理系统级任务，如进程管理、内存管理、设备驱动等。Android 4.0.3对内核进行了优化，提高了系统的稳定性和效率。 3. **Libraries（库）**：包括系统库和应用...
Camera框架分析 - 副本.docx
05-27
Android相机框架是一个复杂而精细的系统，它允许应用层的Java App与硬件驱动进行交互，实现拍照、录像等相机功能。整个框架分为多个层次，从上至下依次是： 1. **应用层 (Java App)**：这是用户直接接触的部分，...
HAL层分析——初步了解HAL
boundlessAbjure的专栏
08-19 2891
HAL是kernel与framework中间的一层。下面通过分析来说明HAL在android架构中起了什么作用，它如何把framework和kernel联系起来，承上启下。它的存在为什么使得android架构被linux踢出linux内核树。注意，HAL的存在仅仅使得android商业化的成功，却限制了android的开源发展，它对于开发本身而言并不是必要的。      1、     H
获取usb设备类型
热门推荐
仓仓
12-05 1万+
项目中需要区分USB的连接设备是打印机还是电子秤，然后上网搜索到了一篇博客，根据这个博客写的一个小的例子：非常感谢hao2014_的这篇博客http://blog.csdn.net/u013686019/article/details/50409421 MainActivity： [java] view plain copy  
android 8.1上新增hidl接口，从hal层往framework层传共享内存
转载和创作优秀的博客
03-09 3687
android8.1和之前的版本有一个很大的不同，那就是8.1以后的版本将hal层和framework层分隔开来，不在同一个进程，不能直接通信。如果framework层需要和hal层通信，需要用到hidl接口。 之前我这边有个模块，在android6.0上时，需要在hal层通过ashmem_create_region来创建一块共享内存。然后将创建的共享内存句柄，通过binder，传送给framework层和app层。在android6.0上，一切都很顺利，framework层通过bin...
从java层到framework到JNI到HAL到kernel的hello 例子
梦家之家
05-21 421
转载自http://blog.csdn.net/Luoshengyang/article/category/838604/3 在智能手机时代，每个品牌的手机都有自己的个性特点。正是依靠这种与众不同的个性来吸引用户，营造品牌凝聚力和用户忠城度，典型的代表非iphone莫属了。据统计，截止2011年5月，AppStore的应用软件数量达381062个，位居第一，而Android Market的应用软件数量达294738，紧随AppStore后面，并有望在8月份越过AppStore。随着Android系..
camera api2 app-fw-hal拍照raw流程
06-13
相机API2是Android系统中用于控制相机硬件的标准接口，它提供了更灵活、更高效的相机控制功能。而app-fw-hal是Android系统中的相机HAL模块，它是应用程序和相机驱动程序之间的接口。在使用相机API2拍摄RAW照片时，其流程如下： 1. 打开相机：应用程序使用相机管理器（CameraManager）打开相机设备。 2. 创建相机会话：应用程序使用相机设备的创建会话方法（createCaptureSession）创建一个用于拍摄的会话。在创建会话时，需要指定输出目标，例如预览或拍照。 3. 配置相机：应用程序使用相机设备的创建请求方法（createCaptureRequest）创建一个请求对象，并通过该对象配置相机的参数。例如，设置相机的曝光时间、ISO等参数。 4. 配置输出目标：应用程序通过请求对象的addTarget方法将输出目标与请求对象关联起来。对于RAW照片，需要将输出目标设置为ImageReader。 5. 开始预览：应用程序通过会话对象的setRepeatingRequest方法开始预览。 6. 拍照：应用程序通过请求对象的capture方法拍摄照片。 7. 获取RAW数据：当拍摄完成后，ImageReader会回调onImageAvailable方法，应用程序可以在该方法中获取RAW数据。 8. 处理RAW数据：应用程序可以将RAW数据转换为JPEG格式并保存到文件系统中，或者进行其他的处理操作。 9. 关闭会话：应用程序使用会话对象的close方法关闭会话。 10. 关闭相机：应用程序使用相机设备的close方法关闭相机。 以上就是使用相机API2拍摄RAW照片的流程，其中app-fw-hal作为相机HAL模块提供了应用程序和相机驱动程序之间的接口。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值