android6.0系统Healthd分析及低电量自动关机流程

 1 int main(int argc, char **argv) {
 2     int ch;
 3     int ret;
 4 /*代码中开始便是解析参数，healthd_mode_ops是一个关于充电状态结构体变量，
 5  *结构体变量里的参数是函数指针，在初始化时指向各个不同的操作函数，
 6  *当开机充电时变量赋值为&android_ops，关机充电时候变量赋值为&charger_ops。
 7  */
 8     klog_set_level(KLOG_LEVEL);
 9     healthd_mode_ops = &android_ops;    //正常开机充电
10     
11 　　//charger为该程序的可执行文件名，该行代码主要用于区分是命令操作还是正常代码启动
12     if (!strcmp(basename(argv[0]), "charger")) {   
13         
14         healthd_mode_ops = &charger_ops;　　　
15     } else {
16         while ((ch = getopt(argc, argv, "cr")) != -1) {
17             switch (ch) {           //根据不同的参数赋与不同的操作方法
18             case ‘c‘:
19                 healthd_mode_ops = &charger_ops;   
20                 break;
21             case ‘r‘:
22                 healthd_mode_ops = &recovery_ops;
23                 break;
24             case ‘?‘:
25             default:
26                 KLOG_ERROR(LOG_TAG, "Unrecognized healthd option: %c\n",
27                            optopt);
28                 exit(1);
29             }
30         }
31     }
32     
33     //对需要数据上报的事件进行初始化，分别是healthd_mode_ops、wakealarm和uevent三个事件
34     ret = healthd_init();   
35     
36     if (ret) {
37         KLOG_ERROR("Initialization failed, exiting\n");
38         exit(2);
39     }
40     healthd_mainloop();
41     KLOG_ERROR("Main loop terminated, exiting\n");
42     return 3;
43 }

 1 static int healthd_init() {
 2     epollfd = epoll_create(MAX_EPOLL_EVENTS);　　//创建epoll用于事件触发
 3     if (epollfd == -1) {
 4         KLOG_ERROR(LOG_TAG,
 5                    "epoll_create failed; errno=%d\n",
 6                    errno);
 7         return -1;
 8     }
 9     healthd_board_init(&healthd_config);     
10     //次处为调用android_ops->init进行初始化    
11     healthd_mode_ops->init(&healthd_config);  
12     //对wakealarm进行初始化，用于周期触发事件上报数据  
13     wakealarm_init();　　　　　　　　　　　　　
14     //对uevent进行初始化，用于域套节字进行数据传输　　　　
15     uevent_init();　　　　　　　　　　　　　　　　　　　
16     
17     /*在healthd_init中最后创建BatteryMonitor的对象，并将其初始化。
18     BatteryMonitor主要接受healthd传来的数据，做电池状态的计算并更新。*/
19     gBatteryMonitor = new BatteryMonitor();　　　　
20     gBatteryMonitor->init(&healthd_config);     
21     return 0;
22 }

 1 void healthd_mode_android_init(struct healthd_config* /*config*/) {
 2     ProcessState::self()->setThreadPoolMaxThreadCount(0);//线程池里最大线程数
 3     IPCThreadState::self()->disableBackgroundScheduling(true);//禁用后台调度
 4     IPCThreadState::self()->setupPolling(&gBinderFd);
 5     if (gBinderFd >= 0) {
 6         //gBinderfd加入到epoll中
 7         if (healthd_register_event(gBinderFd, binder_event))
 8                
 9             /********healthd_register_event函数分析****************
10             int healthd_register_event(int fd, void (*handler)(uint32_t)) {
11                 struct epoll_event ev;
12                 ev.events = EPOLLIN | EPOLLWAKEUP;        //设置事件类型
13                 ev.data.ptr = (void *)handler;　　　　　　　//加入事件处理函数
14                 //将被监听的描述符添加到epoll
15                 if (epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &ev) == -1) {　　
16                 KLOG_ERROR(LOG_TAG,
17                        "epoll_ctl failed; errno=%d\n", errno);
18                         return -1;
19                 }
20                 eventct++;
21                 return 0;
22             }
23             */
24             KLOG_ERROR(LOG_TAG,
25                        "Register for binder events failed\n");
26     }
27     gBatteryPropertiesRegistrar = new BatteryPropertiesRegistrar();
28     //将"batteryproperties"这个Service注册到ServiceManager中
29     gBatteryPropertiesRegistrar->publish();        
30 }

 1 static void wakealarm_init(void) {
 2     //首先创建一个wakealarm_fd的定时器与之对应的文件描述符
 3     wakealarm_fd = timerfd_create(CLOCK_BOOTTIME_ALARM, TFD_NONBLOCK);   
 4     if (wakealarm_fd == -1) {
 5         KLOG_ERROR(LOG_TAG, "wakealarm_init: timerfd_create failed\n");
 6         return;
 7     }
 8 
 9     //healthd_register_event将wakealarm事件注册到wakealarm_fd文件节点用以监听wakealarm事件
10     if (healthd_register_event(wakealarm_fd, wakealarm_event))   
11         KLOG_ERROR(LOG_TAG,
12                    "Registration of wakealarm event failed\n");
13      //wakealarm_set_interval设置alarm唤醒的间隔
14     wakealarm_set_interval(healthd_config.periodic_chores_interval_fast);
15 }

 1 static void uevent_init(void) {
 2   //创建并打开一个64k的socket文件描述符uevent_fd
 3  uevent_fd = uevent_open_socket(64*1024, true);
 4  if (uevent_fd < 0) {
 5      KLOG_ERROR(LOG_TAG, "uevent_init: uevent_open_socket failed\n");
 6      return;
 7  }
 8  fcntl(uevent_fd, F_SETFL, O_NONBLOCK);        //设置文件状态标志为非阻塞模
 9    //将uevent事件注册到uevent_fd文件节点用以监听uevent事件
10  if (healthd_register_event(uevent_fd, uevent_event))  
11      KLOG_ERROR(LOG_TAG,
12                 "register for uevent events failed\n");
13 }

 1 /*POWER_SUPPLY_SYSFS_PATH定义为"/sys/class/power_supply",
 2 在init函数中打开系统该文件夹，然后一一读取该文件夹下的文件内容*/
 3 DIR* dir = opendir(POWER_SUPPLY_SYSFS_PATH);    
 4 struct dirent* entry;
 5 。。。。。。。
 6  //在while循环中判断该文件夹下各个文件节点的内容，并将其初始化给相关的参数
 7  while ((entry = readdir(dir))) {      
 8      const char* name = entry->d_name;
 9 。。。。。。
10 }

static void healthd_mainloop(void) {
 while (1) {
     struct epoll_event events[eventct];
     int nevents;
     int timeout = awake_poll_interval;
     int mode_timeout;
     mode_timeout = healthd_mode_ops->preparetowait();
     if (timeout < 0 || (mode_timeout > 0 && mode_timeout < timeout))
         timeout = mode_timeout;
     
     /*这里介绍一下轮询机制中重要函数epoll_waite().
       epoll_wait运行的道理是:等侍注册在epfd上的socket fd的事务的产生，
       若是产生则将产生的sokct fd和事务类型放入到events数组中。
       且timeout如果为-1则为阻塞式，timeowout为0则表示非阻塞式。
       可以看到代码中timeout为-1，故为阻塞式轮询，当epollfd上有事件发生，
       则会走到下面的处理逻辑。
      */
     nevents = epoll_wait(epollfd, events, eventct, timeout);
     if (nevents == -1) {
         if (errno == EINTR)
             continue;
         KLOG_ERROR(LOG_TAG, "healthd_mainloop: epoll_wait failed\n");
         break;
     }
     for (int n = 0; n < nevents; ++n) {
         if (events[n].data.ptr)
             (*(void (*)(int))events[n].data.ptr)(events[n].events);    //处理事件
     }
     if (!nevents)
         periodic_chores();
     healthd_mode_ops->heartbeat();
 }
 return;
}

 1 void healthd_battery_update(void) {
 2  // Fast wake interval when on charger (watch for overheat);
 3  // slow wake interval when on battery (watch for drained battery).
 4 int new_wake_interval = gBatteryMonitor->update() ? //更新,调用BatteryMonitor的update函数,根据不同充电状态设置不同的定时器唤醒周期
 5     healthd_config.periodic_chores_interval_fast :
 6         healthd_config.periodic_chores_interval_slow;   　
 7  if (new_wake_interval != wakealarm_wake_interval)　    
 8          wakealarm_set_interval(new_wake_interval);     //new_wake_interval表示新的wakealarm唤醒间隔
 9  // During awake periods poll at fast rate.  If wake alarm is set at fast
10  // rate then just use the alarm; if wake alarm is set at slow rate then
11  // poll at fast rate while awake and let alarm wake up at slow rate when
12  // asleep.
13  if (healthd_config.periodic_chores_interval_fast == -1)
14      awake_poll_interval = -1;
15  else
16      awake_poll_interval =
17          new_wake_interval == healthd_config.periodic_chores_interval_fast ?
18              -1 : healthd_config.periodic_chores_interval_fast * 1000;
19 }

 1 int healthd_register_event(int fd, void (*handler)(uint32_t)) {
 2  struct epoll_event ev;
 3  ev.events = EPOLLIN | EPOLLWAKEUP;
 4  ev.data.ptr = (void *)handler;
 5  if (epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &ev) == -1) {
 6      KLOG_ERROR(LOG_TAG,
 7                 "epoll_ctl failed; errno=%d\n", errno);
 8      return -1;
 9  }
10  eventct++;
11  return 0;
12 }

1      nevents = epoll_wait(epollfd, events, eventct, timeout);
2      if (nevents == -1) {
3          if (errno == EINTR)
4              continue;
5          KLOG_ERROR(LOG_TAG, "healthd_mainloop: epoll_wait failed\n");
6          break;
7      }

 1 #define UEVENT_MSG_LEN 2048
 2 static void uevent_event(uint32_t /*epevents*/) {
 3  char msg[UEVENT_MSG_LEN+2];
 4  char *cp;
 5  int n;
 6  n = uevent_kernel_multicast_recv(uevent_fd, msg, UEVENT_MSG_LEN);
 7  if (n <= 0)
 8      return;
 9  if (n >= UEVENT_MSG_LEN)   /* overflow -- discard */
10      return;
11  msg[n] = ‘\0‘;
12  msg[n+1] = ‘\0‘;
13  cp = msg;
14  while (*cp) {
15      if (!strcmp(cp, "SUBSYSTEM=" POWER_SUPPLY_SUBSYSTEM)) {
16          healthd_battery_update();
17          break;
18      }
19      /* advance to after the next \0 */
20      while (*cp++)
21          ;
22  }
23 }

  1 bool BatteryMonitor::update(void) {
  2  bool logthis;
  3  //清除原有属性值
  4  props.chargerAcOnline = false;                        
  5  props.chargerUsbOnline = false;
  6  props.chargerWirelessOnline = false;
  7  props.batteryStatus = BATTERY_STATUS_UNKNOWN;
  8  props.batteryHealth = BATTERY_HEALTH_UNKNOWN;
  9  props.maxChargingCurrent = 0;
 10  if (!mHealthdConfig->batteryPresentPath.isEmpty())
 11      props.batteryPresent = getBooleanField(mHealthdConfig->batteryPresentPath);
 12  else
 13      props.batteryPresent = mBatteryDevicePresent;
 14  props.batteryLevel = mBatteryFixedCapacity ?
 15      mBatteryFixedCapacity :
 16      getIntField(mHealthdConfig->batteryCapacityPath);
 17  props.batteryVoltage = getIntField(mHealthdConfig->batteryVoltagePath) / 1000;
 18  props.batteryTemperature = mBatteryFixedTemperature ?
 19      mBatteryFixedTemperature :
 20      getIntField(mHealthdConfig->batteryTemperaturePath);
 21  // For devices which do not have battery and are always plugged
 22  // into power souce.
 23  if (mAlwaysPluggedDevice) {
 24      props.chargerAcOnline = true;
 25      props.batteryPresent = true;
 26      props.batteryStatus = BATTERY_STATUS_CHARGING;
 27      props.batteryHealth = BATTERY_HEALTH_GOOD;
 28  }
 29  
 30  const int SIZE = 128;
 31  char buf[SIZE];
 32  String8 btech;
 33  //读取/sys/class/power_supply下文件节点信息
 34  if (readFromFile(mHealthdConfig->batteryStatusPath, buf, SIZE) > 0)     
 35      props.batteryStatus = getBatteryStatus(buf);
 36  if (readFromFile(mHealthdConfig->batteryHealthPath, buf, SIZE) > 0)
 37      props.batteryHealth = getBatteryHealth(buf);
 38  if (readFromFile(mHealthdConfig->batteryTechnologyPath, buf, SIZE) > 0)
 39      props.batteryTechnology = String8(buf);
 40  
 41  /*在init函数中将healthd_config 对象传入，并且将里面的成员的一些地址信息去初始化保存起来。
 42  主要是保存一些地址信息，以及充电方式。在BatteryMonitor初始化中，heathd_config传入init函数中，
 43  赋值为mHealthdConfig，上面一段主要是读取/sys/class/power_supply下的
 44  文件节点信息初更新电池数据属性值
 45  */
 46  
 47  unsigned int i;
 48  //遍历/sys/class/power_supply下的文件节点获取信息
 49  for (i = 0; i < mChargerNames.size(); i++) {　　　　　
 50      String8 path;
 51      path.appendFormat("%s/%s/online", POWER_SUPPLY_SYSFS_PATH,    
 52                        mChargerNames[i].string());
 53        //读取子目录文件online的值，online值为１使用，０值没使用
 54      if (readFromFile(path, buf, SIZE) > 0) {  
 55          if (buf[0] != ‘0‘) {
 56              path.clear();
 57              path.appendFormat("%s/%s/type", POWER_SUPPLY_SYSFS_PATH,
 58                                mChargerNames[i].string());
 59              switch(readPowerSupplyType(path)) {　　　　　//根据读取的值将相应的属性值置true
 60              case ANDROID_POWER_SUPPLY_TYPE_AC:
 61                  props.chargerAcOnline = true;     //true,false在framework层用于充电状态判读
 62                  break;
 63              case ANDROID_POWER_SUPPLY_TYPE_USB:
 64                  props.chargerUsbOnline = true;
 65                  break;
 66              case ANDROID_POWER_SUPPLY_TYPE_WIRELESS:
 67                  props.chargerWirelessOnline = true;
 68                  break;
 69              default:
 70                  KLOG_WARNING(LOG_TAG, "%s: Unknown power supply type\n",
 71                               mChargerNames[i].string());
 72              }
 73              path.clear();
 74              path.appendFormat("%s/%s/current_max", POWER_SUPPLY_SYSFS_PATH,
 75                                mChargerNames[i].string());
 76              if (access(path.string(), R_OK) == 0) {
 77                  int maxChargingCurrent = getIntField(path);
 78                  if (props.maxChargingCurrent < maxChargingCurrent) {
 79                      props.maxChargingCurrent = maxChargingCurrent;
 80                  }
 81              }
 82          }
 83      }
 84  }
 85  logthis = !healthd_board_battery_update(&props);    //此处必返回０
 86  if (logthis) {　　　　//此处必执行
 87      char dmesgline[256];
 88      //更新props的各个属性值，props将会被传到framework层进行数据传输
 89      if (props.batteryPresent) {　　
 90          snprintf(dmesgline, sizeof(dmesgline),
 91               "battery l=%d v=%d t=%s%d.%d h=%d st=%d",
 92               props.batteryLevel, props.batteryVoltage,
 93               props.batteryTemperature < 0 ? "-" : "",
 94               abs(props.batteryTemperature / 10),
 95               abs(props.batteryTemperature % 10), props.batteryHealth,
 96               props.batteryStatus);
 97          if (!mHealthdConfig->batteryCurrentNowPath.isEmpty()) {
 98              int c = getIntField(mHealthdConfig->batteryCurrentNowPath);
 99              char b[20];
100              snprintf(b, sizeof(b), " c=%d", c / 1000);
101              strlcat(dmesgline, b, sizeof(dmesgline));
102          }
103      } else {
104          snprintf(dmesgline, sizeof(dmesgline),
105               "battery none");
106      }
107      size_t len = strlen(dmesgline);
108      snprintf(dmesgline + len, sizeof(dmesgline) - len, " chg=%s%s%s",
109               props.chargerAcOnline ? "a" : "",
110               props.chargerUsbOnline ? "u" : "",
111               props.chargerWirelessOnline ? "w" : "");
112      log_time realtime(CLOCK_REALTIME);
113      time_t t = realtime.tv_sec;
114      struct tm *tmp = gmtime(&t);
115      if (tmp) {
116          static const char fmt[] = " %Y-%m-%d %H:%M:%S.XXXXXXXXX UTC";
117          //前的电量级别，电压，温度，健康状况，电池状态以及充放电倍率存入dmesgline变量中，
118          len = strlen(dmesgline);　　　　
119          if ((len < (sizeof(dmesgline) - sizeof(fmt) - 8)) // margin
120                  && strftime(dmesgline + len, sizeof(dmesgline) - len,
121                              fmt, tmp)) {
122              char *usec = strchr(dmesgline + len, ‘X‘);
123              if (usec) {
124                  len = usec - dmesgline;
125                  snprintf(dmesgline + len, sizeof(dmesgline) - len,
126                           "%09u", realtime.tv_nsec);
127                  usec[9] = ‘ ‘;
128              }
129          }
130      }
131      KLOG_WARNING(LOG_TAG, "%s\n", dmesgline);　//向log记录电池当前各种状态信息
132  }
133  healthd_mode_ops->battery_update(&props);　　//更新电池
134  
135  /*回是否在充电状态个update函数做完更新数据，记录数据到log之后，
136  然后调用到BatteryPropertiesRegistrar的update函数继续更新电池状态，
137  最后返回值为是否处于充电状态。*/
138  return props.chargerAcOnline | props.chargerUsbOnline |　　
139          props.chargerWirelessOnline;
140 }

1 void healthd_mode_android_battery_update(
2  struct android::BatteryProperties *props) {    //props携带各种需要传输的数据
3  if (gBatteryPropertiesRegistrar != NULL)
4  　 //调用BatteryPropertiesRegistrar的notifyListeners去通知props改变了
5      gBatteryPropertiesRegistrar->notifyListeners(*props);
6  return;
7 }

 1  public void onStart() {
 2      IBinder b = ServiceManager.getService("batteryproperties");
 3      final IBatteryPropertiesRegistrar batteryPropertiesRegistrar =
 4              IBatteryPropertiesRegistrar.Stub.asInterface(b);
 5      try {
 6          batteryPropertiesRegistrar.registerListener(new BatteryListener());  //监听事件
 7      } catch (RemoteException e) {
 8          // Should never happen.
 9      }
10      publishBinderService("battery", new BinderService());
11      publishLocalService(BatteryManagerInternal.class, new LocalService());
12  }

 1  private final class BatteryListener extends IBatteryPropertiesListener.Stub {
 2      @Override
 3      public void batteryPropertiesChanged(BatteryProperties props) {
 4          final long identity = Binder.clearCallingIdentity();
 5          try {
 6              BatteryService.this.update(props);　　　//监听到数据调用BatteryService的update函数
 7          } finally {
 8              Binder.restoreCallingIdentity(identity);
 9          }
10     }
11  }

 1  private void shutdownIfNoPowerLocked() {
 2      // shut down gracefully if our battery is critically low and we are not powered.
 3      // wait until the system has booted before attempting to display the shutdown dialog.
 4      //isPoweredLocked判断充电的状态，如果电量为零但又没有接充电器的情况下关机
 5      if (mBatteryProps.batteryLevel == 0 && !isPoweredLocked(BatteryManager.BATTERY_PLUGGED_ANY)) {
 6          mHandler.post(new Runnable() {
 7              @Override
 8              public void run() {　　　//执行关机的代码
 9                  if (ActivityManagerNative.isSystemReady()) {
10                      Intent intent = new Intent(Intent.ACTION_REQUEST_SHUTDOWN);
11                      intent.putExtra(Intent.EXTRA_KEY_CONFIRM, false);
12                      intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
13                      mContext.startActivityAsUser(intent, UserHandle.CURRENT);
14                  }
15              }
16          });
17      }
18  }

 1  private boolean isPoweredLocked(int plugTypeSet) {
 2      // assume we are powered if battery state is unknown so
 3      // the "stay on while plugged in" option will work.
 4      
 5      //如果状态不确定，默认为在充电
 6      if (mBatteryProps.batteryStatus == BatteryManager.BATTERY_STATUS_UNKNOWN) {   
 7          return true;
 8      }
 9      //为插入AC并且为AC充电状态则返回true不关机
10      if ((plugTypeSet & BatteryManager.BATTERY_PLUGGED_AC) != 0 && mBatteryProps.chargerAcOnline) {
11          return true;
12      }
13 　　　　　//插入USB并且为USB充电状态则返回true不关机
14      if ((plugTypeSet & BatteryManager.BATTERY_PLUGGED_USB) != 0 && mBatteryProps.chargerUsbOnline) {
15          return true;
16      }
17      //无线充电
18      if ((plugTypeSet & BatteryManager.BATTERY_PLUGGED_WIRELESS) != 0 && mBatteryProps.chargerWirelessOnline) {
19          return true;
20      }
21      return false;
22  }