Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit c7464c91 authored by Todd Poynor's avatar Todd Poynor
Browse files

healthd: move Android communication code to separate source 

* add ops for different "modes" of healthd operation: android vs. recovery
* recovery mode selected by runstring options -r
* binder/Android communication moved to android mode
* recovery mode ops avoiding binder service registration
* "no service manager" flag removed; now handled by android vs. other modes

Change-Id: I3d8c89bf96a18a6a00cc85306f9a07d3f408f2a0
parent 98c23d82

healthd/Android.mk

+1 −0
Original line number Diff line number Diff line
@@ -13,6 +13,7 @@ include $(CLEAR_VARS) 


LOCAL_SRC_FILES := \

	healthd.cpp \

	healthd_mode_android.cpp \

	BatteryMonitor.cpp \

	BatteryPropertiesRegistrar.cpp

healthd/BatteryMonitor.cpp

+2 −10
Original line number Diff line number Diff line
@@ -18,7 +18,6 @@ 


#include "healthd.h"

#include "BatteryMonitor.h"

#include "BatteryPropertiesRegistrar.h"



#include <dirent.h>

#include <errno.h>
@@ -266,9 +265,7 @@ bool BatteryMonitor::update(void) { 
                  props.chargerWirelessOnline ? "w" : "");

    }



    if (mBatteryPropertiesRegistrar != NULL)

        mBatteryPropertiesRegistrar->notifyListeners(props);



    healthd_mode_ops->battery_update(&props);

    return props.chargerAcOnline | props.chargerUsbOnline |

            props.chargerWirelessOnline;

}
@@ -317,7 +314,7 @@ status_t BatteryMonitor::getProperty(int id, struct BatteryProperty *val) { 
    return ret;

}



void BatteryMonitor::init(struct healthd_config *hc, bool nosvcmgr) {

void BatteryMonitor::init(struct healthd_config *hc) {

    String8 path;



    mHealthdConfig = hc;
@@ -467,11 +464,6 @@ void BatteryMonitor::init(struct healthd_config *hc, bool nosvcmgr) { 
        KLOG_WARNING(LOG_TAG, "BatteryTemperaturePath not found\n");

    if (mHealthdConfig->batteryTechnologyPath.isEmpty())

        KLOG_WARNING(LOG_TAG, "BatteryTechnologyPath not found\n");



    if (nosvcmgr == false) {

            mBatteryPropertiesRegistrar = new BatteryPropertiesRegistrar();

            mBatteryPropertiesRegistrar->publish();

    }

}



}; // namespace android

healthd/BatteryMonitor.h

+1 −6
Original line number Diff line number Diff line
@@ -23,12 +23,9 @@ 
#include <utils/Vector.h>



#include "healthd.h"

#include "BatteryPropertiesRegistrar.h"



namespace android {



class BatteryPropertiesRegistrar;



class BatteryMonitor {

  public:
@@ -40,7 +37,7 @@ class BatteryMonitor { 
        ANDROID_POWER_SUPPLY_TYPE_BATTERY

    };



    void init(struct healthd_config *hc, bool nosvcmgr);

    void init(struct healthd_config *hc);

    bool update(void);

    status_t getProperty(int id, struct BatteryProperty *val);
@@ -48,8 +45,6 @@ class BatteryMonitor { 
    struct healthd_config *mHealthdConfig;

    Vector<String8> mChargerNames;



    sp<BatteryPropertiesRegistrar> mBatteryPropertiesRegistrar;



    int getBatteryStatus(const char* status);

    int getBatteryHealth(const char* status);

    int readFromFile(const String8& path, char* buf, size_t size);

healthd/healthd.cpp

+58 −29
Original line number Diff line number Diff line
@@ -25,8 +25,6 @@ 
#include <stdlib.h>

#include <unistd.h>

#include <batteryservice/BatteryService.h>

#include <binder/IPCThreadState.h>

#include <binder/ProcessState.h>

#include <cutils/klog.h>

#include <cutils/uevent.h>

#include <sys/epoll.h>
@@ -72,7 +70,50 @@ static int wakealarm_wake_interval = DEFAULT_PERIODIC_CHORES_INTERVAL_FAST; 


static BatteryMonitor* gBatteryMonitor;



static bool nosvcmgr;

struct healthd_mode_ops *healthd_mode_ops;



// Android mode



extern void healthd_mode_android_init(struct healthd_config *config);

extern int healthd_mode_android_preparetowait(void);

extern void healthd_mode_android_battery_update(

    struct android::BatteryProperties *props);



// NOPs for modes that need no special action



static void healthd_mode_nop_init(struct healthd_config *config);

static int healthd_mode_nop_preparetowait(void);

static void healthd_mode_nop_heartbeat(void);

static void healthd_mode_nop_battery_update(

    struct android::BatteryProperties *props);



static struct healthd_mode_ops android_ops = {

    .init = healthd_mode_android_init,

    .preparetowait = healthd_mode_android_preparetowait,

    .heartbeat = healthd_mode_nop_heartbeat,

    .battery_update = healthd_mode_android_battery_update,

};



static struct healthd_mode_ops recovery_ops = {

    .init = healthd_mode_nop_init,

    .preparetowait = healthd_mode_nop_preparetowait,

    .heartbeat = healthd_mode_nop_heartbeat,

    .battery_update = healthd_mode_nop_battery_update,

};



static void healthd_mode_nop_init(struct healthd_config *config) {

}



static int healthd_mode_nop_preparetowait(void) {

    return -1;

}



static void healthd_mode_nop_heartbeat(void) {

}



static void healthd_mode_nop_battery_update(

    struct android::BatteryProperties *props) {

}



int healthd_register_event(int fd, void (*handler)(uint32_t)) {

    struct epoll_event ev;
@@ -208,32 +249,17 @@ static void wakealarm_init(void) { 
    wakealarm_set_interval(healthd_config.periodic_chores_interval_fast);

}



static void binder_event(uint32_t revents) {

    IPCThreadState::self()->handlePolledCommands();

}



static void binder_init(void) {

    int binder_fd;



    ProcessState::self()->setThreadPoolMaxThreadCount(0);

    IPCThreadState::self()->disableBackgroundScheduling(true);

    IPCThreadState::self()->setupPolling(&binder_fd);



    if (binder_fd >= 0) {

       if (healthd_register_event(binder_fd, binder_event))

            KLOG_ERROR(LOG_TAG,

                       "Register for binder events failed\n");

    }

}



static void healthd_mainloop(void) {

    while (1) {

        struct epoll_event events[eventct];

        int nevents;

        int timeout = awake_poll_interval;

        int mode_timeout;



        IPCThreadState::self()->flushCommands();



        nevents = epoll_wait(epollfd, events, eventct, awake_poll_interval);

        mode_timeout = healthd_mode_ops->preparetowait();

        if (timeout < 0 || (mode_timeout > 0 && mode_timeout < timeout))

            timeout = mode_timeout;

        nevents = epoll_wait(epollfd, events, eventct, timeout);



        if (nevents == -1) {

            if (errno == EINTR)
@@ -249,6 +275,8 @@ static void healthd_mainloop(void) { 


        if (!nevents)

            periodic_chores();



        healthd_mode_ops->heartbeat();

    }



    return;
@@ -263,12 +291,12 @@ static int healthd_init() { 
        return -1;

    }



    healthd_mode_ops->init(&healthd_config);

    healthd_board_init(&healthd_config);

    wakealarm_init();

    uevent_init();

    binder_init();

    gBatteryMonitor = new BatteryMonitor();

    gBatteryMonitor->init(&healthd_config, nosvcmgr);

    gBatteryMonitor->init(&healthd_config);

    return 0;

}
@@ -277,11 +305,12 @@ int main(int argc, char **argv) { 
    int ret;



    klog_set_level(KLOG_LEVEL);

    healthd_mode_ops = &android_ops;



    while ((ch = getopt(argc, argv, "n")) != -1) {

    while ((ch = getopt(argc, argv, "r")) != -1) {

        switch (ch) {

        case 'n':

            nosvcmgr = true;

        case 'r':

            healthd_mode_ops = &recovery_ops;

            break;

        case '?':

        default:

healthd/healthd.h

+9 −0
Original line number Diff line number Diff line
@@ -73,6 +73,15 @@ void healthd_battery_update(); 
android::status_t healthd_get_property(int id,

    struct android::BatteryProperty *val);



struct healthd_mode_ops {

    void (*init)(struct healthd_config *config);

    int (*preparetowait)(void);

    void (*heartbeat)(void);

    void (*battery_update)(struct android::BatteryProperties *props);

};



extern struct healthd_mode_ops *healthd_mode_ops;



// The following are implemented in libhealthd_board to handle board-specific

// behavior.

//