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"
#include "TunerLnb.h"

using ::aidl::android::media::tv::tuner::TunerFrontendAtsc3PlpSettings;
using ::aidl::android::media::tv::tuner::TunerFrontendScanAtsc3PlpInfo;
using ::aidl::android::media::tv::tuner::TunerFrontendStatusAtsc3PlpInfo;
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::FrontendModulationStatus;
using ::android::hardware::tv::tuner::V1_0::FrontendScanAtsc3PlpInfo;
using ::android::hardware::tv::tuner::V1_0::FrontendScanType;
using ::android::hardware::tv::tuner::V1_0::FrontendStatusType;
using ::android::hardware::tv::tuner::V1_0::Result;
using ::android::hardware::tv::tuner::V1_1::FrontendAnalogAftFlag;
using ::android::hardware::tv::tuner::V1_1::FrontendBandwidth;
using ::android::hardware::tv::tuner::V1_1::FrontendCableTimeInterleaveMode;
using ::android::hardware::tv::tuner::V1_1::FrontendDvbcBandwidth;
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::FrontendGuardInterval;
using ::android::hardware::tv::tuner::V1_1::FrontendInterleaveMode;
using ::android::hardware::tv::tuner::V1_1::FrontendModulation;
using ::android::hardware::tv::tuner::V1_1::FrontendRollOff;
using ::android::hardware::tv::tuner::V1_1::FrontendTransmissionMode;
using ::android::hardware::tv::tuner::V1_1::FrontendSpectralInversion;
using ::android::hardware::tv::tuner::V1_1::FrontendStatusTypeExt1_1;

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(const shared_ptr<ITunerLnb>& lnb) {
    if (mFrontend == NULL) {
        ALOGD("IFrontend is not initialized");
        return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
    }

    Result status = mFrontend->setLnb(static_cast<TunerLnb*>(lnb.get())->getId());
    if (status == Result::SUCCESS) {
        return Status::ok();
    }

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

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

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

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

Status TunerFrontend::linkCiCamToFrontend(int ciCamId, int32_t* _aidl_return) {
    if (mFrontend_1_1 == NULL) {
        ALOGD("IFrontend_1_1 is not initialized");
        return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
    }

    int ltsId;
    Result status;
    mFrontend_1_1->linkCiCam(static_cast<uint32_t>(ciCamId),
            [&](Result r, uint32_t id) {
                status = r;
                ltsId = id;
            });

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

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

Status TunerFrontend::unlinkCiCamToFrontend(int ciCamId) {
    if (mFrontend_1_1 == NULL) {
        ALOGD("IFrontend_1_1 is not initialized");
        return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
    }

    Result status = mFrontend_1_1->unlinkCiCam(ciCamId);
    if (status == Result::SUCCESS) {
        return Status::ok();
    }

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

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) {
    if (mFrontend == NULL) {
        ALOGD("IFrontend is not initialized");
        return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
    }

    Result res;
    vector<FrontendStatus> status;
    vector<FrontendStatusType> types;
    for (auto s : statusTypes) {
        types.push_back(static_cast<FrontendStatusType>(s));
    }

    mFrontend->getStatus(types, [&](Result r, const hidl_vec<FrontendStatus>& s) {
        res = r;
        status = s;
    });
    if (res != Result::SUCCESS) {
        return Status::fromServiceSpecificError(static_cast<int32_t>(res));
    }

    getAidlFrontendStatus(status, *_aidl_return);
    return Status::ok();
}

Status TunerFrontend::getStatusExtended_1_1(const vector<int32_t>& statusTypes,
        vector<TunerFrontendStatus>* _aidl_return) {
    if (mFrontend_1_1 == NULL) {
        ALOGD("IFrontend_1_1 is not initialized");
        return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
    }

    Result res;
    vector<FrontendStatusExt1_1> status;
    vector<FrontendStatusTypeExt1_1> types;
    for (auto s : statusTypes) {
        types.push_back(static_cast<FrontendStatusTypeExt1_1>(s));
    }

    mFrontend_1_1->getStatusExt1_1(types, [&](Result r, const hidl_vec<FrontendStatusExt1_1>& s) {
        res = r;
        status = s;
    });
    if (res != Result::SUCCESS) {
        return Status::fromServiceSpecificError(static_cast<int32_t>(res));
    }

    getAidlFrontendStatusExt(status, *_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];
                int8_t plpId = (int8_t) 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 ///////////////////////

void TunerFrontend::getAidlFrontendStatus(
        vector<FrontendStatus>& hidlStatus, vector<TunerFrontendStatus>& aidlStatus) {
    for (FrontendStatus s : hidlStatus) {
        TunerFrontendStatus status;
        switch (s.getDiscriminator()) {
            case FrontendStatus::hidl_discriminator::isDemodLocked: {
                status.set<TunerFrontendStatus::isDemodLocked>(s.isDemodLocked());
                aidlStatus.push_back(status);
                break;
            }
            case FrontendStatus::hidl_discriminator::snr: {
                status.set<TunerFrontendStatus::snr>((int)s.snr());
                aidlStatus.push_back(status);
                break;
            }
            case FrontendStatus::hidl_discriminator::ber: {
                status.set<TunerFrontendStatus::ber>((int)s.ber());
                aidlStatus.push_back(status);
                break;
            }
            case FrontendStatus::hidl_discriminator::per: {
                status.set<TunerFrontendStatus::per>((int)s.per());
                aidlStatus.push_back(status);
                break;
            }
            case FrontendStatus::hidl_discriminator::preBer: {
                status.set<TunerFrontendStatus::preBer>((int)s.preBer());
                aidlStatus.push_back(status);
                break;
            }
            case FrontendStatus::hidl_discriminator::signalQuality: {
                status.set<TunerFrontendStatus::signalQuality>((int)s.signalQuality());
                aidlStatus.push_back(status);
                break;
            }
            case FrontendStatus::hidl_discriminator::signalStrength: {
                status.set<TunerFrontendStatus::signalStrength>((int)s.signalStrength());
                aidlStatus.push_back(status);
                break;
            }
            case FrontendStatus::hidl_discriminator::symbolRate: {
                status.set<TunerFrontendStatus::symbolRate>((int)s.symbolRate());
                aidlStatus.push_back(status);
                break;
            }
            case FrontendStatus::hidl_discriminator::innerFec: {
                status.set<TunerFrontendStatus::innerFec>((long)s.innerFec());
                aidlStatus.push_back(status);
                break;
            }
            case FrontendStatus::hidl_discriminator::modulation: {
                switch (s.modulation().getDiscriminator()) {
                    case FrontendModulationStatus::hidl_discriminator::dvbc:
                        status.set<TunerFrontendStatus::modulation>((int)s.modulation().dvbc());
                        aidlStatus.push_back(status);
                        break;
                    case FrontendModulationStatus::hidl_discriminator::dvbs:
                        status.set<TunerFrontendStatus::modulation>((int)s.modulation().dvbs());
                        aidlStatus.push_back(status);
                        break;
                    case FrontendModulationStatus::hidl_discriminator::isdbs:
                        status.set<TunerFrontendStatus::modulation>((int)s.modulation().isdbs());
                        aidlStatus.push_back(status);
                        break;
                    case FrontendModulationStatus::hidl_discriminator::isdbs3:
                        status.set<TunerFrontendStatus::modulation>((int)s.modulation().isdbs3());
                        aidlStatus.push_back(status);
                        break;
                    case FrontendModulationStatus::hidl_discriminator::isdbt:
                        status.set<TunerFrontendStatus::modulation>((int)s.modulation().isdbt());
                        aidlStatus.push_back(status);
                        break;
                }
                break;
            }
            case FrontendStatus::hidl_discriminator::inversion: {
                status.set<TunerFrontendStatus::inversion>((int)s.inversion());
                aidlStatus.push_back(status);
                break;
            }
            case FrontendStatus::hidl_discriminator::lnbVoltage: {
                status.set<TunerFrontendStatus::lnbVoltage>((int)s.lnbVoltage());
                aidlStatus.push_back(status);
                break;
            }
            case FrontendStatus::hidl_discriminator::plpId: {
                status.set<TunerFrontendStatus::plpId>((int8_t)s.plpId());
                aidlStatus.push_back(status);
                break;
            }
            case FrontendStatus::hidl_discriminator::isEWBS: {
                status.set<TunerFrontendStatus::isEWBS>(s.isEWBS());
                aidlStatus.push_back(status);
                break;
            }
            case FrontendStatus::hidl_discriminator::agc: {
                status.set<TunerFrontendStatus::agc>((int8_t)s.agc());
                aidlStatus.push_back(status);
                break;
            }
            case FrontendStatus::hidl_discriminator::isLnaOn: {
                status.set<TunerFrontendStatus::isLnaOn>(s.isLnaOn());
                aidlStatus.push_back(status);
                break;
            }
            case FrontendStatus::hidl_discriminator::isLayerError: {
                vector<bool> e(s.isLayerError().begin(), s.isLayerError().end());
                status.set<TunerFrontendStatus::isLayerError>(e);
                aidlStatus.push_back(status);
                break;
            }
            case FrontendStatus::hidl_discriminator::mer: {
                status.set<TunerFrontendStatus::mer>((int)s.mer());
                aidlStatus.push_back(status);
                break;
            }
            case FrontendStatus::hidl_discriminator::freqOffset: {
                status.set<TunerFrontendStatus::freqOffset>((int)s.freqOffset());
                aidlStatus.push_back(status);
                break;
            }
            case FrontendStatus::hidl_discriminator::hierarchy: {
                status.set<TunerFrontendStatus::hierarchy>((int)s.hierarchy());
                aidlStatus.push_back(status);
                break;
            }
            case FrontendStatus::hidl_discriminator::isRfLocked: {
                status.set<TunerFrontendStatus::isRfLocked>(s.isRfLocked());
                aidlStatus.push_back(status);
                break;
            }
            case FrontendStatus::hidl_discriminator::plpInfo: {
                vector<TunerFrontendStatusAtsc3PlpInfo> info;
                for (auto i : s.plpInfo()) {
                    info.push_back({
                        .plpId = (int8_t)i.plpId,
                        .isLocked = i.isLocked,
                        .uec = (int)i.uec,
                    });
                }
                status.set<TunerFrontendStatus::plpInfo>(info);
                aidlStatus.push_back(status);
                break;
            }
        }
    }
}

void TunerFrontend::getAidlFrontendStatusExt(
        vector<FrontendStatusExt1_1>& hidlStatus, vector<TunerFrontendStatus>& aidlStatus) {
    for (FrontendStatusExt1_1 s : hidlStatus) {
        TunerFrontendStatus status;
        switch (s.getDiscriminator()) {
            case FrontendStatusExt1_1::hidl_discriminator::modulations: {
                vector<int> aidlMod;
                for (auto m : s.modulations()) {
                    switch (m.getDiscriminator()) {
                        case FrontendModulation::hidl_discriminator::dvbc:
                            aidlMod.push_back((int)m.dvbc());
                            break;
                        case FrontendModulation::hidl_discriminator::dvbs:
                            aidlMod.push_back((int)m.dvbs());
                            break;
                        case FrontendModulation::hidl_discriminator::dvbt:
                            aidlMod.push_back((int)m.dvbt());
                            break;
                        case FrontendModulation::hidl_discriminator::isdbs:
                            aidlMod.push_back((int)m.isdbs());
                            break;
                        case FrontendModulation::hidl_discriminator::isdbs3:
                            aidlMod.push_back((int)m.isdbs3());
                            break;
                        case FrontendModulation::hidl_discriminator::isdbt:
                            aidlMod.push_back((int)m.isdbt());
                            break;
                        case FrontendModulation::hidl_discriminator::atsc:
                            aidlMod.push_back((int)m.atsc());
                            break;
                        case FrontendModulation::hidl_discriminator::atsc3:
                            aidlMod.push_back((int)m.atsc3());
                            break;
                        case FrontendModulation::hidl_discriminator::dtmb:
                            aidlMod.push_back((int)m.dtmb());
                            break;
                    }
                }
                status.set<TunerFrontendStatus::modulations>(aidlMod);
                aidlStatus.push_back(status);
                break;
            }
            case FrontendStatusExt1_1::hidl_discriminator::bers: {
                vector<int> b(s.bers().begin(), s.bers().end());
                status.set<TunerFrontendStatus::bers>(b);
                aidlStatus.push_back(status);
                break;
            }
            case FrontendStatusExt1_1::hidl_discriminator::codeRates: {
                vector<int64_t> codeRates;
                for (auto c : s.codeRates()) {
                    codeRates.push_back((long)c);
                }
                status.set<TunerFrontendStatus::codeRates>(codeRates);
                aidlStatus.push_back(status);
                break;
            }
            case FrontendStatusExt1_1::hidl_discriminator::bandwidth: {
                switch (s.bandwidth().getDiscriminator()) {
                    case FrontendBandwidth::hidl_discriminator::atsc3:
                        status.set<TunerFrontendStatus::bandwidth>((int)s.bandwidth().atsc3());
                        break;
                    case FrontendBandwidth::hidl_discriminator::dvbc:
                        status.set<TunerFrontendStatus::bandwidth>((int)s.bandwidth().dvbc());
                        break;
                    case FrontendBandwidth::hidl_discriminator::dvbt:
                        status.set<TunerFrontendStatus::bandwidth>((int)s.bandwidth().dvbt());
                        break;
                    case FrontendBandwidth::hidl_discriminator::isdbt:
                        status.set<TunerFrontendStatus::bandwidth>((int)s.bandwidth().isdbt());
                        break;
                    case FrontendBandwidth::hidl_discriminator::dtmb:
                        status.set<TunerFrontendStatus::bandwidth>((int)s.bandwidth().dtmb());
                        break;
                }
                aidlStatus.push_back(status);
                break;
            }
            case FrontendStatusExt1_1::hidl_discriminator::interval: {
                switch (s.interval().getDiscriminator()) {
                    case FrontendGuardInterval::hidl_discriminator::dvbt:
                        status.set<TunerFrontendStatus::interval>((int)s.interval().dvbt());
                        break;
                    case FrontendGuardInterval::hidl_discriminator::isdbt:
                        status.set<TunerFrontendStatus::interval>((int)s.interval().isdbt());
                        break;
                    case FrontendGuardInterval::hidl_discriminator::dtmb:
                        status.set<TunerFrontendStatus::interval>((int)s.interval().dtmb());
                        break;
                }
                aidlStatus.push_back(status);
                break;
            }
            case FrontendStatusExt1_1::hidl_discriminator::transmissionMode: {
                switch (s.transmissionMode().getDiscriminator()) {
                    case FrontendTransmissionMode::hidl_discriminator::dvbt:
                        status.set<TunerFrontendStatus::transmissionMode>(
                                (int)s.transmissionMode().dvbt());
                        break;
                    case FrontendTransmissionMode::hidl_discriminator::isdbt:
                        status.set<TunerFrontendStatus::transmissionMode>(
                                (int)s.transmissionMode().isdbt());
                        break;
                    case FrontendTransmissionMode::hidl_discriminator::dtmb:
                        status.set<TunerFrontendStatus::transmissionMode>(
                                (int)s.transmissionMode().dtmb());
                        break;
                }
                aidlStatus.push_back(status);
                break;
            }
            case FrontendStatusExt1_1::hidl_discriminator::uec: {
                status.set<TunerFrontendStatus::uec>((int)s.uec());
                aidlStatus.push_back(status);
                break;
            }
            case FrontendStatusExt1_1::hidl_discriminator::systemId: {
                status.set<TunerFrontendStatus::systemId>((char16_t)s.systemId());
                aidlStatus.push_back(status);
                break;
            }
            case FrontendStatusExt1_1::hidl_discriminator::interleaving: {
                vector<int> aidlInter;
                for (auto i : s.interleaving()) {
                    switch (i.getDiscriminator()) {
                        case FrontendInterleaveMode::hidl_discriminator::atsc3:
                            aidlInter.push_back((int)i.atsc3());
                            break;
                        case FrontendInterleaveMode::hidl_discriminator::dvbc:
                            aidlInter.push_back((int)i.dvbc());
                            break;
                        case FrontendInterleaveMode::hidl_discriminator::dtmb:
                            aidlInter.push_back((int)i.dtmb());
                            break;
                    }
                }
                status.set<TunerFrontendStatus::interleaving>(aidlInter);
                aidlStatus.push_back(status);
                break;
            }
            case FrontendStatusExt1_1::hidl_discriminator::isdbtSegment: {
                auto seg = s.isdbtSegment();
                vector<uint8_t> i(seg.begin(), seg.end());
                status.set<TunerFrontendStatus::isdbtSegment>(i);
                aidlStatus.push_back(status);
                break;
            }
            case FrontendStatusExt1_1::hidl_discriminator::tsDataRate: {
                vector<int> ts(s.tsDataRate().begin(), s.tsDataRate().end());
                status.set<TunerFrontendStatus::tsDataRate>(ts);
                aidlStatus.push_back(status);
                break;
            }
            case FrontendStatusExt1_1::hidl_discriminator::rollOff: {
                switch (s.rollOff().getDiscriminator()) {
                    case FrontendRollOff::hidl_discriminator::dvbs:
                        status.set<TunerFrontendStatus::rollOff>((int)s.rollOff().dvbs());
                        break;
                    case FrontendRollOff::hidl_discriminator::isdbs:
                        status.set<TunerFrontendStatus::rollOff>((int)s.rollOff().isdbs());
                        break;
                    case FrontendRollOff::hidl_discriminator::isdbs3:
                        status.set<TunerFrontendStatus::rollOff>((int)s.rollOff().isdbs3());
                        break;
                }
                aidlStatus.push_back(status);
                break;
            }
            case FrontendStatusExt1_1::hidl_discriminator::isMiso: {
                status.set<TunerFrontendStatus::isMiso>(s.isMiso());
                aidlStatus.push_back(status);
                break;
            }
            case FrontendStatusExt1_1::hidl_discriminator::isLinear: {
                status.set<TunerFrontendStatus::isLinear>(s.isLinear());
                aidlStatus.push_back(status);
                break;
            }
            case FrontendStatusExt1_1::hidl_discriminator::isShortFrames: {
                status.set<TunerFrontendStatus::isShortFrames>(s.isShortFrames());
                aidlStatus.push_back(status);
                break;
            }
        }
    }
}

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