blob: 2be13d3c0b1334c42b866a2b5a30bbf4424976c9 [file] [log] [blame]
Hongguang4092f2f2021-07-08 18:49:12 -07001/*
2 * Copyright 2021 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_NDEBUG 0
18#define LOG_TAG "android.hardware.tv.tuner-service.example-Frontend"
19
20#include "Frontend.h"
21#include <utils/Log.h>
22
23namespace aidl {
24namespace android {
25namespace hardware {
26namespace tv {
27namespace tuner {
28
29Frontend::Frontend(FrontendType type, int32_t id, std::shared_ptr<Tuner> tuner) {
30 mType = type;
31 mId = id;
32 mTunerService = tuner;
33 // Init callback to nullptr
34 mCallback = nullptr;
35}
36
37Frontend::~Frontend() {}
38
39::ndk::ScopedAStatus Frontend::close() {
40 ALOGV("%s", __FUNCTION__);
41 // Reset callback
42 mCallback = nullptr;
43 mIsLocked = false;
44 mTunerService->removeFrontend(mId);
45
46 return ::ndk::ScopedAStatus::ok();
47}
48
49::ndk::ScopedAStatus Frontend::setCallback(const std::shared_ptr<IFrontendCallback>& in_callback) {
50 ALOGV("%s", __FUNCTION__);
51 if (in_callback == nullptr) {
52 ALOGW("[ WARN ] Set Frontend callback with nullptr");
53 return ::ndk::ScopedAStatus::fromExceptionCode(STATUS_INVALID_OPERATION);
54 }
55
56 mCallback = in_callback;
57 return ::ndk::ScopedAStatus::ok();
58}
59
60::ndk::ScopedAStatus Frontend::tune(const FrontendSettings& /* in_settings */) {
61 ALOGV("%s", __FUNCTION__);
62 if (mCallback == nullptr) {
63 ALOGW("[ WARN ] Frontend callback is not set when tune");
64 return ::ndk::ScopedAStatus::fromExceptionCode(STATUS_INVALID_OPERATION);
65 }
66
67 mTunerService->frontendStartTune(mId);
68 mCallback->onEvent(FrontendEventType::LOCKED);
69 mIsLocked = true;
70
71 return ::ndk::ScopedAStatus::ok();
72}
73
74::ndk::ScopedAStatus Frontend::stopTune() {
75 ALOGV("%s", __FUNCTION__);
76
77 mTunerService->frontendStopTune(mId);
78 mIsLocked = false;
79
80 return ::ndk::ScopedAStatus::ok();
81}
82
83::ndk::ScopedAStatus Frontend::scan(const FrontendSettings& in_settings, FrontendScanType in_type) {
84 ALOGV("%s", __FUNCTION__);
85 FrontendScanMessage msg;
86
87 if (mIsLocked) {
88 msg.set<FrontendScanMessage::Tag::isEnd>(true);
89 mCallback->onScanMessage(FrontendScanMessageType::END, msg);
90 return ::ndk::ScopedAStatus::ok();
91 }
92
93 int32_t frequency = 0;
94 switch (in_settings.getTag()) {
95 case FrontendSettings::Tag::analog:
96 frequency = in_settings.get<FrontendSettings::Tag::analog>().frequency;
97 break;
98 case FrontendSettings::Tag::atsc:
99 frequency = in_settings.get<FrontendSettings::Tag::atsc>().frequency;
100 break;
101 case FrontendSettings::Tag::atsc3:
102 frequency = in_settings.get<FrontendSettings::Tag::atsc3>().frequency;
103 break;
104 case FrontendSettings::Tag::dvbs:
105 frequency = in_settings.get<FrontendSettings::Tag::dvbs>().frequency;
106 break;
107 case FrontendSettings::Tag::dvbc:
108 frequency = in_settings.get<FrontendSettings::Tag::dvbc>().frequency;
109 break;
110 case FrontendSettings::Tag::dvbt:
111 frequency = in_settings.get<FrontendSettings::Tag::dvbt>().frequency;
112 break;
113 case FrontendSettings::Tag::isdbs:
114 frequency = in_settings.get<FrontendSettings::Tag::isdbs>().frequency;
115 break;
116 case FrontendSettings::Tag::isdbs3:
117 frequency = in_settings.get<FrontendSettings::Tag::isdbs3>().frequency;
118 break;
119 case FrontendSettings::Tag::isdbt:
120 frequency = in_settings.get<FrontendSettings::Tag::isdbt>().frequency;
121 break;
122 default:
123 break;
124 }
125
126 if (in_type == FrontendScanType::SCAN_BLIND) {
127 frequency += 100;
128 }
129
130 {
131 FrontendScanMessage msg;
132 vector<int32_t> frequencies = {frequency};
133 msg.set<FrontendScanMessage::Tag::frequencies>(frequencies);
134 mCallback->onScanMessage(FrontendScanMessageType::FREQUENCY, msg);
135 }
136
137 {
138 FrontendScanMessage msg;
139 msg.set<FrontendScanMessage::Tag::progressPercent>(20);
140 mCallback->onScanMessage(FrontendScanMessageType::PROGRESS_PERCENT, msg);
141 }
142
143 {
144 FrontendScanMessage msg;
145 vector<int32_t> symbolRates = {30};
146 msg.set<FrontendScanMessage::Tag::symbolRates>(symbolRates);
147 mCallback->onScanMessage(FrontendScanMessageType::SYMBOL_RATE, msg);
148 }
149
150 if (mType == FrontendType::DVBT) {
151 FrontendScanMessage msg;
152 msg.set<FrontendScanMessage::Tag::hierarchy>(FrontendDvbtHierarchy::HIERARCHY_NON_NATIVE);
153 mCallback->onScanMessage(FrontendScanMessageType::HIERARCHY, msg);
154 }
155
156 if (mType == FrontendType::ANALOG) {
157 FrontendScanMessage msg;
158 msg.set<FrontendScanMessage::Tag::analogType>(FrontendAnalogType::PAL);
159 mCallback->onScanMessage(FrontendScanMessageType::ANALOG_TYPE, msg);
160 }
161
162 {
163 FrontendScanMessage msg;
164 vector<uint8_t> plpIds = {2};
165 msg.set<FrontendScanMessage::Tag::plpIds>(plpIds);
166 mCallback->onScanMessage(FrontendScanMessageType::PLP_IDS, msg);
167 }
168
169 {
170 FrontendScanMessage msg;
171 vector<uint8_t> groupIds = {3};
172 msg.set<FrontendScanMessage::Tag::groupIds>(groupIds);
173 mCallback->onScanMessage(FrontendScanMessageType::GROUP_IDS, msg);
174 }
175
176 {
177 FrontendScanMessage msg;
178 vector<char16_t> inputStreamIds = {1};
179 msg.set<FrontendScanMessage::Tag::inputStreamIds>(inputStreamIds);
180 mCallback->onScanMessage(FrontendScanMessageType::INPUT_STREAM_IDS, msg);
181 }
182
183 switch (mType) {
184 case FrontendType::DVBT: {
185 FrontendScanMessage msg;
186 FrontendScanMessageStandard std;
187 std.set<FrontendScanMessageStandard::Tag::tStd>(FrontendDvbtStandard::AUTO);
188 msg.set<FrontendScanMessage::Tag::std>(std);
189 mCallback->onScanMessage(FrontendScanMessageType::STANDARD, msg);
190 break;
191 }
192 case FrontendType::DVBS: {
193 FrontendScanMessage msg;
194 FrontendScanMessageStandard std;
195 std.set<FrontendScanMessageStandard::Tag::sStd>(FrontendDvbsStandard::AUTO);
196 msg.set<FrontendScanMessage::Tag::std>(std);
197 mCallback->onScanMessage(FrontendScanMessageType::STANDARD, msg);
198 break;
199 }
200 case FrontendType::ANALOG: {
201 FrontendScanMessage msg;
202 FrontendScanMessageStandard std;
203 std.set<FrontendScanMessageStandard::Tag::sifStd>(FrontendAnalogSifStandard::AUTO);
204 msg.set<FrontendScanMessage::Tag::std>(std);
205 mCallback->onScanMessage(FrontendScanMessageType::STANDARD, msg);
206 break;
207 }
208 default:
209 break;
210 }
211
212 {
213 FrontendScanMessage msg;
214 FrontendScanAtsc3PlpInfo info;
215 info.plpId = 1;
216 info.bLlsFlag = false;
217 vector<FrontendScanAtsc3PlpInfo> atsc3PlpInfos = {info};
218 msg.set<FrontendScanMessage::Tag::atsc3PlpInfos>(atsc3PlpInfos);
219 mCallback->onScanMessage(FrontendScanMessageType::ATSC3_PLP_INFO, msg);
220 }
221
222 {
223 FrontendScanMessage msg;
224 FrontendModulation modulation;
225 modulation.set<FrontendModulation::Tag::dvbc>(FrontendDvbcModulation::MOD_16QAM);
226 msg.set<FrontendScanMessage::Tag::modulation>(modulation);
227 mCallback->onScanMessage(FrontendScanMessageType::MODULATION, msg);
228 }
229
230 {
231 FrontendScanMessage msg;
232 msg.set<FrontendScanMessage::Tag::isHighPriority>(true);
233 mCallback->onScanMessage(FrontendScanMessageType::HIGH_PRIORITY, msg);
234 }
235
236 {
237 FrontendScanMessage msg;
238 msg.set<FrontendScanMessage::Tag::isLocked>(true);
239 mCallback->onScanMessage(FrontendScanMessageType::LOCKED, msg);
240 mIsLocked = true;
241 }
242
243 return ::ndk::ScopedAStatus::ok();
244}
245
246::ndk::ScopedAStatus Frontend::stopScan() {
247 ALOGV("%s", __FUNCTION__);
248
249 mIsLocked = false;
250 return ::ndk::ScopedAStatus::ok();
251}
252
253::ndk::ScopedAStatus Frontend::getStatus(const std::vector<FrontendStatusType>& in_statusTypes,
254 std::vector<FrontendStatus>* _aidl_return) {
255 ALOGV("%s", __FUNCTION__);
256
257 for (int i = 0; i < in_statusTypes.size(); i++) {
258 FrontendStatusType type = in_statusTypes[i];
259 FrontendStatus status;
260 // assign randomly selected values for testing.
261 switch (type) {
262 case FrontendStatusType::DEMOD_LOCK: {
263 status.set<FrontendStatus::isDemodLocked>(true);
264 break;
265 }
266 case FrontendStatusType::SNR: {
267 status.set<FrontendStatus::snr>(221);
268 break;
269 }
270 case FrontendStatusType::BER: {
271 status.set<FrontendStatus::ber>(1);
272 break;
273 }
274 case FrontendStatusType::PER: {
275 status.set<FrontendStatus::per>(2);
276 break;
277 }
278 case FrontendStatusType::PRE_BER: {
279 status.set<FrontendStatus::preBer>(3);
280 break;
281 }
282 case FrontendStatusType::SIGNAL_QUALITY: {
283 status.set<FrontendStatus::signalQuality>(4);
284 break;
285 }
286 case FrontendStatusType::SIGNAL_STRENGTH: {
287 status.set<FrontendStatus::signalStrength>(5);
288 break;
289 }
290 case FrontendStatusType::SYMBOL_RATE: {
291 status.set<FrontendStatus::symbolRate>(6);
292 break;
293 }
294 case FrontendStatusType::FEC: {
295 status.set<FrontendStatus::innerFec>(FrontendInnerFec::FEC_2_9); // value = 1 << 7
296 break;
297 }
298 case FrontendStatusType::MODULATION: {
299 switch (mType) {
300 case FrontendType::ISDBS: {
301 FrontendModulationStatus modulationStatus;
302 modulationStatus.set<FrontendModulationStatus::Tag::isdbs>(
303 FrontendIsdbsModulation::MOD_BPSK); // value = 1 << 1
304 status.set<FrontendStatus::modulationStatus>(modulationStatus);
305 break;
306 }
307 case FrontendType::DVBC: {
308 FrontendModulationStatus modulationStatus;
309 modulationStatus.set<FrontendModulationStatus::Tag::dvbc>(
310 FrontendDvbcModulation::MOD_16QAM); // value = 1 << 1
311 status.set<FrontendStatus::modulationStatus>(modulationStatus);
312 break;
313 }
314 case FrontendType::DVBS: {
315 FrontendModulationStatus modulationStatus;
316 modulationStatus.set<FrontendModulationStatus::Tag::dvbs>(
317 FrontendDvbsModulation::MOD_QPSK); // value = 1 << 1
318 status.set<FrontendStatus::modulationStatus>(modulationStatus);
319 break;
320 }
321 case FrontendType::ISDBS3: {
322 FrontendModulationStatus modulationStatus;
323 modulationStatus.set<FrontendModulationStatus::Tag::isdbs3>(
324 FrontendIsdbs3Modulation::MOD_BPSK); // value = 1 << 1
325 status.set<FrontendStatus::modulationStatus>(modulationStatus);
326 break;
327 }
328 case FrontendType::ISDBT: {
329 FrontendModulationStatus modulationStatus;
330 modulationStatus.set<FrontendModulationStatus::Tag::isdbt>(
331 FrontendIsdbtModulation::MOD_DQPSK); // value = 1 << 1
332 status.set<FrontendStatus::modulationStatus>(modulationStatus);
333 break;
334 }
335 default:
336 break;
337 }
338 break;
339 }
340 case FrontendStatusType::SPECTRAL: {
341 status.set<FrontendStatus::inversion>(FrontendSpectralInversion::NORMAL);
342 break;
343 }
344 case FrontendStatusType::LNB_VOLTAGE: {
345 status.set<FrontendStatus::lnbVoltage>(LnbVoltage::VOLTAGE_5V);
346 break;
347 }
348 case FrontendStatusType::PLP_ID: {
349 status.set<FrontendStatus::plpId>(101); // type uint8_t
350 break;
351 }
352 case FrontendStatusType::EWBS: {
353 status.set<FrontendStatus::isEWBS>(false);
354 break;
355 }
356 case FrontendStatusType::AGC: {
357 status.set<FrontendStatus::agc>(7);
358 break;
359 }
360 case FrontendStatusType::LNA: {
361 status.set<FrontendStatus::isLnaOn>(false);
362 break;
363 }
364 case FrontendStatusType::LAYER_ERROR: {
365 vector<bool> v = {false, true, true};
366 status.set<FrontendStatus::isLayerError>(v);
367 break;
368 }
369 case FrontendStatusType::MER: {
370 status.set<FrontendStatus::mer>(8);
371 break;
372 }
373 case FrontendStatusType::FREQ_OFFSET: {
374 status.set<FrontendStatus::freqOffset>(9);
375 break;
376 }
377 case FrontendStatusType::HIERARCHY: {
378 status.set<FrontendStatus::hierarchy>(FrontendDvbtHierarchy::HIERARCHY_1_NATIVE);
379 break;
380 }
381 case FrontendStatusType::RF_LOCK: {
382 status.set<FrontendStatus::isRfLocked>(false);
383 break;
384 }
385 case FrontendStatusType::ATSC3_PLP_INFO: {
386 FrontendStatusAtsc3PlpInfo info1;
387 info1.plpId = 3;
388 info1.isLocked = false;
389 info1.uec = 313;
390 FrontendStatusAtsc3PlpInfo info2;
391 info2.plpId = 5;
392 info2.isLocked = true;
393 info2.uec = 515;
394 vector<FrontendStatusAtsc3PlpInfo> infos = {info1, info2};
395 status.set<FrontendStatus::plpInfo>(infos);
396 break;
397 }
398 case FrontendStatusType::MODULATIONS: {
399 FrontendModulation modulation;
400 vector<FrontendModulation> modulations;
401 switch (mType) {
402 case FrontendType::ISDBS: {
403 modulation.set<FrontendModulation::Tag::isdbs>(
404 FrontendIsdbsModulation::MOD_BPSK); // value = 1 << 1
405 modulations.push_back(modulation);
406 status.set<FrontendStatus::modulations>(modulations);
407 break;
408 }
409 case FrontendType::DVBC: {
410 modulation.set<FrontendModulation::Tag::dvbc>(
411 FrontendDvbcModulation::MOD_16QAM); // value = 1 << 1
412 modulations.push_back(modulation);
413 status.set<FrontendStatus::modulations>(modulations);
414 break;
415 }
416 case FrontendType::DVBS: {
417 modulation.set<FrontendModulation::Tag::dvbs>(
418 FrontendDvbsModulation::MOD_QPSK); // value = 1 << 1
419 modulations.push_back(modulation);
420 status.set<FrontendStatus::modulations>(modulations);
421 break;
422 }
423 case FrontendType::DVBT: {
424 modulation.set<FrontendModulation::Tag::dvbt>(
425 FrontendDvbtConstellation::CONSTELLATION_16QAM_R); // value = 1 <<
426 // 16
427 modulations.push_back(modulation);
428 status.set<FrontendStatus::modulations>(modulations);
429 break;
430 }
431 case FrontendType::ISDBS3: {
432 modulation.set<FrontendModulation::Tag::isdbs3>(
433 FrontendIsdbs3Modulation::MOD_BPSK); // value = 1 << 1
434 modulations.push_back(modulation);
435 status.set<FrontendStatus::modulations>(modulations);
436 break;
437 }
438 case FrontendType::ISDBT: {
439 modulation.set<FrontendModulation::Tag::isdbt>(
440 FrontendIsdbtModulation::MOD_DQPSK); // value = 1 << 1
441 modulations.push_back(modulation);
442 status.set<FrontendStatus::modulations>(modulations);
443 break;
444 }
445 case FrontendType::ATSC: {
446 modulation.set<FrontendModulation::Tag::atsc>(
447 FrontendAtscModulation::MOD_8VSB); // value = 1 << 2
448 modulations.push_back(modulation);
449 status.set<FrontendStatus::modulations>(modulations);
450 break;
451 }
452 case FrontendType::ATSC3: {
453 modulation.set<FrontendModulation::Tag::atsc3>(
454 FrontendAtsc3Modulation::MOD_QPSK); // value = 1 << 1
455 modulations.push_back(modulation);
456 status.set<FrontendStatus::modulations>(modulations);
457 break;
458 }
459 case FrontendType::DTMB: {
460 modulation.set<FrontendModulation::Tag::dtmb>(
461 FrontendDtmbModulation::CONSTELLATION_4QAM); // value = 1 << 1
462 modulations.push_back(modulation);
463 status.set<FrontendStatus::modulations>(modulations);
464 break;
465 }
466 default:
467 break;
468 }
469 break;
470 }
471 case FrontendStatusType::BERS: {
472 vector<int32_t> bers = {1};
473 status.set<FrontendStatus::bers>(bers);
474 break;
475 }
476 case FrontendStatusType::CODERATES: {
477 vector<FrontendInnerFec> rates;
478 rates.push_back(FrontendInnerFec::FEC_6_15); // value = 1 << 39
479 status.set<FrontendStatus::codeRates>(rates);
480 break;
481 }
482 case FrontendStatusType::BANDWIDTH: {
483 FrontendBandwidth bandwidth;
484 switch (mType) {
485 case FrontendType::DVBC: {
486 bandwidth.set<FrontendBandwidth::Tag::dvbc>(
487 FrontendDvbcBandwidth::BANDWIDTH_6MHZ); // value = 1 << 1
488 status.set<FrontendStatus::bandwidth>(bandwidth);
489 break;
490 }
491 case FrontendType::DVBT: {
492 bandwidth.set<FrontendBandwidth::Tag::dvbt>(
493 FrontendDvbtBandwidth::BANDWIDTH_8MHZ); // value = 1 << 1
494 status.set<FrontendStatus::bandwidth>(bandwidth);
495 break;
496 }
497 case FrontendType::ISDBT: {
498 bandwidth.set<FrontendBandwidth::Tag::isdbt>(
499 FrontendIsdbtBandwidth::BANDWIDTH_8MHZ); // value = 1 << 1
500 status.set<FrontendStatus::bandwidth>(bandwidth);
501 break;
502 }
503 case FrontendType::ATSC3: {
504 bandwidth.set<FrontendBandwidth::Tag::atsc3>(
505 FrontendAtsc3Bandwidth::BANDWIDTH_6MHZ); // value = 1 << 1
506 status.set<FrontendStatus::bandwidth>(bandwidth);
507 break;
508 }
509 case FrontendType::DTMB: {
510 bandwidth.set<FrontendBandwidth::Tag::dtmb>(
511 FrontendDtmbBandwidth::BANDWIDTH_8MHZ); // value = 1 << 1
512 status.set<FrontendStatus::bandwidth>(bandwidth);
513 break;
514 }
515 default:
516 break;
517 }
518 break;
519 }
520 case FrontendStatusType::GUARD_INTERVAL: {
521 FrontendGuardInterval interval;
522 switch (mType) {
523 case FrontendType::DVBT: {
524 interval.set<FrontendGuardInterval::Tag::dvbt>(
525 FrontendDvbtGuardInterval::INTERVAL_1_32); // value = 1 << 1
526 status.set<FrontendStatus::interval>(interval);
527 break;
528 }
529 case FrontendType::ISDBT: {
530 interval.set<FrontendGuardInterval::Tag::isdbt>(
531 FrontendDvbtGuardInterval::INTERVAL_1_32); // value = 1 << 1
532 status.set<FrontendStatus::interval>(interval);
533 break;
534 }
535 case FrontendType::DTMB: {
536 interval.set<FrontendGuardInterval::Tag::dtmb>(
537 FrontendDtmbGuardInterval::PN_420_VARIOUS); // value = 1 << 1
538 status.set<FrontendStatus::interval>(interval);
539 break;
540 }
541 default:
542 break;
543 }
544 break;
545 }
546 case FrontendStatusType::TRANSMISSION_MODE: {
547 FrontendTransmissionMode transMode;
548 switch (mType) {
549 case FrontendType::DVBT: {
550 transMode.set<FrontendTransmissionMode::Tag::dvbt>(
551 FrontendDvbtTransmissionMode::MODE_16K_E); // value = 1 << 8
552 status.set<FrontendStatus::transmissionMode>(transMode);
553 break;
554 }
555 case FrontendType::ISDBT: {
556 transMode.set<FrontendTransmissionMode::Tag::isdbt>(
557 FrontendIsdbtMode::MODE_1); // value = 1 << 1
558 status.set<FrontendStatus::transmissionMode>(transMode);
559 break;
560 }
561 case FrontendType::DTMB: {
562 transMode.set<FrontendTransmissionMode::Tag::dtmb>(
563 FrontendDtmbTransmissionMode::C1); // value = 1 << 1
564 status.set<FrontendStatus::transmissionMode>(transMode);
565 break;
566 }
567 default:
568 break;
569 }
570 break;
571 }
572 case FrontendStatusType::UEC: {
573 status.set<FrontendStatus::uec>(4);
574 break;
575 }
576 case FrontendStatusType::T2_SYSTEM_ID: {
577 status.set<FrontendStatus::systemId>(5);
578 break;
579 }
580 case FrontendStatusType::INTERLEAVINGS: {
581 FrontendInterleaveMode interleave;
582 vector<FrontendInterleaveMode> interleaves;
583 switch (mType) {
584 case FrontendType::DVBC: {
585 // value = 1 << 1
586 interleave.set<FrontendInterleaveMode::Tag::dvbc>(
587 FrontendCableTimeInterleaveMode::INTERLEAVING_128_1_0);
588 interleaves.push_back(interleave);
589 status.set<FrontendStatus::interleaving>(interleaves);
590 break;
591 }
592 case FrontendType::ATSC3: {
593 interleave.set<FrontendInterleaveMode::Tag::atsc3>(
594 FrontendAtsc3TimeInterleaveMode::CTI); // value = 1 << 1
595 interleaves.push_back(interleave);
596 status.set<FrontendStatus::interleaving>(interleaves);
597 break;
598 }
599 case FrontendType::DTMB: {
600 interleave.set<FrontendInterleaveMode::Tag::dtmb>(
601 FrontendDtmbTimeInterleaveMode::TIMER_INT_240); // value = 1 << 1
602 interleaves.push_back(interleave);
603 status.set<FrontendStatus::interleaving>(interleaves);
604 break;
605 }
606 default:
607 break;
608 }
609 break;
610 }
611 case FrontendStatusType::ISDBT_SEGMENTS: {
612 vector<uint8_t> segments = {2, 3};
613 status.set<FrontendStatus::isdbtSegment>(segments);
614 break;
615 }
616 case FrontendStatusType::TS_DATA_RATES: {
617 vector<int32_t> dataRates = {4, 5};
618 status.set<FrontendStatus::tsDataRate>(dataRates);
619 break;
620 }
621 case FrontendStatusType::ROLL_OFF: {
622 FrontendRollOff rollOff;
623 switch (mType) {
624 case FrontendType::DVBS: {
625 rollOff.set<FrontendRollOff::Tag::dvbs>(
626 FrontendDvbsRolloff::ROLLOFF_0_35); // value = 1
627 status.set<FrontendStatus::rollOff>(rollOff);
628 break;
629 }
630 case FrontendType::ISDBS: {
631 rollOff.set<FrontendRollOff::Tag::isdbs>(
632 FrontendIsdbsRolloff::ROLLOFF_0_35); // value = 1
633 status.set<FrontendStatus::rollOff>(rollOff);
634 break;
635 }
636 case FrontendType::ISDBS3: {
637 rollOff.set<FrontendRollOff::Tag::isdbs3>(
638 FrontendIsdbs3Rolloff::ROLLOFF_0_03); // value = 1
639 status.set<FrontendStatus::rollOff>(rollOff);
640 break;
641 }
642 default:
643 break;
644 }
645 break;
646 }
647 case FrontendStatusType::IS_MISO: {
648 status.set<FrontendStatus::isMiso>(true);
649 break;
650 }
651 case FrontendStatusType::IS_LINEAR: {
652 status.set<FrontendStatus::isLinear>(true);
653 break;
654 }
655 case FrontendStatusType::IS_SHORT_FRAMES: {
656 status.set<FrontendStatus::isShortFrames>(true);
657 break;
658 }
659 default: {
660 continue;
661 }
662 }
663 _aidl_return->push_back(status);
664 }
665
666 return ::ndk::ScopedAStatus::ok();
667}
668
669::ndk::ScopedAStatus Frontend::setLna(bool /* in_bEnable */) {
670 ALOGV("%s", __FUNCTION__);
671
672 return ::ndk::ScopedAStatus::ok();
673}
674
675::ndk::ScopedAStatus Frontend::setLnb(int32_t /* in_lnbId */) {
676 ALOGV("%s", __FUNCTION__);
677 if (!supportsSatellite()) {
678 return ::ndk::ScopedAStatus::fromExceptionCode(STATUS_INVALID_OPERATION);
679 }
680 return ::ndk::ScopedAStatus::ok();
681}
682
683::ndk::ScopedAStatus Frontend::linkCiCam(int32_t in_ciCamId, int32_t* _aidl_return) {
684 ALOGV("%s", __FUNCTION__);
685
686 mCiCamId = in_ciCamId;
687 *_aidl_return = 0;
688
689 return ::ndk::ScopedAStatus::ok();
690}
691
692::ndk::ScopedAStatus Frontend::unlinkCiCam(int32_t /* in_ciCamId */) {
693 ALOGV("%s", __FUNCTION__);
694
695 mCiCamId = -1;
696
697 return ::ndk::ScopedAStatus::ok();
698}
699
700FrontendType Frontend::getFrontendType() {
701 return mType;
702}
703
704int32_t Frontend::getFrontendId() {
705 return mId;
706}
707
708bool Frontend::supportsSatellite() {
709 return mType == FrontendType::DVBS || mType == FrontendType::ISDBS ||
710 mType == FrontendType::ISDBS3;
711}
712
713bool Frontend::isLocked() {
714 return mIsLocked;
715}
716
717} // namespace tuner
718} // namespace tv
719} // namespace hardware
720} // namespace android
721} // namespace aidl