services/tuner/TunerFrontend.cpp

/**
 * 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 "TunerFrontend"

#include "TunerFrontend.h"

using ::aidl::android::media::tv::tuner::TunerFrontendAtsc3PlpSettings;
using ::aidl::android::media::tv::tuner::TunerFrontendScanAtsc3PlpInfo;
using ::aidl::android::media::tv::tuner::TunerFrontendUnionSettings;
using ::android::hardware::tv::tuner::V1_0::FrontendAnalogSifStandard;
using ::android::hardware::tv::tuner::V1_0::FrontendAnalogType;
using ::android::hardware::tv::tuner::V1_0::FrontendAtscModulation;
using ::android::hardware::tv::tuner::V1_0::FrontendAtsc3Bandwidth;
using ::android::hardware::tv::tuner::V1_0::FrontendAtsc3CodeRate;
using ::android::hardware::tv::tuner::V1_0::FrontendAtsc3DemodOutputFormat;
using ::android::hardware::tv::tuner::V1_0::FrontendAtsc3Fec;
using ::android::hardware::tv::tuner::V1_0::FrontendAtsc3Modulation;
using ::android::hardware::tv::tuner::V1_0::FrontendAtsc3TimeInterleaveMode;
using ::android::hardware::tv::tuner::V1_0::FrontendDvbcAnnex;
using ::android::hardware::tv::tuner::V1_0::FrontendDvbcModulation;
using ::android::hardware::tv::tuner::V1_0::FrontendDvbcOuterFec;
using ::android::hardware::tv::tuner::V1_0::FrontendDvbcSpectralInversion;
using ::android::hardware::tv::tuner::V1_0::FrontendDvbsModulation;
using ::android::hardware::tv::tuner::V1_0::FrontendDvbsPilot;
using ::android::hardware::tv::tuner::V1_0::FrontendDvbsRolloff;
using ::android::hardware::tv::tuner::V1_0::FrontendDvbsSettings;
using ::android::hardware::tv::tuner::V1_0::FrontendDvbsStandard;
using ::android::hardware::tv::tuner::V1_0::FrontendDvbsVcmMode;
using ::android::hardware::tv::tuner::V1_0::FrontendDvbtBandwidth;
using ::android::hardware::tv::tuner::V1_0::FrontendDvbtCoderate;
using ::android::hardware::tv::tuner::V1_0::FrontendDvbtConstellation;
using ::android::hardware::tv::tuner::V1_0::FrontendDvbtGuardInterval;
using ::android::hardware::tv::tuner::V1_0::FrontendDvbtHierarchy;
using ::android::hardware::tv::tuner::V1_0::FrontendDvbtPlpMode;
using ::android::hardware::tv::tuner::V1_0::FrontendDvbtSettings;
using ::android::hardware::tv::tuner::V1_0::FrontendDvbtStandard;
using ::android::hardware::tv::tuner::V1_0::FrontendDvbtTransmissionMode;
using ::android::hardware::tv::tuner::V1_0::FrontendInnerFec;
using ::android::hardware::tv::tuner::V1_0::FrontendIsdbs3Coderate;
using ::android::hardware::tv::tuner::V1_0::FrontendIsdbs3Modulation;
using ::android::hardware::tv::tuner::V1_0::FrontendIsdbs3Rolloff;
using ::android::hardware::tv::tuner::V1_0::FrontendIsdbs3Settings;
using ::android::hardware::tv::tuner::V1_0::FrontendIsdbsCoderate;
using ::android::hardware::tv::tuner::V1_0::FrontendIsdbsModulation;
using ::android::hardware::tv::tuner::V1_0::FrontendIsdbsRolloff;
using ::android::hardware::tv::tuner::V1_0::FrontendIsdbsSettings;
using ::android::hardware::tv::tuner::V1_0::FrontendIsdbsStreamIdType;
using ::android::hardware::tv::tuner::V1_0::FrontendIsdbtBandwidth;
using ::android::hardware::tv::tuner::V1_0::FrontendIsdbtCoderate;
using ::android::hardware::tv::tuner::V1_0::FrontendIsdbtGuardInterval;
using ::android::hardware::tv::tuner::V1_0::FrontendIsdbtMode;
using ::android::hardware::tv::tuner::V1_0::FrontendIsdbtModulation;
using ::android::hardware::tv::tuner::V1_0::FrontendIsdbtSettings;
using ::android::hardware::tv::tuner::V1_0::FrontendScanAtsc3PlpInfo;
using ::android::hardware::tv::tuner::V1_0::FrontendScanType;
using ::android::hardware::tv::tuner::V1_0::Result;
using ::android::hardware::tv::tuner::V1_1::FrontendAnalogAftFlag;
using ::android::hardware::tv::tuner::V1_1::FrontendCableTimeInterleaveMode;
using ::android::hardware::tv::tuner::V1_1::FrontendDvbcBandwidth;
using ::android::hardware::tv::tuner::V1_1::FrontendModulation;
using ::android::hardware::tv::tuner::V1_1::FrontendDtmbBandwidth;
using ::android::hardware::tv::tuner::V1_1::FrontendDtmbCodeRate;
using ::android::hardware::tv::tuner::V1_1::FrontendDtmbGuardInterval;
using ::android::hardware::tv::tuner::V1_1::FrontendDtmbModulation;
using ::android::hardware::tv::tuner::V1_1::FrontendDtmbTimeInterleaveMode;
using ::android::hardware::tv::tuner::V1_1::FrontendDtmbTransmissionMode;
using ::android::hardware::tv::tuner::V1_1::FrontendDvbsScanType;
using ::android::hardware::tv::tuner::V1_1::FrontendSpectralInversion;

namespace android {

TunerFrontend::TunerFrontend(sp<IFrontend> frontend, int id) {
    mFrontend = frontend;
    mFrontend_1_1 = ::android::hardware::tv::tuner::V1_1::IFrontend::castFrom(mFrontend);
    mId = id;
}

TunerFrontend::~TunerFrontend() {
    mFrontend = NULL;
    mFrontend_1_1 = NULL;
    mId = -1;
}

Status TunerFrontend::setCallback(
        const shared_ptr<ITunerFrontendCallback>& tunerFrontendCallback) {
    if (mFrontend == NULL) {
        ALOGE("IFrontend is not initialized");
        return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
    }

    if (tunerFrontendCallback == NULL) {
        return Status::fromServiceSpecificError(static_cast<int32_t>(Result::INVALID_ARGUMENT));
    }

    sp<IFrontendCallback> frontendCallback = new FrontendCallback(tunerFrontendCallback);
    Result status = mFrontend->setCallback(frontendCallback);
    if (status == Result::SUCCESS) {
        return Status::ok();
    }

    return Status::fromServiceSpecificError(static_cast<int32_t>(status));
}

Status TunerFrontend::tune(const TunerFrontendSettings& settings) {
    if (mFrontend == NULL) {
        ALOGE("IFrontend is not initialized");
        return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
    }

    Result status;
    FrontendSettings frontendSettings = getHidlFrontendSettings(settings);
    if (settings.isExtended) {
        if (mFrontend_1_1 == NULL) {
            ALOGE("IFrontend_1_1 is not initialized");
            return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
        }
        FrontendSettingsExt1_1 frontendSettingsExt = getHidlFrontendSettingsExt(settings);
        status = mFrontend_1_1->tune_1_1(frontendSettings, frontendSettingsExt);
    } else {
        status = mFrontend->tune(frontendSettings);
    }

    if (status == Result::SUCCESS) {
        return Status::ok();
    }

    return Status::fromServiceSpecificError(static_cast<int32_t>(status));
}

Status TunerFrontend::stopTune() {
    if (mFrontend == NULL) {
        ALOGD("IFrontend is not initialized");
        return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
    }

    Result status = mFrontend->stopTune();
    if (status == Result::SUCCESS) {
        return Status::ok();
    }

    return Status::fromServiceSpecificError(static_cast<int32_t>(status));
}

Status TunerFrontend::scan(const TunerFrontendSettings& settings, int frontendScanType) {
    if (mFrontend == NULL) {
        ALOGD("IFrontend is not initialized");
        return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
    }

    Result status;
    FrontendSettings frontendSettings = getHidlFrontendSettings(settings);
    if (settings.isExtended) {
        if (mFrontend_1_1 == NULL) {
            ALOGE("IFrontend_1_1 is not initialized");
            return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
        }
        FrontendSettingsExt1_1 frontendSettingsExt = getHidlFrontendSettingsExt(settings);
        status = mFrontend_1_1->scan_1_1(frontendSettings,
                static_cast<FrontendScanType>(frontendScanType), frontendSettingsExt);
    } else {
        status = mFrontend->scan(
                frontendSettings, static_cast<FrontendScanType>(frontendScanType));
    }

    if (status == Result::SUCCESS) {
        return Status::ok();
    }

    return Status::fromServiceSpecificError(static_cast<int32_t>(status));
}

Status TunerFrontend::stopScan() {
    if (mFrontend == NULL) {
        ALOGD("IFrontend is not initialized");
        return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
    }

    Result status = mFrontend->stopScan();
    if (status == Result::SUCCESS) {
        return Status::ok();
    }

    return Status::fromServiceSpecificError(static_cast<int32_t>(status));
}

Status TunerFrontend::setLnb(int /*lnbHandle*/) {
    return Status::ok();
}

Status TunerFrontend::setLna(bool /*bEnable*/) {
    return Status::ok();
}

Status TunerFrontend::close() {
    if (mFrontend == NULL) {
        ALOGD("IFrontend is not initialized");
        return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
    }

    Result status = mFrontend->close();
    if (status == Result::SUCCESS) {
        return Status::ok();
    }

    return Status::fromServiceSpecificError(static_cast<int32_t>(status));
}

Status TunerFrontend::getStatus(const vector<int32_t>& /*statusTypes*/,
        vector<TunerFrontendStatus>* /*_aidl_return*/) {
    return Status::ok();
}

Status TunerFrontend::getFrontendId(int* _aidl_return) {
    *_aidl_return = mId;
    return Status::ok();
}

/////////////// FrontendCallback ///////////////////////

Return<void> TunerFrontend::FrontendCallback::onEvent(FrontendEventType frontendEventType) {
    ALOGD("FrontendCallback::onEvent, type=%d", frontendEventType);
    mTunerFrontendCallback->onEvent((int)frontendEventType);
    return Void();
}

Return<void> TunerFrontend::FrontendCallback::onScanMessage(
        FrontendScanMessageType type, const FrontendScanMessage& message) {
    ALOGD("FrontendCallback::onScanMessage, type=%d", type);
    TunerFrontendScanMessage scanMessage;
    switch(type) {
        case FrontendScanMessageType::LOCKED: {
            scanMessage.set<TunerFrontendScanMessage::isLocked>(message.isLocked());
            break;
        }
        case FrontendScanMessageType::END: {
            scanMessage.set<TunerFrontendScanMessage::isEnd>(message.isEnd());
            break;
        }
        case FrontendScanMessageType::PROGRESS_PERCENT: {
            scanMessage.set<TunerFrontendScanMessage::progressPercent>(message.progressPercent());
            break;
        }
        case FrontendScanMessageType::FREQUENCY: {
            auto f = message.frequencies();
            vector<int> frequencies(begin(f), end(f));
            scanMessage.set<TunerFrontendScanMessage::frequencies>(frequencies);
            break;
        }
        case FrontendScanMessageType::SYMBOL_RATE: {
            auto s = message.symbolRates();
            vector<int> symbolRates(begin(s), end(s));
            scanMessage.set<TunerFrontendScanMessage::symbolRates>(symbolRates);
            break;
        }
        case FrontendScanMessageType::HIERARCHY: {
            scanMessage.set<TunerFrontendScanMessage::hierarchy>((int)message.hierarchy());
            break;
        }
        case FrontendScanMessageType::ANALOG_TYPE: {
            scanMessage.set<TunerFrontendScanMessage::analogType>((int)message.analogType());
            break;
        }
        case FrontendScanMessageType::PLP_IDS: {
            auto p = message.plpIds();
            vector<uint8_t> plpIds(begin(p), end(p));
            scanMessage.set<TunerFrontendScanMessage::plpIds>(plpIds);
            break;
        }
        case FrontendScanMessageType::GROUP_IDS: {
            auto g = message.groupIds();
            vector<uint8_t> groupIds(begin(g), end(g));
            scanMessage.set<TunerFrontendScanMessage::groupIds>(groupIds);
            break;
        }
        case FrontendScanMessageType::INPUT_STREAM_IDS: {
            auto i = message.inputStreamIds();
            vector<char16_t> streamIds(begin(i), end(i));
            scanMessage.set<TunerFrontendScanMessage::inputStreamIds>(streamIds);
            break;
        }
        case FrontendScanMessageType::STANDARD: {
            FrontendScanMessage::Standard std = message.std();
            int standard;
            if (std.getDiscriminator() == FrontendScanMessage::Standard::hidl_discriminator::sStd) {
                standard = (int) std.sStd();
            } else if (std.getDiscriminator() ==
                    FrontendScanMessage::Standard::hidl_discriminator::tStd) {
                standard = (int) std.tStd();
            } else if (std.getDiscriminator() ==
                    FrontendScanMessage::Standard::hidl_discriminator::sifStd) {
                standard = (int) std.sifStd();
            }
            scanMessage.set<TunerFrontendScanMessage::std>(standard);
            break;
        }
        case FrontendScanMessageType::ATSC3_PLP_INFO: {
            vector<FrontendScanAtsc3PlpInfo> plpInfos = message.atsc3PlpInfos();
            vector<TunerFrontendScanAtsc3PlpInfo> tunerPlpInfos;
            for (int i = 0; i < plpInfos.size(); i++) {
                auto info = plpInfos[i];
                int plpId = (int) info.plpId;
                bool lls = (bool) info.bLlsFlag;
                TunerFrontendScanAtsc3PlpInfo plpInfo{
                    .plpId = plpId,
                    .llsFlag = lls,
                };
                tunerPlpInfos.push_back(plpInfo);
            }
            scanMessage.set<TunerFrontendScanMessage::atsc3PlpInfos>(tunerPlpInfos);
            break;
        }
        default:
            break;
    }
    mTunerFrontendCallback->onScanMessage((int)type, scanMessage);
    return Void();
}

Return<void> TunerFrontend::FrontendCallback::onScanMessageExt1_1(
        FrontendScanMessageTypeExt1_1 type, const FrontendScanMessageExt1_1& message) {
    ALOGD("onScanMessageExt1_1::onScanMessage, type=%d", type);
    TunerFrontendScanMessage scanMessage;
    switch(type) {
        case FrontendScanMessageTypeExt1_1::MODULATION: {
            FrontendModulation m = message.modulation();
            int modulation;
            switch (m.getDiscriminator()) {
                case FrontendModulation::hidl_discriminator::dvbc:
                    modulation = (int) m.dvbc();
                    break;
                case FrontendModulation::hidl_discriminator::dvbt:
                    modulation = (int) m.dvbt();
                    break;
                case FrontendModulation::hidl_discriminator::dvbs:
                    modulation = (int) m.dvbs();
                    break;
                case FrontendModulation::hidl_discriminator::isdbs:
                    modulation = (int) m.isdbs();
                    break;
                case FrontendModulation::hidl_discriminator::isdbs3:
                    modulation = (int) m.isdbs3();
                    break;
                case FrontendModulation::hidl_discriminator::isdbt:
                    modulation = (int) m.isdbt();
                    break;
                case FrontendModulation::hidl_discriminator::atsc:
                    modulation = (int) m.atsc();
                    break;
                case FrontendModulation::hidl_discriminator::atsc3:
                    modulation = (int) m.atsc3();
                    break;
                case FrontendModulation::hidl_discriminator::dtmb:
                    modulation = (int) m.dtmb();
                    break;
            }
            scanMessage.set<TunerFrontendScanMessage::modulation>(modulation);
            break;
        }
        case FrontendScanMessageTypeExt1_1::DVBC_ANNEX: {
            scanMessage.set<TunerFrontendScanMessage::annex>((int)message.annex());
            break;
        }
        case FrontendScanMessageTypeExt1_1::HIGH_PRIORITY: {
            scanMessage.set<TunerFrontendScanMessage::isHighPriority>(message.isHighPriority());
            break;
        }
        default:
            break;
    }
    mTunerFrontendCallback->onScanMessage((int)type, scanMessage);
    return Void();
}

/////////////// TunerFrontend Helper Methods ///////////////////////

hidl_vec<FrontendAtsc3PlpSettings> TunerFrontend::getAtsc3PlpSettings(
        const TunerFrontendAtsc3Settings& settings) {
    int len = settings.plpSettings.size();
    hidl_vec<FrontendAtsc3PlpSettings> plps = hidl_vec<FrontendAtsc3PlpSettings>(len);
    // parse PLP settings
    for (int i = 0; i < len; i++) {
        uint8_t plpId = static_cast<uint8_t>(settings.plpSettings[i].plpId);
        FrontendAtsc3Modulation modulation =
                static_cast<FrontendAtsc3Modulation>(settings.plpSettings[i].modulation);
        FrontendAtsc3TimeInterleaveMode interleaveMode =
                static_cast<FrontendAtsc3TimeInterleaveMode>(
                        settings.plpSettings[i].interleaveMode);
        FrontendAtsc3CodeRate codeRate =
                static_cast<FrontendAtsc3CodeRate>(settings.plpSettings[i].codeRate);
        FrontendAtsc3Fec fec =
                static_cast<FrontendAtsc3Fec>(settings.plpSettings[i].fec);
        FrontendAtsc3PlpSettings frontendAtsc3PlpSettings {
                .plpId = plpId,
                .modulation = modulation,
                .interleaveMode = interleaveMode,
                .codeRate = codeRate,
                .fec = fec,
        };
        plps[i] = frontendAtsc3PlpSettings;
    }
    return plps;
}

FrontendDvbsCodeRate TunerFrontend::getDvbsCodeRate(const TunerFrontendDvbsCodeRate& codeRate) {
    FrontendInnerFec innerFec = static_cast<FrontendInnerFec>(codeRate.fec);
    bool isLinear = codeRate.isLinear;
    bool isShortFrames = codeRate.isShortFrames;
    uint32_t bitsPer1000Symbol = static_cast<uint32_t>(codeRate.bitsPer1000Symbol);
    FrontendDvbsCodeRate coderate {
            .fec = innerFec,
            .isLinear = isLinear,
            .isShortFrames = isShortFrames,
            .bitsPer1000Symbol = bitsPer1000Symbol,
    };
    return coderate;
}

FrontendSettings TunerFrontend::getHidlFrontendSettings(const TunerFrontendSettings& aidlSettings) {
    auto settings = aidlSettings.settings;
    FrontendSettings frontendSettings;

    switch (settings.getTag()) {
        case TunerFrontendUnionSettings::analog: {
            auto analog = settings.get<TunerFrontendUnionSettings::analog>();
            frontendSettings.analog({
                .frequency = static_cast<uint32_t>(analog.frequency),
                .type = static_cast<FrontendAnalogType>(analog.signalType),
                .sifStandard = static_cast<FrontendAnalogSifStandard>(analog.sifStandard),
            });
            break;
        }
        case TunerFrontendUnionSettings::atsc: {
            auto atsc = settings.get<TunerFrontendUnionSettings::atsc>();
            frontendSettings.atsc({
                .frequency = static_cast<uint32_t>(atsc.frequency),
                .modulation = static_cast<FrontendAtscModulation>(atsc.modulation),
            });
            break;
        }
        case TunerFrontendUnionSettings::atsc3: {
            auto atsc3 = settings.get<TunerFrontendUnionSettings::atsc3>();
            frontendSettings.atsc3({
                .frequency = static_cast<uint32_t>(atsc3.frequency),
                .bandwidth = static_cast<FrontendAtsc3Bandwidth>(atsc3.bandwidth),
                .demodOutputFormat = static_cast<FrontendAtsc3DemodOutputFormat>(
                        atsc3.demodOutputFormat),
                .plpSettings = getAtsc3PlpSettings(atsc3),
            });
            break;
        }
        case TunerFrontendUnionSettings::cable: {
            auto dvbc = settings.get<TunerFrontendUnionSettings::cable>();
            frontendSettings.dvbc({
                .frequency = static_cast<uint32_t>(dvbc.frequency),
                .modulation = static_cast<FrontendDvbcModulation>(dvbc.modulation),
                .fec = static_cast<FrontendInnerFec>(dvbc.innerFec),
                .symbolRate = static_cast<uint32_t>(dvbc.symbolRate),
                .outerFec = static_cast<FrontendDvbcOuterFec>(dvbc.outerFec),
                .annex = static_cast<FrontendDvbcAnnex>(dvbc.annex),
                .spectralInversion = static_cast<FrontendDvbcSpectralInversion>(
                        dvbc.spectralInversion),
            });
            break;
        }
        case TunerFrontendUnionSettings::dvbs: {
            auto dvbs = settings.get<TunerFrontendUnionSettings::dvbs>();
            frontendSettings.dvbs({
                .frequency = static_cast<uint32_t>(dvbs.frequency),
                .modulation = static_cast<FrontendDvbsModulation>(dvbs.modulation),
                .coderate = getDvbsCodeRate(dvbs.codeRate),
                .symbolRate = static_cast<uint32_t>(dvbs.symbolRate),
                .rolloff = static_cast<FrontendDvbsRolloff>(dvbs.rolloff),
                .pilot = static_cast<FrontendDvbsPilot>(dvbs.pilot),
                .inputStreamId = static_cast<uint32_t>(dvbs.inputStreamId),
                .standard = static_cast<FrontendDvbsStandard>(dvbs.standard),
                .vcmMode = static_cast<FrontendDvbsVcmMode>(dvbs.vcm),
            });
            break;
        }
        case TunerFrontendUnionSettings::dvbt: {
            auto dvbt = settings.get<TunerFrontendUnionSettings::dvbt>();
            frontendSettings.dvbt({
                .frequency = static_cast<uint32_t>(dvbt.frequency),
                .transmissionMode = static_cast<FrontendDvbtTransmissionMode>(
                        dvbt.transmissionMode),
                .bandwidth = static_cast<FrontendDvbtBandwidth>(dvbt.bandwidth),
                .constellation = static_cast<FrontendDvbtConstellation>(dvbt.constellation),
                .hierarchy = static_cast<FrontendDvbtHierarchy>(dvbt.hierarchy),
                .hpCoderate = static_cast<FrontendDvbtCoderate>(dvbt.hpCodeRate),
                .lpCoderate = static_cast<FrontendDvbtCoderate>(dvbt.lpCodeRate),
                .guardInterval = static_cast<FrontendDvbtGuardInterval>(dvbt.guardInterval),
                .isHighPriority = dvbt.isHighPriority,
                .standard = static_cast<FrontendDvbtStandard>(dvbt.standard),
                .isMiso = dvbt.isMiso,
                .plpMode = static_cast<FrontendDvbtPlpMode>(dvbt.plpMode),
                .plpId = static_cast<uint8_t>(dvbt.plpId),
                .plpGroupId = static_cast<uint8_t>(dvbt.plpGroupId),
            });
            break;
        }
        case TunerFrontendUnionSettings::isdbs: {
            auto isdbs = settings.get<TunerFrontendUnionSettings::isdbs>();
            frontendSettings.isdbs({
                .frequency = static_cast<uint32_t>(isdbs.frequency),
                .streamId = static_cast<uint16_t>(isdbs.streamId),
                .streamIdType = static_cast<FrontendIsdbsStreamIdType>(isdbs.streamIdType),
                .modulation = static_cast<FrontendIsdbsModulation>(isdbs.modulation),
                .coderate = static_cast<FrontendIsdbsCoderate>(isdbs.codeRate),
                .symbolRate = static_cast<uint32_t>(isdbs.symbolRate),
                .rolloff = static_cast<FrontendIsdbsRolloff>(isdbs.rolloff),
            });
            break;
        }
        case TunerFrontendUnionSettings::isdbs3: {
            auto isdbs3 = settings.get<TunerFrontendUnionSettings::isdbs3>();
            frontendSettings.isdbs3({
                .frequency = static_cast<uint32_t>(isdbs3.frequency),
                .streamId = static_cast<uint16_t>(isdbs3.streamId),
                .streamIdType = static_cast<FrontendIsdbsStreamIdType>(isdbs3.streamIdType),
                .modulation = static_cast<FrontendIsdbs3Modulation>(isdbs3.modulation),
                .coderate = static_cast<FrontendIsdbs3Coderate>(isdbs3.codeRate),
                .symbolRate = static_cast<uint32_t>(isdbs3.symbolRate),
                .rolloff = static_cast<FrontendIsdbs3Rolloff>(isdbs3.rolloff),
            });
            break;
        }
        case TunerFrontendUnionSettings::isdbt: {
            auto isdbt = settings.get<TunerFrontendUnionSettings::isdbt>();
            frontendSettings.isdbt({
                .frequency = static_cast<uint32_t>(isdbt.frequency),
                .modulation = static_cast<FrontendIsdbtModulation>(isdbt.modulation),
                .bandwidth = static_cast<FrontendIsdbtBandwidth>(isdbt.bandwidth),
                .mode = static_cast<FrontendIsdbtMode>(isdbt.mode),
                .coderate = static_cast<FrontendIsdbtCoderate>(isdbt.codeRate),
                .guardInterval = static_cast<FrontendIsdbtGuardInterval>(isdbt.guardInterval),
                .serviceAreaId = static_cast<uint32_t>(isdbt.serviceAreaId),
            });
            break;
        }
        default:
            break;
    }

    return frontendSettings;
}

FrontendSettingsExt1_1 TunerFrontend::getHidlFrontendSettingsExt(
        const TunerFrontendSettings& aidlSettings) {
    FrontendSettingsExt1_1 frontendSettingsExt{
        .endFrequency = static_cast<uint32_t>(aidlSettings.endFrequency),
        .inversion = static_cast<FrontendSpectralInversion>(aidlSettings.inversion),
    };

    auto settings = aidlSettings.settings;
    switch (settings.getTag()) {
        case TunerFrontendUnionSettings::analog: {
            auto analog = settings.get<TunerFrontendUnionSettings::analog>();
            if (analog.isExtended) {
                frontendSettingsExt.settingExt.analog({
                    .aftFlag = static_cast<FrontendAnalogAftFlag>(analog.aftFlag),
                });
            } else {
                frontendSettingsExt.settingExt.noinit();
            }
            break;
        }
        case TunerFrontendUnionSettings::cable: {
            auto dvbc = settings.get<TunerFrontendUnionSettings::cable>();
            if (dvbc.isExtended) {
                frontendSettingsExt.settingExt.dvbc({
                    .interleaveMode = static_cast<FrontendCableTimeInterleaveMode>(
                            dvbc.interleaveMode),
                    .bandwidth = static_cast<FrontendDvbcBandwidth>(
                            dvbc.bandwidth),
                });
            } else {
                frontendSettingsExt.settingExt.noinit();
            }
            break;
        }
        case TunerFrontendUnionSettings::dvbs: {
            auto dvbs = settings.get<TunerFrontendUnionSettings::dvbs>();
            if (dvbs.isExtended) {
                frontendSettingsExt.settingExt.dvbs({
                    .scanType = static_cast<FrontendDvbsScanType>(dvbs.scanType),
                    .isDiseqcRxMessage = dvbs.isDiseqcRxMessage,
                });
            } else {
                frontendSettingsExt.settingExt.noinit();
            }
            break;
        }
        case TunerFrontendUnionSettings::dvbt: {
            auto dvbt = settings.get<TunerFrontendUnionSettings::dvbt>();
            if (dvbt.isExtended) {
                frontendSettingsExt.settingExt.dvbt({
                    .constellation =
                            static_cast<hardware::tv::tuner::V1_1::FrontendDvbtConstellation>(
                                    dvbt.constellation),
                    .transmissionMode =
                            static_cast<hardware::tv::tuner::V1_1::FrontendDvbtTransmissionMode>(
                                    dvbt.transmissionMode),
                });
            } else {
                frontendSettingsExt.settingExt.noinit();
            }
            break;
        }
        case TunerFrontendUnionSettings::dtmb: {
            auto dtmb = settings.get<TunerFrontendUnionSettings::dtmb>();
            frontendSettingsExt.settingExt.dtmb({
                .frequency = static_cast<uint32_t>(dtmb.frequency),
                .transmissionMode = static_cast<FrontendDtmbTransmissionMode>(
                        dtmb.transmissionMode),
                .bandwidth = static_cast<FrontendDtmbBandwidth>(dtmb.bandwidth),
                .modulation = static_cast<FrontendDtmbModulation>(dtmb.modulation),
                .codeRate = static_cast<FrontendDtmbCodeRate>(dtmb.codeRate),
                .guardInterval = static_cast<FrontendDtmbGuardInterval>(dtmb.guardInterval),
                .interleaveMode = static_cast<FrontendDtmbTimeInterleaveMode>(dtmb.interleaveMode),
            });
            break;
        }
        default:
            frontendSettingsExt.settingExt.noinit();
            break;
    }

    return frontendSettingsExt;
}
}  // namespace android