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