Merge "Protobufferize BatteryManager dumpsys"

/*

 * Copyright (C) 2017 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

syntax = "proto3";

package android.service.battery;

option java_multiple_files = true;

option java_outer_classname = "BatteryServiceProto";

message BatteryServiceDumpProto {

    enum BatteryPlugged {

        BATTERY_PLUGGED_NONE = 0;

        BATTERY_PLUGGED_AC = 1;

        BATTERY_PLUGGED_USB = 2;

        BATTERY_PLUGGED_WIRELESS = 4;

    }

    enum BatteryStatus {

        BATTERY_STATUS_INVALID = 0;

        BATTERY_STATUS_UNKNOWN = 1;

        BATTERY_STATUS_CHARGING = 2;

        BATTERY_STATUS_DISCHARGING = 3;

        BATTERY_STATUS_NOT_CHARGING = 4;

        BATTERY_STATUS_FULL = 5;

    }

    enum BatteryHealth {

        BATTERY_HEALTH_INVALID = 0;

        BATTERY_HEALTH_UNKNOWN = 1;

        BATTERY_HEALTH_GOOD = 2;

        BATTERY_HEALTH_OVERHEAT = 3;

        BATTERY_HEALTH_DEAD = 4;

        BATTERY_HEALTH_OVER_VOLTAGE = 5;

        BATTERY_HEALTH_UNSPECIFIED_FAILURE = 6;

        BATTERY_HEALTH_COLD = 7;

    }

    // If true: UPDATES STOPPED -- use 'reset' to restart

    bool are_updates_stopped = 1;

    // Plugged status of power sources

    BatteryPlugged plugged = 2;

    // Max current in microamperes

    int32 max_charging_current = 3;

    // Max voltage

    int32 max_charging_voltage = 4;

    // Battery capacity in microampere-hours

    int32 charge_counter = 5;

    // Charging status

    BatteryStatus status = 6;

    // Battery health

    BatteryHealth health = 7;

    // True if the battery is present

    bool is_present = 8;

    // Charge level, from 0 through "scale" inclusive

    int32 level = 9;

    // The maximum value for the charge level

    int32 scale = 10;

    // Battery voltage in millivolts

    int32 voltage = 11;

    // Battery temperature in tenths of a degree Centigrade

    int32 temperature = 12;

    // The type of battery installed, e.g. "Li-ion"

    string technology = 13;

}

import android.os.UEventObserver;

import android.os.UserHandle;

import android.provider.Settings;

import android.service.battery.BatteryServiceDumpProto;

import android.util.EventLog;

import android.util.Slog;

import android.util.proto.ProtoOutputStream;

import java.io.File;

import java.io.FileDescriptor;

        }

    }

    private void dumpProto(FileDescriptor fd) {

        final ProtoOutputStream proto = new ProtoOutputStream(fd);

        synchronized (mLock) {

            proto.write(BatteryServiceDumpProto.ARE_UPDATES_STOPPED, mUpdatesStopped);

            int batteryPluggedValue = BatteryServiceDumpProto.BATTERY_PLUGGED_NONE;

            if (mBatteryProps.chargerAcOnline) {

                batteryPluggedValue = BatteryServiceDumpProto.BATTERY_PLUGGED_AC;

            } else if (mBatteryProps.chargerUsbOnline) {

                batteryPluggedValue = BatteryServiceDumpProto.BATTERY_PLUGGED_USB;

            } else if (mBatteryProps.chargerWirelessOnline) {

                batteryPluggedValue = BatteryServiceDumpProto.BATTERY_PLUGGED_WIRELESS;

            }

            proto.write(BatteryServiceDumpProto.PLUGGED, batteryPluggedValue);

            proto.write(BatteryServiceDumpProto.MAX_CHARGING_CURRENT, mBatteryProps.maxChargingCurrent);

            proto.write(BatteryServiceDumpProto.MAX_CHARGING_VOLTAGE, mBatteryProps.maxChargingVoltage);

            proto.write(BatteryServiceDumpProto.CHARGE_COUNTER, mBatteryProps.batteryChargeCounter);

            proto.write(BatteryServiceDumpProto.STATUS, mBatteryProps.batteryStatus);

            proto.write(BatteryServiceDumpProto.HEALTH, mBatteryProps.batteryHealth);

            proto.write(BatteryServiceDumpProto.IS_PRESENT, mBatteryProps.batteryPresent);

            proto.write(BatteryServiceDumpProto.LEVEL, mBatteryProps.batteryLevel);

            proto.write(BatteryServiceDumpProto.SCALE, BATTERY_SCALE);

            proto.write(BatteryServiceDumpProto.VOLTAGE, mBatteryProps.batteryVoltage);

            proto.write(BatteryServiceDumpProto.TEMPERATURE, mBatteryProps.batteryTemperature);

            proto.write(BatteryServiceDumpProto.TECHNOLOGY, mBatteryProps.batteryTechnology);

        }

        proto.flush();

    }

    private final class Led {

        private final Light mBatteryLight;

                return;

            }

            if (args.length > 0 && "--proto".equals(args[0])) {

                dumpProto(fd);

            } else {

                dumpInternal(fd, pw, args);

            }

        }

        @Override public void onShellCommand(FileDescriptor in, FileDescriptor out,

                FileDescriptor err, String[] args, ShellCallback callback,