| /* |
| * Copyright 2020 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #define LOG_TAG "android.hardware.tv.tuner@1.1-Frontend" |
| |
| #include "Frontend.h" |
| #include <android/hardware/tv/tuner/1.1/IFrontendCallback.h> |
| #include <utils/Log.h> |
| |
| namespace android { |
| namespace hardware { |
| namespace tv { |
| namespace tuner { |
| namespace V1_0 { |
| namespace implementation { |
| |
| Frontend::Frontend(FrontendType type, FrontendId id, sp<Tuner> tuner) { |
| mType = type; |
| mId = id; |
| mTunerService = tuner; |
| // Init callback to nullptr |
| mCallback = nullptr; |
| } |
| |
| Frontend::~Frontend() {} |
| |
| Return<Result> Frontend::close() { |
| ALOGV("%s", __FUNCTION__); |
| // Reset callback |
| mCallback = nullptr; |
| mIsLocked = false; |
| mTunerService->removeFrontend(mId); |
| |
| return Result::SUCCESS; |
| } |
| |
| Return<Result> Frontend::setCallback(const sp<IFrontendCallback>& callback) { |
| ALOGV("%s", __FUNCTION__); |
| if (callback == nullptr) { |
| ALOGW("[ WARN ] Set Frontend callback with nullptr"); |
| return Result::INVALID_ARGUMENT; |
| } |
| |
| mCallback = callback; |
| return Result::SUCCESS; |
| } |
| |
| Return<Result> Frontend::tune(const FrontendSettings& /* settings */) { |
| ALOGV("%s", __FUNCTION__); |
| if (mCallback == nullptr) { |
| ALOGW("[ WARN ] Frontend callback is not set when tune"); |
| return Result::INVALID_STATE; |
| } |
| |
| mTunerService->frontendStartTune(mId); |
| mCallback->onEvent(FrontendEventType::LOCKED); |
| mIsLocked = true; |
| return Result::SUCCESS; |
| } |
| |
| Return<Result> Frontend::tune_1_1(const FrontendSettings& settings, |
| const V1_1::FrontendSettingsExt1_1& /*settingsExt1_1*/) { |
| ALOGV("%s", __FUNCTION__); |
| return tune(settings); |
| } |
| |
| Return<Result> Frontend::stopTune() { |
| ALOGV("%s", __FUNCTION__); |
| |
| mTunerService->frontendStopTune(mId); |
| mIsLocked = false; |
| |
| return Result::SUCCESS; |
| } |
| |
| Return<Result> Frontend::scan(const FrontendSettings& settings, FrontendScanType type) { |
| ALOGV("%s", __FUNCTION__); |
| |
| // If it's in middle of scanning, stop it first. |
| if (mScanThread.joinable()) { |
| mScanThread.join(); |
| } |
| |
| mFrontendSettings = settings; |
| mFrontendScanType = type; |
| mScanThread = std::thread(&Frontend::scanThreadLoop, this); |
| |
| return Result::SUCCESS; |
| } |
| |
| void Frontend::scanThreadLoop() { |
| FrontendScanMessage msg; |
| |
| if (mIsLocked) { |
| msg.isEnd(true); |
| mCallback->onScanMessage(FrontendScanMessageType::END, msg); |
| return; |
| } |
| |
| uint32_t frequency; |
| switch (mFrontendSettings.getDiscriminator()) { |
| case FrontendSettings::hidl_discriminator::analog: |
| frequency = mFrontendSettings.analog().frequency; |
| break; |
| case FrontendSettings::hidl_discriminator::atsc: |
| frequency = mFrontendSettings.atsc().frequency; |
| break; |
| case FrontendSettings::hidl_discriminator::atsc3: |
| frequency = mFrontendSettings.atsc3().frequency; |
| break; |
| case FrontendSettings::hidl_discriminator::dvbs: |
| frequency = mFrontendSettings.dvbs().frequency; |
| break; |
| case FrontendSettings::hidl_discriminator::dvbc: |
| frequency = mFrontendSettings.dvbc().frequency; |
| break; |
| case FrontendSettings::hidl_discriminator::dvbt: |
| frequency = mFrontendSettings.dvbt().frequency; |
| break; |
| case FrontendSettings::hidl_discriminator::isdbs: |
| frequency = mFrontendSettings.isdbs().frequency; |
| break; |
| case FrontendSettings::hidl_discriminator::isdbs3: |
| frequency = mFrontendSettings.isdbs3().frequency; |
| break; |
| case FrontendSettings::hidl_discriminator::isdbt: |
| frequency = mFrontendSettings.isdbt().frequency; |
| break; |
| } |
| |
| if (mFrontendScanType == FrontendScanType::SCAN_BLIND) { |
| frequency += 100 * 1000; |
| } |
| |
| msg.frequencies({frequency}); |
| mCallback->onScanMessage(FrontendScanMessageType::FREQUENCY, msg); |
| |
| msg.progressPercent(20); |
| mCallback->onScanMessage(FrontendScanMessageType::PROGRESS_PERCENT, msg); |
| |
| msg.symbolRates({30}); |
| mCallback->onScanMessage(FrontendScanMessageType::SYMBOL_RATE, msg); |
| |
| if (mType == FrontendType::DVBT) { |
| msg.hierarchy(FrontendDvbtHierarchy::HIERARCHY_NON_NATIVE); |
| mCallback->onScanMessage(FrontendScanMessageType::HIERARCHY, msg); |
| } |
| |
| if (mType == FrontendType::ANALOG) { |
| msg.analogType(FrontendAnalogType::PAL); |
| mCallback->onScanMessage(FrontendScanMessageType::ANALOG_TYPE, msg); |
| } |
| |
| msg.plpIds({3}); |
| mCallback->onScanMessage(FrontendScanMessageType::PLP_IDS, msg); |
| |
| msg.groupIds({2}); |
| mCallback->onScanMessage(FrontendScanMessageType::GROUP_IDS, msg); |
| |
| msg.inputStreamIds({1}); |
| mCallback->onScanMessage(FrontendScanMessageType::INPUT_STREAM_IDS, msg); |
| |
| FrontendScanMessage::Standard s; |
| switch (mType) { |
| case FrontendType::DVBT: |
| s.tStd(FrontendDvbtStandard::AUTO); |
| msg.std(s); |
| mCallback->onScanMessage(FrontendScanMessageType::STANDARD, msg); |
| break; |
| case FrontendType::DVBS: |
| s.sStd(FrontendDvbsStandard::AUTO); |
| msg.std(s); |
| mCallback->onScanMessage(FrontendScanMessageType::STANDARD, msg); |
| break; |
| case FrontendType::ANALOG: |
| s.sifStd(FrontendAnalogSifStandard::AUTO); |
| msg.std(s); |
| mCallback->onScanMessage(FrontendScanMessageType::STANDARD, msg); |
| break; |
| default: |
| break; |
| } |
| |
| FrontendScanAtsc3PlpInfo info{ |
| .plpId = 1, |
| .bLlsFlag = false, |
| }; |
| msg.atsc3PlpInfos({info}); |
| mCallback->onScanMessage(FrontendScanMessageType::ATSC3_PLP_INFO, msg); |
| |
| sp<V1_1::IFrontendCallback> frontendCallback_v1_1 = |
| V1_1::IFrontendCallback::castFrom(mCallback); |
| if (frontendCallback_v1_1 != NULL) { |
| V1_1::FrontendScanMessageExt1_1 msg; |
| msg.modulation().dvbc(FrontendDvbcModulation::MOD_16QAM); |
| frontendCallback_v1_1->onScanMessageExt1_1(V1_1::FrontendScanMessageTypeExt1_1::MODULATION, |
| msg); |
| msg.isHighPriority(true); |
| frontendCallback_v1_1->onScanMessageExt1_1( |
| V1_1::FrontendScanMessageTypeExt1_1::HIGH_PRIORITY, msg); |
| } else { |
| ALOGD("[Frontend] Couldn't cast to V1_1 IFrontendCallback"); |
| } |
| |
| msg.isLocked(true); |
| mCallback->onScanMessage(FrontendScanMessageType::LOCKED, msg); |
| mIsLocked = true; |
| } |
| |
| Return<Result> Frontend::scan_1_1(const FrontendSettings& settings, FrontendScanType type, |
| const V1_1::FrontendSettingsExt1_1& settingsExt1_1) { |
| ALOGV("%s", __FUNCTION__); |
| ALOGD("[Frontend] scan_1_1 end frequency %d", settingsExt1_1.endFrequency); |
| return scan(settings, type); |
| } |
| |
| Return<Result> Frontend::stopScan() { |
| ALOGV("%s", __FUNCTION__); |
| |
| if (mScanThread.joinable()) { |
| mScanThread.join(); |
| } |
| |
| mIsLocked = false; |
| return Result::SUCCESS; |
| } |
| |
| Return<void> Frontend::getStatus(const hidl_vec<FrontendStatusType>& statusTypes, |
| getStatus_cb _hidl_cb) { |
| ALOGV("%s", __FUNCTION__); |
| |
| vector<FrontendStatus> statuses; |
| for (int i = 0; i < statusTypes.size(); i++) { |
| FrontendStatusType type = statusTypes[i]; |
| FrontendStatus status; |
| // assign randomly selected values for testing. |
| switch (type) { |
| case FrontendStatusType::DEMOD_LOCK: { |
| status.isDemodLocked(true); |
| break; |
| } |
| case FrontendStatusType::SNR: { |
| status.snr(221); |
| break; |
| } |
| case FrontendStatusType::BER: { |
| status.ber(1); |
| break; |
| } |
| case FrontendStatusType::PER: { |
| status.per(2); |
| break; |
| } |
| case FrontendStatusType::PRE_BER: { |
| status.preBer(3); |
| break; |
| } |
| case FrontendStatusType::SIGNAL_QUALITY: { |
| status.signalQuality(4); |
| break; |
| } |
| case FrontendStatusType::SIGNAL_STRENGTH: { |
| status.signalStrength(5); |
| break; |
| } |
| case FrontendStatusType::SYMBOL_RATE: { |
| status.symbolRate(6); |
| break; |
| } |
| case FrontendStatusType::FEC: { |
| status.innerFec(FrontendInnerFec::FEC_2_9); // value = 1 << 7 |
| break; |
| } |
| case FrontendStatusType::MODULATION: { |
| FrontendModulationStatus modulationStatus; |
| switch (mType) { |
| case FrontendType::ISDBS: { |
| modulationStatus.isdbs( |
| FrontendIsdbsModulation::MOD_BPSK); // value = 1 << 1 |
| status.modulation(modulationStatus); |
| break; |
| } |
| case FrontendType::DVBC: { |
| modulationStatus.dvbc(FrontendDvbcModulation::MOD_16QAM); // value = 1 << 1 |
| status.modulation(modulationStatus); |
| break; |
| } |
| case FrontendType::DVBS: { |
| modulationStatus.dvbs(FrontendDvbsModulation::MOD_QPSK); // value = 1 << 1 |
| status.modulation(modulationStatus); |
| break; |
| } |
| case FrontendType::ISDBS3: { |
| modulationStatus.isdbs3( |
| FrontendIsdbs3Modulation::MOD_BPSK); // value = 1 << 1 |
| status.modulation(modulationStatus); |
| break; |
| } |
| case FrontendType::ISDBT: { |
| modulationStatus.isdbt( |
| FrontendIsdbtModulation::MOD_DQPSK); // value = 1 << 1 |
| status.modulation(modulationStatus); |
| break; |
| } |
| default: |
| break; |
| } |
| break; |
| } |
| case FrontendStatusType::SPECTRAL: { |
| status.inversion(FrontendDvbcSpectralInversion::NORMAL); |
| break; |
| } |
| case FrontendStatusType::LNB_VOLTAGE: { |
| status.lnbVoltage(LnbVoltage::VOLTAGE_5V); |
| break; |
| } |
| case FrontendStatusType::PLP_ID: { |
| status.plpId(101); // type uint8_t |
| break; |
| } |
| case FrontendStatusType::EWBS: { |
| status.isEWBS(false); |
| break; |
| } |
| case FrontendStatusType::AGC: { |
| status.agc(7); |
| break; |
| } |
| case FrontendStatusType::LNA: { |
| status.isLnaOn(false); |
| break; |
| } |
| case FrontendStatusType::LAYER_ERROR: { |
| vector<bool> v = {false, true, true}; |
| status.isLayerError(v); |
| break; |
| } |
| case FrontendStatusType::MER: { |
| status.mer(8); |
| break; |
| } |
| case FrontendStatusType::FREQ_OFFSET: { |
| status.freqOffset(9); |
| break; |
| } |
| case FrontendStatusType::HIERARCHY: { |
| status.hierarchy(FrontendDvbtHierarchy::HIERARCHY_1_NATIVE); |
| break; |
| } |
| case FrontendStatusType::RF_LOCK: { |
| status.isRfLocked(false); |
| break; |
| } |
| case FrontendStatusType::ATSC3_PLP_INFO: { |
| vector<FrontendStatusAtsc3PlpInfo> v; |
| FrontendStatusAtsc3PlpInfo info1{ |
| .plpId = 3, |
| .isLocked = false, |
| .uec = 313, |
| }; |
| FrontendStatusAtsc3PlpInfo info2{ |
| .plpId = 5, |
| .isLocked = true, |
| .uec = 515, |
| }; |
| v.push_back(info1); |
| v.push_back(info2); |
| status.plpInfo(v); |
| break; |
| } |
| default: { |
| continue; |
| } |
| } |
| statuses.push_back(status); |
| } |
| _hidl_cb(Result::SUCCESS, statuses); |
| |
| return Void(); |
| } |
| |
| Return<void> Frontend::getStatusExt1_1(const hidl_vec<V1_1::FrontendStatusTypeExt1_1>& statusTypes, |
| V1_1::IFrontend::getStatusExt1_1_cb _hidl_cb) { |
| ALOGV("%s", __FUNCTION__); |
| |
| vector<V1_1::FrontendStatusExt1_1> statuses; |
| for (int i = 0; i < statusTypes.size(); i++) { |
| V1_1::FrontendStatusTypeExt1_1 type = statusTypes[i]; |
| V1_1::FrontendStatusExt1_1 status; |
| |
| switch (type) { |
| case V1_1::FrontendStatusTypeExt1_1::MODULATIONS: { |
| vector<V1_1::FrontendModulation> modulations; |
| V1_1::FrontendModulation modulation; |
| switch ((int)mType) { |
| case (int)FrontendType::ISDBS: { |
| modulation.isdbs(FrontendIsdbsModulation::MOD_BPSK); // value = 1 << 1 |
| modulations.push_back(modulation); |
| status.modulations(modulations); |
| break; |
| } |
| case (int)FrontendType::DVBC: { |
| modulation.dvbc(FrontendDvbcModulation::MOD_16QAM); // value = 1 << 1 |
| modulations.push_back(modulation); |
| status.modulations(modulations); |
| break; |
| } |
| case (int)FrontendType::DVBS: { |
| modulation.dvbs(FrontendDvbsModulation::MOD_QPSK); // value = 1 << 1 |
| modulations.push_back(modulation); |
| status.modulations(modulations); |
| break; |
| } |
| case (int)FrontendType::DVBT: { |
| // value = 1 << 16 |
| modulation.dvbt(V1_1::FrontendDvbtConstellation::CONSTELLATION_16QAM_R); |
| modulations.push_back(modulation); |
| status.modulations(modulations); |
| break; |
| } |
| case (int)FrontendType::ISDBS3: { |
| modulation.isdbs3(FrontendIsdbs3Modulation::MOD_BPSK); // value = 1 << 1 |
| modulations.push_back(modulation); |
| status.modulations(modulations); |
| break; |
| } |
| case (int)FrontendType::ISDBT: { |
| modulation.isdbt(FrontendIsdbtModulation::MOD_DQPSK); // value = 1 << 1 |
| modulations.push_back(modulation); |
| status.modulations(modulations); |
| break; |
| } |
| case (int)FrontendType::ATSC: { |
| modulation.atsc(FrontendAtscModulation::MOD_8VSB); // value = 1 << 2 |
| modulations.push_back(modulation); |
| status.modulations(modulations); |
| break; |
| } |
| case (int)FrontendType::ATSC3: { |
| modulation.atsc3(FrontendAtsc3Modulation::MOD_QPSK); // value = 1 << 1 |
| modulations.push_back(modulation); |
| status.modulations(modulations); |
| break; |
| } |
| case (int)V1_1::FrontendType::DTMB: { |
| // value = 1 << 1 |
| modulation.dtmb(V1_1::FrontendDtmbModulation::CONSTELLATION_4QAM); |
| modulations.push_back(modulation); |
| status.modulations(modulations); |
| break; |
| } |
| default: |
| break; |
| } |
| break; |
| } |
| case V1_1::FrontendStatusTypeExt1_1::BERS: { |
| vector<uint32_t> bers = {1}; |
| status.bers(bers); |
| break; |
| } |
| case V1_1::FrontendStatusTypeExt1_1::CODERATES: { |
| // value = 1 << 39 |
| vector<V1_1::FrontendInnerFec> codeRates = {V1_1::FrontendInnerFec::FEC_6_15}; |
| status.codeRates(codeRates); |
| break; |
| } |
| case V1_1::FrontendStatusTypeExt1_1::BANDWIDTH: { |
| V1_1::FrontendBandwidth bandwidth; |
| switch ((int)mType) { |
| case (int)FrontendType::DVBC: { |
| // value = 1 << 1 |
| bandwidth.dvbc(V1_1::FrontendDvbcBandwidth::BANDWIDTH_6MHZ); |
| status.bandwidth(bandwidth); |
| break; |
| } |
| case (int)FrontendType::DVBT: { |
| // value = 1 << 1 |
| bandwidth.dvbt(FrontendDvbtBandwidth::BANDWIDTH_8MHZ); |
| status.bandwidth(bandwidth); |
| break; |
| } |
| case (int)FrontendType::ISDBT: { |
| bandwidth.isdbt(FrontendIsdbtBandwidth::BANDWIDTH_8MHZ); // value = 1 << 1 |
| status.bandwidth(bandwidth); |
| break; |
| } |
| case (int)FrontendType::ATSC3: { |
| bandwidth.atsc3(FrontendAtsc3Bandwidth::BANDWIDTH_6MHZ); // value = 1 << 1 |
| status.bandwidth(bandwidth); |
| break; |
| } |
| case (int)V1_1::FrontendType::DTMB: { |
| // value = 1 << 1 |
| bandwidth.dtmb(V1_1::FrontendDtmbBandwidth::BANDWIDTH_8MHZ); |
| status.bandwidth(bandwidth); |
| break; |
| } |
| default: |
| break; |
| } |
| break; |
| } |
| case V1_1::FrontendStatusTypeExt1_1::GUARD_INTERVAL: { |
| V1_1::FrontendGuardInterval interval; |
| switch ((int)mType) { |
| case (int)FrontendType::DVBT: { |
| interval.dvbt(FrontendDvbtGuardInterval::INTERVAL_1_32); // value = 1 << 1 |
| status.interval(interval); |
| break; |
| } |
| case (int)FrontendType::ISDBT: { |
| interval.isdbt(FrontendDvbtGuardInterval::INTERVAL_1_32); // value = 1 << 1 |
| status.interval(interval); |
| break; |
| } |
| case (int)V1_1::FrontendType::DTMB: { |
| // value = 1 << 1 |
| interval.dtmb(V1_1::FrontendDtmbGuardInterval::PN_420_VARIOUS); |
| status.interval(interval); |
| break; |
| } |
| default: |
| break; |
| } |
| break; |
| } |
| case V1_1::FrontendStatusTypeExt1_1::TRANSMISSION_MODE: { |
| V1_1::FrontendTransmissionMode transMode; |
| switch ((int)mType) { |
| case (int)FrontendType::DVBT: { |
| // value = 1 << 8 |
| transMode.dvbt(V1_1::FrontendDvbtTransmissionMode::MODE_16K_E); |
| status.transmissionMode(transMode); |
| break; |
| } |
| case (int)FrontendType::ISDBT: { |
| transMode.isdbt(FrontendIsdbtMode::MODE_1); // value = 1 << 1 |
| status.transmissionMode(transMode); |
| break; |
| } |
| case (int)V1_1::FrontendType::DTMB: { |
| transMode.dtmb(V1_1::FrontendDtmbTransmissionMode::C1); // value = 1 << 1 |
| status.transmissionMode(transMode); |
| break; |
| } |
| default: |
| break; |
| } |
| break; |
| } |
| case V1_1::FrontendStatusTypeExt1_1::UEC: { |
| status.uec(4); |
| break; |
| } |
| case V1_1::FrontendStatusTypeExt1_1::T2_SYSTEM_ID: { |
| status.systemId(5); |
| break; |
| } |
| case V1_1::FrontendStatusTypeExt1_1::INTERLEAVINGS: { |
| V1_1::FrontendInterleaveMode interleave; |
| switch ((int)mType) { |
| case (int)FrontendType::DVBC: { |
| // value = 1 << 1 |
| interleave.dvbc( |
| V1_1::FrontendCableTimeInterleaveMode::INTERLEAVING_128_1_0); |
| vector<V1_1::FrontendInterleaveMode> interleaving = {interleave}; |
| status.interleaving(interleaving); |
| break; |
| } |
| case (int)FrontendType::ATSC3: { |
| // value = 1 << 1 |
| interleave.atsc3(FrontendAtsc3TimeInterleaveMode::CTI); |
| vector<V1_1::FrontendInterleaveMode> interleaving = {interleave}; |
| status.interleaving(interleaving); |
| break; |
| } |
| case (int)V1_1::FrontendType::DTMB: { |
| // value = 1 << 1 |
| interleave.dtmb(V1_1::FrontendDtmbTimeInterleaveMode::TIMER_INT_240); |
| vector<V1_1::FrontendInterleaveMode> interleaving = {interleave}; |
| status.interleaving(interleaving); |
| break; |
| } |
| default: |
| break; |
| } |
| break; |
| } |
| case V1_1::FrontendStatusTypeExt1_1::ISDBT_SEGMENTS: { |
| vector<uint8_t> segments = {2, 3}; |
| status.isdbtSegment(segments); |
| break; |
| } |
| case V1_1::FrontendStatusTypeExt1_1::TS_DATA_RATES: { |
| vector<uint32_t> dataRates = {4, 5}; |
| status.tsDataRate(dataRates); |
| break; |
| } |
| case V1_1::FrontendStatusTypeExt1_1::ROLL_OFF: { |
| V1_1::FrontendRollOff rollOff; |
| switch (mType) { |
| case FrontendType::DVBS: { |
| // value = 1 |
| rollOff.dvbs(FrontendDvbsRolloff::ROLLOFF_0_35); |
| status.rollOff(rollOff); |
| break; |
| } |
| case FrontendType::ISDBS: { |
| // value = 1 |
| rollOff.isdbs(FrontendIsdbsRolloff::ROLLOFF_0_35); |
| status.rollOff(rollOff); |
| break; |
| } |
| case FrontendType::ISDBS3: { |
| // value = 1 |
| rollOff.isdbs3(FrontendIsdbs3Rolloff::ROLLOFF_0_03); |
| status.rollOff(rollOff); |
| break; |
| } |
| default: |
| break; |
| } |
| break; |
| } |
| case V1_1::FrontendStatusTypeExt1_1::IS_MISO: { |
| status.isMiso(true); |
| break; |
| } |
| case V1_1::FrontendStatusTypeExt1_1::IS_LINEAR: { |
| status.isLinear(true); |
| break; |
| } |
| case V1_1::FrontendStatusTypeExt1_1::IS_SHORT_FRAMES: { |
| status.isShortFrames(true); |
| break; |
| } |
| default: { |
| continue; |
| } |
| } |
| statuses.push_back(status); |
| } |
| _hidl_cb(Result::SUCCESS, statuses); |
| |
| return Void(); |
| } |
| |
| Return<Result> Frontend::setLna(bool /* bEnable */) { |
| ALOGV("%s", __FUNCTION__); |
| |
| return Result::SUCCESS; |
| } |
| |
| Return<Result> Frontend::setLnb(uint32_t /* lnb */) { |
| ALOGV("%s", __FUNCTION__); |
| if (!supportsSatellite()) { |
| return Result::INVALID_STATE; |
| } |
| return Result::SUCCESS; |
| } |
| |
| Return<void> Frontend::linkCiCam(uint32_t ciCamId, linkCiCam_cb _hidl_cb) { |
| ALOGV("%s", __FUNCTION__); |
| |
| mCiCamId = ciCamId; |
| _hidl_cb(Result::SUCCESS, 0 /*ltsId*/); |
| |
| return Void(); |
| } |
| |
| Return<Result> Frontend::unlinkCiCam(uint32_t /*ciCamId*/) { |
| ALOGV("%s", __FUNCTION__); |
| |
| mCiCamId = -1; |
| |
| return Result::SUCCESS; |
| } |
| |
| FrontendType Frontend::getFrontendType() { |
| return mType; |
| } |
| |
| FrontendId Frontend::getFrontendId() { |
| return mId; |
| } |
| |
| bool Frontend::supportsSatellite() { |
| return mType == FrontendType::DVBS || mType == FrontendType::ISDBS || |
| mType == FrontendType::ISDBS3; |
| } |
| |
| bool Frontend::isLocked() { |
| return mIsLocked; |
| } |
| } // namespace implementation |
| } // namespace V1_0 |
| } // namespace tuner |
| } // namespace tv |
| } // namespace hardware |
| } // namespace android |