电池信息服务。监控电池状态等

Question

我想要跟踪电池信息(是否正在充电、电量等)即使我的应用程序没有打开。我想也许服务会对它有好处？或者也许还有其他的解决方案？我洗耳恭听。

Answer 1

您需要在android清单中声明该服务。如果您将其放在某个包中，则声明为：

<service android:name="packagename.servicename" />

然后，您将需要实现服务类。我已经为我的一个应用程序创建了一个。希望这对你有帮助。

我在传感器的上下文中有这一点。传感器是我想要监控的东西，所以我创建了一个接口，如下所示：

public interface Sensor {

    SensorType getSensorType();

    SensorName getSensorName();

}

我必须使用ENUM类来表示我拥有的传感器的类型和名称：

public enum SensorName {
    ENVIRONMENTAL_SENSOR, AUDIO_SENSOR, SOUND_SENSOR, SOCIAL_SENSOR,
    LOCATION_SENSOR, PHOTO_SENSOR, ACCELEROMETER_SENSOR, BATTERY_SENSOR;
}

public enum SensorType {
    HARDWARE_SENSOR, SOFTWARE_SENSOR, HYBRID_SENSOR;
}

由于我有几个传感器，并且我可能想要列出实现此接口所需的所有传感器。接下来，我创建了一个抽象类来实现与所有传感器相似的行为。

public abstract class SensorElement extends Service implements Sensor{

    protected SensorType type;
    protected SensorName name;

    @Override
    public abstract IBinder onBind(Intent arg0);

    @Override
    public int onStartCommand(Intent intent, int flags, int startId){
        return super.onStartCommand(intent, flags, startId);
    }

    @Override
    public abstract void onCreate();

    @Override
    public void onDestroy(){
        super.onDestroy();
    }
}

我的传感器需要这种方法才能正常工作。在我的例子中，我只需要使用绑定器将服务绑定到我的活动。

现在你想要的是电池传感器本身：

public class BatterySensor extends SensorElement {

    // Binder given to clients
    private final IBinder mBinder = new BatteryLocalBinder();

    /**
     * Class used for the client Binder. Because we know this service always
     * runs in the same process as its clients, we don't need to deal with IPC.
     */
    public class BatteryLocalBinder extends Binder {
        public BatterySensor getService() {
            // Return this instance of MotionLightOrientationSensor so clients
            // can call
            // public
            // methods
            return BatterySensor.this;
        }
    }

    private static final String TAG = "BatterySensor";
    public static final SensorType type = SensorType.SOFTWARE_SENSOR;
    public static final SensorName name = SensorName.BATTERY_SENSOR;

    private int status;
    private boolean isCharging;
    private int chargePlug;
    private boolean usbCharge;
    private boolean acCharge;
    private int level;
    private int scale;
    private double batteryPct;
    private Battery battery;

    @Override
    public SensorType getSensorType() {
        return type;
    }

    @Override
    public SensorName getSensorName() {
        return name;
    }

    @Override
    public IBinder onBind(Intent arg0) {
        return mBinder;
    }

    @Override
    public void onCreate() {
        Log.e(TAG, "onCreate");
        IntentFilter ifilter = new IntentFilter(Intent.ACTION_BATTERY_CHANGED);
        registerReceiver(powerconnectionreceiver, ifilter);
        battery = new Battery();
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.e(TAG, "onStartCommand");
        super.onStartCommand(intent, flags, startId);
        return START_STICKY;
    }

    @Override
    public void onDestroy() {
        Log.e(TAG, "onDestroy");
        super.onDestroy();
        unregisterReceiver(powerconnectionreceiver);
    }

    private BroadcastReceiver powerconnectionreceiver = new BroadcastReceiver() {

        @Override
        public void onReceive(Context context, Intent intent) {
            // Retrieves a map of extended data from the intent.
            status = intent.getIntExtra(BatteryManager.EXTRA_STATUS, -1);
            isCharging = status == BatteryManager.BATTERY_STATUS_CHARGING
                    || status == BatteryManager.BATTERY_STATUS_FULL;

            chargePlug = intent.getIntExtra(BatteryManager.EXTRA_PLUGGED, -1);
            usbCharge = chargePlug == BatteryManager.BATTERY_PLUGGED_USB;
            acCharge = chargePlug == BatteryManager.BATTERY_PLUGGED_AC;
            level = intent.getIntExtra(BatteryManager.EXTRA_LEVEL, -1);
            scale = intent.getIntExtra(BatteryManager.EXTRA_SCALE, -1);
            batteryPct = level / (float) scale;
            battery.setStatus(status);
            battery.setCharging(isCharging);
            battery.setChargePlug(chargePlug);
            battery.setUsbCharge(usbCharge);
            battery.setAcCharge(acCharge);
            battery.setLevel(level);
            battery.setScale(scale);
            battery.setBatteryPct(batteryPct);

        }

    };

    public Battery getBatteryReading() {
        return this.battery;
    }

    public int getStatus() {
        return status;
    }

    public boolean isCharging() {
        return isCharging;
    }

    public int getChargePlug() {
        return chargePlug;
    }

    public boolean isUsbCharge() {
        return usbCharge;
    }

    public boolean isAcCharge() {
        return acCharge;
    }

    public int getLevel() {
        return level;
    }

    public int getScale() {
        return scale;
    }


}

要访问此传感器的数据，您只需在活动中启动它，如下所示：

private BatterySensor batterySensor;
private boolean mBatteryBound = false;
private Intent intentBattery;

intentBattery = new Intent(this.context, BatterySensor.class);

然后我启动服务：

context.startService(intentBattery);

并将其绑定：

if(this.context.bindService(intentBattery, mBatteryConnection, Context.BIND_AUTO_CREATE)){
            this.numBoundedSensors++;
        }

要绑定它，你需要在你的活动中有这个类：

/** Defines callbacks for service binding, passed to bindService() */
    private ServiceConnection mBatteryConnection = new ServiceConnection() {

        @Override
        public void onServiceConnected(ComponentName className,
                IBinder service) {
            // We've bound to LocalService, cast the IBinder and get LocalService instance
            BatteryLocalBinder BatteryBinder = (BatteryLocalBinder) service;
            batterySensor = BatteryBinder.getService();
            mBatteryBound = true;
        }

        @Override
        public void onServiceDisconnected(ComponentName arg0) {
            mBatteryBound = false;
        }
    };

然后，如果它成功绑定，则可以从传感器调用所有方法，如下所示：

public Battery getBatteryData(){
        return mBatteryBound ? batterySensor.getBatteryReading() : null;
}

Answer 2

服务需要在AndroidManifest.xml中声明，并且实现类必须扩展服务类或它的一个子类。下面的代码显示了一个服务声明及其实现的示例。

<service
  android:name="MyService"
  android:icon="@drawable/icon"
  android:label="@string/service_name"
  >
</service> 

public class MyService extends Service {

  @Override
  public int onStartCommand(Intent intent, int flags, int startId) {
    //TODO do something useful
    return Service.START_NOT_STICKY;
  }

  @Override
  public IBinder onBind(Intent intent) {
  //TODO for communication return IBinder implementation
    return null;
  }
}