基于 Light 介绍安卓 8.0 HAL 变化

最新推荐文章于 2024-05-06 22:17:00 发布
置顶 最新推荐文章于 2024-05-06 22:17:00 发布
阅读量4.2k 收藏 20
点赞数 2
分类专栏： Android 文章标签： Android HIDL Light
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangjun7121/article/details/88140862
版权

文章目录

前言

学习笔记，简单介绍了 light 在 Android 8.0 上的整个调用流程
更新上添加下调用流程线，将各个文件串起来

HIDL 简介

一张图开场
在这里插入图片描述
在这里插入图片描述

	其实主要是就是将以前那种 Java-> Jni -> Hal -> Kernel 的结构变成了
	
	Java -> Jni -> Binder 客户端 ====== Binder 通信 ======> Binder 服务端 -> Hal -> Kernel 

 	将 framework 与 Hal 之间的交互变成了 CS 结构了。

插播下 Java Binder 服务编写框图：
在这里插入图片描述

C++ Binder 服务编写框图：
在这里插入图片描述

启动流程

 // SystemServer.java (frameworks\base\services\java\com\android\server)
 import com.android.server.lights.LightsService;
 
 startBootstrapServices()  
    # 此函数可参考 BatteryService 流程分析
    mSystemServiceManager.startService(LightsService.class);
            // SystemServiceManager.java (frameworks\base\services\core\java\com\android\server)
            startService(Class<T> serviceClass)
                # 获取类名
                final String name = serviceClass.getName();
                # 获得构造函数： public LightsService(Context context)
                Constructor<T> constructor = serviceClass.getConstructor(Context.class);
                # 调用构造函数，创建类对象
                service = constructor.newInstance(mContext);
                        // LightsService.java (frameworks\base\services\core\java\com\android\server\lights)
                        // 构造函数：
                        LightsService(Context context)
                            super(context);

                            for (int i = 0; i < LightsManager.LIGHT_ID_COUNT; i++) {
                                mLights[i] = new LightImpl(i);
                            }
                
                
                # 添加到 SystemService 链表中管理，并启动服务
                startService(service);
                    mServices.add(service);
                    service.onStart();
                            // LightsService.java (frameworks\base\services\core\java\com\android\server\lights)
                            onStart()
                                // 这是向 systemservice.java 注册了一些回调，只让其调用使用？
                                // Publish the service so it is only accessible to the system process
                                // 让其只能在 system 进程中访问？
                                //      ./base/services/core/java/com/android/server/power/PowerManagerService.java:736:            
                                //          mBatteryManagerInternal = getLocalService(BatteryManagerInternal.class);
                                publishLocalService(LightsManager.class, mService);

HIDL 使用

// 接口文件：
//  Z:\work\A306_eng\src\hardware\interfaces\light\2.0\ILight.hal
    package android.hardware.light@2.0;

    interface ILight {

        /**
         * Set the provided lights to the provided values.
         *
         * @param type logical light to set
         * @param state describes what the light should look like.
         * @return status result of applying state transformation.
         */
        setLight(Type type, LightState state) generates (Status status);

        /**
         * Discover what indicator lights are available.
         *
         * @return types list of available lights
         */
        getSupportedTypes() generates (vec<Type> types);

    };

// 编译文件：
// Z:\work\A306_eng\src\hardware\interfaces\light\2.0\Android.bp
    filegroup {
        name: "android.hardware.light@2.0_hal",
        srcs: [
            "types.hal",
            "ILight.hal",
        ],
    }

    genrule {
        name: "android.hardware.light@2.0_genc++",
        tools: ["hidl-gen"],
        cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.light@2.0",
        srcs: [
            ":android.hardware.light@2.0_hal",
        ],
        out: [
            "android/hardware/light/2.0/types.cpp",
            "android/hardware/light/2.0/LightAll.cpp",
        ],
    }
    
    // 编译工具： out/host/linux-x86/bin/hidl-gen 
    // 生成文件：
    //      Z:\work\A306_eng\src\out\soong\.intermediates\hardware\interfaces\light\2.0\android.hardware.light@2.0_genc++\gen\android\hardware\light\2.0\LightAll.cpp
            getService(): 获取 servicemanager 中的对应 binder 服务 
            BnHwLight::onTransact()# 服务器端，调用具体子类提供服务操作硬件
                _hidl_mImpl->setLight(type, *state);
                
            BpHwLight::setLight(Type type, const LightState& state): # 客户端，提供远程调用服务端接口
                    1. 填充 Parcel 数据
                    2. 调用 remote() 通过 binder 调用到服务器端执行
                    _hidl_err = remote()->transact(1 /* setLight */, _hidl_data, &_hidl_reply);

Jni 流程： HIDL 客户端使用

// com_android_server_lights_LightsService.cpp (frameworks\base\services\core\jni)
static void setLight_native( JNIEnv* /* env */, jobject /* clazz */, jint light, jint colorARGB, jint flashMode, jint onMS, jint offMS,jint brightnessMode) 
    
    # HAL 服务获取: HIDL 接口，从 servicemanager 中获取 Light 服务
    sp<ILight> hal = LightHal::associate();
            // will return the hal if it exists the first time.
            sLight = ILight::getService();
                // Z:\work\A306_eng\src\out\soong\.intermediates\hardware\interfaces\light\2.0\android.hardware.light@2.0_genc++\gen\android\hardware\light\2.0\LightAll.cpp
                ::android::sp<ILight> ILight::getService(const std::string &serviceName, const bool getStub) 
                        const sp<::android::hidl::manager::V1_0::IServiceManager> sm = defaultServiceManager();
                        Return<Transport> transportRet = sm->getTransport(ILight::descriptor, serviceName);
                        
                       
                        if (getStub || vintfPassthru || vintfLegacy) {
                            
                            # 获取 PassthroughServiceManager 服务 
                            const sp<::android::hidl::manager::V1_0::IServiceManager> pm = getPassthroughServiceManager();
              
                            Return<sp<::android::hidl::base::V1_0::IBase>> ret = pm->get(ILight::descriptor, serviceName);
                                    // ServiceManagement.cpp (system\libhidl\transport)
                                    struct PassthroughServiceManager : IServiceManager {
                                                        Return<sp<IBase>> get(const hidl_string& fqName,
                                                                              const hidl_string& name)
                                    {
                                        # PassthroughServiceManager 的 get(const hidl_string& fqName, const hidl_string& name)
                                        # 函数根据传入的 fqName=(android.hardware.cameraProvider@2.4::ICameraProvider"),
                                        
                                        # 获取当前的接口名ICameraProvider，
                                        #   拼接出后面需要载入的函数名：HIDL_FETCH_ICameraProvider 和库名字：
                                        #           android.hardware.camera.provider@2.4-impl.so
                                        
                                        std::string stdFqName(fqName.c_str());
                                        //fqName looks like android.hardware.foo@1.0::IFoo
                                        size_t idx = stdFqName.find("::");

                                        if (idx == std::string::npos ||
                                                idx + strlen("::") + 1 >= stdFqName.size()) {
                                            LOG(ERROR) << "Invalid interface name passthrough lookup: " << fqName;
                                            return nullptr;
                                        }

                                        std::string packageAndVersion = stdFqName.substr(0, idx);
                                        std::string ifaceName = stdFqName.substr(idx + strlen("::"));

                                        const std::string prefix = packageAndVersion + "-impl";
                                        const std::string sym = "HIDL_FETCH_" + ifaceName;
                                        
                                        

                                        # 接着通过 dlopen 载入 /vendor/lib/hw/android.hardware.light@2.0-impl.so；
                                        #   通过 dlsym 载入 HIDL_FETCH_ICameraProvider 函数
                                        # 至此正式进入cameraprovider的implement

                                        
                                        std::vector<std::string> libs = search(path, prefix, ".so");
                                        handle = dlopen(fullPath.c_str(), dlMode);
                                        IBase* (*generator)(const char* name);
                                        *(void **)(&generator) = dlsym(handle, sym.c_str());
                                        IBase *interface = (*generator)(name.c_str());
                                                #################################################################
                                                # 调用 HIDL 服务入口函数
                                                #################################################################
                                                // Z:\work\A306_eng\src\hardware\interfaces\light\2.0\default\Light.cpp
                                                ILight* HIDL_FETCH_ILight(const char* /* name */) {
                                                    std::map<Type, light_device_t*> lights;

                                                    for(auto const &pair : kLogicalLights) {
                                                        Type type = pair.first;
                                                        const char* name = pair.second;

                                                        light_device_t* light = getLightDevice(name);
                                                                    #############################################
                                                                    # 老 HAL 库加载
                                                                    #############################################
                                                                    light_device_t* getLightDevice(const char* name)
                                                                        int ret = hw_get_module (LIGHTS_HARDWARE_MODULE_ID, &hwModule);
                                                                                    // Lights.c (hardware\qcom\display\liblight)
                                                                                        struct hw_module_t HAL_MODULE_INFO_SYM = {
                                                                                            .tag = HARDWARE_MODULE_TAG,
                                                                                            .version_major = 1,
                                                                                            .version_minor = 0,
                                                                                            .id = LIGHTS_HARDWARE_MODULE_ID,
                                                                                            .name = "lights Module",
                                                                                            .author = "Google, Inc.",
                                                                                            .methods = &lights_module_methods,
                                                                                        };

                                                                                        static struct hw_module_methods_t lights_module_methods = {
                                                                                            .open =  open_lights,
                                                                                        };

                                                                        
                                                                        ret = hwModule->methods->open(hwModule, name,reinterpret_cast<hw_device_t**>(&lightDevice));
                                                                                // Light.cpp (vendor\qcom\proprietary\fastmmi\module\light)
                                                                                open_lights(const struct hw_module_t* module, char const* name,struct hw_device_t** device)
                                                                                    set_light = set_light_notifications;
                                                                                            handle_speaker_battery_locked(dev);
                                                                                                set_speaker_light_locked(dev, &g_notification);
                                                                                                    // wangjun@wind-mobi.com 20180111 begein
                                                                                                    // 闪烁之前清灯状态
                                                                                                    write_int(RED_LED_FILE, 0);
                                                                                                    write_int(GREEN_LED_FILE, 0);
                                                                                                    write_int(BLUE_LED_FILE, 0);
                                                                                                            # 往 /sys/class/leds/green/brightness 这类的结点写亮度值
                                                                                                            fd = open(path, O_RDWR);
                                                                                                            int bytes = snprintf(buffer, sizeof(buffer), "%d\n", value);
                                                                                                            ssize_t amt = write(fd, buffer, (size_t)bytes);
                                                                                                            close(fd);
                                                                                                    // wangjun@wind-mobi.com 20180111 end
                                                                                                
                                                                                                
                                                        if (light != nullptr) {
                                                            lights[type] = light;
                                                        }
                                                    }

                                                    if (lights.size() == 0) {
                                                        // Log information, but still return new Light.
                                                        // Some devices may not have any lights.
                                                        ALOGI("Could not open any lights.");
                                                    }

                                                    return new Light(std::move(lights));
                                                }
                        
                        
    Type type = static_cast<Type>(light);
    // 构造 LightState 状态类 
    LightState state = constructState( colorARGB, flashMode, onMS, offMS, brightnessMode);
    ALOGD_IF_SLOW(50, "Excessive delay setting light");
    
    # HIDL 接口向 HAL 下发灯状态给他处理
    Return<Status> ret = hal->setLight(type, state);
    
    # 处理通信返回值
    processReturn(ret, type, state);

HIDL 服务端

// Z:\work\A306_eng\src\hardware\interfaces\light\2.0\default\Android.mk
    include $(CLEAR_VARS)
    LOCAL_MODULE_RELATIVE_PATH := hw
    LOCAL_PROPRIETARY_MODULE := true
    LOCAL_MODULE := android.hardware.light@2.0-service
    LOCAL_INIT_RC := android.hardware.light@2.0-service.rc
    LOCAL_SRC_FILES := \
        service.cpp \

    LOCAL_SHARED_LIBRARIES := \
        liblog \
        libcutils \
        libdl \
        libbase \
        libutils \
        libhardware \

    LOCAL_SHARED_LIBRARIES += \
        libhidlbase \
        libhidltransport \
        android.hardware.light@2.0 \

    include $(BUILD_EXECUTABLE)

    // 服务启动：
    // Z:\work\A306_eng\src\hardware\interfaces\light\2.0\default\android.hardware.light@2.0-service.rc
    service light-hal-2-0 /vendor/bin/hw/android.hardware.light@2.0-service
        class hal
        user system
        group system    
    
        // Z:\work\A306_eng\src\hardware\interfaces\light\2.0\default\service.cpp
        int main() {
            return defaultPassthroughServiceImplementation<ILight>();
                        /
                        // LegacySupport.h (system\libhidl\transport\include\hidl)
                        defaultPassthroughServiceImplementation(std::string name, size_t maxThreads = 1)
                            configureRpcThreadpool(maxThreads, true);
                                configureBinderRpcThreadpool(maxThreads, callerWillJoin);
                                    ProcessState::self()->setThreadPoolConfiguration(maxThreads, callerWillJoin /*callerJoinsPool*/);
                                
                                
                            status_t result = registerPassthroughServiceImplementation<Interface>(name);                                    
                                                registerPassthroughServiceImplementation( std::string name = "default")
                                                        sp<Interface> service = Interface::getService(name, true /* getStub */);
                                                        status_t status = service->registerAsService(name);
                                                
                            joinRpcThreadpool();
                                joinBinderRpcThreadpool();
                                    IPCThreadState::self()->joinThreadPool();
            
            
        }

相关文件

下面将从上到下介绍：

0.【Java 安卓LED服务类】LightsService.java

public class LightsService extends SystemService {
	
	// 下一级 Jni 接口
	static native void setLight_native(int light, int color, int mode,
        int onMS, int offMS, int brightnessMode);
}

1.【JNI 客户端实现】com_android_server_lights_LightsService.cpp

	static const JNINativeMethod method_table[] = {
	    { "setLight_native", "(IIIIII)V", (void*)setLight_native },
	};

	static void setLight_native(
	        JNIEnv* /* env */,
	        jobject /* clazz */,
	        jint light,
	        jint colorARGB,
	        jint flashMode,
	        jint onMS,
	        jint offMS,
	        jint brightnessMode) {
	
	    if (!validate(light, flashMode, brightnessMode)) {
	        return;
	    }
	    sp<ILight> hal = LightHal::associate();
	
	    if (hal == nullptr) {
	        return;
	    }
	
	    Type type = static_cast<Type>(light);
	    LightState state = constructState(
	        colorARGB, flashMode, onMS, offMS, brightnessMode);
	
	    {
	        ALOGD_IF_SLOW(50, "Excessive delay setting light");
			
			// 下一级入口 
	        Return<Status> ret = hal->setLight(type, state);
	        processReturn(ret, type, state);
	    }
	}

2.【HIDL 客户】ILight.与 HIDL 服务库通信.hal

	定义了 HIDL 接口 
	package android.hardware.light@2.0;

	interface ILight {
	
	    /**
	     * Set the provided lights to the provided values.
	     *
	     * @param type logical light to set
	     * @param state describes what the light should look like.
	     * @return status result of applying state transformation.
	     */
	    setLight(Type type, LightState state) generates (Status status);
	
	    /**
	     * Discover what indicator lights are available.
	     *
	     * @return types list of available lights
	     */
	    getSupportedTypes() generates (vec<Type> types);
	
	};

3.【HIDL 客户】LightAll.cpp.调用 HIDL 服务库

::android::status_t BnHwLight::onTransact(
    uint32_t _hidl_code,
    const ::android::hardware::Parcel &_hidl_data,
    ::android::hardware::Parcel *_hidl_reply,
    uint32_t _hidl_flags,
    TransactCallback _hidl_cb)
			// 下一级接口
			Status _hidl_out_status = _hidl_mImpl->setLight(type, *state);

4.【HIDL 服务】android.hardware.light@2.0-service.启动注册 HIDL 服务库

	service light-hal-2-0 /vendor/bin/hw/android.hardware.light@2.0-service
	    class hal
	    user system
	    group system

4.【HIDL 服务】service.cpp.向上注册 HIDL 服务库

	int main() {
		    return defaultPassthroughServiceImplementation<ILight>();    
		            /
		            // LegacySupport.h (system\libhidl\transport\include\hidl)
		            defaultPassthroughServiceImplementation(std::string name, size_t maxThreads = 1)
		                configureRpcThreadpool(maxThreads, true);
		                    configureBinderRpcThreadpool(maxThreads, callerWillJoin);
		                        ProcessState::self()->setThreadPoolConfiguration(maxThreads, callerWillJoin /*callerJoinsPool*/);
		                    
		                    
		                status_t result = registerPassthroughServiceImplementation<Interface>(name);                                    
		                                    registerPassthroughServiceImplementation( std::string name = "default")
		                                            sp<Interface> service = Interface::getService(name, true /* getStub */);
		                                            status_t status = service->registerAsService(name);
		                                    
		                joinRpcThreadpool();
		                    joinBinderRpcThreadpool();
		                        IPCThreadState::self()->joinThreadPool();

5.【HIDL 服务】Light.h

	namespace android {
	namespace hardware {
	namespace light {
	namespace V2_0 {
	namespace implementation {
	
	using ::android::hardware::light::V2_0::ILight;
	using ::android::hardware::light::V2_0::LightState;
	using ::android::hardware::light::V2_0::Status;
	using ::android::hardware::light::V2_0::Type;
	using ::android::hardware::Return;
	using ::android::hardware::Void;
	using ::android::hardware::hidl_vec;
	using ::android::hardware::hidl_string;
	using ::android::sp;
	
	struct Light : public ILight {
	    Light(std::map<Type, light_device_t*> &&lights);
	
	    // Methods from ::android::hardware::light::V2_0::ILight follow.
	    Return<Status> setLight(Type type, const LightState& state)  override;
	    Return<void> getSupportedTypes(getSupportedTypes_cb _hidl_cb)  override;
	
	private:
	    std::map<Type, light_device_t*> mLights;
	};
	
	extern "C" ILight* HIDL_FETCH_ILight(const char* name);
	
	}  // namespace implementation
	}  // namespace V2_0
	}  // namespace light
	}  // namespace hardware
	}  // namespace android

6.【HIDL 服务】Light.cpp.加载调用传统库

	ILight* HIDL_FETCH_ILight(const char* /* name */) {
	   std::map<Type, light_device_t*> lights;
	
	    for(auto const &pair : kLogicalLights) {
	        Type type = pair.first;
	        const char* name = pair.second;
	
			// 加载传统 HAL 库 
	        light_device_t* light = getLightDevice(name);
	
	        if (light != nullptr) {
	            lights[type] = light;
	        }
	    }
	
	    if (lights.size() == 0) {
	        // Log information, but still return new Light.
	        // Some devices may not have any lights.
	        ALOGI("Could not open any lights.");
	    }
	
	    return new Light(std::move(lights));
	}


	Light::Light(std::map<Type, light_device_t*> &&lights)
	  : mLights(std::move(lights)) {}
	
	// Methods from ::android::hardware::light::V2_0::ILight follow.
	Return<Status> Light::setLight(Type type, const LightState& state)  {
	    auto it = mLights.find(type);
	
	    if (it == mLights.end()) {
	        return Status::LIGHT_NOT_SUPPORTED;
	    }
	
	    light_device_t* hwLight = it->second;
	
	    light_state_t legacyState {
	        .color = state.color,
	        .flashMode = static_cast<int>(state.flashMode),
	        .flashOnMS = state.flashOnMs,
	        .flashOffMS = state.flashOffMs,
	        .brightnessMode = static_cast<int>(state.brightnessMode),
	    };
	
	    int ret = hwLight->set_light(hwLight, &legacyState);
	
	    switch (ret) {
	        case -ENOSYS:
	            return Status::BRIGHTNESS_NOT_SUPPORTED;
	        case 0:
	            return Status::SUCCESS;
	        default:
	            return Status::UNKNOWN;
	    }
	}

7.【HAL 实现】lights.c.传统 HAL 库

	/*
	 * The lights Module
	 */
	struct hw_module_t HAL_MODULE_INFO_SYM = {
	    .tag = HARDWARE_MODULE_TAG,
	    .version_major = 1,
	    .version_minor = 0,
	    .id = LIGHTS_HARDWARE_MODULE_ID,
	    .name = "lights Module",
	    .author = "Google, Inc.",
	    .methods = &lights_module_methods,
	};

/**
 * module methods
 */

/** Open a new instance of a lights device using name */
static int open_lights(const struct hw_module_t* module, char const* name,
        struct hw_device_t** device)
{
    int (*set_light)(struct light_device_t* dev,
            struct light_state_t const* state);

    if (0 == strcmp(LIGHT_ID_BACKLIGHT, name)) {
        char property[PROPERTY_VALUE_MAX];
        property_get("persist.extend.brightness", property, "0");

        if(!(strncmp(property, "1", PROPERTY_VALUE_MAX)) ||
           !(strncmp(property, "true", PROPERTY_VALUE_MAX))) {
            property_get("persist.display.max_brightness", property, "255");
            g_brightness_max = atoi(property);
            set_brightness_ext_init();
            set_light = set_light_backlight_ext;
        } else

			// 调用接口 set_light , 上层会调用到这里来
            set_light = set_light_backlight;
    } else if (0 == strcmp(LIGHT_ID_BATTERY, name))
        set_light = set_light_battery;
    else if (0 == strcmp(LIGHT_ID_NOTIFICATIONS, name))
        set_light = set_light_notifications;
    else if (0 == strcmp(LIGHT_ID_BUTTONS, name)) {
        if (!access(BUTTON_FILE, F_OK)) {
          // enable light button when the file is present			  
          set_light = set_light_buttons;
        } else {
          return -EINVAL;
        }
    }
    else if (0 == strcmp(LIGHT_ID_ATTENTION, name))
        set_light = set_light_attention;
    else
        return -EINVAL;

    pthread_once(&g_init, init_globals);

    struct light_device_t *dev = malloc(sizeof(struct light_device_t));

    if(!dev)
        return -ENOMEM;

    memset(dev, 0, sizeof(*dev));

    dev->common.tag = HARDWARE_DEVICE_TAG;
    dev->common.version = LIGHTS_DEVICE_API_VERSION_2_0;
    dev->common.module = (struct hw_module_t*)module;
    dev->common.close = (int (*)(struct hw_device_t*))close_lights;
    dev->set_light = set_light;

    *device = (struct hw_device_t*)dev;
    return 0;
}


# 更新灯则通过 sys/class/led/xxx/bright 来操作的
// char const*const RED_LED_FILE    = "/sys/class/leds/red/brightness";
set_speaker_light_locked(struct light_device_t* dev,
    struct light_state_t const* state)
		write_int(RED_LED_FILE, 0);
			int bytes = snprintf(buffer, sizeof(buffer), "%d\n", value);
    		ssize_t amt = write(fd, buffer, (size_t)bytes);

8.【内核实现】leds-qpnp.c

【充电 CHG_LED 可用红灯配置流程】：
	// Msm8937-pmi8940-mtp.dtsi (kernel\msm-3.18\arch\arm64\boot\dts\qcom)
	    &pmi8940_charger {
	        qcom,battery-data = <&mtp_batterydata>;
	        qcom,chg-led-sw-controls;
	        qcom,chg-led-support;
	    };
	
	    解析使用位置：Qpnp-smbcharger.c (kernel\msm-3.18\drivers\power)
	        static int __init smbchg_init(void)
	            // static struct spmi_driver smbchg_driver = {
	            //     .driver		= {
	            //         .name		= "qpnp-smbcharger",
	            //         .owner		= THIS_MODULE,
	            //         .of_match_table	= smbchg_match_table,
	            //         .pm		= &smbchg_pm_ops,
	            //     },
	            //     .probe		= smbchg_probe,
	            //     .remove		= smbchg_remove,
	            //     .shutdown	= smbchg_shutdown,
	            // };
	            return spmi_driver_register(&smbchg_driver);
	
	
	        smbchg_probe(struct spmi_device *spmi)
	            smb_parse_dt(struct smbchg_chip *chip)
	                chip->cfg_chg_led_support =	of_property_read_bool(node, "qcom,chg-led-support");
	                
	            。。。    
	            if (chip->cfg_chg_led_support && chip->schg_version == QPNP_SCHG_LITE)    
	                rc = smbchg_register_chg_led(chip);
	                        chip->led_cdev.name = "red";
	                        chip->led_cdev.brightness_set = smbchg_chg_led_brightness_set;
	                        chip->led_cdev.brightness_get = smbchg_chg_led_brightness_get;
	                        rc = led_classdev_register(chip->dev, &chip->led_cdev);
Android HAL深入探索(5): 调试HAL报错与解决方案
我其实什么都不会
09-09 2134
本文将介绍一些我自己在学习Android HAL的调试技巧和常见错误的解决方案，希望能帮助到大家。如果有错误 请指正，后面HAL相关的调试和解决方案将更新在此。
Android 8.0 工程之sepolicy权限
Tree_in_sea的博客
07-20 6959
/*****************************************************************************  * Author : Elvins Fu    yeyecheng_93@163.com  *  * Info : xxx Inc,(C) 2018-01-11, All rights revseved.  *  * Description...
编写android灯光系统的hal程序
疾风剑豪
06-25 417
编写android灯光系统的hal程序 Java: frameworks/base/services/core/java/com/android/server/lights/LightsService.java JNI: frameworks/base/services/core/jni/com_android_server_lights_LightsService.cpp Hal: lights.c
第四章：Android灯光系统(3)-编写HAL
江南才尽江南山，年少无知年少狂！
02-09 1247
该小节首先简单分析了一下java应用层，然后参考hardware/rockchip/liblights/lights.cpp编写了HAL文件lights.c，并且分析其原理。下小节将为大家分析安卓源码中的电池灯部分，敬请期待。https。
Android Light
liuning1985622的博客
05-06 758
LightsService(光服务)，Android光系统用来控制系统中的各个光源，实际上是一个输出控制系统。LightsService上层服务主要由三个类构成 Light、LightsService、LightsManager。
Android按键灯，指示灯总结【Android源码解析十一】
836811384
09-25 572
Android中有各种灯，背光灯，按键灯，指示灯，等等；前几天修改了这部分代码，整理下思路，其实都不难； 首先，来说说指示灯（提示灯），即未接电话，未接短信的时候，会闪灯，这个其实就是NotificationManager这个类中的notify（）方法来处理的；流程简单来过一下： Step 1：从应用层发送的notify（），到framework层被NotificationMa...
Android硬件抽象层（HAL）概要介绍和学习计划---Android8.0版本实现-对照老罗版本
zhuhualoyal的博客
04-26 428
做了一段时间的android蓝牙了，对android的框架有了些了解。由于在工作中只是为了解决项目中的问题，对技术疏于专研，对框架还是有些云里雾里，盲人摸象的感觉。一谈到技术，感受到自身水平很菜，在竞争日益激烈的今天，非常焦虑，于是开始想沉下心来好好提升自己。任何时候现在都是最好的学习时间，因此现在开始提升。 站在巨人的肩膀上才能看得更远，因为本身是和android系统...
Android灯光系统(硬件访问服务框架)
阿路
02-09 1837
Android灯光系统(硬件访问服务框架) Java类：LightsService.java LightsService.java通过调用，LightsService JNI来实现com.android.server包中的LightsService类。 这个类不是平台API，被Android系统JAVA框架中的其他一些部分调用。 /* * Copyright (C) 2008 The Androi...
Light改变，
最新发布
03-15
例如，在 Android 8.0 及以上版本中，HIDL 提供了一种标准化的方法来管理硬件抽象层 (HAL)，从而允许开发者更灵活地操作底层资源。为了适配特定需求，需了解完整的调用链路并将新增逻辑嵌入其中[^2]。 --- #### 3....
Android11添加AIDL系统服务及HIDL接口服务
kevin's cache的专栏
12-22 5431
frameworks/base/services/core/java/com/android/server目录添加HandWriteManagerService.java。可以看到“======”标示的内容，从自定义服务开始到SF日志，到最终HW层扩展接口拿到传递的数据值证明接口通了～～～～完事大吉！将刚刚得到的新 hashcode 值更新到 hardware/interfaces/current.txt。Mark一下，本文只做数据通路走通，可参考实现自己的控制和数据传输接口！
ADROID 2.1 架构解析 3 亮度设置
祥子的技术博客
10-25 541
<br />3 亮度设置<br />3.1 应用设计<br />3.1.1 设置进度条范围<br />背光设置是在：设置->声音和显示->亮度，通过进度条来设置的。<br />文件：packages/apps/Settings/src/com/android/settings/BrightnessPreference.java<br />private static final int MINIMUM_BACKLIGHT = android.os.Power.BRIGHTNESS_DIM + 10;<br
编写android HAL举例: lights
manshq163com的专栏
12-14 774
androidHAL层主要在hardware目录下，其中hardware\libhardware\下是同一用模块的概念来加载HAL的.so库。这里以背光lights为例： HAL模块要以MODULE_ID.platform.so的名字存放在文件系统的/system/lib/hw/下面。 看一下\hardware\libhardware\include\hardware\ligh
第四章：Android灯光系统(5)-通知灯
江南才尽江南山，年少无知年少狂！
02-14 1470
上小节我们分析了电池灯的源码，这小节我们将编写通知灯的使用过程。 我们知道，当手机接收到短信的时候，他会发出声音，并且这个通知灯会亮起，那么我们怎么实现呢？一般步骤如下： 1. getSystemService（&quot;NOTIFICATION_SERVICE&quot;） 2. 构造notfification （1）类别：该次实现类别为通知等 （2）其他：颜色，OnMS，OffMS。 3. 发出通知 ......
android button light 流程分析(二) — HAL & JNI
嵌入式技术博客
09-05 6152
一、基础数据信息 首先看一下HAL定义的light类型： /** * The id of this module */ #define LIGHTS_HARDWARE_MODULE_ID "lights" /* * These light IDs correspond to logical lights, not physical. * So for example, if yo
Android HAL层到驱动代码搜索---基于背光亮度的调试
风和先行的专栏
09-03 1333
以前阅读源码时一般只阅读到fwk层部分，近期因为一个问题，想顺便把fwk层到hal 到驱动的调用关系都看下。在此做下记录。 原始问题是客户嫌屏幕调到最大亮度后仍然觉得亮度不够亮，让看看能不能把亮度调亮点。 分析 这个需求首先得硬件上能支持亮度能满足客户需求，在硬件上支持的前提下再看软件上怎么把亮度设置到满足需求（驱动得能调节到那个值，应用层到驱动间的映射能满足在设置最大亮度时驱动能调到对应值...
Android Light开发（一）
欢迎加入Android老司机学院 482266514（技术交流群）密码CSDN
03-19 5049
Light源码 public abstract class Light { public static final int LIGHT_FLASH_NONE = 0; public static final int LIGHT_FLASH_TIMED = 1; public static final int LIGHT_FLASH_HARDWARE = 2; /
Android Lights笔记
Run for the future!
12-15 2387
Android Lights1、lights类型在Android中目前定义的lights有以下的几种。/* * These light IDs correspond to logical lights, not physical. * So for example, if your INDICATOR light is in line with your * BUTTONS, it might make sense to also light the INDICATOR * light to a reaso
android.hardware.light
05-17
android.hardware.light 是 Android 系统中的一个硬件抽象层，用于控制设备上的 LED 灯。通过该 API，应用程序可以控制设备上的 LED 灯的亮度和颜色，以及设置 LED 灯的闪烁频率。 使用 android.hardware.light API 首先需要通过 getSystemService() 方法获取一个 LightManager 对象。然后，可以使用 LightManager 对象的 setLightBrightness()、setLightColor()、setLightFlashing() 等方法来控制 LED 灯的行为。 需要注意的是，android.hardware.light API 并不保证在所有设备上都能正常运行。因此，在使用该 API 时，应该首先检查设备是否支持该 API，并且尽可能地进行兼容性测试。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值