LED硬件方法服务(2)

/* ILedService.aidl文件 */
package android.os;

/** {@hide} */
interface ILedService
{
    int ledControl(int which, int status);
}

package com.android.server;

import android.os.ILedService;


/*
此文件的作用: 调用本地方法来操作硬件
*/

public class LedService extends ILedService.Stub
{
    private static final String TAG = "LedService"; /*只有在打印信息的时候会使用到*/

    /*不要忘记加native*/
    public native static int native_ledOpen();
    public native static int native_ledCtrl(int which, int status);
    public native static int native_ledClose();

    @Override
    public int ledControl(int which, int status) throws android.os.RemoteException {
        return native_ledCtrl(which, status);
    }

    public LedService() {
        native_ledOpen();
    }
}

仿照Vibrator添加：
Slog.i(TAG, "Led Service");
led = new LedService();
ServiceManager.addService("led", led);

<application
    android:name="android.support.multidex.MultiDexApplication"
    ...
application>

build.gradle(Module:app)中添加：
defaultConfig {
    ...
    multiDexEnabled true
}
dependencies {
    ...
    implementation ‘com.android.support:multidex:1.0.3‘
}

package com.example.mm.app_0001_led_demo;

import android.os.RemoteException;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.widget.Button;
import android.view.View;
import android.widget.CheckBox;
import android.widget.Toast;
import android.os.ILedService; //1.导入这个包
import android.os.ServiceManager;

public class MainActivity extends AppCompatActivity {

    private boolean ledon = false;
    private Button button = null;

    private CheckBox checkBoxLed1 = null;
    private CheckBox checkBoxLed2 = null;
    private CheckBox checkBoxLed3 = null;
    private CheckBox checkBoxLed4 = null;

    private ILedService iLedService = null;

    class MyButtonListener implements View.OnClickListener { //OnClickListener is a inner interface of View

        //iLedService hradControl = new iLedService();

        /* Ctrl + i  auto override*/
        @Override
        public void onClick(View v) {
            ledon = !ledon;
            if (ledon) {
                button.setText("ALL OFF");
                checkBoxLed1.setChecked(true);
                checkBoxLed2.setChecked(true);
                checkBoxLed3.setChecked(true);
                checkBoxLed4.setChecked(true);
                try {
                    for (int i = 0; i < 4; i++) {
                        /*3.通过该实例直接调用aidl中的函数*/
                        iLedService.ledControl(i, 1);
                    }
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            } else {
                button.setText("ALL ON");
                checkBoxLed1.setChecked(false);
                checkBoxLed2.setChecked(false);
                checkBoxLed3.setChecked(false);
                checkBoxLed4.setChecked(false);
                try {
                    for (int i = 0; i < 4; i++) {
                        iLedService.ledControl(i, 0);
                    }
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public void onCheckboxClicked(View view) {
        // Is the view now checked?
        boolean checked = ((CheckBox) view).isChecked();

        try {
            // Check which checkbox was clicked
            switch(view.getId()) {
                case R.id.LED1:
                    if (checked) {
                        iLedService.ledControl(0, 1);
                        Toast.makeText(getApplicationContext(), "LED1 on", Toast.LENGTH_SHORT).show();
                    } else {
                        iLedService.ledControl(0, 0);
                        Toast.makeText(getApplicationContext(), "LED1 off", Toast.LENGTH_SHORT).show();
                    }
                    break;
                case R.id.LED2:
                    if (checked) {
                        iLedService.ledControl(1, 1);
                        Toast.makeText(getApplicationContext(), "LED2 on", Toast.LENGTH_SHORT).show();
                    } else {
                        iLedService.ledControl(1, 0);
                        Toast.makeText(getApplicationContext(), "LED2 off", Toast.LENGTH_SHORT).show();
                    }
                    break;
                case R.id.LED3:
                    if (checked) {
                        iLedService.ledControl(2, 1);
                        Toast.makeText(getApplicationContext(), "LED3 on", Toast.LENGTH_SHORT).show();
                    } else {
                        iLedService.ledControl(2, 0);
                        Toast.makeText(getApplicationContext(), "LED3 off",Toast.LENGTH_SHORT).show();
                    }
                    break;
                case R.id.LED4:
                    if (checked) {
                        iLedService.ledControl(3, 1);
                        Toast.makeText(getApplicationContext(), "LED4 on", Toast.LENGTH_SHORT).show();
                    } else {
                        iLedService.ledControl(3, 0);
                        Toast.makeText(getApplicationContext(), "LED4 off", Toast.LENGTH_SHORT).show();
                    }
                    break;
            }
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        /*2.获取一个ILedService的实例*/
        /* name "led" should the same as the name of addService() */
        iLedService = ILedService.Stub.asInterface(ServiceManager.getService("led"));

        /* Ctrl+r and then replace all make iLedService-->iLedService */

        button = (Button) findViewById(R.id.BUTTON);
        button.setOnClickListener(new MyButtonListener());

        /* Ctrl + shift + Space to insert CheckBox to ()*/
        checkBoxLed1 = (CheckBox) findViewById(R.id.LED1);
        checkBoxLed2 = (CheckBox) findViewById(R.id.LED2);
        checkBoxLed3 = (CheckBox) findViewById(R.id.LED3);
        checkBoxLed4 = (CheckBox) findViewById(R.id.LED4);
    }
}

load
    dlopen
        (struct hw_module_t *)dlsym(handle, "HMI") //从so文件中获取名为HMI的hw_module_t类型的结构体
        strcmp(id, hmi->id) //检验hmi->id的id是否等于"led"
        
函数原型如下：
int hw_get_module(const char *id, const struct hw_module_t **module)
void *dlopen(const char *filename, int flag);

#define LOG_TAG "LedService"

#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>

#include "jni.h"
#include "JNIHelp.h" /*must contain, else build error*/

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

#include <hardware/hardware.h>
#include <hardware/led_hal.h>


namespace android
{

static led_device_t *g_device;

static int init_native(led_device_t ** device)
{
    int ret;
    hw_module_t *module;
    led_device_t *led_device;

    ret = hw_get_module(LED_HARDWARE_MODULE_ID, (hw_module_t const**)&module);
    if (ret) {
        ALOGE("init_native failed, ret=%d", ret);
        return -1;
    }

    ret = module->methods->open(module, NULL, (hw_device_t **)&led_device);
    if (ret < 0) {
        return -1;
    }

    *device = led_device;

    return 0;
}


static jint led_open(JNIEnv *env, jclass cls) {
    int ret;
    static int first = 0;

    if (first == 0) {
        first++;
        ret = init_native(&g_device);
        if (ret) {
            return -1;
        }
    }

    if (g_device) {
        return g_device->led_open(g_device);
    } else {
        return -1;
    }
}


static jint led_ctrl(JNIEnv * env, jclass cls, jint which, jint status) {
    if (g_device) {
        return g_device->led_ioctl(g_device, which, status);
    } else {
        return -1;
    }
}

static void led_close(JNIEnv *env, jclass cls) {
    if (g_device) {
        g_device->led_close(g_device);
    }
}


static const JNINativeMethod method_table[] = {
    { "native_ledOpen", "()I", (void*)led_open },
    { "native_ledCtrl", "(II)I", (void*)led_ctrl },
    { "native_ledClose", "()V", (void*)led_close },
};

int register_android_server_LedService(JNIEnv *env)
{
    /*把method_table中的方法注册到类com.android.server.LedService中*/
    return jniRegisterNativeMethods(env, "com/android/server/LedService", method_table, NELEM(method_table));
}

};

#define LOG_TAG "LedHal"


#include <hardware/hardware.h>
#include <hardware/led_hal.h>
#include <cutils/log.h>

#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>


#define DEV_FILE     "/dev/leds"


int hal_led_open(led_device_t *device) {
    int fd = open(DEV_FILE, O_RDWR);
    if (fd < 0) {
        ALOGE("hal_led_open failed!");
        return -1;
    }
    device->fd = fd;

    ALOGI("hal_led_open called");
    return 0;
}

int hal_led_ioctl(led_device_t *device, int which, int status) {
    int ret;
    ret = ioctl(device->fd, status, which);
    if (ret != 0) {
        ALOGE("hal_led_ioctl failed: which=%d, status=%d", which, status);
        return -1;
    }
    ALOGI("hal_led_ioctl called: which=%d, status=%d", which, status);
    return 0;

}

/*这里传参数是hw_device_t，其它函数传参是led_device_t*/
int hal_led_close(led_device_t *device) {
    close(device->fd);
    ALOGI("hal_led_close called!");
    return 0;
}


/* here id is device_id, when more than one device, use it to choose */
/*加上"__unused"可以防止编译器报警告:warning: unused parameter ‘id‘ [-Wunused-parameter]*/
int led_module_open(const struct hw_module_t* module, const char* id __unused,
    struct hw_device_t** device) {

    led_device_t *led_device = calloc(1, sizeof(led_device_t));
    if (!led_device) {
        ALOGE("Can not allocate memory for led_device");
        *device = NULL;
        return -ENOMEM;
    }

    led_device->common.tag = HARDWARE_DEVICE_TAG;
    led_device->common.module = (hw_module_t *) module;
    led_device->common.version = HARDWARE_DEVICE_API_VERSION(1,0);
    //led_device->common.close = hal_led_close;
    led_device->led_open = hal_led_open;
    led_device->led_ioctl = hal_led_ioctl;    
    led_device->led_close = hal_led_close;

    *device = (hw_device_t *)led_device;

    return 0;
}


static struct hw_module_methods_t led_module_methods = {
    .open = led_module_open,
};

/*这里必须不能加static修饰，否则dlsym()找不到这个HMI结构体*/
//static hw_module_t HAL_MODULE_INFO_SYM = {
struct hw_module_t HAL_MODULE_INFO_SYM = {

    .tag = HARDWARE_MODULE_TAG,
    .module_api_version = LED_API_VERSION,
    .hal_api_version = HARDWARE_HAL_API_VERSION,
    .id = LED_HARDWARE_MODULE_ID,
    .name = "Led HAL of Mr.Sun",
    .author = "Mr.Sun",
    .methods = &led_module_methods,
};

#ifndef HARDWARE_LED_HAL_H
#define HARDWARE_LED_HAL_H


#define LED_HARDWARE_MODULE_ID "led"

#define LED_API_VERSION HARDWARE_MODULE_API_VERSION(1,0)



typedef struct _led_device {
    struct hw_device_t common;

    int fd;
    int (*led_open)(led_device_t *device);
    int (*led_ioctl)(led_device_t *device, int which, int status);
    void (*led_close)(led_device_t *device);
} led_device_t;





#endif /*HARDWARE_LED_HAL_H*/