Remove libbatteryservice. (cd8ebabb) · Commits · e / os / platform_frameworks_native

services/batteryservice/Android.bp

+0 −26

Original line number	Diff line number	Diff line
		@@ -5,29 +5,3 @@ cc_library_headers {
		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",
		],
		}

services/batteryservice/BatteryProperties.cpp

deleted100644 → 0

+0 −68

Original line number	Diff line number	Diff line
		/*
		* 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

services/batteryservice/BatteryProperty.cpp

deleted100644 → 0

+0 −40

Original line number	Diff line number	Diff line
		/*
		* 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

services/batteryservice/IBatteryPropertiesListener.cpp

deleted100644 → 0

+0 −64

Original line number	Diff line number	Diff line
		/*
		* 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

services/batteryservice/IBatteryPropertiesRegistrar.cpp

deleted100644 → 0

+0 −118

Original line number	Diff line number	Diff line
		/*
		* 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