1 /*
2  * Copyright (C) 2013 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #include <batterystats/IBatteryStats.h>
18 
19 #include <utils/Log.h>
20 #include <binder/Parcel.h>
21 #include <utils/String8.h>
22 
23 namespace android {
24 
25 // ----------------------------------------------------------------------
26 
27 class BpBatteryStats : public BpInterface<IBatteryStats>
28 {
29 public:
BpBatteryStats(const sp<IBinder> & impl)30     explicit BpBatteryStats(const sp<IBinder>& impl)
31         : BpInterface<IBatteryStats>(impl)
32     {
33     }
34 
noteStartSensor(int uid,int sensor)35     virtual void noteStartSensor(int uid, int sensor) {
36         Parcel data, reply;
37         data.writeInterfaceToken(IBatteryStats::getInterfaceDescriptor());
38         data.writeInt32(uid);
39         data.writeInt32(sensor);
40         remote()->transact(NOTE_START_SENSOR_TRANSACTION, data, &reply);
41     }
42 
noteStopSensor(int uid,int sensor)43     virtual void noteStopSensor(int uid, int sensor) {
44         Parcel data, reply;
45         data.writeInterfaceToken(IBatteryStats::getInterfaceDescriptor());
46         data.writeInt32(uid);
47         data.writeInt32(sensor);
48         remote()->transact(NOTE_STOP_SENSOR_TRANSACTION, data, &reply);
49     }
50 
noteStartVideo(int uid)51     virtual void noteStartVideo(int uid) {
52         Parcel data, reply;
53         data.writeInterfaceToken(IBatteryStats::getInterfaceDescriptor());
54         data.writeInt32(uid);
55         remote()->transact(NOTE_START_VIDEO_TRANSACTION, data, &reply);
56     }
57 
noteStopVideo(int uid)58     virtual void noteStopVideo(int uid) {
59         Parcel data, reply;
60         data.writeInterfaceToken(IBatteryStats::getInterfaceDescriptor());
61         data.writeInt32(uid);
62         remote()->transact(NOTE_STOP_VIDEO_TRANSACTION, data, &reply);
63     }
64 
noteStartAudio(int uid)65     virtual void noteStartAudio(int uid) {
66         Parcel data, reply;
67         data.writeInterfaceToken(IBatteryStats::getInterfaceDescriptor());
68         data.writeInt32(uid);
69         remote()->transact(NOTE_START_AUDIO_TRANSACTION, data, &reply);
70     }
71 
noteStopAudio(int uid)72     virtual void noteStopAudio(int uid) {
73         Parcel data, reply;
74         data.writeInterfaceToken(IBatteryStats::getInterfaceDescriptor());
75         data.writeInt32(uid);
76         remote()->transact(NOTE_STOP_AUDIO_TRANSACTION, data, &reply);
77     }
78 
noteResetVideo()79     virtual void noteResetVideo() {
80         Parcel data, reply;
81         data.writeInterfaceToken(IBatteryStats::getInterfaceDescriptor());
82         remote()->transact(NOTE_RESET_VIDEO_TRANSACTION, data, &reply);
83     }
84 
noteResetAudio()85     virtual void noteResetAudio() {
86         Parcel data, reply;
87         data.writeInterfaceToken(IBatteryStats::getInterfaceDescriptor());
88         remote()->transact(NOTE_RESET_AUDIO_TRANSACTION, data, &reply);
89     }
90 
noteFlashlightOn(int uid)91     virtual void noteFlashlightOn(int uid) {
92         Parcel data, reply;
93         data.writeInterfaceToken(IBatteryStats::getInterfaceDescriptor());
94         data.writeInt32(uid);
95         remote()->transact(NOTE_FLASHLIGHT_ON_TRANSACTION, data, &reply);
96     }
97 
noteFlashlightOff(int uid)98     virtual void noteFlashlightOff(int uid) {
99         Parcel data, reply;
100         data.writeInterfaceToken(IBatteryStats::getInterfaceDescriptor());
101         data.writeInt32(uid);
102         remote()->transact(NOTE_FLASHLIGHT_OFF_TRANSACTION, data, &reply);
103     }
104 
noteStartCamera(int uid)105     virtual void noteStartCamera(int uid) {
106         Parcel data, reply;
107         data.writeInterfaceToken(IBatteryStats::getInterfaceDescriptor());
108         data.writeInt32(uid);
109         remote()->transact(NOTE_START_CAMERA_TRANSACTION, data, &reply);
110     }
111 
noteStopCamera(int uid)112     virtual void noteStopCamera(int uid) {
113         Parcel data, reply;
114         data.writeInterfaceToken(IBatteryStats::getInterfaceDescriptor());
115         data.writeInt32(uid);
116         remote()->transact(NOTE_STOP_CAMERA_TRANSACTION, data, &reply);
117     }
118 
noteResetCamera()119     virtual void noteResetCamera() {
120         Parcel data, reply;
121         data.writeInterfaceToken(IBatteryStats::getInterfaceDescriptor());
122         remote()->transact(NOTE_RESET_CAMERA_TRANSACTION, data, &reply);
123     }
124 
noteResetFlashlight()125     virtual void noteResetFlashlight() {
126         Parcel data, reply;
127         data.writeInterfaceToken(IBatteryStats::getInterfaceDescriptor());
128         remote()->transact(NOTE_RESET_FLASHLIGHT_TRANSACTION, data, &reply);
129     }
130 
131 };
132 
133 IMPLEMENT_META_INTERFACE(BatteryStats, "com.android.internal.app.IBatteryStats")
134 
135 // ----------------------------------------------------------------------
136 
137 // NOLINTNEXTLINE(google-default-arguments)
138 status_t BnBatteryStats::onTransact(
139     uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
140 {
141     switch(code) {
142         case NOTE_START_SENSOR_TRANSACTION: {
143             CHECK_INTERFACE(IBatteryStats, data, reply);
144             int uid = data.readInt32();
145             int sensor = data.readInt32();
146             noteStartSensor(uid, sensor);
147             reply->writeNoException();
148             return NO_ERROR;
149         } break;
150         case NOTE_STOP_SENSOR_TRANSACTION: {
151             CHECK_INTERFACE(IBatteryStats, data, reply);
152             int uid = data.readInt32();
153             int sensor = data.readInt32();
154             noteStopSensor(uid, sensor);
155             reply->writeNoException();
156             return NO_ERROR;
157         } break;
158         case NOTE_START_VIDEO_TRANSACTION: {
159             CHECK_INTERFACE(IBatteryStats, data, reply);
160             int uid = data.readInt32();
161             noteStartVideo(uid);
162             reply->writeNoException();
163             return NO_ERROR;
164         } break;
165         case NOTE_STOP_VIDEO_TRANSACTION: {
166             CHECK_INTERFACE(IBatteryStats, data, reply);
167             int uid = data.readInt32();
168             noteStopVideo(uid);
169             reply->writeNoException();
170             return NO_ERROR;
171         } break;
172         case NOTE_START_AUDIO_TRANSACTION: {
173             CHECK_INTERFACE(IBatteryStats, data, reply);
174             int uid = data.readInt32();
175             noteStartAudio(uid);
176             reply->writeNoException();
177             return NO_ERROR;
178         } break;
179         case NOTE_STOP_AUDIO_TRANSACTION: {
180             CHECK_INTERFACE(IBatteryStats, data, reply);
181             int uid = data.readInt32();
182             noteStopAudio(uid);
183             reply->writeNoException();
184             return NO_ERROR;
185         } break;
186         case NOTE_RESET_VIDEO_TRANSACTION: {
187             CHECK_INTERFACE(IBatteryStats, data, reply);
188             noteResetVideo();
189             reply->writeNoException();
190             return NO_ERROR;
191         } break;
192         case NOTE_RESET_AUDIO_TRANSACTION: {
193             CHECK_INTERFACE(IBatteryStats, data, reply);
194             noteResetAudio();
195             reply->writeNoException();
196             return NO_ERROR;
197         } break;
198         case NOTE_FLASHLIGHT_ON_TRANSACTION: {
199             CHECK_INTERFACE(IBatteryStats, data, reply);
200             int uid = data.readInt32();
201             noteFlashlightOn(uid);
202             reply->writeNoException();
203             return NO_ERROR;
204         } break;
205         case NOTE_FLASHLIGHT_OFF_TRANSACTION: {
206             CHECK_INTERFACE(IBatteryStats, data, reply);
207             int uid = data.readInt32();
208             noteFlashlightOff(uid);
209             reply->writeNoException();
210             return NO_ERROR;
211         } break;
212         case NOTE_START_CAMERA_TRANSACTION: {
213             CHECK_INTERFACE(IBatteryStats, data, reply);
214             int uid = data.readInt32();
215             noteStartCamera(uid);
216             reply->writeNoException();
217             return NO_ERROR;
218         } break;
219         case NOTE_STOP_CAMERA_TRANSACTION: {
220             CHECK_INTERFACE(IBatteryStats, data, reply);
221             int uid = data.readInt32();
222             noteStopCamera(uid);
223             reply->writeNoException();
224             return NO_ERROR;
225         } break;
226         case NOTE_RESET_CAMERA_TRANSACTION: {
227             CHECK_INTERFACE(IBatteryStats, data, reply);
228             noteResetCamera();
229             reply->writeNoException();
230             return NO_ERROR;
231         } break;
232         case NOTE_RESET_FLASHLIGHT_TRANSACTION: {
233             CHECK_INTERFACE(IBatteryStats, data, reply);
234             noteResetFlashlight();
235             reply->writeNoException();
236             return NO_ERROR;
237         } break;
238         default:
239             return BBinder::onTransact(code, data, reply, flags);
240     }
241 }
242 
243 } // namespace android
244