blob: f400a71570515bcff8e465ad7822946b4f247221 [file] [log] [blame]
Amy Zhangbf68a162020-11-23 17:42:40 -08001/*
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 "FrontendClient"
18
19#include <android-base/logging.h>
20#include <utils/Log.h>
21
22#include "FrontendClient.h"
23
Amy Zhangb9f3cab2021-01-13 15:24:14 -080024using ::aidl::android::media::tv::tuner::TunerFrontendScanAtsc3PlpInfo;
Amy Zhang2f3c64a2021-02-02 20:39:05 -080025using ::aidl::android::media::tv::tuner::TunerFrontendUnionSettings;
Amy Zhangb9f3cab2021-01-13 15:24:14 -080026
27using ::android::hardware::tv::tuner::V1_0::FrontendAnalogSifStandard;
28using ::android::hardware::tv::tuner::V1_0::FrontendAnalogType;
29using ::android::hardware::tv::tuner::V1_0::FrontendAtscModulation;
Amy Zhang46c31ec2021-02-03 18:19:10 -080030using ::android::hardware::tv::tuner::V1_0::FrontendAtsc3Bandwidth;
Amy Zhangb9f3cab2021-01-13 15:24:14 -080031using ::android::hardware::tv::tuner::V1_0::FrontendAtsc3Modulation;
Amy Zhang46c31ec2021-02-03 18:19:10 -080032using ::android::hardware::tv::tuner::V1_0::FrontendAtsc3TimeInterleaveMode;
Amy Zhangb9f3cab2021-01-13 15:24:14 -080033using ::android::hardware::tv::tuner::V1_0::FrontendDvbcAnnex;
34using ::android::hardware::tv::tuner::V1_0::FrontendDvbcModulation;
Amy Zhang46c31ec2021-02-03 18:19:10 -080035using ::android::hardware::tv::tuner::V1_0::FrontendDvbcSpectralInversion;
Amy Zhangb9f3cab2021-01-13 15:24:14 -080036using ::android::hardware::tv::tuner::V1_0::FrontendDvbsModulation;
37using ::android::hardware::tv::tuner::V1_0::FrontendDvbsStandard;
Amy Zhang46c31ec2021-02-03 18:19:10 -080038using ::android::hardware::tv::tuner::V1_0::FrontendDvbsRolloff;
39using ::android::hardware::tv::tuner::V1_0::FrontendDvbtBandwidth;
40using ::android::hardware::tv::tuner::V1_0::FrontendDvbtGuardInterval;
Amy Zhangb9f3cab2021-01-13 15:24:14 -080041using ::android::hardware::tv::tuner::V1_0::FrontendDvbtHierarchy;
42using ::android::hardware::tv::tuner::V1_0::FrontendDvbtStandard;
Amy Zhang46c31ec2021-02-03 18:19:10 -080043using ::android::hardware::tv::tuner::V1_0::FrontendInnerFec;
Amy Zhangb9f3cab2021-01-13 15:24:14 -080044using ::android::hardware::tv::tuner::V1_0::FrontendIsdbsModulation;
Amy Zhang46c31ec2021-02-03 18:19:10 -080045using ::android::hardware::tv::tuner::V1_0::FrontendIsdbsRolloff;
Amy Zhangb9f3cab2021-01-13 15:24:14 -080046using ::android::hardware::tv::tuner::V1_0::FrontendIsdbs3Modulation;
Amy Zhang46c31ec2021-02-03 18:19:10 -080047using ::android::hardware::tv::tuner::V1_0::FrontendIsdbs3Rolloff;
48using ::android::hardware::tv::tuner::V1_0::FrontendIsdbtBandwidth;
49using ::android::hardware::tv::tuner::V1_0::FrontendIsdbtGuardInterval;
50using ::android::hardware::tv::tuner::V1_0::FrontendIsdbtMode;
Amy Zhangb9f3cab2021-01-13 15:24:14 -080051using ::android::hardware::tv::tuner::V1_0::FrontendIsdbtModulation;
Amy Zhang9abbe102021-02-08 19:51:18 -080052using ::android::hardware::tv::tuner::V1_0::FrontendModulationStatus;
Amy Zhangb9f3cab2021-01-13 15:24:14 -080053using ::android::hardware::tv::tuner::V1_0::FrontendScanAtsc3PlpInfo;
Amy Zhang9abbe102021-02-08 19:51:18 -080054using ::android::hardware::tv::tuner::V1_0::FrontendStatusAtsc3PlpInfo;
Amy Zhang46c31ec2021-02-03 18:19:10 -080055using ::android::hardware::tv::tuner::V1_0::LnbVoltage;
Amy Zhangd08c2732021-01-08 17:22:59 -080056using ::android::hardware::tv::tuner::V1_1::Constant;
Amy Zhang9abbe102021-02-08 19:51:18 -080057using ::android::hardware::tv::tuner::V1_1::FrontendBandwidth;
Amy Zhang46c31ec2021-02-03 18:19:10 -080058using ::android::hardware::tv::tuner::V1_1::FrontendCableTimeInterleaveMode;
59using ::android::hardware::tv::tuner::V1_1::FrontendDtmbBandwidth;
60using ::android::hardware::tv::tuner::V1_1::FrontendDtmbGuardInterval;
Amy Zhangb9f3cab2021-01-13 15:24:14 -080061using ::android::hardware::tv::tuner::V1_1::FrontendDtmbModulation;
Amy Zhang46c31ec2021-02-03 18:19:10 -080062using ::android::hardware::tv::tuner::V1_1::FrontendDtmbTimeInterleaveMode;
63using ::android::hardware::tv::tuner::V1_1::FrontendDtmbTransmissionMode;
64using ::android::hardware::tv::tuner::V1_1::FrontendDvbcBandwidth;
Amy Zhangb9f3cab2021-01-13 15:24:14 -080065using ::android::hardware::tv::tuner::V1_1::FrontendDvbtConstellation;
Amy Zhang46c31ec2021-02-03 18:19:10 -080066using ::android::hardware::tv::tuner::V1_1::FrontendDvbtTransmissionMode;
Amy Zhang9abbe102021-02-08 19:51:18 -080067using ::android::hardware::tv::tuner::V1_1::FrontendGuardInterval;
68using ::android::hardware::tv::tuner::V1_1::FrontendInterleaveMode;
Amy Zhangb9f3cab2021-01-13 15:24:14 -080069using ::android::hardware::tv::tuner::V1_1::FrontendModulation;
Amy Zhang9abbe102021-02-08 19:51:18 -080070using ::android::hardware::tv::tuner::V1_1::FrontendRollOff;
Amy Zhang2f3c64a2021-02-02 20:39:05 -080071using ::android::hardware::tv::tuner::V1_1::FrontendSpectralInversion;
Amy Zhang9abbe102021-02-08 19:51:18 -080072using ::android::hardware::tv::tuner::V1_1::FrontendTransmissionMode;
Amy Zhang46c31ec2021-02-03 18:19:10 -080073using ::android::hardware::tv::tuner::V1_1::FrontendType;
Amy Zhanga6734682020-11-30 16:14:38 -080074
Amy Zhangbf68a162020-11-23 17:42:40 -080075namespace android {
76
Amy Zhanga6734682020-11-30 16:14:38 -080077/////////////// FrontendClient ///////////////////////
78
Amy Zhang9abbe102021-02-08 19:51:18 -080079FrontendClient::FrontendClient(shared_ptr<ITunerFrontend> tunerFrontend, int type) {
Amy Zhangbf68a162020-11-23 17:42:40 -080080 mTunerFrontend = tunerFrontend;
Amy Zhangb9f3cab2021-01-13 15:24:14 -080081 mType = type;
Amy Zhangbf68a162020-11-23 17:42:40 -080082}
83
84FrontendClient::~FrontendClient() {
85 mTunerFrontend = NULL;
86 mFrontend = NULL;
87 mFrontend_1_1 = NULL;
Amy Zhang210c26a2021-01-12 11:25:27 -080088 mId = -1;
Amy Zhangb9f3cab2021-01-13 15:24:14 -080089 mType = -1;
Amy Zhanga6734682020-11-30 16:14:38 -080090}
91
92Result FrontendClient::setCallback(sp<FrontendClientCallback> frontendClientCallback) {
93 if (mTunerFrontend != NULL) {
Amy Zhang1ce3a592021-02-22 13:53:46 -080094 shared_ptr<TunerFrontendCallback> aidlCallback =
95 ::ndk::SharedRefBase::make<TunerFrontendCallback>(frontendClientCallback);
96 aidlCallback->setFrontendType(mType);
97 Status s = mTunerFrontend->setCallback(aidlCallback);
Amy Zhang379cb482021-02-04 21:05:11 -080098 return ClientHelper::getServiceSpecificErrorCode(s);
Amy Zhanga6734682020-11-30 16:14:38 -080099 }
100
Amy Zhang1ce3a592021-02-22 13:53:46 -0800101 sp<HidlFrontendCallback> hidlCallback = new HidlFrontendCallback(frontendClientCallback);
102 return mFrontend->setCallback(hidlCallback);
Amy Zhangbf68a162020-11-23 17:42:40 -0800103}
104
105void FrontendClient::setHidlFrontend(sp<IFrontend> frontend) {
106 mFrontend = frontend;
107 mFrontend_1_1 = ::android::hardware::tv::tuner::V1_1::IFrontend::castFrom(mFrontend);
108}
Amy Zhanga6734682020-11-30 16:14:38 -0800109
Amy Zhang9abbe102021-02-08 19:51:18 -0800110// TODO: move after migration is done
111void FrontendClient::setId(int id) {
112 mId = id;
113}
114
Amy Zhanga6734682020-11-30 16:14:38 -0800115Result FrontendClient::tune(const FrontendSettings& settings,
116 const FrontendSettingsExt1_1& settingsExt1_1) {
117 if (mTunerFrontend != NULL) {
Amy Zhangb5809be2021-01-26 16:27:23 -0800118 TunerFrontendSettings tunerFeSettings = getAidlFrontendSettings(settings, settingsExt1_1);
119 Status s = mTunerFrontend->tune(tunerFeSettings);
Amy Zhang4a07e802021-01-21 17:10:21 -0800120 return ClientHelper::getServiceSpecificErrorCode(s);
Amy Zhanga6734682020-11-30 16:14:38 -0800121 }
122
123 Result result;
Amy Zhang2f3c64a2021-02-02 20:39:05 -0800124 if (mFrontend_1_1 != NULL && validateExtendedSettings(settingsExt1_1)) {
Amy Zhanga6734682020-11-30 16:14:38 -0800125 result = mFrontend_1_1->tune_1_1(settings, settingsExt1_1);
126 return result;
127 }
128
129 if (mFrontend != NULL) {
130 result = mFrontend->tune(settings);
131 return result;
132 }
133
134 return Result::INVALID_STATE;
Amy Zhangbf68a162020-11-23 17:42:40 -0800135}
Amy Zhanga6734682020-11-30 16:14:38 -0800136
137Result FrontendClient::stopTune() {
138 if (mTunerFrontend != NULL) {
Amy Zhang4a07e802021-01-21 17:10:21 -0800139 Status s = mTunerFrontend->stopTune();
140 return ClientHelper::getServiceSpecificErrorCode(s);
Amy Zhanga6734682020-11-30 16:14:38 -0800141 }
142
143 if (mFrontend != NULL) {
144 Result result = mFrontend->stopTune();
145 return result;
146 }
147
148 return Result::INVALID_STATE;
149}
150
Amy Zhangd08c2732021-01-08 17:22:59 -0800151Result FrontendClient::scan(const FrontendSettings& settings, FrontendScanType type,
152 const FrontendSettingsExt1_1& settingsExt1_1) {
153 if (mTunerFrontend != NULL) {
Amy Zhangb5809be2021-01-26 16:27:23 -0800154 TunerFrontendSettings tunerFeSettings = getAidlFrontendSettings(settings, settingsExt1_1);
155 Status s = mTunerFrontend->scan(tunerFeSettings, (int)type);
Amy Zhang4a07e802021-01-21 17:10:21 -0800156 return ClientHelper::getServiceSpecificErrorCode(s);
Amy Zhangd08c2732021-01-08 17:22:59 -0800157 }
158
159 Result result;
Amy Zhang2f3c64a2021-02-02 20:39:05 -0800160 if (mFrontend_1_1 != NULL && validateExtendedSettings(settingsExt1_1)) {
Amy Zhangd08c2732021-01-08 17:22:59 -0800161 result = mFrontend_1_1->scan_1_1(settings, type, settingsExt1_1);
162 return result;
163 }
164
165 if (mFrontend != NULL) {
166 result = mFrontend->scan(settings, type);
167 return result;
168 }
169
170 return Result::INVALID_STATE;
171}
172
173Result FrontendClient::stopScan() {
174 if (mTunerFrontend != NULL) {
Amy Zhang4a07e802021-01-21 17:10:21 -0800175 Status s = mTunerFrontend->stopScan();
176 return ClientHelper::getServiceSpecificErrorCode(s);
Amy Zhangd08c2732021-01-08 17:22:59 -0800177 }
178
179 if (mFrontend != NULL) {
180 Result result = mFrontend->stopScan();
181 return result;
182 }
183
184 return Result::INVALID_STATE;
185}
186
187vector<FrontendStatus> FrontendClient::getStatus(vector<FrontendStatusType> statusTypes) {
188 vector<FrontendStatus> status;
189
190 if (mTunerFrontend != NULL) {
Amy Zhang46c31ec2021-02-03 18:19:10 -0800191 vector<TunerFrontendStatus> aidlStatus;
192 vector<int> types;
193 for (auto t : statusTypes) {
194 types.push_back((int)t);
195 }
196 Status s = mTunerFrontend->getStatus(types, &aidlStatus);
197 if (ClientHelper::getServiceSpecificErrorCode(s) != Result::SUCCESS) {
198 return status;
199 }
200 return getHidlStatus(aidlStatus);
Amy Zhangd08c2732021-01-08 17:22:59 -0800201 }
202
203 if (mFrontend != NULL && statusTypes.size() > 0) {
204 Result res;
205 mFrontend->getStatus(statusTypes,
206 [&](Result r, const hidl_vec<FrontendStatus>& s) {
207 res = r;
208 status = s;
209 });
210 if (res != Result::SUCCESS) {
211 status.clear();
212 return status;
213 }
214 }
215
216 return status;
217}
Amy Zhang46c31ec2021-02-03 18:19:10 -0800218
Amy Zhangd08c2732021-01-08 17:22:59 -0800219vector<FrontendStatusExt1_1> FrontendClient::getStatusExtended_1_1(
220 vector<FrontendStatusTypeExt1_1> statusTypes) {
221 vector<FrontendStatusExt1_1> status;
222
223 if (mTunerFrontend != NULL) {
Amy Zhang46c31ec2021-02-03 18:19:10 -0800224 vector<TunerFrontendStatus> aidlStatus;
225 vector<int> types;
226 for (auto t : statusTypes) {
227 types.push_back((int)t);
228 }
229 Status s = mTunerFrontend->getStatusExtended_1_1(types, &aidlStatus);
230 if (ClientHelper::getServiceSpecificErrorCode(s) != Result::SUCCESS) {
231 return status;
232 }
233 return getHidlStatusExt(aidlStatus);
Amy Zhangd08c2732021-01-08 17:22:59 -0800234 }
235
236 if (mFrontend_1_1 != NULL && statusTypes.size() > 0) {
237 Result res;
238 mFrontend_1_1->getStatusExt1_1(statusTypes,
239 [&](Result r, const hidl_vec<FrontendStatusExt1_1>& s) {
240 res = r;
241 status = s;
242 });
243 if (res != Result::SUCCESS) {
244 status.clear();
245 return status;
246 }
247 }
248
249 return status;
250}
251
Amy Zhangd3d57b42021-01-07 11:14:43 -0800252Result FrontendClient::setLnb(sp<LnbClient> lnbClient) {
253 if (mTunerFrontend != NULL) {
Amy Zhang379cb482021-02-04 21:05:11 -0800254 Status s = mTunerFrontend->setLnb(lnbClient->getAidlLnb());
255 return ClientHelper::getServiceSpecificErrorCode(s);
Amy Zhangd3d57b42021-01-07 11:14:43 -0800256 }
257
258 if (mFrontend != NULL) {
259 Result result = mFrontend->setLnb(lnbClient->getId());
260 return result;
261 }
262
263 return Result::INVALID_STATE;
264}
265
Amy Zhangd08c2732021-01-08 17:22:59 -0800266Result FrontendClient::setLna(bool bEnable) {
267 if (mTunerFrontend != NULL) {
Amy Zhang379cb482021-02-04 21:05:11 -0800268 Status s = mTunerFrontend->setLna(bEnable);
269 return ClientHelper::getServiceSpecificErrorCode(s);
Amy Zhangd08c2732021-01-08 17:22:59 -0800270 }
271
272 if (mFrontend != NULL) {
273 Result result = mFrontend->setLna(bEnable);
274 return result;
275 }
276
277 return Result::INVALID_STATE;
278}
279
280int FrontendClient::linkCiCamToFrontend(int ciCamId) {
281 int ltsId = (int)Constant::INVALID_LTS_ID;
282
283 if (mTunerFrontend != NULL) {
Amy Zhang379cb482021-02-04 21:05:11 -0800284 Status s = mTunerFrontend->linkCiCamToFrontend(ciCamId, &ltsId);
285 if (ClientHelper::getServiceSpecificErrorCode(s) == Result::SUCCESS) {
286 return ltsId;
287 }
288 return (int)Constant::INVALID_LTS_ID;
Amy Zhangd08c2732021-01-08 17:22:59 -0800289 }
290
291 if (mFrontend_1_1 != NULL) {
292 Result res;
293 mFrontend_1_1->linkCiCam(static_cast<uint32_t>(ciCamId),
294 [&](Result r, uint32_t id) {
295 res = r;
296 ltsId = id;
297 });
298 if (res != Result::SUCCESS) {
299 return (int)Constant::INVALID_LTS_ID;
300 }
301 }
302
303 return ltsId;
304}
305
306Result FrontendClient::unlinkCiCamToFrontend(int ciCamId) {
307 if (mTunerFrontend != NULL) {
Amy Zhang379cb482021-02-04 21:05:11 -0800308 Status s = mTunerFrontend->unlinkCiCamToFrontend(ciCamId);
309 return ClientHelper::getServiceSpecificErrorCode(s);
Amy Zhangd08c2732021-01-08 17:22:59 -0800310 }
311
312 if (mFrontend_1_1 != NULL) {
313 return mFrontend_1_1->unlinkCiCam(static_cast<uint32_t>(ciCamId));
314 }
315
316 return Result::INVALID_STATE;
317}
318
Amy Zhanga6734682020-11-30 16:14:38 -0800319Result FrontendClient::close() {
320 if (mTunerFrontend != NULL) {
Amy Zhang4a07e802021-01-21 17:10:21 -0800321 Status s = mTunerFrontend->close();
Amy Zhangec3b4872021-02-11 15:38:20 -0800322 mTunerFrontend = NULL;
Amy Zhang4a07e802021-01-21 17:10:21 -0800323 return ClientHelper::getServiceSpecificErrorCode(s);
Amy Zhanga6734682020-11-30 16:14:38 -0800324 }
325
326 if (mFrontend != NULL) {
327 Result result = mFrontend->close();
Amy Zhangec3b4872021-02-11 15:38:20 -0800328 mFrontend = NULL;
329 mFrontend_1_1 = NULL;
Amy Zhanga6734682020-11-30 16:14:38 -0800330 return result;
331 }
332
333 return Result::INVALID_STATE;
334}
335
Amy Zhang2f3c64a2021-02-02 20:39:05 -0800336/////////////// TunerFrontend Helper Methods ///////////////////////
337
Amy Zhang6bfeaa02020-11-30 15:16:39 -0800338shared_ptr<ITunerFrontend> FrontendClient::getAidlFrontend() {
339 return mTunerFrontend;
340}
341
342int FrontendClient::getId() {
Amy Zhang9abbe102021-02-08 19:51:18 -0800343 if (mTunerFrontend != NULL) {
344 Status s = mTunerFrontend->getFrontendId(&mId);
345 if (ClientHelper::getServiceSpecificErrorCode(s) == Result::SUCCESS) {
346 return mId;
347 }
348 ALOGE("Failed to getFrontendId from Tuner Frontend");
349 return -1;
350 }
351
352 if (mFrontend != NULL) {
353 return mId;
354 }
355
356 return -1;
Amy Zhang6bfeaa02020-11-30 15:16:39 -0800357}
358
Amy Zhang46c31ec2021-02-03 18:19:10 -0800359vector<FrontendStatus> FrontendClient::getHidlStatus(vector<TunerFrontendStatus>& aidlStatus) {
360 vector<FrontendStatus> hidlStatus;
361 for (TunerFrontendStatus s : aidlStatus) {
Amy Zhang9abbe102021-02-08 19:51:18 -0800362 FrontendStatus status = FrontendStatus();
Amy Zhang46c31ec2021-02-03 18:19:10 -0800363 switch (s.getTag()) {
364 case TunerFrontendStatus::isDemodLocked: {
365 status.isDemodLocked(s.get<TunerFrontendStatus::isDemodLocked>());
366 hidlStatus.push_back(status);
367 break;
368 }
369 case TunerFrontendStatus::snr: {
370 status.snr(s.get<TunerFrontendStatus::snr>());
371 hidlStatus.push_back(status);
372 break;
373 }
374 case TunerFrontendStatus::ber: {
375 status.ber((uint32_t)s.get<TunerFrontendStatus::ber>());
376 hidlStatus.push_back(status);
377 break;
378 }
379 case TunerFrontendStatus::per: {
380 status.per((uint32_t)s.get<TunerFrontendStatus::per>());
381 hidlStatus.push_back(status);
382 break;
383 }
384 case TunerFrontendStatus::preBer: {
385 status.preBer((uint32_t)s.get<TunerFrontendStatus::preBer>());
386 hidlStatus.push_back(status);
387 break;
388 }
389 case TunerFrontendStatus::signalQuality: {
390 status.signalQuality((uint32_t)s.get<TunerFrontendStatus::signalQuality>());
391 hidlStatus.push_back(status);
392 break;
393 }
394 case TunerFrontendStatus::signalStrength: {
395 status.signalStrength(s.get<TunerFrontendStatus::signalStrength>());
396 hidlStatus.push_back(status);
397 break;
398 }
399 case TunerFrontendStatus::symbolRate: {
400 status.symbolRate((uint32_t)s.get<TunerFrontendStatus::symbolRate>());
401 hidlStatus.push_back(status);
402 break;
403 }
404 case TunerFrontendStatus::innerFec: {
405 status.innerFec(static_cast<FrontendInnerFec>(
406 s.get<TunerFrontendStatus::innerFec>()));
407 hidlStatus.push_back(status);
408 break;
409 }
410 case TunerFrontendStatus::modulation: {
411 auto aidlMod = s.get<TunerFrontendStatus::modulation>();
Amy Zhang9abbe102021-02-08 19:51:18 -0800412 FrontendModulationStatus modulation;
Amy Zhang46c31ec2021-02-03 18:19:10 -0800413 switch (mType) {
414 case (int)FrontendType::DVBC:
Amy Zhang9abbe102021-02-08 19:51:18 -0800415 modulation.dvbc(static_cast<FrontendDvbcModulation>(aidlMod));
416 status.modulation(modulation);
Amy Zhang46c31ec2021-02-03 18:19:10 -0800417 hidlStatus.push_back(status);
418 break;
419 case (int)FrontendType::DVBS:
Amy Zhang9abbe102021-02-08 19:51:18 -0800420 modulation.dvbs(static_cast<FrontendDvbsModulation>(aidlMod));
421 status.modulation(modulation);
Amy Zhang46c31ec2021-02-03 18:19:10 -0800422 hidlStatus.push_back(status);
423 break;
424 case (int)FrontendType::ISDBS:
Amy Zhang9abbe102021-02-08 19:51:18 -0800425 modulation.isdbs(static_cast<FrontendIsdbsModulation>(aidlMod));
426 status.modulation(modulation);
Amy Zhang46c31ec2021-02-03 18:19:10 -0800427 hidlStatus.push_back(status);
428 break;
429 case (int)FrontendType::ISDBS3:
Amy Zhang9abbe102021-02-08 19:51:18 -0800430 modulation.isdbs3(static_cast<FrontendIsdbs3Modulation>(aidlMod));
431 status.modulation(modulation);
Amy Zhang46c31ec2021-02-03 18:19:10 -0800432 hidlStatus.push_back(status);
433 break;
434 case (int)FrontendType::ISDBT:
Amy Zhang9abbe102021-02-08 19:51:18 -0800435 modulation.isdbt(static_cast<FrontendIsdbtModulation>(aidlMod));
436 status.modulation(modulation);
Amy Zhang46c31ec2021-02-03 18:19:10 -0800437 hidlStatus.push_back(status);
438 break;
439 default:
440 break;
441 }
442 break;
443 }
444 case TunerFrontendStatus::inversion: {
445 status.inversion(static_cast<FrontendDvbcSpectralInversion>(
446 s.get<TunerFrontendStatus::inversion>()));
447 hidlStatus.push_back(status);
448 break;
449 }
450 case TunerFrontendStatus::lnbVoltage: {
451 status.lnbVoltage(static_cast<LnbVoltage>(
452 s.get<TunerFrontendStatus::lnbVoltage>()));
453 hidlStatus.push_back(status);
454 break;
455 }
456 case TunerFrontendStatus::plpId: {
457 status.plpId((uint8_t)s.get<TunerFrontendStatus::plpId>());
458 hidlStatus.push_back(status);
459 break;
460 }
461 case TunerFrontendStatus::isEWBS: {
462 status.isEWBS(s.get<TunerFrontendStatus::isEWBS>());
463 hidlStatus.push_back(status);
464 break;
465 }
466 case TunerFrontendStatus::agc: {
467 status.agc((uint8_t)s.get<TunerFrontendStatus::agc>());
468 hidlStatus.push_back(status);
469 break;
470 }
471 case TunerFrontendStatus::isLnaOn: {
472 status.isLnaOn(s.get<TunerFrontendStatus::isLnaOn>());
473 hidlStatus.push_back(status);
474 break;
475 }
476 case TunerFrontendStatus::isLayerError: {
477 auto aidlE = s.get<TunerFrontendStatus::isLayerError>();
478 hidl_vec<bool> e(aidlE.begin(), aidlE.end());
479 status.isLayerError(e);
480 hidlStatus.push_back(status);
481 break;
482 }
483 case TunerFrontendStatus::mer: {
484 status.mer(s.get<TunerFrontendStatus::mer>());
485 hidlStatus.push_back(status);
486 break;
487 }
488 case TunerFrontendStatus::freqOffset: {
489 status.freqOffset(s.get<TunerFrontendStatus::freqOffset>());
490 hidlStatus.push_back(status);
491 break;
492 }
493 case TunerFrontendStatus::hierarchy: {
494 status.hierarchy(static_cast<FrontendDvbtHierarchy>(
Amy Zhang9abbe102021-02-08 19:51:18 -0800495 s.get<TunerFrontendStatus::hierarchy>()));
Amy Zhang46c31ec2021-02-03 18:19:10 -0800496 hidlStatus.push_back(status);
497 break;
498 }
499 case TunerFrontendStatus::isRfLocked: {
500 status.isRfLocked(s.get<TunerFrontendStatus::isRfLocked>());
501 hidlStatus.push_back(status);
502 break;
503 }
504 case TunerFrontendStatus::plpInfo: {
505 int size = s.get<TunerFrontendStatus::plpInfo>().size();
Amy Zhang9abbe102021-02-08 19:51:18 -0800506 hidl_vec<FrontendStatusAtsc3PlpInfo> info(size);
Amy Zhang46c31ec2021-02-03 18:19:10 -0800507 for (int i = 0; i < size; i++) {
508 auto aidlInfo = s.get<TunerFrontendStatus::plpInfo>()[i];
Amy Zhang9abbe102021-02-08 19:51:18 -0800509 info[i] = {
Amy Zhang46c31ec2021-02-03 18:19:10 -0800510 .plpId = (uint8_t)aidlInfo.plpId,
511 .isLocked = aidlInfo.isLocked,
512 .uec = (uint32_t)aidlInfo.uec,
513 };
514 }
Amy Zhang9abbe102021-02-08 19:51:18 -0800515 status.plpInfo(info);
Amy Zhang46c31ec2021-02-03 18:19:10 -0800516 hidlStatus.push_back(status);
517 break;
518 }
519 default:
520 break;
521 }
522 }
523 return hidlStatus;
524}
525
526vector<FrontendStatusExt1_1> FrontendClient::getHidlStatusExt(
527 vector<TunerFrontendStatus>& aidlStatus) {
528 vector<FrontendStatusExt1_1> hidlStatus;
529 for (TunerFrontendStatus s : aidlStatus) {
530 FrontendStatusExt1_1 status;
531 switch (s.getTag()) {
532 case TunerFrontendStatus::modulations: {
Amy Zhang9abbe102021-02-08 19:51:18 -0800533 vector<FrontendModulation> ms;
Amy Zhang46c31ec2021-02-03 18:19:10 -0800534 for (auto aidlMod : s.get<TunerFrontendStatus::modulations>()) {
Amy Zhang9abbe102021-02-08 19:51:18 -0800535 FrontendModulation m;
Amy Zhang46c31ec2021-02-03 18:19:10 -0800536 switch (mType) {
537 case (int)FrontendType::DVBC:
Amy Zhang9abbe102021-02-08 19:51:18 -0800538 m.dvbc(static_cast<FrontendDvbcModulation>(aidlMod));
539 ms.push_back(m);
Amy Zhang46c31ec2021-02-03 18:19:10 -0800540 break;
541 case (int)FrontendType::DVBS:
Amy Zhang9abbe102021-02-08 19:51:18 -0800542 m.dvbs(static_cast<FrontendDvbsModulation>(aidlMod));
543 ms.push_back(m);
Amy Zhang46c31ec2021-02-03 18:19:10 -0800544 break;
545 case (int)FrontendType::DVBT:
Amy Zhang9abbe102021-02-08 19:51:18 -0800546 m.dvbt(static_cast<FrontendDvbtConstellation>(aidlMod));
547 ms.push_back(m);
Amy Zhang46c31ec2021-02-03 18:19:10 -0800548 break;
549 case (int)FrontendType::ISDBS:
Amy Zhang9abbe102021-02-08 19:51:18 -0800550 m.isdbs(static_cast<FrontendIsdbsModulation>(aidlMod));
551 ms.push_back(m);
Amy Zhang46c31ec2021-02-03 18:19:10 -0800552 break;
553 case (int)FrontendType::ISDBS3:
Amy Zhang9abbe102021-02-08 19:51:18 -0800554 m.isdbs3(static_cast<FrontendIsdbs3Modulation>(aidlMod));
555 ms.push_back(m);
Amy Zhang46c31ec2021-02-03 18:19:10 -0800556 break;
557 case (int)FrontendType::ISDBT:
Amy Zhang9abbe102021-02-08 19:51:18 -0800558 m.isdbt(static_cast<FrontendIsdbtModulation>(aidlMod));
559 ms.push_back(m);
Amy Zhang46c31ec2021-02-03 18:19:10 -0800560 break;
561 case (int)FrontendType::ATSC:
Amy Zhang9abbe102021-02-08 19:51:18 -0800562 m.atsc(static_cast<FrontendAtscModulation>(aidlMod));
563 ms.push_back(m);
Amy Zhang46c31ec2021-02-03 18:19:10 -0800564 break;
565 case (int)FrontendType::ATSC3:
Amy Zhang9abbe102021-02-08 19:51:18 -0800566 m.atsc3(static_cast<FrontendAtsc3Modulation>(aidlMod));
567 ms.push_back(m);
Amy Zhang46c31ec2021-02-03 18:19:10 -0800568 break;
569 case (int)FrontendType::DTMB:
Amy Zhang9abbe102021-02-08 19:51:18 -0800570 m.dtmb(static_cast<FrontendDtmbModulation>(aidlMod));
571 ms.push_back(m);
Amy Zhang46c31ec2021-02-03 18:19:10 -0800572 break;
573 default:
Amy Zhang46c31ec2021-02-03 18:19:10 -0800574 break;
575 }
576 }
Amy Zhang9abbe102021-02-08 19:51:18 -0800577 if (ms.size() > 0) {
578 status.modulations(ms);
579 hidlStatus.push_back(status);
580 }
Amy Zhang46c31ec2021-02-03 18:19:10 -0800581 break;
582 }
583 case TunerFrontendStatus::bers: {
584 auto aidlB = s.get<TunerFrontendStatus::bers>();
585 hidl_vec<uint32_t> b(aidlB.begin(), aidlB.end());
586 status.bers(b);
587 hidlStatus.push_back(status);
588 break;
589 }
590 case TunerFrontendStatus::codeRates: {
591 int size = s.get<TunerFrontendStatus::codeRates>().size();
592 status.codeRates().resize(size);
593 for (int i = 0; i < size; i++) {
594 auto aidlCodeRate = s.get<TunerFrontendStatus::codeRates>()[i];
595 status.codeRates()[i] =
596 static_cast<hardware::tv::tuner::V1_1::FrontendInnerFec>(aidlCodeRate);
597 }
598 hidlStatus.push_back(status);
599 break;
600 }
601 case TunerFrontendStatus::bandwidth: {
602 auto aidlBand = s.get<TunerFrontendStatus::bandwidth>();
Amy Zhang9abbe102021-02-08 19:51:18 -0800603 FrontendBandwidth band;
Amy Zhang46c31ec2021-02-03 18:19:10 -0800604 switch (mType) {
605 case (int)FrontendType::ATSC3:
Amy Zhang9abbe102021-02-08 19:51:18 -0800606 band.atsc3(static_cast<FrontendAtsc3Bandwidth>(aidlBand));
607 status.bandwidth(band);
Amy Zhang46c31ec2021-02-03 18:19:10 -0800608 hidlStatus.push_back(status);
609 break;
610 case (int)FrontendType::DVBC:
Amy Zhang9abbe102021-02-08 19:51:18 -0800611 band.dvbc(static_cast<FrontendDvbcBandwidth>(aidlBand));
612 status.bandwidth(band);
Amy Zhang46c31ec2021-02-03 18:19:10 -0800613 hidlStatus.push_back(status);
614 break;
615 case (int)FrontendType::DVBT:
Amy Zhang9abbe102021-02-08 19:51:18 -0800616 band.dvbt(static_cast<FrontendDvbtBandwidth>(aidlBand));
617 status.bandwidth(band);
Amy Zhang46c31ec2021-02-03 18:19:10 -0800618 hidlStatus.push_back(status);
619 break;
620 case (int)FrontendType::ISDBT:
Amy Zhang9abbe102021-02-08 19:51:18 -0800621 band.isdbt(static_cast<FrontendIsdbtBandwidth>(aidlBand));
622 status.bandwidth(band);
Amy Zhang46c31ec2021-02-03 18:19:10 -0800623 hidlStatus.push_back(status);
624 break;
625 case (int)FrontendType::DTMB:
Amy Zhang9abbe102021-02-08 19:51:18 -0800626 band.dtmb(static_cast<FrontendDtmbBandwidth>(aidlBand));
627 status.bandwidth(band);
Amy Zhang46c31ec2021-02-03 18:19:10 -0800628 hidlStatus.push_back(status);
629 break;
630 default:
631 break;
632 }
633 break;
634 }
635 case TunerFrontendStatus::interval: {
636 auto aidlInter = s.get<TunerFrontendStatus::interval>();
Amy Zhang9abbe102021-02-08 19:51:18 -0800637 FrontendGuardInterval inter;
Amy Zhang46c31ec2021-02-03 18:19:10 -0800638 switch (mType) {
639 case (int)FrontendType::DVBT:
Amy Zhang9abbe102021-02-08 19:51:18 -0800640 inter.dvbt(static_cast<FrontendDvbtGuardInterval>(aidlInter));
641 status.interval(inter);
Amy Zhang46c31ec2021-02-03 18:19:10 -0800642 hidlStatus.push_back(status);
643 break;
644 case (int)FrontendType::ISDBT:
Amy Zhang9abbe102021-02-08 19:51:18 -0800645 inter.isdbt(static_cast<FrontendIsdbtGuardInterval>(aidlInter));
646 status.interval(inter);
Amy Zhang46c31ec2021-02-03 18:19:10 -0800647 hidlStatus.push_back(status);
648 break;
649 case (int)FrontendType::DTMB:
Amy Zhang9abbe102021-02-08 19:51:18 -0800650 inter.dtmb(static_cast<FrontendDtmbGuardInterval>(aidlInter));
651 status.interval(inter);
Amy Zhang46c31ec2021-02-03 18:19:10 -0800652 hidlStatus.push_back(status);
653 break;
654 default:
655 break;
656 }
657 break;
658 }
659 case TunerFrontendStatus::transmissionMode: {
660 auto aidlTran = s.get<TunerFrontendStatus::transmissionMode>();
Amy Zhang9abbe102021-02-08 19:51:18 -0800661 FrontendTransmissionMode trans;
Amy Zhang46c31ec2021-02-03 18:19:10 -0800662 switch (mType) {
663 case (int)FrontendType::DVBT:
Amy Zhang9abbe102021-02-08 19:51:18 -0800664 trans.dvbt(static_cast<FrontendDvbtTransmissionMode>(aidlTran));
665 status.transmissionMode(trans);
Amy Zhang46c31ec2021-02-03 18:19:10 -0800666 hidlStatus.push_back(status);
667 break;
668 case (int)FrontendType::ISDBT:
Amy Zhang9abbe102021-02-08 19:51:18 -0800669 trans.isdbt(static_cast<FrontendIsdbtMode>(aidlTran));
670 status.transmissionMode(trans);
Amy Zhang46c31ec2021-02-03 18:19:10 -0800671 hidlStatus.push_back(status);
672 break;
673 case (int)FrontendType::DTMB:
Amy Zhang9abbe102021-02-08 19:51:18 -0800674 trans.dtmb(static_cast<FrontendDtmbTransmissionMode>(aidlTran));
675 status.transmissionMode(trans);
Amy Zhang46c31ec2021-02-03 18:19:10 -0800676 hidlStatus.push_back(status);
677 break;
678 default:
679 break;
680 }
681 break;
682 }
683 case TunerFrontendStatus::uec: {
684 status.uec((uint32_t)s.get<TunerFrontendStatus::uec>());
685 hidlStatus.push_back(status);
686 break;
687 }
688 case TunerFrontendStatus::systemId: {
689 status.systemId((uint16_t)s.get<TunerFrontendStatus::systemId>());
690 hidlStatus.push_back(status);
691 break;
692 }
693 case TunerFrontendStatus::interleaving: {
Amy Zhang9abbe102021-02-08 19:51:18 -0800694 vector<FrontendInterleaveMode> modes;
Amy Zhang46c31ec2021-02-03 18:19:10 -0800695 for (auto aidlInter : s.get<TunerFrontendStatus::interleaving>()) {
Amy Zhang9abbe102021-02-08 19:51:18 -0800696 FrontendInterleaveMode mode;
Amy Zhang46c31ec2021-02-03 18:19:10 -0800697 switch (mType) {
698 case (int)FrontendType::DVBC:
Amy Zhang9abbe102021-02-08 19:51:18 -0800699 mode.dvbc(static_cast<FrontendCableTimeInterleaveMode>(aidlInter));
700 modes.push_back(mode);
Amy Zhang46c31ec2021-02-03 18:19:10 -0800701 break;
702 case (int)FrontendType::ATSC3:
Amy Zhang9abbe102021-02-08 19:51:18 -0800703 mode.atsc3(static_cast<FrontendAtsc3TimeInterleaveMode>(aidlInter));
704 modes.push_back(mode);
Amy Zhang46c31ec2021-02-03 18:19:10 -0800705 break;
706 case (int)FrontendType::DTMB:
Amy Zhang9abbe102021-02-08 19:51:18 -0800707 mode.dtmb(static_cast<FrontendDtmbTimeInterleaveMode>(aidlInter));
708 modes.push_back(mode);
Amy Zhang46c31ec2021-02-03 18:19:10 -0800709 break;
710 default:
Amy Zhang46c31ec2021-02-03 18:19:10 -0800711 break;
712 }
713 }
Amy Zhang9abbe102021-02-08 19:51:18 -0800714 if (modes.size() > 0) {
715 status.interleaving(modes);
716 hidlStatus.push_back(status);
717 }
Amy Zhang46c31ec2021-02-03 18:19:10 -0800718 break;
719 }
720 case TunerFrontendStatus::isdbtSegment: {
721 auto aidlSeg = s.get<TunerFrontendStatus::isdbtSegment>();
722 hidl_vec<uint8_t> s(aidlSeg.begin(), aidlSeg.end());
723 status.isdbtSegment(s);
724 hidlStatus.push_back(status);
725 break;
726 }
727 case TunerFrontendStatus::tsDataRate: {
728 auto aidlTs = s.get<TunerFrontendStatus::tsDataRate>();
729 hidl_vec<uint32_t> ts(aidlTs.begin(), aidlTs.end());
730 status.tsDataRate(ts);
731 hidlStatus.push_back(status);
732 break;
733 }
734 case TunerFrontendStatus::rollOff: {
735 auto aidlRoll = s.get<TunerFrontendStatus::rollOff>();
Amy Zhang9abbe102021-02-08 19:51:18 -0800736 FrontendRollOff roll;
Amy Zhang46c31ec2021-02-03 18:19:10 -0800737 switch (mType) {
738 case (int)FrontendType::DVBS:
Amy Zhang9abbe102021-02-08 19:51:18 -0800739 roll.dvbs(static_cast<FrontendDvbsRolloff>(aidlRoll));
740 status.rollOff(roll);
Amy Zhang46c31ec2021-02-03 18:19:10 -0800741 hidlStatus.push_back(status);
742 break;
743 case (int)FrontendType::ISDBS:
Amy Zhang9abbe102021-02-08 19:51:18 -0800744 roll.isdbs(static_cast<FrontendIsdbsRolloff>(aidlRoll));
745 status.rollOff(roll);
Amy Zhang46c31ec2021-02-03 18:19:10 -0800746 hidlStatus.push_back(status);
747 break;
748 case (int)FrontendType::ISDBS3:
Amy Zhang9abbe102021-02-08 19:51:18 -0800749 roll.isdbs3(static_cast<FrontendIsdbs3Rolloff>(aidlRoll));
750 status.rollOff(roll);
Amy Zhang46c31ec2021-02-03 18:19:10 -0800751 hidlStatus.push_back(status);
752 break;
753 default:
754 break;
755 }
756 break;
757 }
758 case TunerFrontendStatus::isMiso: {
759 status.isMiso(s.get<TunerFrontendStatus::isMiso>());
760 hidlStatus.push_back(status);
761 break;
762 }
763 case TunerFrontendStatus::isLinear: {
764 status.isLinear(s.get<TunerFrontendStatus::isLinear>());
765 hidlStatus.push_back(status);
766 break;
767 }
768 case TunerFrontendStatus::isShortFrames: {
769 status.isShortFrames(s.get<TunerFrontendStatus::isShortFrames>());
770 hidlStatus.push_back(status);
771 break;
772 }
773 default:
774 break;
775 }
776 }
777 return hidlStatus;
778}
779
Amy Zhangb5809be2021-01-26 16:27:23 -0800780TunerFrontendSettings FrontendClient::getAidlFrontendSettings(const FrontendSettings& settings,
Amy Zhang2f3c64a2021-02-02 20:39:05 -0800781 const FrontendSettingsExt1_1& settingsExt1_1) {
782 bool isExtended = validateExtendedSettings(settingsExt1_1);
783 TunerFrontendSettings s{
784 .isExtended = isExtended,
785 .endFrequency = (int) settingsExt1_1.endFrequency,
786 .inversion = (int) settingsExt1_1.inversion,
787 };
788
789 if (settingsExt1_1.settingExt.getDiscriminator()
790 == FrontendSettingsExt1_1::SettingsExt::hidl_discriminator::dtmb) {
791 s.settings.set<TunerFrontendUnionSettings::dtmb>(getAidlDtmbSettings(settingsExt1_1));
792 return s;
793 }
794
Amy Zhangb5809be2021-01-26 16:27:23 -0800795 switch (settings.getDiscriminator()) {
796 case FrontendSettings::hidl_discriminator::analog: {
Amy Zhang2f3c64a2021-02-02 20:39:05 -0800797 s.settings.set<TunerFrontendUnionSettings::analog>(
798 getAidlAnalogSettings(settings, settingsExt1_1));
Amy Zhangb5809be2021-01-26 16:27:23 -0800799 break;
800 }
801 case FrontendSettings::hidl_discriminator::atsc: {
Amy Zhang2f3c64a2021-02-02 20:39:05 -0800802 s.settings.set<TunerFrontendUnionSettings::atsc>(getAidlAtscSettings(settings));
Amy Zhangb5809be2021-01-26 16:27:23 -0800803 break;
804 }
805 case FrontendSettings::hidl_discriminator::atsc3: {
Amy Zhang2f3c64a2021-02-02 20:39:05 -0800806 s.settings.set<TunerFrontendUnionSettings::atsc3>(getAidlAtsc3Settings(settings));
Amy Zhangb5809be2021-01-26 16:27:23 -0800807 break;
808 }
809 case FrontendSettings::hidl_discriminator::dvbs: {
Amy Zhang2f3c64a2021-02-02 20:39:05 -0800810 s.settings.set<TunerFrontendUnionSettings::dvbs>(
811 getAidlDvbsSettings(settings, settingsExt1_1));
Amy Zhangb5809be2021-01-26 16:27:23 -0800812 break;
813 }
814 case FrontendSettings::hidl_discriminator::dvbc: {
Amy Zhang2f3c64a2021-02-02 20:39:05 -0800815 s.settings.set<TunerFrontendUnionSettings::cable>(
816 getAidlCableSettings(settings, settingsExt1_1));
Amy Zhangb5809be2021-01-26 16:27:23 -0800817 break;
818 }
819 case FrontendSettings::hidl_discriminator::dvbt: {
Amy Zhang2f3c64a2021-02-02 20:39:05 -0800820 s.settings.set<TunerFrontendUnionSettings::dvbt>(
821 getAidlDvbtSettings(settings, settingsExt1_1));
Amy Zhangb5809be2021-01-26 16:27:23 -0800822 break;
823 }
824 case FrontendSettings::hidl_discriminator::isdbs: {
Amy Zhang2f3c64a2021-02-02 20:39:05 -0800825 s.settings.set<TunerFrontendUnionSettings::isdbs>(getAidlIsdbsSettings(settings));
Amy Zhangb5809be2021-01-26 16:27:23 -0800826 break;
827 }
828 case FrontendSettings::hidl_discriminator::isdbs3: {
Amy Zhang2f3c64a2021-02-02 20:39:05 -0800829 s.settings.set<TunerFrontendUnionSettings::isdbs3>(getAidlIsdbs3Settings(settings));
Amy Zhangb5809be2021-01-26 16:27:23 -0800830 break;
831 }
832 case FrontendSettings::hidl_discriminator::isdbt: {
Amy Zhang2f3c64a2021-02-02 20:39:05 -0800833 s.settings.set<TunerFrontendUnionSettings::isdbt>(getAidlIsdbtSettings(settings));
Amy Zhangb5809be2021-01-26 16:27:23 -0800834 break;
835 }
836 default:
837 break;
838 }
839 return s;
840}
841
Amy Zhang2f3c64a2021-02-02 20:39:05 -0800842TunerFrontendAnalogSettings FrontendClient::getAidlAnalogSettings(const FrontendSettings& settings,
843 const FrontendSettingsExt1_1& settingsExt1_1) {
844 TunerFrontendAnalogSettings analogSettings{
845 .frequency = (int)settings.analog().frequency,
846 .signalType = (int)settings.analog().type,
847 .sifStandard = (int)settings.analog().sifStandard,
848 };
849 if (settingsExt1_1.settingExt.getDiscriminator()
850 == FrontendSettingsExt1_1::SettingsExt::hidl_discriminator::analog) {
851 analogSettings.isExtended = true;
852 analogSettings.aftFlag = (int)settingsExt1_1.settingExt.analog().aftFlag;
853 } else {
854 analogSettings.isExtended = false;
855 }
856 return analogSettings;
857}
858
859TunerFrontendDvbsSettings FrontendClient::getAidlDvbsSettings(const FrontendSettings& settings,
860 const FrontendSettingsExt1_1& settingsExt1_1) {
861 TunerFrontendDvbsSettings dvbsSettings{
862 .frequency = (int)settings.dvbs().frequency,
863 .modulation = (int)settings.dvbs().modulation,
864 .codeRate = {
865 .fec = (long)settings.dvbs().coderate.fec,
866 .isLinear = settings.dvbs().coderate.isLinear,
867 .isShortFrames = settings.dvbs().coderate.isShortFrames,
868 .bitsPer1000Symbol = (int)settings.dvbs().coderate.bitsPer1000Symbol,
869 },
870 .symbolRate = (int)settings.dvbs().symbolRate,
871 .rolloff = (int)settings.dvbs().rolloff,
872 .pilot = (int)settings.dvbs().pilot,
873 .inputStreamId = (int)settings.dvbs().inputStreamId,
874 .standard = (int)settings.dvbs().standard,
875 .vcm = (int)settings.dvbs().vcmMode,
876 };
877 if (settingsExt1_1.settingExt.getDiscriminator()
878 == FrontendSettingsExt1_1::SettingsExt::hidl_discriminator::dvbs) {
879 dvbsSettings.isExtended = true;
880 dvbsSettings.scanType = (int)settingsExt1_1.settingExt.dvbs().scanType;
881 dvbsSettings.isDiseqcRxMessage = settingsExt1_1.settingExt.dvbs().isDiseqcRxMessage;
882 } else {
883 dvbsSettings.isExtended = false;
884 }
885 return dvbsSettings;
886}
887
888TunerFrontendCableSettings FrontendClient::getAidlCableSettings(const FrontendSettings& settings,
889 const FrontendSettingsExt1_1& settingsExt1_1) {
890 TunerFrontendCableSettings cableSettings{
891 .frequency = (int)settings.dvbc().frequency,
892 .modulation = (int)settings.dvbc().modulation,
893 .innerFec = (long)settings.dvbc().fec,
894 .symbolRate = (int)settings.dvbc().symbolRate,
895 .outerFec = (int)settings.dvbc().outerFec,
896 .annex = (int)settings.dvbc().annex,
897 .spectralInversion = (int)settings.dvbc().spectralInversion,
898 };
899 if (settingsExt1_1.settingExt.getDiscriminator()
900 == FrontendSettingsExt1_1::SettingsExt::hidl_discriminator::dvbc) {
901 cableSettings.isExtended = true;
902 cableSettings.interleaveMode = (int)settingsExt1_1.settingExt.dvbc().interleaveMode;
903 cableSettings.bandwidth = (int)settingsExt1_1.settingExt.dvbc().bandwidth;
904 } else {
905 cableSettings.isExtended = false;
906 }
907 return cableSettings;
908}
909
910TunerFrontendDvbtSettings FrontendClient::getAidlDvbtSettings(const FrontendSettings& settings,
911 const FrontendSettingsExt1_1& settingsExt1_1) {
912 TunerFrontendDvbtSettings dvbtSettings{
913 .frequency = (int)settings.dvbt().frequency,
914 .transmissionMode = (int)settings.dvbt().transmissionMode,
915 .bandwidth = (int)settings.dvbt().bandwidth,
916 .constellation = (int)settings.dvbt().constellation,
917 .hierarchy = (int)settings.dvbt().hierarchy,
918 .hpCodeRate = (int)settings.dvbt().hpCoderate,
919 .lpCodeRate = (int)settings.dvbt().lpCoderate,
920 .guardInterval = (int)settings.dvbt().guardInterval,
921 .isHighPriority = settings.dvbt().isHighPriority,
922 .standard = (int)settings.dvbt().standard,
923 .isMiso = settings.dvbt().isMiso,
924 .plpMode = (int)settings.dvbt().plpMode,
925 .plpId = (int)settings.dvbt().plpId,
926 .plpGroupId = (int)settings.dvbt().plpGroupId,
927 };
928 if (settingsExt1_1.settingExt.getDiscriminator()
929 == FrontendSettingsExt1_1::SettingsExt::hidl_discriminator::dvbt) {
930 dvbtSettings.isExtended = true;
931 dvbtSettings.constellation = (int)settingsExt1_1.settingExt.dvbt().constellation;
932 dvbtSettings.transmissionMode =
933 (int)settingsExt1_1.settingExt.dvbt().transmissionMode;
934 } else {
935 dvbtSettings.isExtended = false;
936 }
937 return dvbtSettings;
938}
939
940TunerFrontendDtmbSettings FrontendClient::getAidlDtmbSettings(
941 const FrontendSettingsExt1_1& settingsExt1_1) {
942 TunerFrontendDtmbSettings dtmbSettings{
943 .frequency = (int)settingsExt1_1.settingExt.dtmb().frequency,
944 .transmissionMode = (int)settingsExt1_1.settingExt.dtmb().transmissionMode,
945 .bandwidth = (int)settingsExt1_1.settingExt.dtmb().bandwidth,
946 .modulation = (int)settingsExt1_1.settingExt.dtmb().modulation,
947 .codeRate = (int)settingsExt1_1.settingExt.dtmb().codeRate,
948 .guardInterval = (int)settingsExt1_1.settingExt.dtmb().guardInterval,
949 .interleaveMode = (int)settingsExt1_1.settingExt.dtmb().interleaveMode,
950 };
951 return dtmbSettings;
952}
953
954TunerFrontendAtscSettings FrontendClient::getAidlAtscSettings(const FrontendSettings& settings) {
955 TunerFrontendAtscSettings atscSettings{
956 .frequency = (int)settings.atsc().frequency,
957 .modulation = (int)settings.atsc().modulation,
958 };
959 return atscSettings;
960}
961
962TunerFrontendAtsc3Settings FrontendClient::getAidlAtsc3Settings(const FrontendSettings& settings) {
963 TunerFrontendAtsc3Settings atsc3Settings{
964 .frequency = (int)settings.atsc3().frequency,
965 .bandwidth = (int)settings.atsc3().bandwidth,
966 .demodOutputFormat = (int)settings.atsc3().demodOutputFormat,
967 };
968 atsc3Settings.plpSettings.resize(settings.atsc3().plpSettings.size());
969 for (auto plpSetting : settings.atsc3().plpSettings) {
970 atsc3Settings.plpSettings.push_back({
971 .plpId = (int)plpSetting.plpId,
972 .modulation = (int)plpSetting.modulation,
973 .interleaveMode = (int)plpSetting.interleaveMode,
974 .codeRate = (int)plpSetting.codeRate,
975 .fec = (int)plpSetting.fec,
976 });
977 }
978 return atsc3Settings;
979}
980
981TunerFrontendIsdbsSettings FrontendClient::getAidlIsdbsSettings(const FrontendSettings& settings) {
982 TunerFrontendIsdbsSettings isdbsSettings{
983 .frequency = (int)settings.isdbs().frequency,
984 .streamId = (int)settings.isdbs().streamId,
985 .streamIdType = (int)settings.isdbs().streamIdType,
986 .modulation = (int)settings.isdbs().modulation,
987 .codeRate = (int)settings.isdbs().coderate,
988 .symbolRate = (int)settings.isdbs().symbolRate,
989 .rolloff = (int)settings.isdbs().rolloff,
990 };
991 return isdbsSettings;
992}
993
994TunerFrontendIsdbs3Settings FrontendClient::getAidlIsdbs3Settings(
995 const FrontendSettings& settings) {
996 TunerFrontendIsdbs3Settings isdbs3Settings{
997 .frequency = (int)settings.isdbs3().frequency,
998 .streamId = (int)settings.isdbs3().streamId,
999 .streamIdType = (int)settings.isdbs3().streamIdType,
1000 .modulation = (int)settings.isdbs3().modulation,
1001 .codeRate = (int)settings.isdbs3().coderate,
1002 .symbolRate = (int)settings.isdbs3().symbolRate,
1003 .rolloff = (int)settings.isdbs3().rolloff,
1004 };
1005 return isdbs3Settings;
1006}
1007
1008TunerFrontendIsdbtSettings FrontendClient::getAidlIsdbtSettings(const FrontendSettings& settings) {
1009 TunerFrontendIsdbtSettings isdbtSettings{
1010 .frequency = (int)settings.isdbt().frequency,
1011 .modulation = (int)settings.isdbt().modulation,
1012 .bandwidth = (int)settings.isdbt().bandwidth,
1013 .mode = (int)settings.isdbt().mode,
1014 .codeRate = (int)settings.isdbt().coderate,
1015 .guardInterval = (int)settings.isdbt().guardInterval,
1016 .serviceAreaId = (int)settings.isdbt().serviceAreaId,
1017 };
1018 return isdbtSettings;
1019}
1020
1021bool FrontendClient::validateExtendedSettings(const FrontendSettingsExt1_1& settingsExt1_1) {
1022 return settingsExt1_1.endFrequency != (uint32_t)Constant::INVALID_FRONTEND_SETTING_FREQUENCY
1023 || settingsExt1_1.inversion != FrontendSpectralInversion::UNDEFINED
1024 || settingsExt1_1.settingExt.getDiscriminator()
1025 != FrontendSettingsExt1_1::SettingsExt::hidl_discriminator::noinit;
1026}
1027
Amy Zhanga6734682020-11-30 16:14:38 -08001028/////////////// TunerFrontendCallback ///////////////////////
1029
1030TunerFrontendCallback::TunerFrontendCallback(sp<FrontendClientCallback> frontendClientCallback)
1031 : mFrontendClientCallback(frontendClientCallback) {}
1032
1033Status TunerFrontendCallback::onEvent(int frontendEventType) {
1034 if (mFrontendClientCallback != NULL) {
1035 mFrontendClientCallback->onEvent(static_cast<FrontendEventType>(frontendEventType));
1036 return Status::ok();
1037 }
1038 return Status::fromServiceSpecificError(static_cast<int32_t>(Result::INVALID_STATE));
1039}
1040
Amy Zhangb9f3cab2021-01-13 15:24:14 -08001041Status TunerFrontendCallback::onScanMessage(int messageType,
1042 const TunerFrontendScanMessage& message) {
1043 if (mFrontendClientCallback != NULL) {
1044 if (!is1_1ExtendedScanMessage(messageType)) {
1045 mFrontendClientCallback->onScanMessage(
1046 static_cast<FrontendScanMessageType>(messageType),
1047 getHalScanMessage(messageType, message));
1048 } else {
1049 mFrontendClientCallback->onScanMessageExt1_1(
1050 static_cast<FrontendScanMessageTypeExt1_1>(messageType),
1051 getHalScanMessageExt1_1(messageType, message));
1052 }
1053 return Status::ok();
1054 }
1055 return Status::fromServiceSpecificError(static_cast<int32_t>(Result::INVALID_STATE));
Amy Zhanga6734682020-11-30 16:14:38 -08001056}
1057
1058/////////////// IFrontendCallback ///////////////////////
1059
1060HidlFrontendCallback::HidlFrontendCallback(sp<FrontendClientCallback> frontendClientCallback)
1061 : mFrontendClientCallback(frontendClientCallback) {}
1062
1063Return<void> HidlFrontendCallback::onEvent(FrontendEventType frontendEventType) {
1064 if (mFrontendClientCallback != NULL) {
1065 mFrontendClientCallback->onEvent(frontendEventType);
1066 }
1067 return Void();
1068}
1069
1070Return<void> HidlFrontendCallback::onScanMessage(FrontendScanMessageType type,
1071 const FrontendScanMessage& message) {
1072 if (mFrontendClientCallback != NULL) {
1073 mFrontendClientCallback->onScanMessage(type, message);
1074 }
1075 return Void();
1076}
1077
1078Return<void> HidlFrontendCallback::onScanMessageExt1_1(FrontendScanMessageTypeExt1_1 type,
1079 const FrontendScanMessageExt1_1& message) {
1080 if (mFrontendClientCallback != NULL) {
1081 mFrontendClientCallback->onScanMessageExt1_1(type, message);
1082 }
1083 return Void();
1084}
Amy Zhangb9f3cab2021-01-13 15:24:14 -08001085
1086/////////////// FrontendClientCallback Helper Methods ///////////////////////
1087
1088FrontendScanMessage TunerFrontendCallback::getHalScanMessage(
1089 int messageType, const TunerFrontendScanMessage& message) {
1090 FrontendScanMessage scanMessage;
1091 switch (messageType) {
1092 case (int) FrontendScanMessageType::LOCKED:
1093 scanMessage.isLocked(message.get<TunerFrontendScanMessage::isLocked>());
1094 break;
1095 case (int) FrontendScanMessageType::END:
1096 scanMessage.isEnd(message.get<TunerFrontendScanMessage::isEnd>());
1097 break;
1098 case (int) FrontendScanMessageType::PROGRESS_PERCENT:
1099 scanMessage.progressPercent(message.get<TunerFrontendScanMessage::progressPercent>());
1100 break;
1101 case (int) FrontendScanMessageType::FREQUENCY: {
1102 vector<int> f = message.get<TunerFrontendScanMessage::frequencies>();
1103 hidl_vec<uint32_t> frequencies(begin(f), end(f));
1104 scanMessage.frequencies(frequencies);
1105 break;
1106 }
1107 case (int) FrontendScanMessageType::SYMBOL_RATE: {
1108 vector<int> s = message.get<TunerFrontendScanMessage::symbolRates>();
1109 hidl_vec<uint32_t> symbolRates(begin(s), end(s));
1110 scanMessage.symbolRates(symbolRates);
1111 break;
1112 }
1113 case (int) FrontendScanMessageType::HIERARCHY:
1114 scanMessage.hierarchy(static_cast<FrontendDvbtHierarchy>(
1115 message.get<TunerFrontendScanMessage::hierarchy>()));
1116 break;
1117 case (int) FrontendScanMessageType::ANALOG_TYPE:
1118 scanMessage.analogType(static_cast<FrontendAnalogType>(
1119 message.get<TunerFrontendScanMessage::analogType>()));
1120 break;
1121 case (int) FrontendScanMessageType::PLP_IDS: {
1122 vector<uint8_t> p = message.get<TunerFrontendScanMessage::plpIds>();
1123 hidl_vec<uint8_t> plpIds(begin(p), end(p));
1124 scanMessage.plpIds(plpIds);
1125 break;
1126 }
1127 case (int) FrontendScanMessageType::GROUP_IDS: {
1128 vector<uint8_t> g = message.get<TunerFrontendScanMessage::groupIds>();
1129 hidl_vec<uint8_t> groupIds(begin(g), end(g));
1130 scanMessage.groupIds(groupIds);
1131 break;
1132 }
1133 case (int) FrontendScanMessageType::INPUT_STREAM_IDS: {
1134 vector<char16_t> i = message.get<TunerFrontendScanMessage::inputStreamIds>();
1135 hidl_vec<uint16_t> inputStreamIds(begin(i), end(i));
1136 scanMessage.inputStreamIds(inputStreamIds);
1137 break;
1138 }
1139 case (int) FrontendScanMessageType::STANDARD: {
1140 FrontendScanMessage::Standard std;
1141 int standard = message.get<TunerFrontendScanMessage::std>();
1142 switch (mType) {
1143 case (int) FrontendType::DVBS:
1144 std.sStd(static_cast<FrontendDvbsStandard>(standard));
1145 scanMessage.std(std);
1146 break;
1147 case (int) FrontendType::DVBT:
1148 std.tStd(static_cast<FrontendDvbtStandard>(standard));
1149 scanMessage.std(std);
1150 break;
1151 case (int) FrontendType::ANALOG:
1152 std.sifStd(static_cast<FrontendAnalogSifStandard>(standard));
1153 scanMessage.std(std);
1154 break;
1155 default:
1156 break;
1157 }
1158 break;
1159 }
1160 case (int) FrontendScanMessageType::ATSC3_PLP_INFO: {
1161 vector<TunerFrontendScanAtsc3PlpInfo> plp =
1162 message.get<TunerFrontendScanMessage::atsc3PlpInfos>();
1163 hidl_vec<FrontendScanAtsc3PlpInfo> plpInfo;
Amy Zhang46c31ec2021-02-03 18:19:10 -08001164 int size = plp.size();
1165 plpInfo.resize(size);
1166 for (int i = 0; i < size; i++) {
1167 auto info = message.get<TunerFrontendScanMessage::atsc3PlpInfos>()[i];
Amy Zhangb9f3cab2021-01-13 15:24:14 -08001168 FrontendScanAtsc3PlpInfo p{
1169 .plpId = static_cast<uint8_t>(info.plpId),
1170 .bLlsFlag = info.llsFlag,
1171 };
Amy Zhang46c31ec2021-02-03 18:19:10 -08001172 plpInfo[i] = p;
Amy Zhangb9f3cab2021-01-13 15:24:14 -08001173 }
1174 scanMessage.atsc3PlpInfos(plpInfo);
1175 break;
1176 }
1177 default:
1178 break;
1179 }
1180 return scanMessage;
1181}
1182
1183FrontendScanMessageExt1_1 TunerFrontendCallback::getHalScanMessageExt1_1(
1184 int messageType, const TunerFrontendScanMessage& message) {
1185 FrontendScanMessageExt1_1 scanMessage;
1186 switch (messageType) {
1187 case (int) FrontendScanMessageTypeExt1_1::HIGH_PRIORITY:
1188 scanMessage.isHighPriority(message.get<TunerFrontendScanMessage::isHighPriority>());
1189 break;
1190 case (int) FrontendScanMessageTypeExt1_1::DVBC_ANNEX:
1191 scanMessage.annex(static_cast<FrontendDvbcAnnex>(
1192 message.get<TunerFrontendScanMessage::annex>()));
1193 break;
1194 case (int) FrontendScanMessageTypeExt1_1::MODULATION: {
1195 FrontendModulation m;
1196 int modulation = message.get<TunerFrontendScanMessage::modulation>();
1197 switch (mType) {
1198 case (int) FrontendType::DVBC:
1199 m.dvbc(static_cast<FrontendDvbcModulation>(modulation));
1200 scanMessage.modulation(m);
1201 break;
1202 case (int) FrontendType::DVBS:
1203 m.dvbs(static_cast<FrontendDvbsModulation>(modulation));
1204 scanMessage.modulation(m);
1205 break;
1206 case (int) FrontendType::DVBT:
1207 m.dvbt(static_cast<FrontendDvbtConstellation>(modulation));
1208 scanMessage.modulation(m);
1209 break;
1210 case (int) FrontendType::ISDBS:
1211 m.isdbs(static_cast<FrontendIsdbsModulation>(modulation));
1212 scanMessage.modulation(m);
1213 break;
1214 case (int) FrontendType::ISDBS3:
1215 m.isdbs3(static_cast<FrontendIsdbs3Modulation>(modulation));
1216 scanMessage.modulation(m);
1217 break;
1218 case (int) FrontendType::ISDBT:
1219 m.isdbt(static_cast<FrontendIsdbtModulation>(modulation));
1220 scanMessage.modulation(m);
1221 break;
1222 case (int) FrontendType::ATSC:
1223 m.atsc(static_cast<FrontendAtscModulation>(modulation));
1224 scanMessage.modulation(m);
1225 break;
1226 case (int) FrontendType::ATSC3:
1227 m.atsc3(static_cast<FrontendAtsc3Modulation>(modulation));
1228 scanMessage.modulation(m);
1229 break;
1230 case (int) hardware::tv::tuner::V1_1::FrontendType::DTMB:
1231 m.dtmb(static_cast<FrontendDtmbModulation>(modulation));
1232 scanMessage.modulation(m);
1233 break;
1234 default:
1235 break;
1236 }
1237 break;
1238 }
1239 default:
1240 break;
1241 }
1242 return scanMessage;
1243}
1244
1245bool TunerFrontendCallback::is1_1ExtendedScanMessage(int messageType) {
1246 return messageType >= (int)FrontendScanMessageTypeExt1_1::MODULATION
1247 && messageType <= (int)FrontendScanMessageTypeExt1_1::HIGH_PRIORITY;
1248}
Amy Zhanga6734682020-11-30 16:14:38 -08001249} // namespace android