1 /*
2 * Copyright 2020 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 #define LOG_TAG "TunerClient"
18
19 #include <android/binder_manager.h>
20 #include <android-base/logging.h>
21 #include <utils/Log.h>
22
23 #include "TunerClient.h"
24
25 using ::aidl::android::media::tv::tuner::TunerFrontendCapabilities;
26 using ::aidl::android::media::tv::tuner::TunerFrontendDtmbCapabilities;
27 using ::android::hardware::tv::tuner::V1_0::FrontendId;
28 using ::android::hardware::tv::tuner::V1_0::FrontendStatusType;
29 using ::android::hardware::tv::tuner::V1_0::FrontendType;
30
31 namespace android {
32
33 sp<ITuner> TunerClient::mTuner;
34 sp<::android::hardware::tv::tuner::V1_1::ITuner> TunerClient::mTuner_1_1;
35 shared_ptr<ITunerService> TunerClient::mTunerService;
36 int TunerClient::mTunerVersion;
37
38 /////////////// TunerClient ///////////////////////
39
TunerClient()40 TunerClient::TunerClient() {
41 // Get HIDL Tuner in migration stage.
42 getHidlTuner();
43 if (mTuner != NULL) {
44 updateTunerResources();
45 }
46 // Connect with Tuner Service.
47 ::ndk::SpAIBinder binder(AServiceManager_getService("media.tuner"));
48 mTunerService = ITunerService::fromBinder(binder);
49 if (mTunerService == NULL) {
50 ALOGE("Failed to get tuner service");
51 } else {
52 mTunerService->getTunerHalVersion(&mTunerVersion);
53 }
54 }
55
~TunerClient()56 TunerClient::~TunerClient() {
57 mTuner = NULL;
58 mTuner_1_1 = NULL;
59 mTunerVersion = 0;
60 mTunerService = NULL;
61 }
62
getFrontendIds()63 vector<FrontendId> TunerClient::getFrontendIds() {
64 vector<FrontendId> ids;
65
66 if (mTunerService != NULL) {
67 vector<int32_t> v;
68 Status s = mTunerService->getFrontendIds(&v);
69 if (ClientHelper::getServiceSpecificErrorCode(s) != Result::SUCCESS || v.size() == 0) {
70 ids.clear();
71 return ids;
72 }
73 for (int32_t id : v) {
74 ids.push_back(static_cast<FrontendId>(id));
75 }
76 return ids;
77 }
78
79 if (mTuner != NULL) {
80 Result res;
81 mTuner->getFrontendIds([&](Result r, const hardware::hidl_vec<FrontendId>& frontendIds) {
82 res = r;
83 ids = frontendIds;
84 });
85 if (res != Result::SUCCESS || ids.size() == 0) {
86 ALOGW("Frontend ids not available");
87 ids.clear();
88 return ids;
89 }
90 return ids;
91 }
92
93 return ids;
94 }
95
96
openFrontend(int frontendHandle)97 sp<FrontendClient> TunerClient::openFrontend(int frontendHandle) {
98 if (mTunerService != NULL) {
99 shared_ptr<ITunerFrontend> tunerFrontend;
100 Status s = mTunerService->openFrontend(frontendHandle, &tunerFrontend);
101 if (ClientHelper::getServiceSpecificErrorCode(s) != Result::SUCCESS
102 || tunerFrontend == NULL) {
103 return NULL;
104 }
105 int id;
106 s = tunerFrontend->getFrontendId(&id);
107 if (ClientHelper::getServiceSpecificErrorCode(s) != Result::SUCCESS) {
108 return NULL;
109 }
110 TunerFrontendInfo aidlFrontendInfo;
111 s = mTunerService->getFrontendInfo(id, &aidlFrontendInfo);
112 if (ClientHelper::getServiceSpecificErrorCode(s) != Result::SUCCESS) {
113 return NULL;
114 }
115 return new FrontendClient(tunerFrontend, aidlFrontendInfo.type);
116 }
117
118 if (mTuner != NULL) {
119 int id = getResourceIdFromHandle(frontendHandle, FRONTEND);
120 sp<IFrontend> hidlFrontend = openHidlFrontendById(id);
121 if (hidlFrontend != NULL) {
122 FrontendInfo hidlInfo;
123 Result res = getHidlFrontendInfo(id, hidlInfo);
124 if (res != Result::SUCCESS) {
125 return NULL;
126 }
127 sp<FrontendClient> frontendClient = new FrontendClient(
128 NULL, (int)hidlInfo.type);
129 frontendClient->setHidlFrontend(hidlFrontend);
130 frontendClient->setId(id);
131 return frontendClient;
132 }
133 }
134
135 return NULL;
136 }
137
getFrontendInfo(int id)138 shared_ptr<FrontendInfo> TunerClient::getFrontendInfo(int id) {
139 if (mTunerService != NULL) {
140 TunerFrontendInfo aidlFrontendInfo;
141 Status s = mTunerService->getFrontendInfo(id, &aidlFrontendInfo);
142 if (ClientHelper::getServiceSpecificErrorCode(s) != Result::SUCCESS) {
143 return NULL;
144 }
145 return make_shared<FrontendInfo>(frontendInfoAidlToHidl(aidlFrontendInfo));
146 }
147
148 if (mTuner != NULL) {
149 FrontendInfo hidlInfo;
150 Result res = getHidlFrontendInfo(id, hidlInfo);
151 if (res != Result::SUCCESS) {
152 return NULL;
153 }
154 return make_shared<FrontendInfo>(hidlInfo);
155 }
156
157 return NULL;
158 }
159
getFrontendDtmbCapabilities(int id)160 shared_ptr<FrontendDtmbCapabilities> TunerClient::getFrontendDtmbCapabilities(int id) {
161 if (mTunerService != NULL) {
162 TunerFrontendDtmbCapabilities dtmbCaps;
163 Status s = mTunerService->getFrontendDtmbCapabilities(id, &dtmbCaps);
164 if (ClientHelper::getServiceSpecificErrorCode(s) != Result::SUCCESS) {
165 return NULL;
166 }
167 FrontendDtmbCapabilities hidlCaps{
168 .transmissionModeCap = static_cast<uint32_t>(dtmbCaps.transmissionModeCap),
169 .bandwidthCap = static_cast<uint32_t>(dtmbCaps.bandwidthCap),
170 .modulationCap = static_cast<uint32_t>(dtmbCaps.modulationCap),
171 .codeRateCap = static_cast<uint32_t>(dtmbCaps.codeRateCap),
172 .guardIntervalCap = static_cast<uint32_t>(dtmbCaps.guardIntervalCap),
173 .interleaveModeCap = static_cast<uint32_t>(dtmbCaps.interleaveModeCap),
174 };
175 return make_shared<FrontendDtmbCapabilities>(hidlCaps);
176 }
177
178 if (mTuner_1_1 != NULL) {
179 Result result;
180 FrontendDtmbCapabilities dtmbCaps;
181 mTuner_1_1->getFrontendDtmbCapabilities(id,
182 [&](Result r, const FrontendDtmbCapabilities& caps) {
183 dtmbCaps = caps;
184 result = r;
185 });
186 if (result == Result::SUCCESS) {
187 return make_shared<FrontendDtmbCapabilities>(dtmbCaps);
188 }
189 }
190
191 return NULL;
192 }
193
openDemux(int demuxHandle)194 sp<DemuxClient> TunerClient::openDemux(int demuxHandle) {
195 if (mTunerService != NULL) {
196 shared_ptr<ITunerDemux> tunerDemux;
197 Status s = mTunerService->openDemux(demuxHandle, &tunerDemux);
198 if (ClientHelper::getServiceSpecificErrorCode(s) != Result::SUCCESS) {
199 return NULL;
200 }
201 return new DemuxClient(tunerDemux);
202 }
203
204 if (mTuner != NULL) {
205 sp<DemuxClient> demuxClient = new DemuxClient(NULL);
206 int demuxId;
207 sp<IDemux> hidlDemux = openHidlDemux(demuxId);
208 if (hidlDemux != NULL) {
209 demuxClient->setHidlDemux(hidlDemux);
210 demuxClient->setId(demuxId);
211 return demuxClient;
212 }
213 }
214
215 return NULL;
216 }
217
getDemuxCaps()218 shared_ptr<DemuxCapabilities> TunerClient::getDemuxCaps() {
219 if (mTunerService != NULL) {
220 TunerDemuxCapabilities aidlCaps;
221 Status s = mTunerService->getDemuxCaps(&aidlCaps);
222 if (ClientHelper::getServiceSpecificErrorCode(s) != Result::SUCCESS) {
223 return NULL;
224 }
225 return make_shared<DemuxCapabilities>(getHidlDemuxCaps(aidlCaps));
226 }
227
228 if (mTuner != NULL) {
229 Result res;
230 DemuxCapabilities caps;
231 mTuner->getDemuxCaps([&](Result r, const DemuxCapabilities& demuxCaps) {
232 caps = demuxCaps;
233 res = r;
234 });
235 if (res == Result::SUCCESS) {
236 return make_shared<DemuxCapabilities>(caps);
237 }
238 }
239
240 return NULL;
241 }
242
openDescrambler(int descramblerHandle)243 sp<DescramblerClient> TunerClient::openDescrambler(int descramblerHandle) {
244 if (mTunerService != NULL) {
245 shared_ptr<ITunerDescrambler> tunerDescrambler;
246 Status s = mTunerService->openDescrambler(descramblerHandle, &tunerDescrambler);
247 if (ClientHelper::getServiceSpecificErrorCode(s) != Result::SUCCESS) {
248 return NULL;
249 }
250 return new DescramblerClient(tunerDescrambler);
251 }
252
253 if (mTuner != NULL) {
254 sp<DescramblerClient> descramblerClient = new DescramblerClient(NULL);
255 sp<IDescrambler> hidlDescrambler = openHidlDescrambler();
256 if (hidlDescrambler != NULL) {
257 descramblerClient->setHidlDescrambler(hidlDescrambler);
258 return descramblerClient;
259 }
260 }
261
262 return NULL;
263 }
264
openLnb(int lnbHandle)265 sp<LnbClient> TunerClient::openLnb(int lnbHandle) {
266 if (mTunerService != NULL) {
267 shared_ptr<ITunerLnb> tunerLnb;
268 Status s = mTunerService->openLnb(lnbHandle, &tunerLnb);
269 if (ClientHelper::getServiceSpecificErrorCode(s) != Result::SUCCESS) {
270 return NULL;
271 }
272 return new LnbClient(tunerLnb);
273 }
274
275 if (mTuner != NULL) {
276 int id = getResourceIdFromHandle(lnbHandle, LNB);
277 sp<LnbClient> lnbClient = new LnbClient(NULL);
278 sp<ILnb> hidlLnb = openHidlLnbById(id);
279 if (hidlLnb != NULL) {
280 lnbClient->setHidlLnb(hidlLnb);
281 lnbClient->setId(id);
282 return lnbClient;
283 }
284 }
285
286 return NULL;
287 }
288
openLnbByName(string lnbName)289 sp<LnbClient> TunerClient::openLnbByName(string lnbName) {
290 if (mTunerService != NULL) {
291 shared_ptr<ITunerLnb> tunerLnb;
292 Status s = mTunerService->openLnbByName(lnbName, &tunerLnb);
293 if (ClientHelper::getServiceSpecificErrorCode(s) != Result::SUCCESS) {
294 return NULL;
295 }
296 return new LnbClient(tunerLnb);
297 }
298
299 if (mTuner != NULL) {
300 sp<LnbClient> lnbClient = new LnbClient(NULL);
301 LnbId id;
302 sp<ILnb> hidlLnb = openHidlLnbByName(lnbName, id);
303 if (hidlLnb != NULL) {
304 lnbClient->setHidlLnb(hidlLnb);
305 lnbClient->setId(id);
306 return lnbClient;
307 }
308 }
309
310 return NULL;
311 }
312
313 /////////////// TunerClient Helper Methods ///////////////////////
314
updateTunerResources()315 void TunerClient::updateTunerResources() {
316 if (mTuner == NULL) {
317 return;
318 }
319
320 // Connect with Tuner Resource Manager.
321 ::ndk::SpAIBinder binder(AServiceManager_getService("tv_tuner_resource_mgr"));
322 mTunerResourceManager = ITunerResourceManager::fromBinder(binder);
323
324 updateFrontendResources();
325 updateLnbResources();
326 // TODO: update Demux, Descrambler.
327 }
328
329 // TODO: remove after migration to Tuner Service is done.
updateFrontendResources()330 void TunerClient::updateFrontendResources() {
331 vector<FrontendId> ids = getFrontendIds();
332 if (ids.size() == 0) {
333 return;
334 }
335 vector<TunerFrontendInfo> infos;
336 for (int i = 0; i < ids.size(); i++) {
337 shared_ptr<FrontendInfo> frontendInfo = getFrontendInfo((int)ids[i]);
338 if (frontendInfo == NULL) {
339 continue;
340 }
341 TunerFrontendInfo tunerFrontendInfo{
342 .handle = getResourceHandleFromId((int)ids[i], FRONTEND),
343 .type = static_cast<int>(frontendInfo->type),
344 .exclusiveGroupId = static_cast<int>(frontendInfo->exclusiveGroupId),
345 };
346 infos.push_back(tunerFrontendInfo);
347 }
348 mTunerResourceManager->setFrontendInfoList(infos);
349 }
350
updateLnbResources()351 void TunerClient::updateLnbResources() {
352 vector<int> handles = getLnbHandles();
353 if (handles.size() == 0) {
354 return;
355 }
356 mTunerResourceManager->setLnbInfoList(handles);
357 }
358
getHidlTuner()359 sp<ITuner> TunerClient::getHidlTuner() {
360 if (mTuner == NULL) {
361 mTunerVersion = TUNER_HAL_VERSION_UNKNOWN;
362 mTuner_1_1 = ::android::hardware::tv::tuner::V1_1::ITuner::getService();
363
364 if (mTuner_1_1 == NULL) {
365 ALOGW("Failed to get tuner 1.1 service.");
366 mTuner = ITuner::getService();
367 if (mTuner == NULL) {
368 ALOGW("Failed to get tuner 1.0 service.");
369 } else {
370 mTunerVersion = TUNER_HAL_VERSION_1_0;
371 }
372 } else {
373 mTuner = static_cast<sp<ITuner>>(mTuner_1_1);
374 mTunerVersion = TUNER_HAL_VERSION_1_1;
375 }
376 }
377 return mTuner;
378 }
379
openHidlFrontendById(int id)380 sp<IFrontend> TunerClient::openHidlFrontendById(int id) {
381 sp<IFrontend> fe;
382 Result res;
383 mTuner->openFrontendById(id, [&](Result r, const sp<IFrontend>& frontend) {
384 fe = frontend;
385 res = r;
386 });
387 if (res != Result::SUCCESS || fe == nullptr) {
388 ALOGE("Failed to open frontend");
389 return NULL;
390 }
391 return fe;
392 }
393
getHidlFrontendInfo(int id,FrontendInfo & feInfo)394 Result TunerClient::getHidlFrontendInfo(int id, FrontendInfo& feInfo) {
395 Result res;
396 mTuner->getFrontendInfo(id, [&](Result r, const FrontendInfo& info) {
397 feInfo = info;
398 res = r;
399 });
400 return res;
401 }
402
openHidlDemux(int & demuxId)403 sp<IDemux> TunerClient::openHidlDemux(int& demuxId) {
404 sp<IDemux> demux;
405 Result res;
406
407 mTuner->openDemux([&](Result result, uint32_t id, const sp<IDemux>& demuxSp) {
408 demux = demuxSp;
409 demuxId = id;
410 res = result;
411 });
412 if (res != Result::SUCCESS || demux == nullptr) {
413 ALOGE("Failed to open demux");
414 return NULL;
415 }
416 return demux;
417 }
418
openHidlLnbById(int id)419 sp<ILnb> TunerClient::openHidlLnbById(int id) {
420 sp<ILnb> lnb;
421 Result res;
422
423 mTuner->openLnbById(id, [&](Result r, const sp<ILnb>& lnbSp) {
424 res = r;
425 lnb = lnbSp;
426 });
427 if (res != Result::SUCCESS || lnb == nullptr) {
428 ALOGE("Failed to open lnb by id");
429 return NULL;
430 }
431 return lnb;
432 }
433
openHidlLnbByName(string name,LnbId & lnbId)434 sp<ILnb> TunerClient::openHidlLnbByName(string name, LnbId& lnbId) {
435 sp<ILnb> lnb;
436 Result res;
437
438 mTuner->openLnbByName(name, [&](Result r, LnbId id, const sp<ILnb>& lnbSp) {
439 res = r;
440 lnb = lnbSp;
441 lnbId = id;
442 });
443 if (res != Result::SUCCESS || lnb == nullptr) {
444 ALOGE("Failed to open lnb by name");
445 return NULL;
446 }
447 return lnb;
448 }
449
450 // TODO: remove after migration to Tuner Service is done.
getLnbHandles()451 vector<int> TunerClient::getLnbHandles() {
452 vector<int> lnbHandles;
453 if (mTuner != NULL) {
454 Result res;
455 vector<LnbId> lnbIds;
456 mTuner->getLnbIds([&](Result r, const hardware::hidl_vec<LnbId>& ids) {
457 lnbIds = ids;
458 res = r;
459 });
460 if (res != Result::SUCCESS || lnbIds.size() == 0) {
461 ALOGW("Lnb isn't available");
462 } else {
463 for (int i = 0; i < lnbIds.size(); i++) {
464 lnbHandles.push_back(getResourceHandleFromId((int)lnbIds[i], LNB));
465 }
466 }
467 }
468
469 return lnbHandles;
470 }
471
openHidlDescrambler()472 sp<IDescrambler> TunerClient::openHidlDescrambler() {
473 sp<IDescrambler> descrambler;
474 Result res;
475
476 mTuner->openDescrambler([&](Result r, const sp<IDescrambler>& descramblerSp) {
477 res = r;
478 descrambler = descramblerSp;
479 });
480
481 if (res != Result::SUCCESS || descrambler == NULL) {
482 return NULL;
483 }
484
485 return descrambler;
486 }
487
getHidlDemuxCaps(TunerDemuxCapabilities & aidlCaps)488 DemuxCapabilities TunerClient::getHidlDemuxCaps(TunerDemuxCapabilities& aidlCaps) {
489 DemuxCapabilities caps{
490 .numDemux = (uint32_t)aidlCaps.numDemux,
491 .numRecord = (uint32_t)aidlCaps.numRecord,
492 .numPlayback = (uint32_t)aidlCaps.numPlayback,
493 .numTsFilter = (uint32_t)aidlCaps.numTsFilter,
494 .numSectionFilter = (uint32_t)aidlCaps.numSectionFilter,
495 .numAudioFilter = (uint32_t)aidlCaps.numAudioFilter,
496 .numVideoFilter = (uint32_t)aidlCaps.numVideoFilter,
497 .numPesFilter = (uint32_t)aidlCaps.numPesFilter,
498 .numPcrFilter = (uint32_t)aidlCaps.numPcrFilter,
499 .numBytesInSectionFilter = (uint32_t)aidlCaps.numBytesInSectionFilter,
500 .filterCaps = (uint32_t)aidlCaps.filterCaps,
501 .bTimeFilter = aidlCaps.bTimeFilter,
502 };
503 caps.linkCaps.resize(aidlCaps.linkCaps.size());
504 copy(aidlCaps.linkCaps.begin(), aidlCaps.linkCaps.end(), caps.linkCaps.begin());
505 return caps;
506 }
507
frontendInfoAidlToHidl(TunerFrontendInfo aidlFrontendInfo)508 FrontendInfo TunerClient::frontendInfoAidlToHidl(TunerFrontendInfo aidlFrontendInfo) {
509 FrontendInfo hidlFrontendInfo {
510 .type = static_cast<FrontendType>(aidlFrontendInfo.type),
511 .minFrequency = static_cast<uint32_t>(aidlFrontendInfo.minFrequency),
512 .maxFrequency = static_cast<uint32_t>(aidlFrontendInfo.maxFrequency),
513 .minSymbolRate = static_cast<uint32_t>(aidlFrontendInfo.minSymbolRate),
514 .maxSymbolRate = static_cast<uint32_t>(aidlFrontendInfo.maxSymbolRate),
515 .acquireRange = static_cast<uint32_t>(aidlFrontendInfo.acquireRange),
516 .exclusiveGroupId = static_cast<uint32_t>(aidlFrontendInfo.exclusiveGroupId),
517 };
518
519 int size = aidlFrontendInfo.statusCaps.size();
520 hidlFrontendInfo.statusCaps.resize(size);
521 for (int i = 0; i < size; i++) {
522 hidlFrontendInfo.statusCaps[i] =
523 static_cast<FrontendStatusType>(aidlFrontendInfo.statusCaps[i]);
524 }
525
526 switch (aidlFrontendInfo.caps.getTag()) {
527 case TunerFrontendCapabilities::analogCaps: {
528 auto analog = aidlFrontendInfo.caps.get<TunerFrontendCapabilities::analogCaps>();
529 hidlFrontendInfo.frontendCaps.analogCaps({
530 .typeCap = static_cast<uint32_t>(analog.typeCap),
531 .sifStandardCap = static_cast<uint32_t>(analog.sifStandardCap),
532 });
533 break;
534 }
535 case TunerFrontendCapabilities::atscCaps: {
536 auto atsc = aidlFrontendInfo.caps.get<TunerFrontendCapabilities::atscCaps>();
537 hidlFrontendInfo.frontendCaps.atscCaps({
538 .modulationCap = static_cast<uint32_t>(atsc.modulationCap),
539 });
540 break;
541 }
542 case TunerFrontendCapabilities::atsc3Caps: {
543 auto atsc3 = aidlFrontendInfo.caps.get<TunerFrontendCapabilities::atsc3Caps>();
544 hidlFrontendInfo.frontendCaps.atsc3Caps({
545 .bandwidthCap = static_cast<uint32_t>(atsc3.bandwidthCap),
546 .modulationCap = static_cast<uint32_t>(atsc3.modulationCap),
547 .timeInterleaveModeCap = static_cast<uint32_t>(atsc3.timeInterleaveModeCap),
548 .codeRateCap = static_cast<uint32_t>(atsc3.codeRateCap),
549 .fecCap = static_cast<uint32_t>(atsc3.fecCap),
550 .demodOutputFormatCap = static_cast<uint8_t>(atsc3.demodOutputFormatCap),
551 });
552 break;
553 }
554 case TunerFrontendCapabilities::cableCaps: {
555 auto cable = aidlFrontendInfo.caps.get<TunerFrontendCapabilities::cableCaps>();
556 hidlFrontendInfo.frontendCaps.dvbcCaps({
557 .modulationCap = static_cast<uint32_t>(cable.modulationCap),
558 .fecCap = static_cast<uint64_t>(cable.codeRateCap),
559 .annexCap = static_cast<uint8_t>(cable.annexCap),
560 });
561 break;
562 }
563 case TunerFrontendCapabilities::dvbsCaps: {
564 auto dvbs = aidlFrontendInfo.caps.get<TunerFrontendCapabilities::dvbsCaps>();
565 hidlFrontendInfo.frontendCaps.dvbsCaps({
566 .modulationCap = static_cast<int32_t>(dvbs.modulationCap),
567 .innerfecCap = static_cast<uint64_t>(dvbs.codeRateCap),
568 .standard = static_cast<uint8_t>(dvbs.standard),
569 });
570 break;
571 }
572 case TunerFrontendCapabilities::dvbtCaps: {
573 auto dvbt = aidlFrontendInfo.caps.get<TunerFrontendCapabilities::dvbtCaps>();
574 hidlFrontendInfo.frontendCaps.dvbtCaps({
575 .transmissionModeCap = static_cast<uint32_t>(dvbt.transmissionModeCap),
576 .bandwidthCap = static_cast<uint32_t>(dvbt.bandwidthCap),
577 .constellationCap = static_cast<uint32_t>(dvbt.constellationCap),
578 .coderateCap = static_cast<uint32_t>(dvbt.codeRateCap),
579 .hierarchyCap = static_cast<uint32_t>(dvbt.hierarchyCap),
580 .guardIntervalCap = static_cast<uint32_t>(dvbt.guardIntervalCap),
581 .isT2Supported = dvbt.isT2Supported,
582 .isMisoSupported = dvbt.isMisoSupported,
583 });
584 break;
585 }
586 case TunerFrontendCapabilities::isdbsCaps: {
587 auto isdbs = aidlFrontendInfo.caps.get<TunerFrontendCapabilities::isdbsCaps>();
588 hidlFrontendInfo.frontendCaps.isdbsCaps({
589 .modulationCap = static_cast<uint32_t>(isdbs.modulationCap),
590 .coderateCap = static_cast<uint32_t>(isdbs.codeRateCap),
591 });
592 break;
593 }
594 case TunerFrontendCapabilities::isdbs3Caps: {
595 auto isdbs3 = aidlFrontendInfo.caps.get<TunerFrontendCapabilities::isdbs3Caps>();
596 hidlFrontendInfo.frontendCaps.isdbs3Caps({
597 .modulationCap = static_cast<uint32_t>(isdbs3.modulationCap),
598 .coderateCap = static_cast<uint32_t>(isdbs3.codeRateCap),
599 });
600 break;
601 }
602 case TunerFrontendCapabilities::isdbtCaps: {
603 auto isdbt = aidlFrontendInfo.caps.get<TunerFrontendCapabilities::isdbtCaps>();
604 hidlFrontendInfo.frontendCaps.isdbtCaps({
605 .modeCap = static_cast<uint32_t>(isdbt.modeCap),
606 .bandwidthCap = static_cast<uint32_t>(isdbt.bandwidthCap),
607 .modulationCap = static_cast<uint32_t>(isdbt.modulationCap),
608 .coderateCap = static_cast<uint32_t>(isdbt.codeRateCap),
609 .guardIntervalCap = static_cast<uint32_t>(isdbt.guardIntervalCap),
610 });
611 break;
612 }
613 }
614 return hidlFrontendInfo;
615 }
616
617 // TODO: remove after migration to Tuner Service is done.
getResourceIdFromHandle(int handle,int)618 int TunerClient::getResourceIdFromHandle(int handle, int /*resourceType*/) {
619 return (handle & 0x00ff0000) >> 16;
620 }
621
622 // TODO: remove after migration to Tuner Service is done.
getResourceHandleFromId(int id,int resourceType)623 int TunerClient::getResourceHandleFromId(int id, int resourceType) {
624 return (resourceType & 0x000000ff) << 24
625 | (id << 16)
626 | (mResourceRequestCount++ & 0xffff);
627 }
628 } // namespace android
629