android（linux） 背光流程

最新推荐文章于 2022-05-29 20:44:31 发布
转载 最新推荐文章于 2022-05-29 20:44:31 发布 · 815 阅读 · 0

本文深入解析了Android系统中屏幕亮度调节的技术实现，从上层应用到底层硬件接口，包括PowerManagerService如何设置亮度，JNI层如何与底层通信，以及底层硬件如何响应这些设置。
1. 上层处理

PowerManagerService.java (frameworks\base\services\java\com\android\server)


[java] view plain copy print ?
  1. private LightsService.Light mLcdLight; 
  2.  
  3.     private void setLightBrightness(int mask, int value) { 
  4.         int brightnessMode = (mAutoBrightessEnabled 
  5.                             ? LightsService.BRIGHTNESS_MODE_SENSOR 
  6.                             : LightsService.BRIGHTNESS_MODE_USER); 
  7.         if ((mask & SCREEN_BRIGHT_BIT) != 0) { 
  8.             if (DEBUG_SCREEN_ON) { 
  9.                 RuntimeException e = new RuntimeException("here"); 
  10.                 e.fillInStackTrace(); 
  11.                 Slog.i(TAG, "Set LCD brightness: " + value, e); 
  12.             } 
  13.             mLcdLight.setBrightness(value, brightnessMode); 
  14.         } 
  15.         if ((mask & BUTTON_BRIGHT_BIT) != 0) { 
  16.             mButtonLight.setBrightness(value); 
  17.         } 
  18.         if ((mask & KEYBOARD_BRIGHT_BIT) != 0) { 
  19.             mKeyboardLight.setBrightness(value); 
  20.         } 
  21.     }  
private LightsService.Light mLcdLight;

    private void setLightBrightness(int mask, int value) {
        int brightnessMode = (mAutoBrightessEnabled
                            ? LightsService.BRIGHTNESS_MODE_SENSOR
                            : LightsService.BRIGHTNESS_MODE_USER);
        if ((mask & SCREEN_BRIGHT_BIT) != 0) {
            if (DEBUG_SCREEN_ON) {
                RuntimeException e = new RuntimeException("here");
                e.fillInStackTrace();
                Slog.i(TAG, "Set LCD brightness: " + value, e);
            }
            mLcdLight.setBrightness(value, brightnessMode);
        }
        if ((mask & BUTTON_BRIGHT_BIT) != 0) {
            mButtonLight.setBrightness(value);
        }
        if ((mask & KEYBOARD_BRIGHT_BIT) != 0) {
            mKeyboardLight.setBrightness(value);
        }
    }

LightsService.java (frameworks\base\services\java\com\android\server)

[java] view plain copy print ?
  1. public void setBrightness(int brightness, int brightnessMode) { 
  2.     synchronized (this) { 
  3.         int color = brightness & 0x000000ff; 
  4.         color = 0xff000000 | (color << 16) | (color << 8) | color; 
  5.         setLightLocked(color, LIGHT_FLASH_NONE, 0, 0, brightnessMode); 
  6.     } 
  7. } 
  8.  
  9. private void setLightLocked(int color, int mode, int onMS, int offMS, int brightnessMode) { 
  10.     if (color != mColor || mode != mMode || onMS != mOnMS || offMS != mOffMS) { 
  11.         if (DEBUG) Slog.v(TAG, "setLight #" + mId + ": color=#" 
  12.                 + Integer.toHexString(color)); 
  13.         mColor = color; 
  14.         mMode = mode; 
  15.         mOnMS = onMS; 
  16.         mOffMS = offMS; 
  17.         setLight_native(mNativePointer, mId, color, mode, onMS, offMS, brightnessMode); 
  18.     } 
  19. }  
        public void setBrightness(int brightness, int brightnessMode) {
            synchronized (this) {
                int color = brightness & 0x000000ff;
                color = 0xff000000 | (color << 16) | (color << 8) | color;
                setLightLocked(color, LIGHT_FLASH_NONE, 0, 0, brightnessMode);
            }
        }

        private void setLightLocked(int color, int mode, int onMS, int offMS, int brightnessMode) {
            if (color != mColor || mode != mMode || onMS != mOnMS || offMS != mOffMS) {
                if (DEBUG) Slog.v(TAG, "setLight #" + mId + ": color=#"
                        + Integer.toHexString(color));
                mColor = color;
                mMode = mode;
                mOnMS = onMS;
                mOffMS = offMS;
                setLight_native(mNativePointer, mId, color, mode, onMS, offMS, brightnessMode);
            }
        }

2. JNI 处理

com_android_server_LightsService.cpp（/framework/base/services/jni/）


[cpp] view plain copy print ?
  1. static JNINativeMethod method_table[] = {   
  2.     { "init_native", "()I", (void*)init_native },   
  3.     { "finalize_native", "(I)V", (void*)finalize_native },   
  4.     { "setLight_native", "(IIIIIII)V", (void*)setLight_native },    
static JNINativeMethod method_table[] = {  
    { "init_native", "()I", (void*)init_native },  
    { "finalize_native", "(I)V", (void*)finalize_native },  
    { "setLight_native", "(IIIIIII)V", (void*)setLight_native },

[cpp] view plain copy print ?
  1. static light_device_t* get_device(hw_module_t* module, char const* name)   
  2. {   
  3.     int err;   
  4.     hw_device_t* device;   
  5.     err = module->methods->open(module, name, &device);   
  6.     if (err == 0) {   
  7.         return (light_device_t*)device;   
  8.     } else {   
  9.         return NULL;   
  10.     }   
  11. }   
  12.    
  13. static jint init_native(JNIEnv *env, jobject clazz)   
  14. {   
  15.     int err;   
  16.     hw_module_t* module;   
  17.     Devices* devices;   
  18.        
  19.     devices = (Devices*)malloc(sizeof(Devices));   
  20.    
  21.     err = hw_get_module(LIGHTS_HARDWARE_MODULE_ID, (hw_module_t const**)&module);   
  22.     if (err == 0) {   
  23.         devices->lights[LIGHT_INDEX_BACKLIGHT]   
  24.                 = get_device(module, LIGHT_ID_BACKLIGHT);   
  25.         devices->lights[LIGHT_INDEX_KEYBOARD]   
  26.                 = get_device(module, LIGHT_ID_KEYBOARD);   
  27.         devices->lights[LIGHT_INDEX_BUTTONS]   
  28.                 = get_device(module, LIGHT_ID_BUTTONS);   
  29.         devices->lights[LIGHT_INDEX_BATTERY]   
  30.                 = get_device(module, LIGHT_ID_BATTERY);   
  31.         devices->lights[LIGHT_INDEX_NOTIFICATIONS]   
  32.                 = get_device(module, LIGHT_ID_NOTIFICATIONS);   
  33.         devices->lights[LIGHT_INDEX_ATTENTION]   
  34.                 = get_device(module, LIGHT_ID_ATTENTION);   
  35.         devices->lights[LIGHT_INDEX_BLUETOOTH]   
  36.                 = get_device(module, LIGHT_ID_BLUETOOTH);   
  37.         devices->lights[LIGHT_INDEX_WIFI]   
  38.                 = get_device(module, LIGHT_ID_WIFI);   
  39.     } else {   
  40.         memset(devices, 0, sizeof(Devices));   
  41.     }   
  42.    
  43.     return (jint)devices;   
  44. }   
  45.    
  46.     
  47.    
  48. static void setLight_native(JNIEnv *env, jobject clazz, int ptr,   
  49.         int light, int colorARGB, int flashMode, int onMS, int offMS, int brightnessMode)   
  50. {   
  51.     Devices* devices = (Devices*)ptr;   
  52.     light_state_t state;   
  53.    
  54.     if (light < 0 || light >= LIGHT_COUNT || devices->lights[light] == NULL) {   
  55.         return ;   
  56.     }   
  57.    
  58.     memset(&state, 0, sizeof(light_state_t));   
  59.     state.color = colorARGB;   
  60.     state.flashMode = flashMode;   
  61.     state.flashOnMS = onMS;   
  62.     state.flashOffMS = offMS;   
  63.     state.brightnessMode = brightnessMode;   
  64.    
  65.     devices->lights[light]->set_light(devices->lights[light], &state);   
  66. }  
static light_device_t* get_device(hw_module_t* module, char const* name)  
{  
    int err;  
    hw_device_t* device;  
    err = module->methods->open(module, name, &device);  
    if (err == 0) {  
        return (light_device_t*)device;  
    } else {  
        return NULL;  
    }  
}  
  
static jint init_native(JNIEnv *env, jobject clazz)  
{  
    int err;  
    hw_module_t* module;  
    Devices* devices;  
      
    devices = (Devices*)malloc(sizeof(Devices));  
  
    err = hw_get_module(LIGHTS_HARDWARE_MODULE_ID, (hw_module_t const**)&module);  
    if (err == 0) {  
        devices->lights[LIGHT_INDEX_BACKLIGHT]  
                = get_device(module, LIGHT_ID_BACKLIGHT);  
        devices->lights[LIGHT_INDEX_KEYBOARD]  
                = get_device(module, LIGHT_ID_KEYBOARD);  
        devices->lights[LIGHT_INDEX_BUTTONS]  
                = get_device(module, LIGHT_ID_BUTTONS);  
        devices->lights[LIGHT_INDEX_BATTERY]  
                = get_device(module, LIGHT_ID_BATTERY);  
        devices->lights[LIGHT_INDEX_NOTIFICATIONS]  
                = get_device(module, LIGHT_ID_NOTIFICATIONS);  
        devices->lights[LIGHT_INDEX_ATTENTION]  
                = get_device(module, LIGHT_ID_ATTENTION);  
        devices->lights[LIGHT_INDEX_BLUETOOTH]  
                = get_device(module, LIGHT_ID_BLUETOOTH);  
        devices->lights[LIGHT_INDEX_WIFI]  
                = get_device(module, LIGHT_ID_WIFI);  
    } else {  
        memset(devices, 0, sizeof(Devices));  
    }  
  
    return (jint)devices;  
}  
  
   
  
static void setLight_native(JNIEnv *env, jobject clazz, int ptr,  
        int light, int colorARGB, int flashMode, int onMS, int offMS, int brightnessMode)  
{  
    Devices* devices = (Devices*)ptr;  
    light_state_t state;  
  
    if (light < 0 || light >= LIGHT_COUNT || devices->lights[light] == NULL) {  
        return ;  
    }  
  
    memset(&state, 0, sizeof(light_state_t));  
    state.color = colorARGB;  
    state.flashMode = flashMode;  
    state.flashOnMS = onMS;  
    state.flashOffMS = offMS;  
    state.brightnessMode = brightnessMode;  
  
    devices->lights[light]->set_light(devices->lights[light], &state);  
}

3. 底层处理

Lights.c (device\marvell\***\lights)

[cpp] view plain copy print ?
  1. const char * const LCD_BACKLIGHT = "/sys/class/backlight/pwm-backlight.2/brightness";   
  2. static int lights_device_open(const struct hw_module_t *module,   
  3.                 const char *name, struct hw_device_t **device);   
  4.    
  5. static struct hw_module_methods_t lights_module_methods = {   
  6.     .open      = lights_device_open   
  7. };   
  8.    
  9. struct light_module_t   
  10. {   
  11.     struct hw_module_t common;   
  12. };   
  13.    
  14. const struct light_module_t HAL_MODULE_INFO_SYM = {   
  15.     common: {   
  16.         tag : HARDWARE_MODULE_TAG,   
  17.         version_major : 1,   
  18.         version_minor : 0,   
  19.         id : LIGHTS_HARDWARE_MODULE_ID,   
  20.         name : "lights module",   
  21.         author : "",   
  22.         methods : &lights_module_methods,   
  23.     }   
  24. };   
  25.    
  26. int lights_set(struct light_device_t* dev, struct light_state_t const* state, const char* brightness_node) {   
  27.     struct light_state_t const *light_state = (struct light_state_t const*)state;   
  28.     unsigned char brightness = 0;   
  29.     int fd = -1;   
  30.     struct my_light_device_t *mydev = (struct my_light_device_t*)dev;   
  31.     if( light_state ) {   
  32.         unsigned int color = light_state->color;   
  33.         brightness = (color & 0xff) * mydev->max_brightness / 0xff;   
  34.     } else {   
  35.         LOGE("lights_set_brightness failed: light state is null\n");   
  36.         return -EINVAL;   
  37.     }   
  38.     fd = open(brightness_node, O_RDWR);   
  39.     if( fd >= 0 ) {   
  40.         char buffer[20];   
  41.         int bytes = sprintf(buffer, "%d", brightness);   
  42.         int rlt = write(fd, buffer, bytes);   
  43.         if( rlt < 0 ){   
  44.             LOGE("lights_set_brightness %s, fail to set brightness to:%s, errno:%d\n", brightness_node, buffer, errno);    
  45.             close(fd);   
  46.             return -1;   
  47.         }   
  48.         close(fd);   
  49.     } else {   
  50.         static int already_warned = 0;   
  51.         if (already_warned < 5) {   
  52.             LOGE("lights_set_brightness failed to open %s, errno:%d\n", brightness_node, errno);   
  53.             already_warned++;   
  54.         }   
  55.         return -1;   
  56.     }   
  57.     return 0;   
  58. }   
  59. int lights_set_lcd(struct light_device_t* dev, struct light_state_t const* state)   
  60. {   
  61.     return lights_set( dev, state, LCD_BACKLIGHT);   
  62. }   
  63.    
  64. static int lights_device_open(const struct hw_module_t *module,   
  65.                 const char *name, struct hw_device_t **device)   
  66. {   
  67.     int status = -EINVAL;   
  68.     int ret;   
  69. #ifdef LIGHTS_DEBUG   
  70.     LOGD("lights_device_open: device name: %s\n", name);   
  71. #endif   
  72.    
  73.     struct light_device_t *dev = NULL;   
  74.     struct my_light_device_t *mydev = NULL;   
  75.        
  76.     mydev = (struct my_light_device_t *)calloc(sizeof(struct my_light_device_t), 1);   
  77.     dev = &(mydev->dev);   
  78.     dev->common.tag = HARDWARE_DEVICE_TAG;   
  79.     dev->common.version = 0;   
  80.     dev->common.module = (struct hw_module_t *)(module);   
  81.     dev->common.close = lights_device_close;   
  82.    
  83.     mydev->max_brightness = 0xff;//default max brightness is 255   
  84.            
  85.     *device = &dev->common;   
  86.        
  87.     if (!strcmp(name, LIGHT_ID_BACKLIGHT)) {   
  88.         dev->set_light = lights_set_lcd;   
  89.         readIntFromFile( LCD_MAX_BACKLIGHT, &mydev->max_brightness);   
  90.         ret = access(LCD_BACKLIGHT, F_OK);   
  91.         if (ret != 0)   
  92.             return status;   
  93.     } else if (!strcmp(name, LIGHT_ID_KEYBOARD)) {   
  94.         dev->set_light = lights_set_keyboard;   
  95.         readIntFromFile( KEYBOARD_MAX_BACKLIGHT, &mydev->max_brightness);   
  96.         ret = access(KEYBOARD_BACKLIGHT, F_OK);   
  97.         if (ret != 0)   
  98.             return status;   
  99.     } else if (!strcmp(name, LIGHT_ID_BUTTONS)) {   
  100.         dev->set_light = lights_set_button;   
  101.         ret = access(BUTTON_BACKLIGHT, F_OK);   
  102.         if (ret != 0)   
  103.             return status;   
  104.     } else if (!strcmp(name, LIGHT_ID_BATTERY)) {   
  105.         dev->set_light = lights_set_battery;   
  106.         ret = access(BATTERY_BACKLIGHT, F_OK);   
  107.         if (ret != 0)   
  108.             return status;   
  109.     } else if (!strcmp(name, LIGHT_ID_NOTIFICATIONS)) {   
  110.         dev->set_light = lights_set_notifications;   
  111.         ret = access(NOTIFICATIONS_BACKLIGHT, F_OK);   
  112.         if (ret != 0)   
  113.             return status;   
  114.     } else if (!strcmp(name, LIGHT_ID_ATTENTION)) {   
  115.         dev->set_light = lights_set_attention;   
  116.         ret = access(ATTENTION_BACKLIGHT, F_OK);   
  117.         if (ret != 0)   
  118.             return status;   
  119.     } else   
  120.         return status;   
  121.        
  122.     return 0;   
  123. }    
const char * const LCD_BACKLIGHT = "/sys/class/backlight/pwm-backlight.2/brightness";  
static int lights_device_open(const struct hw_module_t *module,  
                const char *name, struct hw_device_t **device);  
  
static struct hw_module_methods_t lights_module_methods = {  
    .open      = lights_device_open  
};  
  
struct light_module_t  
{  
    struct hw_module_t common;  
};  
  
const struct light_module_t HAL_MODULE_INFO_SYM = {  
    common: {  
        tag : HARDWARE_MODULE_TAG,  
        version_major : 1,  
        version_minor : 0,  
        id : LIGHTS_HARDWARE_MODULE_ID,  
        name : "lights module",  
        author : "",  
        methods : &lights_module_methods,  
    }  
};  
  
int lights_set(struct light_device_t* dev, struct light_state_t const* state, const char* brightness_node) {  
    struct light_state_t const *light_state = (struct light_state_t const*)state;  
    unsigned char brightness = 0;  
    int fd = -1;  
    struct my_light_device_t *mydev = (struct my_light_device_t*)dev;  
    if( light_state ) {  
        unsigned int color = light_state->color;  
        brightness = (color & 0xff) * mydev->max_brightness / 0xff;  
    } else {  
        LOGE("lights_set_brightness failed: light state is null\n");  
        return -EINVAL;  
    }  
    fd = open(brightness_node, O_RDWR);  
    if( fd >= 0 ) {  
        char buffer[20];  
        int bytes = sprintf(buffer, "%d", brightness);  
        int rlt = write(fd, buffer, bytes);  
        if( rlt < 0 ){  
            LOGE("lights_set_brightness %s, fail to set brightness to:%s, errno:%d\n", brightness_node, buffer, errno);   
            close(fd);  
            return -1;  
        }  
        close(fd);  
    } else {  
        static int already_warned = 0;  
        if (already_warned < 5) {  
            LOGE("lights_set_brightness failed to open %s, errno:%d\n", brightness_node, errno);  
            already_warned++;  
        }  
        return -1;  
    }  
    return 0;  
}  
int lights_set_lcd(struct light_device_t* dev, struct light_state_t const* state)  
{  
    return lights_set( dev, state, LCD_BACKLIGHT);  
}  
  
static int lights_device_open(const struct hw_module_t *module,  
                const char *name, struct hw_device_t **device)  
{  
    int status = -EINVAL;  
    int ret;  
#ifdef LIGHTS_DEBUG  
    LOGD("lights_device_open: device name: %s\n", name);  
#endif  
  
    struct light_device_t *dev = NULL;  
    struct my_light_device_t *mydev = NULL;  
      
    mydev = (struct my_light_device_t *)calloc(sizeof(struct my_light_device_t), 1);  
    dev = &(mydev->dev);  
    dev->common.tag = HARDWARE_DEVICE_TAG;  
    dev->common.version = 0;  
    dev->common.module = (struct hw_module_t *)(module);  
    dev->common.close = lights_device_close;  
  
    mydev->max_brightness = 0xff;//default max brightness is 255  
          
    *device = &dev->common;  
      
    if (!strcmp(name, LIGHT_ID_BACKLIGHT)) {  
        dev->set_light = lights_set_lcd;  
        readIntFromFile( LCD_MAX_BACKLIGHT, &mydev->max_brightness);  
        ret = access(LCD_BACKLIGHT, F_OK);  
        if (ret != 0)  
            return status;  
    } else if (!strcmp(name, LIGHT_ID_KEYBOARD)) {  
        dev->set_light = lights_set_keyboard;  
        readIntFromFile( KEYBOARD_MAX_BACKLIGHT, &mydev->max_brightness);  
        ret = access(KEYBOARD_BACKLIGHT, F_OK);  
        if (ret != 0)  
            return status;  
    } else if (!strcmp(name, LIGHT_ID_BUTTONS)) {  
        dev->set_light = lights_set_button;  
        ret = access(BUTTON_BACKLIGHT, F_OK);  
        if (ret != 0)  
            return status;  
    } else if (!strcmp(name, LIGHT_ID_BATTERY)) {  
        dev->set_light = lights_set_battery;  
        ret = access(BATTERY_BACKLIGHT, F_OK);  
        if (ret != 0)  
            return status;  
    } else if (!strcmp(name, LIGHT_ID_NOTIFICATIONS)) {  
        dev->set_light = lights_set_notifications;  
        ret = access(NOTIFICATIONS_BACKLIGHT, F_OK);  
        if (ret != 0)  
            return status;  
    } else if (!strcmp(name, LIGHT_ID_ATTENTION)) {  
        dev->set_light = lights_set_attention;  
        ret = access(ATTENTION_BACKLIGHT, F_OK);  
        if (ret != 0)  
            return status;  
    } else  
        return status;  
      
    return 0;  
}

Linux/Android背光控制
OneSea的专栏
04-28 663
0 前言 本文重点介绍目前主流Linux发行版，Android版本的屏幕背光控制原理和实现。 1 正文 更新中。。。 参考资料
Android4.4 背光亮度最低设置
程序人生
05-16 3846
在android中可能出现这样一种不友好的现象，当用户选择自动调整屏幕亮度或者将屏幕亮度调整为最小时，系统整个屏幕都黑了。 完全不知道这么解决？ 有两种解决办法： 1. 在android中设置用户能够设置的最低亮度。 diff --git a/frameworks/base/core/res/res/values/config.xml b/frameworks/base/core/res/
Android Telechips89xx背光控制流程
dadahacker的笔记
03-22 3059
<br />Android Telechips89xx背光控制流程<br /> Rocky@20110322<br /><br /> 这里我们以Telechips89xx背光控制来示例讲解一下Android2.1下的背光控制。<br /><br /> 这个分成几个部分：<br /><br /> *********************************************<br /> 应用层调用<br /> Framework层<br /> Hardwa
linux 背光驱动程序,Android 背光驱动
weixin_39638647的博客
05-09 184
Android里，自带的背光亮度调节，会调用哪个接口？会调用/sys/class/leds/lcd-backlight/brightness而这个brightness节点，是如何声明的呢请看LED驱动里的这么一句static DEVICE_ATTR(brightness, /*NAME*/0644, /*权限*/led_brightness_show, /*Read Point*/led_brig...
Android屏幕背光调整机制
wince--linux的专栏
06-26 836
扩展一个硬件（比如LED、蓝牙、传感器等），至少需要硬件、驱动、驱动交互模块。至于系统的层面如何把系统库加入自己的体系里面去，就是操作系统自己的事了。这里分析一下以背光调整为例Android。 源码在这里： flying_2011.6.211.zip (14.47 KB, 下载次数: 35) 2011-8-26 14:28 上传 点击文件名下载附件 下载积分:
debug00:详解Genymotion模拟器“Could not open ‘/sys/class/power_supply/genymotion_fake_path/present‘”原因及破解
MobGapDev
10-11 7817
无法部署自己的APP到genymotion模拟器上，报错提示是
android休眠与唤醒驱动流程分析.doc
02-23
Android 休眠与唤醒驱动流程分析 Android 休眠与唤醒驱动流程分析是 Android 系统中的一部分，主要负责控制系统的休眠和唤醒过程。该过程是基于 Linux 内核的电源管理设计，但Android 对其进行了修改和优化，以适应...
android 休眠唤醒驱动流程分析,Android 电源管理——gotosleep和userActivity关注
weixin_34684880的博客
05-25 904
一、Android power management应用层分析Android提供了android.os.PowerManager类,该类用于控制设备的电源状态的切换.该类对外有三个接口函数:1、void goToSleep(long time);强制设备进入Sleep状态要注意权限问题。2、newWakeLock(int flags, String tag);取得相应层次的锁flags参数说明:P...
立即优化Android 10.0 背光响应：8个实用技巧
[Android 10.0 自动背光调节流程.pdf](https://opengraph.githubassets.com/7085f6fe8117903a2a6eb03b6707efa9dadfac6e73b90b55a361c7c701f4d4dd/osebin/android-light-sensor) # 摘要 随着Android 10.0的发布，其...
基于Android P 背光流程
TSK_Amine的博客
07-03 1188
一、SystemUI、Settings中手动调节 /frameworks/base/packages/SystemUI/src/com/android/systemui/settings/BrightnessController.java @Override public void onChanged(ToggleSlider toggleSlider, boolean tracking, boolean automatic, int value, boolean stopTrackin
App读写文件节点配置Se linux权限
苏法迪的专栏
06-27 3536
0.文章参考 https://blog.youkuaiyun.com/xiaoxiangyuhai/article/details/76270294 https://blog.youkuaiyun.com/u014341735/article/details/51244258 1. 需求 App 中进行读写Linux下的文件节点 /sys/class/power_supply/battery/coulomb_cou...
"Could not open '/sys/class/power_supply/genymotion_fake_path/present'
Xiehaiping_的博客
06-03 1286
相信大家在开始使用Genymotion的时候都遇到这样的问题 "Could not open '/sys/class/power_supply/genymotion_fake_path/present'  解决这样的问题，第一种办法： 下载一个Genymotion-ARM-Translation_v1.1.zip 拖拽到你的genymotion的模拟器窗口里面，按照提示点击ok即可
Android原生调节屏幕背光流程
huiming_hou
08-16 5688
Android 5.1调节背光流程 目录 1、启动相关服务(PMS,LightService,DMS) 2、背光修改Code执行流程 3、背光调整框架图 4、如何通过log分析设备界面背光调节无效问题 具体分析 1、启动相关服务(PMS,LightService,DMS) 1.1 主机开机，在启动SystemServer进程时，会启动电源和背光等相关服务； 启动PMS服务之后，里面调用AMS的in...
LightsService分析 --- 流程分析
Jack的博客
11-26 1062
2.2 控制流程分析 2.2.1 LightsService服务启动流程 LightsService是从SystemServer中启动的，在运行SystemServer的run()方法时会启动所有必须的系统服务， 这其中就包含用来控制LED灯以及屏幕背光的LightsService，在SystemServer中启动服务: private void startBootstrapService
Android 灯带功能开发 基与Android N 过gms认证
Mis_wenwen的博客
03-26 2362
之前公司安排一个灯带的功能让开发。现在整理下，针对开发过程中碰到的一些问题提出来分享一下。大家可以根据目录来选择性的查看。最终效果图：真机图：客户基本需求：蓝灯：开机亮屏时显示绿灯：来电时闪烁黄灯：有未接来电时闪烁粉灯：有未读消息或未读短信时闪烁红灯：低电量时闪烁UI显示：Settings一级菜单新增灯效item，并新增对应二级菜单扩展功能：静音模式下关闭灯效时刻表范围内关闭灯效灯带定时关闭 简述...
电池报警温度客制化
chylovecsd的博客
05-25 2159
电池报警温度客制化 https://www.jianshu.com/p/2d1d83c4aab8/ 1. LK启动阶段，有些平台会显示CHARGER_OV_INDEX \vendor\mediatek\proprietary\bootable\bootloader\lk\dev\logo\rules.mk 1 2 3 4 5 RESOURCE_OBJ_LIST+=\ $(BOOT_LOGO_DIR)/$...
09.mtk背光流程
chylovecsd的博客
05-29 1248
基于 Light 介绍安卓 8.0 HAL 变化 /frameworks/base/services/core/java/com/android/server/lights/LightsService.java 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 .
2021-03-02 Linux C语言读写节点代码-读写背光值brightness为例
海月汐辰
03-02 1866
Linux C语言读写节点代码-读写背光值brightness为例 一、adb 读写背光节点 /sys/class/backlight/backlight/brightness 二、C语言读写该节点代码。 static int write_int(char const *path, int value) { int fd; static int already_warned; already_warned = 0; LO...
Android电源管理系统详解
Android电源管理框架基于Linux内核，并且结合了Android特有的服务和守护进程来实现。 1. Android电源管理概述 1.1 简介 Android电源管理系统（Power Management System，PMS）主要负责监控和控制设备的各种电源...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值