Gitiles
Code Review Sign In
review.evervolv.com / android_frameworks_av / 951bd8d1ad9581a414e171ad8605a9515d0ad667 / . / media / common_time / ICommonTimeConfig.cpp
blob: 8eb37cb8064ac3068383a21257e2644902498a78 [file] [log] [blame]
Mike J. Chen951bd8d2011-08-15 11:59:47 -0700[diff] [blame^]1/*
2 * Copyright (C) 2011 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#include <linux/socket.h>
17
18#include <common_time/ICommonTimeConfig.h>
19#include <binder/Parcel.h>
20
21#include "utils.h"
22
23namespace android {
24
25/***** ICommonTimeConfig *****/
26
27enum {
28 GET_MASTER_ELECTION_PRIORITY = IBinder::FIRST_CALL_TRANSACTION,
29 SET_MASTER_ELECTION_PRIORITY,
30 GET_MASTER_ELECTION_ENDPOINT,
31 SET_MASTER_ELECTION_ENDPOINT,
32 GET_MASTER_ELECTION_GROUP_ID,
33 SET_MASTER_ELECTION_GROUP_ID,
34 GET_INTERFACE_BINDING,
35 SET_INTERFACE_BINDING,
36 GET_MASTER_ANNOUNCE_INTERVAL,
37 SET_MASTER_ANNOUNCE_INTERVAL,
38 GET_CLIENT_SYNC_INTERVAL,
39 SET_CLIENT_SYNC_INTERVAL,
40 GET_PANIC_THRESHOLD,
41 SET_PANIC_THRESHOLD,
42 GET_AUTO_DISABLE,
43 SET_AUTO_DISABLE,
44 FORCE_NETWORKLESS_MASTER_MODE,
45};
46
47const String16 ICommonTimeConfig::kServiceName("common_time.config");
48
49class BpCommonTimeConfig : public BpInterface<ICommonTimeConfig>
50{
51 public:
52 BpCommonTimeConfig(const sp<IBinder>& impl)
53 : BpInterface<ICommonTimeConfig>(impl) {}
54
55 virtual status_t getMasterElectionPriority(uint8_t *priority) {
56 Parcel data, reply;
57 data.writeInterfaceToken(ICommonTimeConfig::getInterfaceDescriptor());
58 status_t status = remote()->transact(GET_MASTER_ELECTION_PRIORITY,
59 data,
60 &reply);
61 if (status == OK) {
62 status = reply.readInt32();
63 if (status == OK) {
64 *priority = static_cast<uint8_t>(reply.readInt32());
65 }
66 }
67
68 return status;
69 }
70
71 virtual status_t setMasterElectionPriority(uint8_t priority) {
72 Parcel data, reply;
73 data.writeInterfaceToken(ICommonTimeConfig::getInterfaceDescriptor());
74 data.writeInt32(static_cast<int32_t>(priority));
75 status_t status = remote()->transact(SET_MASTER_ELECTION_PRIORITY,
76 data,
77 &reply);
78 if (status == OK) {
79 status = reply.readInt32();
80 }
81
82 return status;
83 }
84
85 virtual status_t getMasterElectionEndpoint(struct sockaddr_storage *addr) {
86 Parcel data, reply;
87 data.writeInterfaceToken(ICommonTimeConfig::getInterfaceDescriptor());
88 status_t status = remote()->transact(GET_MASTER_ELECTION_ENDPOINT,
89 data,
90 &reply);
91 if (status == OK) {
92 status = reply.readInt32();
93 if (status == OK) {
94 deserializeSockaddr(&reply, addr);
95 }
96 }
97
98 return status;
99 }
100
101 virtual status_t setMasterElectionEndpoint(
102 const struct sockaddr_storage *addr) {
103 Parcel data, reply;
104 data.writeInterfaceToken(ICommonTimeConfig::getInterfaceDescriptor());
105 if (!canSerializeSockaddr(addr))
106 return BAD_VALUE;
107 if (NULL == addr) {
108 data.writeInt32(0);
109 } else {
110 data.writeInt32(1);
111 serializeSockaddr(&data, addr);
112 }
113 status_t status = remote()->transact(SET_MASTER_ELECTION_ENDPOINT,
114 data,
115 &reply);
116 if (status == OK) {
117 status = reply.readInt32();
118 }
119
120 return status;
121 }
122
123 virtual status_t getMasterElectionGroupId(uint64_t *id) {
124 Parcel data, reply;
125 data.writeInterfaceToken(ICommonTimeConfig::getInterfaceDescriptor());
126 status_t status = remote()->transact(GET_MASTER_ELECTION_GROUP_ID,
127 data,
128 &reply);
129
130 if (status == OK) {
131 status = reply.readInt32();
132 if (status == OK) {
133 *id = static_cast<uint64_t>(reply.readInt64());
134 }
135 }
136
137 return status;
138 }
139
140 virtual status_t setMasterElectionGroupId(uint64_t id) {
141 Parcel data, reply;
142 data.writeInterfaceToken(ICommonTimeConfig::getInterfaceDescriptor());
143 data.writeInt64(id);
144 status_t status = remote()->transact(SET_MASTER_ELECTION_GROUP_ID,
145 data,
146 &reply);
147
148 if (status == OK) {
149 status = reply.readInt32();
150 }
151
152 return status;
153 }
154
155 virtual status_t getInterfaceBinding(String16& ifaceName) {
156 Parcel data, reply;
157 data.writeInterfaceToken(ICommonTimeConfig::getInterfaceDescriptor());
158 status_t status = remote()->transact(GET_INTERFACE_BINDING,
159 data,
160 &reply);
161 if (status == OK) {
162 status = reply.readInt32();
163 if (status == OK) {
164 ifaceName = reply.readString16();
165 }
166 }
167
168 return status;
169 }
170
171 virtual status_t setInterfaceBinding(const String16& ifaceName) {
172 Parcel data, reply;
173 data.writeInterfaceToken(ICommonTimeConfig::getInterfaceDescriptor());
174 data.writeString16(ifaceName);
175 status_t status = remote()->transact(SET_INTERFACE_BINDING,
176 data,
177 &reply);
178 if (status == OK) {
179 status = reply.readInt32();
180 }
181
182 return status;
183 }
184
185 virtual status_t getMasterAnnounceInterval(int *interval) {
186 Parcel data, reply;
187 data.writeInterfaceToken(ICommonTimeConfig::getInterfaceDescriptor());
188 status_t status = remote()->transact(GET_MASTER_ANNOUNCE_INTERVAL,
189 data,
190 &reply);
191 if (status == OK) {
192 status = reply.readInt32();
193 if (status == OK) {
194 *interval = reply.readInt32();
195 }
196 }
197
198 return status;
199 }
200
201 virtual status_t setMasterAnnounceInterval(int interval) {
202 Parcel data, reply;
203 data.writeInterfaceToken(ICommonTimeConfig::getInterfaceDescriptor());
204 data.writeInt32(interval);
205 status_t status = remote()->transact(SET_MASTER_ANNOUNCE_INTERVAL,
206 data,
207 &reply);
208 if (status == OK) {
209 status = reply.readInt32();
210 }
211
212 return status;
213 }
214
215 virtual status_t getClientSyncInterval(int *interval) {
216 Parcel data, reply;
217 data.writeInterfaceToken(ICommonTimeConfig::getInterfaceDescriptor());
218 status_t status = remote()->transact(GET_CLIENT_SYNC_INTERVAL,
219 data,
220 &reply);
221 if (status == OK) {
222 status = reply.readInt32();
223 if (status == OK) {
224 *interval = reply.readInt32();
225 }
226 }
227
228 return status;
229 }
230
231 virtual status_t setClientSyncInterval(int interval) {
232 Parcel data, reply;
233 data.writeInterfaceToken(ICommonTimeConfig::getInterfaceDescriptor());
234 data.writeInt32(interval);
235 status_t status = remote()->transact(SET_CLIENT_SYNC_INTERVAL,
236 data,
237 &reply);
238 if (status == OK) {
239 status = reply.readInt32();
240 }
241
242 return status;
243 }
244
245 virtual status_t getPanicThreshold(int *threshold) {
246 Parcel data, reply;
247 data.writeInterfaceToken(ICommonTimeConfig::getInterfaceDescriptor());
248 status_t status = remote()->transact(GET_PANIC_THRESHOLD,
249 data,
250 &reply);
251 if (status == OK) {
252 status = reply.readInt32();
253 if (status == OK) {
254 *threshold = reply.readInt32();
255 }
256 }
257
258 return status;
259 }
260
261 virtual status_t setPanicThreshold(int threshold) {
262 Parcel data, reply;
263 data.writeInterfaceToken(ICommonTimeConfig::getInterfaceDescriptor());
264 data.writeInt32(threshold);
265 status_t status = remote()->transact(SET_PANIC_THRESHOLD,
266 data,
267 &reply);
268 if (status == OK) {
269 status = reply.readInt32();
270 }
271
272 return status;
273 }
274
275 virtual status_t getAutoDisable(bool *autoDisable) {
276 Parcel data, reply;
277 data.writeInterfaceToken(ICommonTimeConfig::getInterfaceDescriptor());
278 status_t status = remote()->transact(GET_AUTO_DISABLE,
279 data,
280 &reply);
281 if (status == OK) {
282 status = reply.readInt32();
283 if (status == OK) {
284 *autoDisable = (0 != reply.readInt32());
285 }
286 }
287
288 return status;
289 }
290
291 virtual status_t setAutoDisable(bool autoDisable) {
292 Parcel data, reply;
293 data.writeInterfaceToken(ICommonTimeConfig::getInterfaceDescriptor());
294 data.writeInt32(autoDisable ? 1 : 0);
295 status_t status = remote()->transact(SET_AUTO_DISABLE,
296 data,
297 &reply);
298
299 if (status == OK) {
300 status = reply.readInt32();
301 }
302
303 return status;
304 }
305
306 virtual status_t forceNetworklessMasterMode() {
307 Parcel data, reply;
308 data.writeInterfaceToken(ICommonTimeConfig::getInterfaceDescriptor());
309 status_t status = remote()->transact(FORCE_NETWORKLESS_MASTER_MODE,
310 data,
311 &reply);
312
313 if (status == OK) {
314 status = reply.readInt32();
315 }
316
317 return status;
318 }
319};
320
321IMPLEMENT_META_INTERFACE(CommonTimeConfig, "android.os.ICommonTimeConfig");
322
323status_t BnCommonTimeConfig::onTransact(uint32_t code,
324 const Parcel& data,
325 Parcel* reply,
326 uint32_t flags) {
327 switch(code) {
328 case GET_MASTER_ELECTION_PRIORITY: {
329 CHECK_INTERFACE(ICommonTimeConfig, data, reply);
330 uint8_t priority;
331 status_t status = getMasterElectionPriority(&priority);
332 reply->writeInt32(status);
333 if (status == OK) {
334 reply->writeInt32(static_cast<int32_t>(priority));
335 }
336 return OK;
337 } break;
338
339 case SET_MASTER_ELECTION_PRIORITY: {
340 CHECK_INTERFACE(ICommonTimeConfig, data, reply);
341 uint8_t priority = static_cast<uint8_t>(data.readInt32());
342 status_t status = setMasterElectionPriority(priority);
343 reply->writeInt32(status);
344 return OK;
345 } break;
346
347 case GET_MASTER_ELECTION_ENDPOINT: {
348 CHECK_INTERFACE(ICommonTimeConfig, data, reply);
349 struct sockaddr_storage addr;
350 status_t status = getMasterElectionEndpoint(&addr);
351
352 if ((status == OK) && !canSerializeSockaddr(&addr)) {
353 status = UNKNOWN_ERROR;
354 }
355
356 reply->writeInt32(status);
357
358 if (status == OK) {
359 serializeSockaddr(reply, &addr);
360 }
361
362 return OK;
363 } break;
364
365 case SET_MASTER_ELECTION_ENDPOINT: {
366 CHECK_INTERFACE(ICommonTimeConfig, data, reply);
367 struct sockaddr_storage addr;
368 int hasAddr = data.readInt32();
369
370 status_t status;
371 if (hasAddr) {
372 deserializeSockaddr(&data, &addr);
373 status = setMasterElectionEndpoint(&addr);
374 } else {
375 status = setMasterElectionEndpoint(&addr);
376 }
377
378 reply->writeInt32(status);
379 return OK;
380 } break;
381
382 case GET_MASTER_ELECTION_GROUP_ID: {
383 CHECK_INTERFACE(ICommonTimeConfig, data, reply);
384 uint64_t id;
385 status_t status = getMasterElectionGroupId(&id);
386 reply->writeInt32(status);
387 if (status == OK) {
388 reply->writeInt64(id);
389 }
390 return OK;
391 } break;
392
393 case SET_MASTER_ELECTION_GROUP_ID: {
394 CHECK_INTERFACE(ICommonTimeConfig, data, reply);
395 uint64_t id = static_cast<uint64_t>(data.readInt64());
396 status_t status = setMasterElectionGroupId(id);
397 reply->writeInt32(status);
398 return OK;
399 } break;
400
401 case GET_INTERFACE_BINDING: {
402 CHECK_INTERFACE(ICommonTimeConfig, data, reply);
403 String16 ret;
404 status_t status = getInterfaceBinding(ret);
405 reply->writeInt32(status);
406 if (status == OK) {
407 reply->writeString16(ret);
408 }
409 return OK;
410 } break;
411
412 case SET_INTERFACE_BINDING: {
413 CHECK_INTERFACE(ICommonTimeConfig, data, reply);
414 String16 ifaceName;
415 ifaceName = data.readString16();
416 status_t status = setInterfaceBinding(ifaceName);
417 reply->writeInt32(status);
418 return OK;
419 } break;
420
421 case GET_MASTER_ANNOUNCE_INTERVAL: {
422 CHECK_INTERFACE(ICommonTimeConfig, data, reply);
423 int interval;
424 status_t status = getMasterAnnounceInterval(&interval);
425 reply->writeInt32(status);
426 if (status == OK) {
427 reply->writeInt32(interval);
428 }
429 return OK;
430 } break;
431
432 case SET_MASTER_ANNOUNCE_INTERVAL: {
433 CHECK_INTERFACE(ICommonTimeConfig, data, reply);
434 int interval = data.readInt32();
435 status_t status = setMasterAnnounceInterval(interval);
436 reply->writeInt32(status);
437 return OK;
438 } break;
439
440 case GET_CLIENT_SYNC_INTERVAL: {
441 CHECK_INTERFACE(ICommonTimeConfig, data, reply);
442 int interval;
443 status_t status = getClientSyncInterval(&interval);
444 reply->writeInt32(status);
445 if (status == OK) {
446 reply->writeInt32(interval);
447 }
448 return OK;
449 } break;
450
451 case SET_CLIENT_SYNC_INTERVAL: {
452 CHECK_INTERFACE(ICommonTimeConfig, data, reply);
453 int interval = data.readInt32();
454 status_t status = setClientSyncInterval(interval);
455 reply->writeInt32(status);
456 return OK;
457 } break;
458
459 case GET_PANIC_THRESHOLD: {
460 CHECK_INTERFACE(ICommonTimeConfig, data, reply);
461 int threshold;
462 status_t status = getPanicThreshold(&threshold);
463 reply->writeInt32(status);
464 if (status == OK) {
465 reply->writeInt32(threshold);
466 }
467 return OK;
468 } break;
469
470 case SET_PANIC_THRESHOLD: {
471 CHECK_INTERFACE(ICommonTimeConfig, data, reply);
472 int threshold = data.readInt32();
473 status_t status = setPanicThreshold(threshold);
474 reply->writeInt32(status);
475 return OK;
476 } break;
477
478 case GET_AUTO_DISABLE: {
479 CHECK_INTERFACE(ICommonTimeConfig, data, reply);
480 bool autoDisable;
481 status_t status = getAutoDisable(&autoDisable);
482 reply->writeInt32(status);
483 if (status == OK) {
484 reply->writeInt32(autoDisable ? 1 : 0);
485 }
486 return OK;
487 } break;
488
489 case SET_AUTO_DISABLE: {
490 CHECK_INTERFACE(ICommonTimeConfig, data, reply);
491 bool autoDisable = (0 != data.readInt32());
492 status_t status = setAutoDisable(autoDisable);
493 reply->writeInt32(status);
494 return OK;
495 } break;
496
497 case FORCE_NETWORKLESS_MASTER_MODE: {
498 CHECK_INTERFACE(ICommonTimeConfig, data, reply);
499 status_t status = forceNetworklessMasterMode();
500 reply->writeInt32(status);
501 return OK;
502 } break;
503 }
504 return BBinder::onTransact(code, data, reply, flags);
505}
506
507}; // namespace android
508