android（linux） 背光流程

最新推荐文章于 2021-05-26 16:13:23 发布
最新推荐文章于 2021-05-26 16:13:23 发布
阅读量745 收藏
点赞数
分类专栏： Linux backlight子系统
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;  
}

sir_zeng
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux/Android背光控制
OneSea的专栏
04-28 561
0 前言 本文重点介绍目前主流Linux发行版，Android版本的屏幕背光控制原理和实现。 1 正文 更新中。。。 参考资料
Android4.4 背光亮度最低设置
程序人生
05-16 3708
在android中可能出现这样一种不友好的现象，当用户选择自动调整屏幕亮度或者将屏幕亮度调整为最小时，系统整个屏幕都黑了。 完全不知道这么解决？ 有两种解决办法： 1. 在android中设置用户能够设置的最低亮度。 diff --git a/frameworks/base/core/res/res/values/config.xml b/frameworks/base/core/res/
Android Telechips89xx背光控制流程
dadahacker的笔记
03-22 2937
<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 120
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 759
扩展一个硬件（比如LED、蓝牙、传感器等），至少需要硬件、驱动、驱动交互模块。至于系统的层面如何把系统库加入自己的体系里面去，就是操作系统自己的事了。这里分析一下以背光调整为例Android。 源码在这里： flying_2011.6.211.zip (14.47 KB, 下载次数: 35) 2011-8-26 14:28 上传 点击文件名下载附件 下载积分:
App读写文件节点配置Se linux权限
苏法迪的专栏
06-27 3269
0.文章参考 https://blog.csdn.net/xiaoxiangyuhai/article/details/76270294 https://blog.csdn.net/u014341735/article/details/51244258 1. 需求 App 中进行读写Linux下的文件节点 /sys/class/power_supply/battery/coulomb_cou...
android休眠与唤醒驱动流程分析.doc
02-23
Android 休眠与唤醒驱动流程分析 Android 休眠与唤醒驱动流程分析是 Android 系统中的一部分，主要负责控制系统的休眠和唤醒过程。该过程是基于 Linux 内核的电源管理设计，但Android 对其进行了修改和优化，以适应...
android 休眠唤醒驱动流程分析,Android 电源管理——gotosleep和userActivity关注
weixin_34684880的博客
05-25 716
一、Android power management应用层分析Android提供了android.os.PowerManager类,该类用于控制设备的电源状态的切换.该类对外有三个接口函数:1、void goToSleep(long time);强制设备进入Sleep状态要注意权限问题。2、newWakeLock(int flags, String tag);取得相应层次的锁flags参数说明:P...
Android 系统背光设置
tq501501的博客
01-07 5106
1、设置背光 // 修改当前Activity界面的窗口亮度 private void setScreenLight(int brightness) { WindowManager.LayoutParams lp = getWindow().getAttributes(); lp.screenBrightness = Float.valueOf(brightness) * (1f / 255f); getWindow().setAttributes(lp); } // 修改系统的
解决Genymotion报错：Could not open '/sys/class/power_supply/genymotion_fake_path/present'
莫负青春取自惭
06-07 2452
Genymotion模拟器速度比较流畅，比较不错，推荐使用。 在Android Studio控制台一直打印那个错误，虽然不影响使用，不过Error还是碍眼啊~查到2个解决办法， - 第一种： 下载一个Genymotion-ARM-Translation_v1.1.zip - 第二种：修改AndroidMainfest.xml 在添加一行这个:android:installLocation
Android & linux充电模块分析
大帅的博客
05-26 2346
核心模块是 drivers/power/supply/power_supply_core.c drivers/power/supply/power_supply_leds.c drivers/power/supply/power_supply_fysfs.c 模块入口函数在power_supply_core.c中 subsys_initcall(power_supply_class_init); 提前于驱动模块的加载。 // drivers/power/supply/power_supply_core.
1.[Lights]-(Android 8.1 lights分析)
大王来巡山
11-06 662
lightsService 注册: 路径：frameworks/base/services/java/com/android/server/SystemServer.java // Manages LEDs and display backlight so we need it to bring up the display. traceBeginAndSlog("...
linux背光子系统(backlight)
热门推荐
yuanlulu的博客
12-27 1万+
(基于linux2.6.34)   概述 ===== linux的背光(backlight)子系统用于在/sys目录下提供用户空间控制LCD或者其他显示设备的背光亮度的接口。这里的亮度并不是亮和灭两个状态，可有很多个等级的亮度，便于用户空间根据节能、可视范围等需求调节背光的亮度。 相关代码 ====== 背光子系统的代码在/driver/video/backlight目录中
Android 系统7.0上 屏幕背光流程分析
风花散却隽世间，雪月寥落化雨田
03-02 1万+
Android 系统 屏幕背光流程分析（未完待续） 概述 自动背光初始化 自动背光的初始化 概述最近关于自动背光的问题报的比较多，多是背光不灵敏以及背光调节不正常的问题，并且自动背光也是直接和用户交互的一个模块，对于用户体验有着最直观的影响，所以在此分析一下关于自动背光模块的处理逻辑，以及小米对于自动背光所作的优化，关于后期优化方案，也希望大家能多多建议。自动背光在android系统中属于displ
修改底层文件，实现修改Android设备屏幕亮度和控制led灯
DvLee
11-27 7609
分享一个很酷的玩法，通过修改Android系统底层文件，实现修改设备屏幕亮度和led灯。 即使没有这个需求，可以作为一种炫技的玩法！！ 1、“adb shell” 进入系统目录 2、“adb root” 获取root权限； 3、进入该目录 “/sys/class/leds/lcd-backlight/”，目录下“brightness”即为屏幕亮度数值，可以通过命令“cat
Android自动背光调节机制分析
wcsbhwy的博客
05-25 1万+
文章目录1. 手动背光调节1.1 在Settings/SystemUI中手动调节2.自适应背光调节2.1 类架构2.2 创建背光样条曲线2.3.AutomaticBrightnessController的初始化2.4 AutomaticBrightnessController的配置2.4.1 setBrightnessConfiguration():2.4.2 setDisplayPolicy()2.4.3 setAutoBrightnessAdjustment()2.4.4 setScreenBright
Android4.4 平板背光设置
zhujm320的专栏
11-12 2385
对于平板来说，设置背光对于省点来说比较重要。本文从应用层到内核层讲解系统是如何成功的设置背光的。设置背光，本质上是调节LCD的电压，达到对亮度的控制，Framework层的一系列的接口都是kernel层gpio操作的层层封装和相应的管理。      对于app来说亮度的控制如下:         /* *  关闭自动调节亮度，改为手动调节亮度 */       public static
android自动调节屏幕亮度自动调节流程解析
mmdev
11-22 1870
屏幕亮度自动调节： 主要是从Sensor分析之中分离出来分析LIGHT 光线感应器，因此就分析一下自动调节屏幕亮度（手机随着光线的强度自我调节，也就是在亮的光线下屏幕自动调亮一些，暗的时候就自动调暗一些，省得光线对眼睛有刺激）..... (本人从历经挫折才大概了解流程)，现在就开始讲一下流程，如果有不对地方希望牛人指出来。。。 先从Sttings入手吧，在diaplay中有屏幕亮...
android原生背光流程，结合代码
最新发布
05-24
Android原生背光流程如下： 1. 系统启动时，加载驱动程序并初始化背光硬件。 2. 在Android系统中，背光控制是通过sysfs节点进行的，所以要获取背光节点，可以使用以下代码： ```java File blFile = new File("/...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值