Merge "Remove libbatteryservice."

    header_libs: ["libbinder_headers"],

    export_header_lib_headers: ["libbinder_headers"],

}

cc_library {

    name: "libbatteryservice",

    srcs: [

        "BatteryProperties.cpp",

        "BatteryProperty.cpp",

        "IBatteryPropertiesListener.cpp",

        "IBatteryPropertiesRegistrar.cpp",

    ],

    header_libs: ["libbatteryservice_headers"],

    export_header_lib_headers: ["libbatteryservice_headers"],

    shared_libs: [

        "libutils",

        "libbinder",

    ],

    cflags: [

        "-Wall",

        "-Werror",

        "-Wunused",

        "-Wunreachable-code",

    ],

}

/*

 * Copyright (C) 2013 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.

 */

#include <stdint.h>

#include <sys/types.h>

#include <batteryservice/BatteryService.h>

#include <binder/Parcel.h>

#include <utils/Errors.h>

#include <utils/String8.h>

#include <utils/String16.h>

namespace android {

/*

 * Parcel read/write code must be kept in sync with

 * frameworks/base/core/java/android/os/BatteryProperties.java

 */

status_t BatteryProperties::readFromParcel(Parcel* p) {

    chargerAcOnline = p->readInt32() == 1 ? true : false;

    chargerUsbOnline = p->readInt32() == 1 ? true : false;

    chargerWirelessOnline = p->readInt32() == 1 ? true : false;

    maxChargingCurrent = p->readInt32();

    maxChargingVoltage = p->readInt32();

    batteryStatus = p->readInt32();

    batteryHealth = p->readInt32();

    batteryPresent = p->readInt32() == 1 ? true : false;

    batteryLevel = p->readInt32();

    batteryVoltage = p->readInt32();

    batteryTemperature = p->readInt32();

    batteryFullCharge = p->readInt32();

    batteryChargeCounter = p->readInt32();

    batteryTechnology = String8((p->readString16()).string());

    return OK;

}

status_t BatteryProperties::writeToParcel(Parcel* p) const {

    p->writeInt32(chargerAcOnline ? 1 : 0);

    p->writeInt32(chargerUsbOnline ? 1 : 0);

    p->writeInt32(chargerWirelessOnline ? 1 : 0);

    p->writeInt32(maxChargingCurrent);

    p->writeInt32(maxChargingVoltage);

    p->writeInt32(batteryStatus);

    p->writeInt32(batteryHealth);

    p->writeInt32(batteryPresent ? 1 : 0);

    p->writeInt32(batteryLevel);

    p->writeInt32(batteryVoltage);

    p->writeInt32(batteryTemperature);

    p->writeInt32(batteryFullCharge);

    p->writeInt32(batteryChargeCounter);

    p->writeString16(String16(batteryTechnology));

    return OK;

}

}; // namespace android

/*

 * Copyright (C) 2013 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.

 */

#include <stdint.h>

#include <sys/types.h>

#include <batteryservice/BatteryService.h>

#include <binder/Parcel.h>

#include <utils/Errors.h>

namespace android {

/*

 * Parcel read/write code must be kept in sync with

 * frameworks/base/core/java/android/os/BatteryProperty.java

 */

status_t BatteryProperty::readFromParcel(Parcel* p) {

    valueInt64 = p->readInt64();

    return OK;

}

status_t BatteryProperty::writeToParcel(Parcel* p) const {

    p->writeInt64(valueInt64);

    return OK;

}

}; // namespace android

/*

 * Copyright (C) 2013 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.

 */

#include <stdint.h>

#include <sys/types.h>

#include <batteryservice/IBatteryPropertiesListener.h>

#include <binder/Parcel.h>

namespace android {

class BpBatteryPropertiesListener : public BpInterface<IBatteryPropertiesListener>

{

public:

    explicit BpBatteryPropertiesListener(const sp<IBinder>& impl)

        : BpInterface<IBatteryPropertiesListener>(impl)

    {

    }

    void batteryPropertiesChanged(struct BatteryProperties props)

    {

        Parcel data, reply;

        data.writeInterfaceToken(IBatteryPropertiesListener::getInterfaceDescriptor());

        data.writeInt32(1);

        props.writeToParcel(&data);

        remote()->transact(TRANSACT_BATTERYPROPERTIESCHANGED, data, &reply, IBinder::FLAG_ONEWAY);

    }

};

IMPLEMENT_META_INTERFACE(BatteryPropertiesListener, "android.os.IBatteryPropertiesListener");

// ----------------------------------------------------------------------------

status_t BnBatteryPropertiesListener::onTransact(uint32_t code, const Parcel& data,

                                                 Parcel* reply, uint32_t flags)

{

    switch(code) {

        case TRANSACT_BATTERYPROPERTIESCHANGED: {

            CHECK_INTERFACE(IBatteryPropertiesListener, data, reply);

            struct BatteryProperties props = {};

            if (data.readInt32() != 0) {

                props.readFromParcel((Parcel*)&data);

            }

            batteryPropertiesChanged(props);

            return NO_ERROR;

        }

        default:

            return BBinder::onTransact(code, data, reply, flags);

    }

};

}; // namespace android

/*

 * Copyright (C) 2013 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.

 */

#define LOG_TAG "IBatteryPropertiesRegistrar"

//#define LOG_NDEBUG 0

#include <utils/Log.h>

#include <batteryservice/IBatteryPropertiesListener.h>

#include <batteryservice/IBatteryPropertiesRegistrar.h>

#include <stdint.h>

#include <sys/types.h>

#include <binder/Parcel.h>

namespace android {

class BpBatteryPropertiesRegistrar : public BpInterface<IBatteryPropertiesRegistrar> {

public:

    explicit BpBatteryPropertiesRegistrar(const sp<IBinder>& impl)

        : BpInterface<IBatteryPropertiesRegistrar>(impl) {}

        void registerListener(const sp<IBatteryPropertiesListener>& listener) {

            Parcel data;

            data.writeInterfaceToken(IBatteryPropertiesRegistrar::getInterfaceDescriptor());

            data.writeStrongBinder(IInterface::asBinder(listener));

            remote()->transact(REGISTER_LISTENER, data, NULL);

        }

        void unregisterListener(const sp<IBatteryPropertiesListener>& listener) {

            Parcel data;

            data.writeInterfaceToken(IBatteryPropertiesRegistrar::getInterfaceDescriptor());

            data.writeStrongBinder(IInterface::asBinder(listener));

            remote()->transact(UNREGISTER_LISTENER, data, NULL);

        }

        status_t getProperty(int id, struct BatteryProperty *val) {

            Parcel data, reply;

            data.writeInterfaceToken(IBatteryPropertiesRegistrar::getInterfaceDescriptor());

            data.writeInt32(id);

            remote()->transact(GET_PROPERTY, data, &reply);

            int32_t ret = reply.readExceptionCode();

            if (ret != 0) {

                return ret;

            }

            ret = reply.readInt32();

            int parcelpresent = reply.readInt32();

            if (parcelpresent)

                val->readFromParcel(&reply);

            return ret;

        }

        void scheduleUpdate() {

            Parcel data;

            data.writeInterfaceToken(IBatteryPropertiesRegistrar::getInterfaceDescriptor());

            remote()->transact(SCHEDULE_UPDATE, data, NULL);

        }

};

IMPLEMENT_META_INTERFACE(BatteryPropertiesRegistrar, "android.os.IBatteryPropertiesRegistrar");

status_t BnBatteryPropertiesRegistrar::onTransact(uint32_t code,

                                                  const Parcel& data,

                                                  Parcel* reply,

                                                  uint32_t flags)

{

    switch(code) {

        case REGISTER_LISTENER: {

            CHECK_INTERFACE(IBatteryPropertiesRegistrar, data, reply);

            sp<IBatteryPropertiesListener> listener =

                interface_cast<IBatteryPropertiesListener>(data.readStrongBinder());

            registerListener(listener);

            return OK;

        }

        case UNREGISTER_LISTENER: {

            CHECK_INTERFACE(IBatteryPropertiesRegistrar, data, reply);

            sp<IBatteryPropertiesListener> listener =

                interface_cast<IBatteryPropertiesListener>(data.readStrongBinder());

            unregisterListener(listener);

            return OK;

        }

        case GET_PROPERTY: {

            CHECK_INTERFACE(IBatteryPropertiesRegistrar, data, reply);

            int id = data.readInt32();

            struct BatteryProperty val;

            status_t result = getProperty(id, &val);

            reply->writeNoException();

            reply->writeInt32(result);

            reply->writeInt32(1);

            val.writeToParcel(reply);

            return OK;

        }

        case SCHEDULE_UPDATE: {

            CHECK_INTERFACE(IBatteryPropertiesRegistrar, data, reply);

            scheduleUpdate();

            return OK;

        }

    }

    return BBinder::onTransact(code, data, reply, flags);

};

// ----------------------------------------------------------------------------

}; // namespace android