设置模块流程分析

 

EditPinPreference.java (packages\apps\settings\src\com\android\settings)
private OnPinEnteredListener mPinListener;
protected void onDialogClosed(boolean positiveResult)
 mPinListener.onPinEntered(this, positiveResult);
执行  SimLockSettings.java (packages\apps\settings\src\com\android\settings)中函数：
public void onPinEntered(EditPinPreference preference, boolean positiveResult)
修改pin状态： tryChangeSimLockState();
修改pin：        tryChangePin();
 

设置pin状态
private void tryChangeSimLockState()
Message callback = Message.obtain(mHandler, ENABLE_SIM_PIN_COMPLETE);
mPhone.getSimCard().setSimLockEnabled(mToState, mPin, callback);

进入sim lock 菜单会显示初始化pin状态，是通过下面语句得到：
mPinToggle.setChecked(mPhone.getSimCard().getSimLockEnabled());
mPhone.getSimCard().setSimLockEnabled(mToState, mPin, callback)调用的是文件：
GsmSimCard.java (frameworks\base\telephony\java\com\android\internal\telephony\gsm)中的函数：
public void setSimLockEnabled (boolean enabled,String password, Message onComplete) {
  int serviceClassX;
  serviceClassX = CommandsInterface.SERVICE_CLASS_VOICE +
                CommandsInterface.SERVICE_CLASS_DATA +
                CommandsInterface.SERVICE_CLASS_FAX;
  mDesiredPinLocked = enabled;
  phone.mCM.setFacilityLock(CommandsInterface.CB_FACILITY_BA_SIM,
                enabled, password, serviceClassX,
                obtainMessage(EVENT_CHANGE_FACILITY_LOCK_DONE, onComplete));

phone.mCM.setFacilityLock 调用的是文件：
RIL.java (frameworks\base\telephony\java\com\android\internal\telephony\gsm)中的函数：
    public void  setFacilityLock (String facility, boolean lockState, String password,
                        int serviceClass, Message response) {
        String lockString;
        RILRequest rr =  RILRequest.obtain(RIL_REQUEST_SET_FACILITY_LOCK, response);
        if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest));
        // count strings
        rr.mp.writeInt(4);
        rr.mp.writeString(facility);
        lockString = (lockState)?"1":"0";
        rr.mp.writeString(lockString);
        rr.mp.writeString(password);
        rr.mp.writeString(Integer.toString(serviceClass));
        send(rr);
    }
设置应用程序向 rild 发送 RIL_REQUEST_SET_FACILITY_LOCK　请求的 socket消息，
android的初始源代码中 RIL_REQUEST_SET_FACILITY_LOCK 请求，在参考实现　Reference-ril.c
(hardware\ril\reference-ril) 中没有实现。
 ＝＝＝＝＝＝＝＝＝＝
修改sim卡pin
private void tryChangePin()
mPhone.getSimCard().changeSimLockPassword(mOldPin,mNewPin, callback);

mPhone.getSimCard 调用的是文件：
GsmSimCard.java (frameworks\base\telephony\java\com\android\internal\telephony\gsm)中的函数：
public void changeSimLockPassword(String oldPassword, String newPassword,Message onComplete)
phone.mCM.changeSimPin(oldPassword, newPassword,
               obtainMessage(EVENT_CHANGE_SIM_PASSWORD_DONE, onComplete));

phone.mCM.changeSimPin 调用的是文件：
RIL.java (frameworks\base\telephony\java\com\android\internal\telephony\gsm)中的函数：
    public void  changeSimPin(String oldPin, String newPin, Message result){
        RILRequest rr = RILRequest.obtain(RIL_REQUEST_CHANGE_SIM_PIN, result);
        if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest));
        rr.mp.writeInt(2);
        rr.mp.writeString(oldPin);
        rr.mp.writeString(newPin);
        send(rr);
    }
rild端处理流程：

pin认证流程
＝＝＝＝＝＝＝＝
网络设置
＝＝＝＝＝＝＝
屏幕背光设置
packages/apps/Settings/src/com/android/settings/BrightnessPreference.java
背光设置滚动条和关闭按钮都会调用  setBrightness(mOldBrightness);
public void onProgressChanged(SeekBar seekBar, int progress,boolean fromTouch)
protected void onDialogClosed(boolean positiveResult)
    private void setBrightness(int brightness) {
        try {

            IHardwareService hardware = IHardwareService.Stub.asInterface(
                    ServiceManager.getService("hardware"));
            if (hardware != null) {
                hardware.setBacklights(brightness);
            }
        } catch (RemoteException doe) {        
        }        
    }
调用硬件服务器 HardwareService 的 setBacklights 函数
HardwareService.java (frameworks\base\services\java\com\android\server):   
public void setBacklights(int brightness){
        . . .
        // Don't let applications turn the screen all the way off
        brightness = Math.max(brightness, Power.BRIGHTNESS_DIM);
        setLightBrightness_UNCHECKED(LIGHT_ID_BACKLIGHT, brightness);
        setLightBrightness_UNCHECKED(LIGHT_ID_KEYBOARD, brightness);
        setLightBrightness_UNCHECKED(LIGHT_ID_BUTTONS, brightness);
        . . .
}
void setLightOff_UNCHECKED(int light)
{
        //本地调用 setLight_native
        setLight_native(mNativePointer, light, 0, LIGHT_FLASH_NONE, 0, 0);
}
    void setLightBrightness_UNCHECKED(int light, int brightness) {
        int b = brightness & 0x000000ff;
        b = 0xff000000 | (b = 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;
    devices->lights[light]->set_light(devices->lights[light], &state);
}
Lights.h (hardware\libhardware\include\hardware):#define LIGHTS_HARDWARE_MODULE_ID "lights"
com_android_server_HardwareService.cpp (frameworks\base\services\jni)
err = hw_get_module(LIGHTS_HARDWARE_MODULE_ID, (hw_module_t const**)&module);
static const char *variant_keys[] = {
    "ro.hardware",  /* This goes first so that it can pick up a different
                       file on the emulator. */
    "ro.product.board",
    "ro.board.platform",
    "ro.arch"
};
int hw_get_module(const char *id, const struct hw_module_t **module)
        status = load(id, prop, &hmi);
        status = load(id, HAL_DEFAULT_VARIANT, &hmi);
static int load(const char *id, const char *variant,const struct hw_module_t **pHmi)
        snprintf(path, sizeof(path), "%s/%s.%s.so", HAL_LIBRARY_PATH, id, variant);
#define HAL_DEFAULT_VARIANT     "default"
#define HAL_LIBRARY_PATH "/system/lib/hw"
所以path等于：
/system/lib/hw/light.marvell.so
/system/lib/hw/light.default.so
我们编译的light模块放在  /system/lib/hw/light.default.so 所以初始化成功。
property_get(variant_keys, prop, NULL) 只有 ro.hardware 存在 [ro.hardware]: [marvell]
static int lights_device_open(const struct hw_module_t* module, const char* name,struct hw_device_t** device)
    dev->set_light = set_light_backlight;
static struct hw_module_methods_t lights_module_methods = {
    open: lights_device_open
};
hardware/libhardware/modules/lights/Android.mk
LOCAL_MODULE:= lights.default
err = module->methods->open(module, name, &device);
执行的是 ： lights_device_open
const char * const brightness_file = "/sys/class/backlight/micco-bl/brightness";
static int  set_light_backlight(struct light_device_t* dev,
            struct light_state_t const* state)｛
   . .  .
   color = state->color;
    tmp = ((77*((color>>16)&0x00ff)) + (150*((color>>8)&0x00ff)) + (29*(color&0x00ff))) >> 8;
    brightness = tmp/16;
    LOGD("---->calling %s(),line=%d state->color=%d,brightness=%d\n",__FUNCTION__,__LINE__,state->color,brightness);
    len = sprintf(buf,"%d",brightness);
    len = write(fd, buf, len);
    . . .
｝
上面的函数完成了与内核的交互
综上所述，程序调用流程如下，上层应用通过 /sys/class/leds/lcd-backlight/brightnes 于内核打交道
设置模块 -> 硬件服务器 -> 本地调用 ->功能库 -> 读写  /sys/class/leds/lcd-backlight/brightness 函数与内核交互
Init.rc (vendor\marvell\littleton):    chown system system /sys/class/leds/keyboard-backlight/brightness
Init.rc (vendor\marvell\littleton):    chown system system /sys/class/leds/lcd-backlight/brightness
Init.rc (vendor\marvell\littleton):    chown system system /sys/class/leds/button-backlight/brightness
获取，显示电池状态
电池状态（正在充电（AC））：
Status.java
String statusString;
mBatteryStatus.setSummary(statusString);
    public static final int BATTERY_STATUS_UNKNOWN = 1;
    public static final int BATTERY_STATUS_CHARGING = 2;
    public static final int BATTERY_STATUS_DISCHARGING = 3;
    public static final int BATTERY_STATUS_NOT_CHARGING = 4;
    public static final int BATTERY_STATUS_FULL = 5;
    // values for "health" field in the ACTION_BATTERY_CHANGED Intent
    public static final int BATTERY_HEALTH_UNKNOWN = 1;
    public static final int BATTERY_HEALTH_GOOD = 2;
    public static final int BATTERY_HEALTH_OVERHEAT = 3;
    public static final int BATTERY_HEALTH_DEAD = 4;
    public static final int BATTERY_HEALTH_OVER_VOLTAGE = 5;
    public static final int BATTERY_HEALTH_UNSPECIFIED_FAILURE = 6;
public static final int BATTERY_PLUGGED_AC = 1;  电源充电
public static final int BATTERY_PLUGGED_USB = 2; USB充电
BatteryInfo.java (packages\apps\settings\src\com\android\settings)
电池级别（50％）
BatteryService.java (frameworks\base\services\java\com\android\server)
电池服务器：
构造函数：
public BatteryService(Context context)
  mUEventObserver.startObserving("SUBSYSTEM=power_supply");
－－－－－－－－－－
UEventObserver.java (frameworks\base\core\java\android\os)
void startObserving(String match)
  ensureThreadStarted();
    sThread = new UEventThread();
    sThread.start();
  sThread.addObserver(match, this);
－－－－－－－－－－－
  update()
    native_update();
    sendIntent();
private final void sendIntent()
  Intent intent = new Intent(Intent.ACTION_BATTERY_CHANGED);
  intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);
  ...
  intent.putExtra("status", mBatteryStatus);
  intent.putExtra("health", mBatteryHealth);
  intent.putExtra("present", mBatteryPresent);
  intent.putExtra("level", mBatteryLevel);
  intent.putExtra("scale", BATTERY_SCALE);
  intent.putExtra("icon-small", icon);
  intent.putExtra("plugged", mPlugType);
  intent.putExtra("voltage", mBatteryVoltage);
  intent.putExtra("temperature", mBatteryTemperature);
  intent.putExtra("technology", mBatteryTechnology);
ActivityManagerNative.broadcastStickyIntent(intent, null);
把读取的电池信息通过广播信息发送给所有的应用程序。
native_update 本地调用的是文件 com_android_server_BatteryService.cpp (frameworks\base\services\jni) 中的函数：
static void android_server_BatteryService_update(JNIEnv* env, jobject obj){
    setBooleanField(env, obj, AC_ONLINE_PATH, gFieldIds.mAcOnline);
    setBooleanField(env, obj, USB_ONLINE_PATH, gFieldIds.mUsbOnline);
    setBooleanField(env, obj, BATTERY_PRESENT_PATH, gFieldIds.mBatteryPresent);
   
    setIntField(env, obj, BATTERY_CAPACITY_PATH, gFieldIds.mBatteryLevel);
    setIntField(env, obj, BATTERY_VOLTAGE_PATH, gFieldIds.mBatteryVoltage);
    setIntField(env, obj, BATTERY_TEMPERATURE_PATH, gFieldIds.mBatteryTemperature);
   
    const int SIZE = 128;
    char buf[SIZE];
   
    if (readFromFile(BATTERY_STATUS_PATH, buf, SIZE) > 0)
        env->SetIntField(obj, gFieldIds.mBatteryStatus, getBatteryStatus(buf));
   
    if (readFromFile(BATTERY_HEALTH_PATH, buf, SIZE) > 0)
        env->SetIntField(obj, gFieldIds.mBatteryHealth, getBatteryHealth(buf));
    if (readFromFile(BATTERY_TECHNOLOGY_PATH, buf, SIZE) > 0)
        env->SetObjectField(obj, gFieldIds.mBatteryTechnology, env->NewStringUTF(buf));
}
#define AC_ONLINE_PATH "/sys/class/power_supply/ac/online"
#define USB_ONLINE_PATH "/sys/class/power_supply/usb/online"
#define BATTERY_STATUS_PATH "/sys/class/power_supply/battery/status"
#define BATTERY_HEALTH_PATH "/sys/class/power_supply/battery/health"
#define BATTERY_PRESENT_PATH "/sys/class/power_supply/battery/present"
#define BATTERY_CAPACITY_PATH "/sys/class/power_supply/battery/capacity"
#define BATTERY_VOLTAGE_PATH "/sys/class/power_supply/battery/batt_vol"
#define BATTERY_TEMPERATURE_PATH "/sys/class/power_supply/battery/batt_temp"
#define BATTERY_TECHNOLOGY_PATH "/sys/class/power_supply/battery/technology"
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝