Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit d61491e8 authored by Amy Zhang's avatar Amy Zhang
Browse files

Change Tuner Frontend Callback to align with the aidl callback interface 

Test: make libtunerservice
Bug: 172079283
Change-Id: I788d333448ae61d2008187e832276b19921299b8
parent c9901ce7

services/tuner/Android.bp

+2 −28
Original line number Diff line number Diff line 
filegroup {

    name: "tv_tuner_aidl",

    srcs: [

        "aidl/android/media/tv/tuner/ITunerFrontend.aidl",

        "aidl/android/media/tv/tuner/ITunerFrontendCallback.aidl",

        "aidl/android/media/tv/tuner/ITunerService.aidl",

        "aidl/android/media/tv/tuner/TunerAtsc3PlpInfo.aidl",

        "aidl/android/media/tv/tuner/TunerFrontendAnalogCapabilities.aidl",

        "aidl/android/media/tv/tuner/TunerFrontendAtscCapabilities.aidl",

        "aidl/android/media/tv/tuner/TunerFrontendAtsc3Capabilities.aidl",

        "aidl/android/media/tv/tuner/TunerFrontendCableCapabilities.aidl",

        "aidl/android/media/tv/tuner/TunerFrontendCapabilities.aidl",

        "aidl/android/media/tv/tuner/TunerFrontendDvbsCapabilities.aidl",

        "aidl/android/media/tv/tuner/TunerFrontendDvbtCapabilities.aidl",

        "aidl/android/media/tv/tuner/TunerFrontendIsdbsCapabilities.aidl",

        "aidl/android/media/tv/tuner/TunerFrontendIsdbs3Capabilities.aidl",

        "aidl/android/media/tv/tuner/TunerFrontendIsdbtCapabilities.aidl",

        "aidl/android/media/tv/tuner/TunerFrontendAnalogSettings.aidl",

        "aidl/android/media/tv/tuner/TunerFrontendAtsc3PlpSettings.aidl",

        "aidl/android/media/tv/tuner/TunerFrontendAtsc3Settings.aidl",

        "aidl/android/media/tv/tuner/TunerFrontendAtscSettings.aidl",

        "aidl/android/media/tv/tuner/TunerFrontendCableSettings.aidl",

        "aidl/android/media/tv/tuner/TunerFrontendDvbsCodeRate.aidl",

        "aidl/android/media/tv/tuner/TunerFrontendDvbsSettings.aidl",

        "aidl/android/media/tv/tuner/TunerFrontendDvbtSettings.aidl",

        "aidl/android/media/tv/tuner/TunerFrontendIsdbs3Settings.aidl",

        "aidl/android/media/tv/tuner/TunerFrontendIsdbsSettings.aidl",

        "aidl/android/media/tv/tuner/TunerFrontendIsdbtSettings.aidl",

        "aidl/android/media/tv/tuner/TunerFrontendSettings.aidl",

        "aidl/android/media/tv/tuner/TunerFrontendStatus.aidl",

        "aidl/android/media/tv/tuner/TunerServiceFrontendInfo.aidl",

        "aidl/android/media/tv/tuner/*.aidl",

    ],

    path: "aidl",

}
@@ -67,6 +40,7 @@ cc_library { 


    shared_libs: [

        "android.hardware.tv.tuner@1.0",

        "android.hardware.tv.tuner@1.1",

        "libbase",

        "libbinder_ndk",

        "libcutils",

services/tuner/TunerFrontend.cpp

+75 −29
Original line number Diff line number Diff line
@@ -19,8 +19,8 @@ 
#include "TunerFrontend.h"

#include "TunerService.h"



using ::aidl::android::media::tv::tuner::TunerAtsc3PlpInfo;

using ::aidl::android::media::tv::tuner::TunerFrontendAtsc3PlpSettings;

using ::aidl::android::media::tv::tuner::TunerFrontendScanAtsc3PlpInfo;

using ::android::hardware::tv::tuner::V1_0::FrontendAnalogSifStandard;

using ::android::hardware::tv::tuner::V1_0::FrontendAnalogType;

using ::android::hardware::tv::tuner::V1_0::FrontendAtscModulation;
@@ -69,12 +69,13 @@ using ::android::hardware::tv::tuner::V1_0::FrontendScanAtsc3PlpInfo; 
using ::android::hardware::tv::tuner::V1_0::FrontendScanType;

using ::android::hardware::tv::tuner::V1_0::FrontendSettings;;

using ::android::hardware::tv::tuner::V1_0::Result;

using ::android::hardware::tv::tuner::V1_1::FrontendModulation;



namespace android {



TunerFrontend::TunerFrontend(sp<ITuner> tuner, int frontendHandle) {

TunerFrontend::TunerFrontend(sp<ITuner> tuner, int id) {

    mTuner = tuner;

    mId = TunerService::getResourceIdFromHandle(frontendHandle);

    mId = id;



    if (mTuner != NULL) {

        Result status;
@@ -312,6 +313,10 @@ Status TunerFrontend::getStatus(const std::vector<int32_t>& /*statusTypes*/, 
    return Status::ok();

}



Status TunerFrontend::getFrontendId(int* _aidl_return) {

    *_aidl_return = mId;

    return Status::ok();

}

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



Return<void> TunerFrontend::FrontendCallback::onEvent(FrontendEventType frontendEventType) {
@@ -323,59 +328,56 @@ Return<void> TunerFrontend::FrontendCallback::onEvent(FrontendEventType frontend 
Return<void> TunerFrontend::FrontendCallback::onScanMessage(

        FrontendScanMessageType type, const FrontendScanMessage& message) {

    ALOGD("FrontendCallback::onScanMessage, type=%d", type);

    TunerFrontendScanMessage scanMessage;

    switch(type) {

        case FrontendScanMessageType::LOCKED: {

            if (message.isLocked()) {

                mTunerFrontendCallback->onLocked();

            }

            scanMessage.set<TunerFrontendScanMessage::isLocked>(message.isLocked());

            break;

        }

        case FrontendScanMessageType::END: {

            if (message.isEnd()) {

                mTunerFrontendCallback->onScanStopped();

            }

            scanMessage.set<TunerFrontendScanMessage::isEnd>(message.isEnd());

            break;

        }

        case FrontendScanMessageType::PROGRESS_PERCENT: {

            mTunerFrontendCallback->onProgress((int)message.progressPercent());

            scanMessage.set<TunerFrontendScanMessage::progressPercent>(message.progressPercent());

            break;

        }

        case FrontendScanMessageType::FREQUENCY: {

            auto f = message.frequencies();

            std::vector<int32_t> frequencies(std::begin(f), std::end(f));

            mTunerFrontendCallback->onFrequenciesReport(frequencies);

            std::vector<int> frequencies(std::begin(f), std::end(f));

            scanMessage.set<TunerFrontendScanMessage::frequencies>(frequencies);

            break;

        }

        case FrontendScanMessageType::SYMBOL_RATE: {

            auto s = message.symbolRates();

            std::vector<int32_t> symbolRates(std::begin(s), std::end(s));

            mTunerFrontendCallback->onSymbolRates(symbolRates);

            std::vector<int> symbolRates(std::begin(s), std::end(s));

            scanMessage.set<TunerFrontendScanMessage::symbolRates>(symbolRates);

            break;

        }

        case FrontendScanMessageType::HIERARCHY: {

            mTunerFrontendCallback->onHierarchy((int)message.hierarchy());

            scanMessage.set<TunerFrontendScanMessage::hierarchy>((int)message.hierarchy());

            break;

        }

        case FrontendScanMessageType::ANALOG_TYPE: {

            mTunerFrontendCallback->onSignalType((int)message.analogType());

            scanMessage.set<TunerFrontendScanMessage::analogType>((int)message.analogType());

            break;

        }

        case FrontendScanMessageType::PLP_IDS: {

            auto p = message.plpIds();

            std::vector<int32_t> plpIds(std::begin(p), std::end(p));

            mTunerFrontendCallback->onPlpIds(plpIds);

            std::vector<uint8_t> plpIds(std::begin(p), std::end(p));

            scanMessage.set<TunerFrontendScanMessage::plpIds>(plpIds);

            break;

        }

        case FrontendScanMessageType::GROUP_IDS: {

            auto g = message.groupIds();

            std::vector<int32_t> groupIds(std::begin(g), std::end(g));

            mTunerFrontendCallback->onGroupIds(groupIds);

            std::vector<uint8_t> groupIds(std::begin(g), std::end(g));

            scanMessage.set<TunerFrontendScanMessage::groupIds>(groupIds);

            break;

        }

        case FrontendScanMessageType::INPUT_STREAM_IDS: {

            auto i = message.inputStreamIds();

            std::vector<int32_t> streamIds(std::begin(i), std::end(i));

            mTunerFrontendCallback->onInputStreamIds(streamIds);

            std::vector<char16_t> streamIds(std::begin(i), std::end(i));

            scanMessage.set<TunerFrontendScanMessage::inputStreamIds>(streamIds);

            break;

        }

        case FrontendScanMessageType::STANDARD: {
@@ -383,37 +385,81 @@ Return<void> TunerFrontend::FrontendCallback::onScanMessage( 
            int standard;

            if (std.getDiscriminator() == FrontendScanMessage::Standard::hidl_discriminator::sStd) {

                standard = (int) std.sStd();

                mTunerFrontendCallback->onDvbsStandard(standard);

            } else if (std.getDiscriminator() ==

                    FrontendScanMessage::Standard::hidl_discriminator::tStd) {

                standard = (int) std.tStd();

                mTunerFrontendCallback->onDvbsStandard(standard);

            } else if (std.getDiscriminator() ==

                    FrontendScanMessage::Standard::hidl_discriminator::sifStd) {

                standard = (int) std.sifStd();

                mTunerFrontendCallback->onAnalogSifStandard(standard);

            }

            scanMessage.set<TunerFrontendScanMessage::std>(standard);

            break;

        }

        case FrontendScanMessageType::ATSC3_PLP_INFO: {

            std::vector<FrontendScanAtsc3PlpInfo> plpInfos = message.atsc3PlpInfos();

            std::vector<TunerAtsc3PlpInfo> tunerPlpInfos;

            std::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;

                TunerAtsc3PlpInfo plpInfo{

                TunerFrontendScanAtsc3PlpInfo plpInfo{

                    .plpId = plpId,

                    .llsFlag = lls,

                };

                tunerPlpInfos.push_back(plpInfo);

            }

            mTunerFrontendCallback->onAtsc3PlpInfos(tunerPlpInfos);

            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;

            if (m.getDiscriminator() == FrontendModulation::hidl_discriminator::dvbc) {

                modulation = (int) m.dvbc();

            } else if (m.getDiscriminator() == FrontendModulation::hidl_discriminator::dvbt) {

                modulation = (int) m.dvbt();

            } else if (m.getDiscriminator() == FrontendModulation::hidl_discriminator::dvbs) {

                modulation = (int) m.dvbs();

            } else if (m.getDiscriminator() == FrontendModulation::hidl_discriminator::isdbs) {

                modulation = (int) m.isdbs();

            } else if (m.getDiscriminator() == FrontendModulation::hidl_discriminator::isdbs3) {

                modulation = (int) m.isdbs3();

            } else if (m.getDiscriminator() == FrontendModulation::hidl_discriminator::isdbt) {

                modulation = (int) m.isdbt();

            } else if (m.getDiscriminator() == FrontendModulation::hidl_discriminator::atsc) {

                modulation = (int) m.atsc();

            } else if (m.getDiscriminator() == FrontendModulation::hidl_discriminator::atsc3) {

                modulation = (int) m.atsc3();

            } else if (m.getDiscriminator() == FrontendModulation::hidl_discriminator::dtmb) {

                modulation = (int) m.dtmb();

            }

            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();

}

services/tuner/TunerFrontend.h

+9 −3
Original line number Diff line number Diff line
@@ -19,6 +19,7 @@ 


#include <aidl/android/media/tv/tuner/BnTunerFrontend.h>

#include <android/hardware/tv/tuner/1.0/ITuner.h>

#include <android/hardware/tv/tuner/1.1/IFrontendCallback.h>

#include <media/stagefright/foundation/ADebug.h>

#include <utils/Log.h>
@@ -27,6 +28,7 @@ using ::aidl::android::media::tv::tuner::BnTunerFrontend; 
using ::aidl::android::media::tv::tuner::ITunerFrontendCallback;

using ::aidl::android::media::tv::tuner::TunerFrontendAtsc3Settings;

using ::aidl::android::media::tv::tuner::TunerFrontendDvbsCodeRate;

using ::aidl::android::media::tv::tuner::TunerFrontendScanMessage;

using ::aidl::android::media::tv::tuner::TunerFrontendSettings;

using ::aidl::android::media::tv::tuner::TunerFrontendStatus;

using ::android::hardware::Return;
@@ -39,16 +41,17 @@ using ::android::hardware::tv::tuner::V1_0::FrontendId; 
using ::android::hardware::tv::tuner::V1_0::FrontendScanMessage;

using ::android::hardware::tv::tuner::V1_0::FrontendScanMessageType;

using ::android::hardware::tv::tuner::V1_0::IFrontend;

using ::android::hardware::tv::tuner::V1_0::IFrontendCallback;

using ::android::hardware::tv::tuner::V1_0::ITuner;



using ::android::hardware::tv::tuner::V1_1::IFrontendCallback;

using ::android::hardware::tv::tuner::V1_1::FrontendScanMessageExt1_1;

using ::android::hardware::tv::tuner::V1_1::FrontendScanMessageTypeExt1_1;



namespace android {



class TunerFrontend : public BnTunerFrontend {



public:

    TunerFrontend(sp<ITuner> tuner, int frontendHandle);

    TunerFrontend(sp<ITuner> tuner, int id);

    virtual ~TunerFrontend();

    Status setCallback(

            const std::shared_ptr<ITunerFrontendCallback>& tunerFrontendCallback) override;
@@ -61,6 +64,7 @@ public: 
    Status close() override;

    Status getStatus(const std::vector<int32_t>& statusTypes,

            std::vector<TunerFrontendStatus>* _aidl_return) override;

    Status getFrontendId(int* _aidl_return) override;



    struct FrontendCallback : public IFrontendCallback {

        FrontendCallback(const std::shared_ptr<ITunerFrontendCallback> tunerFrontendCallback)
@@ -69,6 +73,8 @@ public: 
        virtual Return<void> onEvent(FrontendEventType frontendEventType);

        virtual Return<void> onScanMessage(

                FrontendScanMessageType type, const FrontendScanMessage& message);

        virtual Return<void> onScanMessageExt1_1(

                FrontendScanMessageTypeExt1_1 type, const FrontendScanMessageExt1_1& message);



        std::shared_ptr<ITunerFrontendCallback> mTunerFrontendCallback;

    };

services/tuner/TunerService.cpp

+2 −1
Original line number Diff line number Diff line
@@ -252,7 +252,8 @@ Status TunerService::openFrontend( 
                static_cast<int32_t>(Result::UNAVAILABLE));

    }



    *_aidl_return = ::ndk::SharedRefBase::make<TunerFrontend>(mTuner, frontendHandle);

    int id = getResourceIdFromHandle(frontendHandle);

    *_aidl_return = ::ndk::SharedRefBase::make<TunerFrontend>(mTuner, id);

    return Status::ok();

}

services/tuner/TunerService.h

+1 −0
Original line number Diff line number Diff line
@@ -80,6 +80,7 @@ public: 
    TunerService();

    virtual ~TunerService();



    // TODO: create a map between resource id and handles.

    static int getResourceIdFromHandle(int resourceHandle) {

        return (resourceHandle & 0x00ff0000) >> 16;

    }