LightsService：led灯显示管理

前言：LightsService是用来管理手机led指示灯显示;

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;//Home Menu,Back键灯
    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;//WIFI灯
    public static final int LIGHT_ID_COUNT = Type.COUNT;

    //根据id获取相应类型的灯
    public abstract Light getLight(int id);
}

LightsManager中定义了逻辑灯的类型，也就是ID，每一个ID都唯一标识了一个物理设备，准确来说是一个灯，这些ID主要是为了保证设备的唯一性，同时也为上层调用提供了一个接口。

我们能看到LightsManager只是个抽象类，那他的实现类在哪里呢？答案是LightsService中：

LightsService.java

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;
        }
    }
};

这个mLights是什么？

LightsService.java

//mLights是一个数组，长度为8
final LightImpl mLights[] = new LightImpl[LightsManager.LIGHT_ID_COUNT];

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

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


private final class LightImpl extends Light {

    //通过这个id，来指定当前要操作的灯类型
    private LightImpl(int 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
    //灯光闪烁,onMS表示led闪烁时亮的时间，offMS表示led闪烁时灭的时间
    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 {
                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;
}

我们可以通过设置id来指定某一类型的灯，并控制它的颜色，开启等，最终都是将参数传递给了setLightLocked()，这个方法最终会调用一个native方法setLight_native()，这个本地方法会最终读写灯的控制文件，将最终实现还是交给native层去处理;

解释下这个setBrightness()：

当我们设置灯的亮度值时，最终会将这个亮度brightness（取值范围0~255）转换成色彩值color（ARGB）。我们知道颜色都是三基色RGB组成的，我们要控制的灯基本上都是单色的，要么是红色，要么是绿色。所以在转换过程中，是将亮度值对应的数值分别设置到RGB三色中，也就是每一个单色上都设置为跟亮度相同的数值，这样无论控制的是什么颜色的灯，都会将亮度值设置为brightness。

举个例子：

如下代码所示：

int color = brightness & 0x000000ff;

//其中0xff000000表示的是ARGB模式，A表示的是透明度。
color = 0xff000000 | (color << 16) | (color << 8) | color;

在实际调用setBrightness()过程中，只要传递进来的亮度值大于0，设置任意数值都能够达到点亮灯的效果。

 

2.来看一个通知灯的例子

//我们要控制通知灯
private Light mNotificationLight;

//获取LightsManager
LightsManager lightsManager = getLocalService(LightsManager.class),

//得到通知灯
mNotificationLight = lightsManager.getLight(LightsManager.LIGHT_ID_NOTIFICATIONS);

//通知灯闪烁
mNotificationLight.setFlashing(color, Light.LIGHT_FLASH_HARDWARE,onMs, offMs);

//通知灯关闭
mNotificationLight.turnOff();

这个Light是什么？

Light.java

public abstract class Light {
    public static final int LIGHT_FLASH_NONE = Flash.NONE;//无闪烁
    public static final int LIGHT_FLASH_TIMED = Flash.TIMED;//根据设定的时间闪烁
    public static final int LIGHT_FLASH_HARDWARE = Flash.HARDWARE;//根据硬件控制的闪烁

    /**
     * Light brightness is managed by a user setting.
     */
    public static final int BRIGHTNESS_MODE_USER = Brightness.USER;

    /**
     * Light brightness is managed by a light sensor.
     */
    public static final int BRIGHTNESS_MODE_SENSOR = Brightness.SENSOR;

    /**
     * Low-persistence light mode.
     */
    public static final int BRIGHTNESS_MODE_LOW_PERSISTENCE = Brightness.LOW_PERSISTENCE;

    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);
}

Light实质是一个led硬件的抽象，那么一个led就被抽象成一个Light对象。因此，要控制led，只要拿到led的抽象对象Light即可实现驱动led。

在Light中定义了闪烁类型，分别是无闪烁，定时闪烁和由硬件产生闪烁 ;

 

3.Hal层的处理

(1)首先LightsService启动时，会初始化硬件，打通软硬件的通道。

(2)setLight_native()的方法的具体实现，会因为led的硬件厂商的不同而不同，也就是说，对于很多设备，不支持设置led颜色，设置了也只能是一种颜色，所以在这些设备上，可以说是大多数设备，这个功能基本就没有任何用处。另外，因led硬件的不同，上文中的8个led id，可能有，可能没有。

(3)LightsService中的native方法setLight_native()，最终会传递到light.c中，light.c会根据穿进来的ID类型，进行相应的设置，比如，我们设置的通知灯，也就是LIGHT_ID_NOTIFICATIONS，在light.c中会进行这番设置：

char const *const LCD_FILE           = "/sys/class/leds/lcd-backlight/brightness";
char const *const RED_LED_FILE       = "/sys/class/leds/red/brightness";
char const *const GREEN_LED_FILE     = "/sys/class/leds/green/brightness";
char const *const BLUE_LED_FILE      = "/sys/class/leds/blue/brightness";
char const *const RED_TIMEOUT_FILE   = "/sys/class/leds/red/on_off_ms";
char const *const GREEN_TIMEOUT_FILE = "/sys/class/leds/green/on_off_ms";
char const *const BLUE_TIMEOUT_FILE  = "/sys/class/leds/blue/on_off_ms";
char const *const RGB_LOCKED_FILE    = "/sys/class/leds/red/rgb_start";

static int set_light_notifications(struct light_device_t* dev __unused,
        struct light_state_t const* state)
{
    pthread_mutex_lock(&g_lock);
    set_light_locked(state, 0);
    pthread_mutex_unlock(&g_lock);

    return 0;
}


static int set_light_locked(struct light_state_t const* state, int type __unused)
{
    int len;
    int red, green, blue;
    int onMS, offMS;
    unsigned int colorRGB;

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

    colorRGB = state->color;

#if DEBUG
    ALOGD("set_light_locked mode %d, colorRGB=%08X, onMS=%d, offMS=%d\n",
            state->flashMode, colorRGB, onMS, offMS);
#endif

    red = (colorRGB >> 16) & 0xFF;
    green = (colorRGB >> 8) & 0xFF;
    blue = colorRGB & 0xFF;

    // due to limitation of driver
    if (onMS == 0) {
        red = 0;
        green = 0;
        blue = 0;
    }

    write_int(RGB_LOCKED_FILE, 0);

    write_int(RED_LED_FILE, red);
    write_int(GREEN_LED_FILE, green);
    write_int(BLUE_LED_FILE, blue);

    write_on_off(RED_TIMEOUT_FILE, onMS, offMS);
    write_on_off(GREEN_TIMEOUT_FILE, onMS, offMS);
    write_on_off(BLUE_TIMEOUT_FILE, onMS, offMS);

    write_int(RGB_LOCKED_FILE, 1);

    return 0;
}

我们来看下这个write_int(RED_LED_FILE, red)，该方法是将亮度值写到了文件"/sys/class/leds/red/brightness"中，为什么要这么做呢？之前我们就说过，颜色都是三基色RGB组成的，所以在最终的转换过程中，将亮度值对应的数值分别设置到RGB三色中，也就是设置到这三个文件中;

所以：虽然APP是不可以直接驱动led，但是可以通过其他方式来操纵led灯;

第一个种是通过notification来使用led;

第二种就是将3个颜色值直接写到相应的red，green，blue文件，举个例子：

static String RED_LED_DEV = "/sys/class/leds/red/brightness";
static String GREEN_LED_DEV = "/sys/class/leds/green/brightness";
static String BLUE_LED_DEV = "/sys/class/leds/blue/brightness";

static void setLedStatus (String ledDev, boolean setStatusOn) {
   try {
       FileOutputStream fLed = new FileOutputStream(ledDev);
       fLed.write((setStatusOn ? "255" : "0").getBytes());
       fLed.close();
   } catch (Exception e) {
       e.printStackTrace(); 
   }
}