Android 8.0 led 灯处理流程

最新推荐文章于 2023-04-09 19:21:09 发布
最新推荐文章于 2023-04-09 19:21:09 发布
阅读量1.9k 收藏 1
点赞数
分类专栏： 个人笔记 文章标签： Android8.0 LED
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SeakIsBest/article/details/80578386
版权

1. 灯的定义：LightsManager.java

public abstract class LightsManager {
    public static final int LIGHT_ID_BACKLIGHT = Type.BACKLIGHT;                  //背景灯，即屏幕灯光
    public static final int LIGHT_ID_KEYBOARD = Type.KEYBOARD;                    //键盘灯
    public static final int LIGHT_ID_BUTTONS = Type.BUTTONS;                      //按键灯，BACK，HOME，MENU实体按键的背景灯
    public static final int LIGHT_ID_BATTERY = Type.BATTERY;                      //电池灯，当电量改变时（如低电量），闪烁的灯    
    public static final int LIGHT_ID_NOTIFICATIONS = Type.NOTIFICATIONS;          //通知灯，应用发送通知时，闪烁的灯，和电池灯共用
    public static final int LIGHT_ID_ATTENTION = Type.ATTENTION;                  //警告灯，和电池灯共用
    public static final int LIGHT_ID_BLUETOOTH = Type.BLUETOOTH;
    public static final int LIGHT_ID_WIFI = Type.WIFI;
    public static final int LIGHT_ID_COUNT = Type.COUNT;

    public abstract Light getLight(int id);                                       //其他模块通过此方法获取灯的ID
}

2. 设置灯的属性：Light.java （接口类，实现在LightsService.java）

    public abstract void setBrightness(int brightness);
    public abstract void setBrightness(int brightness, int brightnessMode);
    public abstract void setColor(int color);
    public abstract void setFlashing(int color, int mode, int onMS, int offMS);
    public abstract void pulse();
    public abstract void pulse(int color, int onMS);
    public abstract void turnOff();
    public abstract void setVrMode(boolean enabled);

3. 接收上层的亮灯命令，筛选判断后向HAL层发送命令：LightsService.java

public class LightsService extends SystemService {
    static final String TAG = "LightsService";
    static final boolean DEBUG = false;

    final LightImpl mLights[] = new LightImpl[LightsManager.LIGHT_ID_COUNT];    //定义LightsManager中所有的灯

    private final class LightImpl extends Light {

        private LightImpl(int id) {    以灯的id来区分当前是哪个灯
            mId = id;
        }

        @Override
        public void setBrightness(int brightness) {    //设置亮度
            setBrightness(brightness, BRIGHTNESS_MODE_USER);
        }

        @Override
        public void setBrightness(int brightness, int brightnessMode) {    //设置亮度
            synchronized (this) {
                // LOW_PERSISTENCE cannot be manually set
                if (brightnessMode == BRIGHTNESS_MODE_LOW_PERSISTENCE) {
                    Slog.w(TAG, "setBrightness with LOW_PERSISTENCE unexpected #" + mId +
                            ": brightness=0x" + Integer.toHexString(brightness));
                    return;
                }

                int color = brightness & 0x000000ff;
                color = 0xff000000 | (color << 16) | (color << 8) | color;
                setLightLocked(color, LIGHT_FLASH_NONE, 0, 0, brightnessMode);
            }
        }

        @Override
        public void setColor(int color) {    //设置颜色
            synchronized (this) {
                setLightLocked(color, LIGHT_FLASH_NONE, 0, 0, 0);
            }
        }

        @Override
        public void setFlashing(int color, int mode, int onMS, int offMS) {    //设置亮灯属性
            synchronized (this) {
                setLightLocked(color, mode, onMS, offMS, BRIGHTNESS_MODE_USER);
            }
        }

        @Override
        public void pulse() {    //闪烁亮灯
            pulse(0x00ffffff, 7);
        }

        @Override
        public void pulse(int color, int onMS) {    //闪烁亮灯，可设置颜色和亮起的时间
            synchronized (this) {
                if (mColor == 0 && !mFlashing) {
                    setLightLocked(color, LIGHT_FLASH_HARDWARE, onMS, 1000,
                            BRIGHTNESS_MODE_USER);
                    mColor = 0;
                    mH.sendMessageDelayed(Message.obtain(mH, 1, this), onMS);
                }
            }
        }

        @Override
        public void turnOff() {    //关灯
            synchronized (this) {
                setLightLocked(0, LIGHT_FLASH_NONE, 0, 0, 0);
            }
        }

        @Override
        public void setVrMode(boolean enabled) {
            synchronized (this) {
                if (mVrModeEnabled != enabled) {
                    mVrModeEnabled = enabled;

                    mUseLowPersistenceForVR =
                            (getVrDisplayMode() == Settings.Secure.VR_DISPLAY_MODE_LOW_PERSISTENCE);
                    if (shouldBeInLowPersistenceMode()) {
                        mLastBrightnessMode = mBrightnessMode;
                    }

                    // NOTE: We do not trigger a call to setLightLocked here.  We do not know the
                    // current brightness or other values when leaving VR so we avoid any incorrect
                    // jumps. The code that calls this method will immediately issue a brightness
                    // update which is when the change will occur.
                }
            }
        }

        private void stopFlashing() {    
            synchronized (this) {
                setLightLocked(mColor, LIGHT_FLASH_NONE, 0, 0, BRIGHTNESS_MODE_USER);
            }
        }

        private void setLightLocked(int color, int mode, int onMS, int offMS, int brightnessMode) {    //以上所有方法都是调用的此方法
            if (shouldBeInLowPersistenceMode()) {
                brightnessMode = BRIGHTNESS_MODE_LOW_PERSISTENCE;
            } else if (brightnessMode == BRIGHTNESS_MODE_LOW_PERSISTENCE) {
                brightnessMode = mLastBrightnessMode;
            }
            //如果传来的参数和上次的参数一样，则不进行任何动作
            if (!mInitialized || color != mColor || mode != mMode || onMS != mOnMS ||
                    offMS != mOffMS || mBrightnessMode != brightnessMode) {
                if (DEBUG) Slog.v(TAG, "setLight #" + mId + ": color=#"
                        + Integer.toHexString(color) + ": brightnessMode=" + brightnessMode);
                //保留这次的参数，用作下次做对比
                mInitialized = true;
                mLastColor = mColor;
                mColor = color;
                mMode = mode;
                mOnMS = onMS;
                mOffMS = offMS;
                mBrightnessMode = brightnessMode;
                Trace.traceBegin(Trace.TRACE_TAG_POWER, "setLight(" + mId + ", 0x"
                        + Integer.toHexString(color) + ")");
                try {
                    //调用HAL层方法（com_android_server_lights_LightsService.cpp），将参数传到底层
                    setLight_native(mId, color, mode, onMS, offMS, brightnessMode);
                } finally {
                    Trace.traceEnd(Trace.TRACE_TAG_POWER);
                }
            }
        }

        private boolean shouldBeInLowPersistenceMode() {
            return mVrModeEnabled && mUseLowPersistenceForVR;
        }

        private int mId;
        private int mColor;
        private int mMode;
        private int mOnMS;
        private int mOffMS;
        private boolean mFlashing;
        private int mBrightnessMode;
        private int mLastBrightnessMode;
        private int mLastColor;
        private boolean mVrModeEnabled;
        private boolean mUseLowPersistenceForVR;
        private boolean mInitialized;
    }

    public LightsService(Context context) {
        super(context);

        for (int i = 0; i < LightsManager.LIGHT_ID_COUNT; i++) {
            mLights[i] = new LightImpl(i);
        }
    }

    @Override
    public void onStart() {
        publishLocalService(LightsManager.class, mService);
    }

    @Override
    public void onBootPhase(int phase) {
    }

    private int getVrDisplayMode() {
        int currentUser = ActivityManager.getCurrentUser();
        return Settings.Secure.getIntForUser(getContext().getContentResolver(),
                Settings.Secure.VR_DISPLAY_MODE,
                /*default*/Settings.Secure.VR_DISPLAY_MODE_LOW_PERSISTENCE,
                currentUser);
    }

    private final LightsManager mService = new LightsManager() {
        @Override
        public Light getLight(int id) {
            if (0 <= id && id < LIGHT_ID_COUNT) {
                return mLights[id];
            } else {
                return null;
            }
        }
    };

    private Handler mH = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            LightImpl light = (LightImpl)msg.obj;
            light.stopFlashing();
        }
    };

    static native void setLight_native(int light, int color, int mode,
            int onMS, int offMS, int brightnessMode);
}

4. HAL层中转信息：com_android_server_lights_LightsService.cpp

static void setLight_native(
        JNIEnv* /* env */,
        jobject /* clazz */,
        jint light,        //上层的id
        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);

    {
        android::base::Timer t;
        Return<Status> ret = hal->setLight(type, state);
        processReturn(ret, type, state);
        if (t.duration() > 50ms) ALOGD("Excessive delay setting light");
    }
}

5. 调用驱动层：lights.c

static int
set_light_backlight(struct light_device_t* dev,
        struct light_state_t const* state)                    //背景灯
{
    int err = 0;
    int brightness = rgb_to_brightness(state);
    pthread_mutex_lock(&g_lock);
    g_backlight = brightness;
    err = write_int(LCD_FILE, brightness);
    if (g_haveTrackballLight) {
        handle_trackball_light_locked(dev);
    }
    pthread_mutex_unlock(&g_lock);
    return err;
}

static int
set_light_keyboard(__attribute__((__unused__)) struct light_device_t* dev,
        struct light_state_t const* state)                    //键盘灯
{
    int err = 0;
    int on = is_lit(state);
    pthread_mutex_lock(&g_lock);
    err = write_int(KEYBOARD_FILE, on?255:0);
    pthread_mutex_unlock(&g_lock);
    return err;
}

static int
set_light_buttons(__attribute__((__unused__)) struct light_device_t* dev,
        struct light_state_t const* state)                       //按键灯
{
    int err = 0;
    int on = is_lit(state);
    pthread_mutex_lock(&g_lock);
    g_buttons = on;
    err = write_int(BUTTON_FILE, on?255:0);
    pthread_mutex_unlock(&g_lock);
    return err;
}

static int
set_speaker_light_locked(__attribute__((__unused__)) struct light_device_t* dev,
        struct light_state_t const* state)            //battery 和 notification 使用的方法
{
    int len;
    int alpha, red, green, blue;
    int onMS, offMS;
    unsigned int colorRGB;

    switch (state->flashMode) {
        case LIGHT_FLASH_TIMED:
            onMS = state->flashOnMS;
            offMS = state->flashOffMS;
            break;
        case LIGHT_FLASH_NONE:
        default:
            onMS = 0;
            offMS = 0;
            break;
    }

    colorRGB = state->color;

#ifdef LIGHTS_DBG_ON
    ALOGD("set_led_state colorRGB=%08X, onMS=%d, offMS=%d\n",
            colorRGB, onMS, offMS);
#endif

    alpha = (colorRGB >> 24) & 0xFF;
    if (alpha) {
    	red = (colorRGB >> 16) & 0xFF;
    	green = (colorRGB >> 8) & 0xFF;
    	blue = colorRGB & 0xFF;
    } else { // alpha = 0 means turn the LED off
    	red = green = blue = 0;
    }

    if (red) {
        ALOGD("wxmled  if (red) ");
        //Redmine112320 wuxiaoming modify for vdf led 2017-12-06 begin        //如果是单色灯，则要去掉其他颜色，不然会报错导致不亮灯
        //blink_green(0, 0, 0);
        //blink_blue(0, 0, 0);
        blink_red(red, onMS, offMS);
    } else {
        ALOGD("wxmled  if (red) else turnOff");
        blink_red(0, 0, 0);
        //blink_blue(0, 0, 0);
        //blink_green(green, onMS, offMS);
    }
    /*
    else if (blue) {
        blink_red(0, 0, 0);
        blink_green(0, 0, 0);
        blink_blue(blue, onMS, offMS);
    }
    else {
        blink_red(0, 0, 0);
        blink_green(0, 0, 0);
        blink_blue(0, 0, 0);
    }*/
    //Redmine112320 wuxiaoming modify for vdf led 2017-12-06 end
    return 0;
}

static void
handle_speaker_battery_locked(struct light_device_t* dev)            //设置电池灯和通知灯的优先级
{
    //Redmine112320 wuxiaoming modify for vdf led 2017-12-06 begin
    ALOGD("wxmled  handle_speaker_battery_locked");
    /*if (is_lit(&g_battery)) {
        set_speaker_light_locked(dev, &g_battery);
    } else {
        set_speaker_light_locked(dev, &g_battery); Turkey workaround: notification and Low battery case, IPO bootup, NLED cannot blink*/
    /*    set_speaker_light_locked(dev, &g_notification);
    }*/
    if (is_lit(&g_notification)) {
        ALOGD("wxmled  handle_speaker_battery_locked g_notification");
        set_speaker_light_locked(dev, &g_notification);
    } else {
        ALOGD("wxmled  handle_speaker_battery_locked g_notification then g_battery");
        set_speaker_light_locked(dev, &g_notification);
        set_speaker_light_locked(dev, &g_battery);
    }
    //Redmine112320 wuxiaoming modify for vdf led 2017-12-06 end
}

static int
set_light_battery(struct light_device_t* dev,
        struct light_state_t const* state)                    //电池灯
{
    pthread_mutex_lock(&g_lock);
    g_battery = *state;
    if (g_haveTrackballLight) {
        set_speaker_light_locked(dev, state);
    }
    handle_speaker_battery_locked(dev);
    pthread_mutex_unlock(&g_lock);
    return 0;
}

static int
set_light_notifications(struct light_device_t* dev,
        struct light_state_t const* state)                    //通知灯
{
    pthread_mutex_lock(&g_lock);
    g_notification = *state;
    ALOGV("set_light_notifications g_trackball=%d color=0x%08x",
            g_trackball, state->color);
    //Redmine112320 wuxiaoming modify for vdf led 2017-12-06 begin
    ALOGD("wxmled  set_light_notifications: g_battery.flashOnMS = %d; flashOffMS = %d", g_battery.flashOnMS, g_battery.flashOffMS);
    if (g_battery.flashOnMS > 0 && g_battery.flashOffMS > 0) {
        ALOGD("wxmled  set_light_notifications: low power, so notification return");
        pthread_mutex_unlock(&g_lock);
        return 0;
    }
    //Redmine112320 wuxiaoming modify for vdf led 2017-12-06 end
    if (g_haveTrackballLight) {
        handle_trackball_light_locked(dev);
    }
    handle_speaker_battery_locked(dev);
    pthread_mutex_unlock(&g_lock);
    return 0;
}

static int
set_light_attention(struct light_device_t* dev,
        struct light_state_t const* state)            //警告灯
{
    pthread_mutex_lock(&g_lock);
    ALOGV("set_light_attention g_trackball=%d color=0x%08x",
            g_trackball, state->color);
    if (state->flashMode == LIGHT_FLASH_HARDWARE) {
        g_attention = state->flashOnMS;
    } else if (state->flashMode == LIGHT_FLASH_NONE) {
        g_attention = 0;
    }
    if (g_haveTrackballLight) {
        handle_trackball_light_locked(dev);
    }
    pthread_mutex_unlock(&g_lock);
    return 0;
}
/**
 * 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)                //初始化动作
{
    ALOGD("wxmled  open_lights");//Redmine112320 wuxiaoming modify for vdf led 2017-12-06
    int (*set_light)(struct light_device_t* dev,
            struct light_state_t const* state);

    if (0 == strcmp(LIGHT_ID_BACKLIGHT, name)) {
        set_light = set_light_backlight;
        if (access(LCD_FILE, F_OK) < 0)
            return -errno;
    }
    else if (0 == strcmp(LIGHT_ID_KEYBOARD, name)) {
        set_light = set_light_keyboard;
        if (access(KEYBOARD_FILE, F_OK) < 0)
            return -errno;
    }
    else if (0 == strcmp(LIGHT_ID_BUTTONS, name)) {
        set_light = set_light_buttons;
        if (access(BUTTON_FILE, F_OK) < 0)
            return -errno;
    }
    else if (0 == strcmp(LIGHT_ID_BATTERY, name)) {
        set_light = set_light_battery;
        if (access(RED_LED_FILE, F_OK) < 0)
            return -errno;
    //Redmine112320 wuxiaoming modify for vdf led 2017-12-06 begin        //如果为单色灯，不要检查其他颜色的文件，不然报错无法亮灯
	/*
        if (access(GREEN_LED_FILE, F_OK) < 0)
            return -errno;
        if (access(BLUE_LED_FILE, F_OK) < 0)
            return -errno;
	*/
    //Redmine112320 wuxiaoming modify for vdf led 2017-12-06 end
    }
    else if (0 == strcmp(LIGHT_ID_NOTIFICATIONS, name)) {
        set_light = set_light_notifications;
        if (access(RED_LED_FILE, F_OK) < 0)
            return -errno;
    //Redmine112320 wuxiaoming modify for vdf led 2017-12-06 begin
	/*
        if (access(GREEN_LED_FILE, F_OK) < 0)
            return -errno;
        if (access(BLUE_LED_FILE, F_OK) < 0)
            return -errno;
	*/
    //Redmine112320 wuxiaoming modify for vdf led 2017-12-06 end
    }
    else if (0 == strcmp(LIGHT_ID_ATTENTION, name)) {
        set_light = set_light_attention;
        if (access(RED_LED_FILE, F_OK) < 0)
            return -errno;
    //Redmine112320 wuxiaoming modify for vdf led 2017-12-06 begin
    /*
        if (access(GREEN_LED_FILE, F_OK) < 0)
            return -errno;
        if (access(BLUE_LED_FILE, F_OK) < 0)
            return -errno;
    */
    //Redmine112320 wuxiaoming modify for vdf led 2017-12-06 end
    }
    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 = 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;
}




SeakIsBest
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android5.0 framework 灯光系统 -- 电池灯源码分析
韩朋的博客
08-11 924
本文章分析Android系统中，灯光系统如何调用灯光服务、JNI、HAL等从而操控底层Linux驱动控制的led电池灯去闪烁或者亮不同颜色的灯来通知用户。不扯别的，直接上图，简单描述整个调用过程： 以下是详细调用过程： 1. 首先Android系统加载后会执行init进程，然后加载SystemService.java系统服务 SystemService.javaprivate void sta
android8.0 api
12-13
Android 8.0，代号Oreo，是Google在2017年发布的一个重要的操作系统更新，对开发者和用户都带来了许多新特性和改进。这个API级别26的更新不仅提升了系统的性能和效率，还引入了一系列针对应用开发的优化，旨在帮助...
第四章：Android灯光系统(2)-led_class驱动
江南才尽江南山，年少无知年少狂！
02-09 1958
在我们的安卓手机中，有多种灯光，在SDK/hardware/libhardware/include/hardware文件中，可以看到如下定义 #define LIGHT_ID_BACKLIGHT &quot;backlight&quot; #define LIGHT_ID_KEYBOARD &quot;keyboard&quot; #define LIGHT_ID_BUTTONS ......
Android led灯实现大致流程
FinyGao
03-08 4961
ed灯的控制在http://gqdy365.iteye.com/admin/blogs/2208344中写的方法是直接通过操作led设置来控制灯的开关。这样做的问题是未按Android标准结构实现，可能存在潜在的问题，后面分析的一下灯的源码，原来Android系统里面已经提供的相关的实现。  Android系统标准的led可以通过发送通知来控制led灯，做法如下：  Java代
Android 呼吸灯控制逻辑
最新发布
ztisen的博客
04-09 1227
呼吸灯控制逻辑
Android灯光系统笔记
清风不知妻美的博客
05-20 434
Android 底层与应用层之间的传递过程如下图 Andriod app（java） 这里表示的是一个应用程序，可以当做一个client（客户，即我们硬件访问服务器服务的对象），我们所做的一切，都是为了给client提供合适的java接口去控制硬件。当然，即使客户是上帝，也的遵循一定的规则。那么客户，需要遵循什么样的规则，才能达到他访问硬件的目的呢？ 1.需要申请具体服务（getService），就好像你去酒店吃饭一样，你需要点菜，指定具体的菜名。只有菜单里存在的菜式才可以点 2.指令发送，你获得服务以后
第四章：Android灯光系统(4)-电池灯
江南才尽江南山，年少无知年少狂！
02-14 930
通过前面几个小节，我们编写了灯光系统的驱动程序以及Hal文件，并且实现了我们想要的功能，下面我们将对源码中的电池灯进行分析，然后编写我们的APP程序。 我们知道驱动程序是不会主动做任何事情的， ......
Android Oreo8.0.rar
07-11
Android 8.0的NotoColorEmoji.ttf文件，push进自己android的/system/fonts目录替换，可以使手机显示Android 8.0风格的emoji。 注意：解压后需要修改修改文件名为NotoColorEmoji.ttf，并且记得备份原文件，以备...
Android 8.0的缓存大小和缓存清理接口方法
08-27
Android 8.0 缓存大小和缓存清理接口方法 在 Android 8.0 中，获取缓存大小和清理缓存接口方法与 Android 7.0 不兼容。本文将为大家分享 Android 8.0 的缓存大小和缓存清理接口方法的实现细节。 一、获取缓存大小...
android8.0 API26.zip
12-27
android8.0-API26.CHM中文版chmandroid8.0-API26.CHM中文版chmandroid8.0-android8.0-API26.CHM中文版chmAPI26.CHM中文版chmandroid8.0-API26.CHM中文版chm
android 通知的使用小实例（振动，灯光，声音）
10-26
android 通知的使用小实例（振动，灯光，声音）
Android8.0 APP更新
02-16
在Android 8.0系统中，应用程序的更新和文件分享是两个重要的功能，它们涉及到用户交互、系统安全以及用户体验等多个方面。以下将详细介绍这两个知识点。 首先，我们来谈谈"Android 8.0 APP更新"。Android 8.0，又...
android 通知 灯光,第四章：Android灯光系统(5)-通知灯
weixin_29832179的博客
05-29 465
上小节我们分析了电池灯的源码，这小节我们将编写通知灯的使用过程。我们知道，当手机接收到短信的时候，他会发出声音，并且这个通知灯会亮起，那么我们怎么实现呢？一般步骤如下：1. getSystemService("NOTIFICATION_SERVICE")2. 构造notfification(1)类别：该次实现类别为通知等(2)其他：颜色，OnMS，OffMS。3. 发出通知以上是我们自己编写AP...
Android Light
探索未知，成就非凡
02-25 1633
Light note: Android O 1 LightsService启动 /frameworks/base/services/java/com/android/server/SystemServer.java [SystemServer.java::run()] private void run() { ...... /...
android屏幕灯光app,屏幕边缘LED灯光
weixin_34498545的博客
06-03 1480
屏幕边缘LED灯光app将为我们提供优质的闪光特效和边缘模式玩法，在这里你的手机桌面就成了闪光LED特效，你可以自由设置屏幕边缘闪光。屏幕边缘LED灯光给大家准备了海量炫酷功能，快来体验吧。软件介绍屏幕边缘LED灯光app是一款非常好用的手机在线led闪光屏幕壁纸。屏幕边缘LED灯光还能自由选择样式，透明度，宽度等，制作出心仪的精美闪光边缘，屏幕边缘LED灯光的这些设置可让您可以任意调整边缘照明的...
探索 Android Q 中的边对边功能
Android_XG的博客
07-23 724
随着AndoridQ的到来，Android为用户提供了他们最喜欢的应用程序的EdgetoEdge体验，这并不意味着你有一个隐藏的导航面板或隐藏状态栏。是不是很棒？所以，让我们潜入其中。边缘到边缘应用程序就像您的应用程序占据了整个高度，包括从顶部屏幕边缘到底部屏幕边缘的导航和状态区域。为了更好地理解它，请将其视为使您的状态和导航面板具有透明背景。让我们了解我们如何在应用程序中做到这一点步骤01你的应用应该以AndroidQ为目标，所以你的目标版本看起来像，步骤02...
Android Light开发（一）
欢迎加入Android老司机学院 482266514（技术交流群）密码CSDN
03-19 4964
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; /
Android8.0 LED灯上层控制之--battery light
06-05 3400
BatteryService.java1. 定义及初始化 private Led mLed;        //定义 public BatteryService(Context context) { super(context); mContext = context; mHandler = new Handler(true /*a...
Android按键灯，指示灯总结【Android源码解析十一】
836811384
09-25 498
Android中有各种灯，背光灯，按键灯，指示灯，等等；前几天修改了这部分代码，整理下思路，其实都不难； 首先，来说说指示灯（提示灯），即未接电话，未接短信的时候，会闪灯，这个其实就是NotificationManager这个类中的notify（）方法来处理的；流程简单来过一下： Step 1：从应用层发送的notify（），到framework层被NotificationMa...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值