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

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

Add TunerTimeFilter/Lnb interface and add openLnb in TunerService 

Note that this CL also does some clean up on the namespace of
TunerService and TunerFrontend.

Also replaced the ITuner with IFrontend in TunerFrontend.

Test: make
Bug: 159067322
Change-Id: I3d32511a20b69b323331471c222762aa306a8eab
parent 1d28bbb5

services/tuner/Android.bp

+1 −2
Original line number Diff line number Diff line
@@ -64,8 +64,7 @@ cc_library { 
    name: "libtunerservice",



    srcs: [

        "TunerService.cpp",

        "TunerFrontend.cpp"

        "Tuner*.cpp"

    ],



    shared_libs: [

services/tuner/TunerFrontend.cpp

+20 −26
Original line number Diff line number Diff line
@@ -17,7 +17,6 @@ 
#define LOG_TAG "TunerFrontend"



#include "TunerFrontend.h"

#include "TunerService.h"



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

using ::aidl::android::media::tv::tuner::TunerFrontendScanAtsc3PlpInfo;
@@ -73,26 +72,19 @@ using ::android::hardware::tv::tuner::V1_1::FrontendModulation; 


namespace android {



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

    mTuner = tuner;

TunerFrontend::TunerFrontend(sp<IFrontend> frontend, int id) {

    mFrontend = frontend;

    mFrontend_1_1 = ::android::hardware::tv::tuner::V1_1::IFrontend::castFrom(mFrontend);

    mId = id;

}



    if (mTuner != NULL) {

        Result status;

        mTuner->openFrontendById(mId, [&](Result result, const sp<IFrontend>& frontend) {

            mFrontend = frontend;

            status = result;

        });

        if (status != Result::SUCCESS) {

TunerFrontend::~TunerFrontend() {

    mFrontend = NULL;

        }

    }

    mId = -1;

}



TunerFrontend::~TunerFrontend() {}



Status TunerFrontend::setCallback(

        const std::shared_ptr<ITunerFrontendCallback>& tunerFrontendCallback) {

        const shared_ptr<ITunerFrontendCallback>& tunerFrontendCallback) {

    if (mFrontend == NULL) {

        ALOGE("IFrontend is not initialized");

        return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
@@ -125,6 +117,7 @@ Status TunerFrontend::scan(const TunerFrontendSettings& settings, int frontendSc 
        return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));

    }



    // TODO: extend TunerFrontendSettings to use 1.1 types

    FrontendSettings frontendSettings;

    switch (settings.getTag()) {

        case TunerFrontendSettings::analog:
@@ -308,8 +301,8 @@ Status TunerFrontend::close() { 
    return Status::ok();

}



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

        std::vector<TunerFrontendStatus>* /*_aidl_return*/) {

Status TunerFrontend::getStatus(const vector<int32_t>& /*statusTypes*/,

        vector<TunerFrontendStatus>* /*_aidl_return*/) {

    return Status::ok();

}
@@ -317,6 +310,7 @@ Status TunerFrontend::getFrontendId(int* _aidl_return) { 
    *_aidl_return = mId;

    return Status::ok();

}



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



Return<void> TunerFrontend::FrontendCallback::onEvent(FrontendEventType frontendEventType) {
@@ -344,13 +338,13 @@ Return<void> TunerFrontend::FrontendCallback::onScanMessage( 
        }

        case FrontendScanMessageType::FREQUENCY: {

            auto f = message.frequencies();

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

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

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

            break;

        }

        case FrontendScanMessageType::SYMBOL_RATE: {

            auto s = message.symbolRates();

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

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

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

            break;

        }
@@ -364,19 +358,19 @@ Return<void> TunerFrontend::FrontendCallback::onScanMessage( 
        }

        case FrontendScanMessageType::PLP_IDS: {

            auto p = message.plpIds();

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

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

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

            break;

        }

        case FrontendScanMessageType::GROUP_IDS: {

            auto g = message.groupIds();

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

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

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

            break;

        }

        case FrontendScanMessageType::INPUT_STREAM_IDS: {

            auto i = message.inputStreamIds();

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

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

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

            break;

        }
@@ -396,8 +390,8 @@ Return<void> TunerFrontend::FrontendCallback::onScanMessage( 
            break;

        }

        case FrontendScanMessageType::ATSC3_PLP_INFO: {

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

            std::vector<TunerFrontendScanAtsc3PlpInfo> tunerPlpInfos;

            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;
@@ -463,7 +457,7 @@ Return<void> TunerFrontend::FrontendCallback::onScanMessageExt1_1( 
    return Void();

}



////////////////////////////////////////////////////////////////////////////////

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



hidl_vec<FrontendAtsc3PlpSettings> TunerFrontend::getAtsc3PlpSettings(

        const TunerFrontendAtsc3Settings& settings) {

services/tuner/TunerFrontend.h

+11 −8
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/IFrontend.h>

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

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

#include <utils/Log.h>
@@ -41,20 +42,21 @@ 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::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;



using namespace std;



namespace android {



class TunerFrontend : public BnTunerFrontend {



public:

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

    TunerFrontend(sp<IFrontend> frontend, int id);

    virtual ~TunerFrontend();

    Status setCallback(

            const std::shared_ptr<ITunerFrontendCallback>& tunerFrontendCallback) override;

            const shared_ptr<ITunerFrontendCallback>& tunerFrontendCallback) override;

    Status tune(const TunerFrontendSettings& settings) override;

    Status stopTune() override;

    Status scan(const TunerFrontendSettings& settings, int frontendScanType) override;
@@ -62,12 +64,12 @@ public: 
    Status setLnb(int lnbHandle) override;

    Status setLna(bool bEnable) override;

    Status close() override;

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

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

    Status getStatus(const vector<int32_t>& statusTypes,

            vector<TunerFrontendStatus>* _aidl_return) override;

    Status getFrontendId(int* _aidl_return) override;



    struct FrontendCallback : public IFrontendCallback {

        FrontendCallback(const std::shared_ptr<ITunerFrontendCallback> tunerFrontendCallback)

        FrontendCallback(const shared_ptr<ITunerFrontendCallback> tunerFrontendCallback)

                : mTunerFrontendCallback(tunerFrontendCallback) {};



        virtual Return<void> onEvent(FrontendEventType frontendEventType);
@@ -76,16 +78,17 @@ public: 
        virtual Return<void> onScanMessageExt1_1(

                FrontendScanMessageTypeExt1_1 type, const FrontendScanMessageExt1_1& message);



        std::shared_ptr<ITunerFrontendCallback> mTunerFrontendCallback;

        shared_ptr<ITunerFrontendCallback> mTunerFrontendCallback;

    };



private:

    hidl_vec<FrontendAtsc3PlpSettings> getAtsc3PlpSettings(

            const TunerFrontendAtsc3Settings& settings);

    FrontendDvbsCodeRate getDvbsCodeRate(const TunerFrontendDvbsCodeRate& codeRate);



    int mId;

    sp<ITuner> mTuner;

    sp<IFrontend> mFrontend;

    sp<::android::hardware::tv::tuner::V1_1::IFrontend> mFrontend_1_1;

};



} // namespace android

services/tuner/TunerLnb.cpp

0 → 100644
+91 −0
Original line number Diff line number Diff line 
/**

 * Copyright 2021, 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 "TunerLnb"



#include "TunerLnb.h"



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



namespace android {



TunerLnb::TunerLnb(sp<ILnb> lnb, int id) {

    mLnb = lnb;

    mId = id;

}



TunerLnb::~TunerLnb() {

    mLnb = NULL;

    mId = -1;

}



Status TunerLnb::setCallback(

        const shared_ptr<ITunerLnbCallback>& tunerLnbCallback) {

    if (mLnb == NULL) {

        ALOGE("ILnb is not initialized");

        return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));

    }



    if (tunerLnbCallback == NULL) {

        return Status::fromServiceSpecificError(static_cast<int32_t>(Result::INVALID_ARGUMENT));

    }



    sp<ILnbCallback> lnbCallback = new LnbCallback(tunerLnbCallback);

    Result status = mLnb->setCallback(lnbCallback);

    if (status == Result::SUCCESS) {

        return Status::ok();

    }



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

}



Status TunerLnb::setVoltage(int /*voltage*/) {

    return Status::ok();

}



Status TunerLnb::setTone(int /*voltage*/) {

    return Status::ok();

}



Status TunerLnb::setSatellitePosition(int /*position*/) {

    return Status::ok();

}



Status TunerLnb::sendDiseqcMessage(const vector<uint8_t>& /*diseqcMessage*/) {

    return Status::ok();

}



Status TunerLnb::close() {

    return Status::ok();

}



/////////////// ILnbCallback ///////////////////////



Return<void> TunerLnb::LnbCallback::onEvent(const LnbEventType lnbEventType) {

    if (mTunerLnbCallback != NULL) {

        mTunerLnbCallback->onEvent((int)lnbEventType);

    }

    return Void();

}



Return<void> TunerLnb::LnbCallback::onDiseqcMessage(const hidl_vec<uint8_t>& diseqcMessage) {

    if (mTunerLnbCallback != NULL && diseqcMessage != NULL) {

        vector<uint8_t> msg(begin(diseqcMessage), end(diseqcMessage));

        mTunerLnbCallback->onDiseqcMessage(msg);

    }

    return Void();

}

}  // namespace android

services/tuner/TunerLnb.h

0 → 100644
+69 −0
Original line number Diff line number Diff line 
/**

 * Copyright 2021, 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.

 */



#ifndef ANDROID_MEDIA_TUNERFLNB_H

#define ANDROID_MEDIA_TUNERFLNB_H



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

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

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

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

#include <utils/Log.h>



using Status = ::ndk::ScopedAStatus;

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

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

using ::android::hardware::Return;

using ::android::hardware::Void;

using ::android::hardware::hidl_vec;

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

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

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



using namespace std;



namespace android {



class TunerLnb : public BnTunerLnb {



public:

    TunerLnb(sp<ILnb> lnb, int id);

    virtual ~TunerLnb();

    Status setCallback(const shared_ptr<ITunerLnbCallback>& tunerLnbCallback) override;

    Status setVoltage(int voltage) override;

    Status setTone(int voltage) override;

    Status setSatellitePosition(int position) override;

    Status sendDiseqcMessage(const vector<uint8_t>& diseqcMessage) override;

    Status close() override;



    struct LnbCallback : public ILnbCallback {

        LnbCallback(const shared_ptr<ITunerLnbCallback> tunerLnbCallback)

                : mTunerLnbCallback(tunerLnbCallback) {};



        virtual Return<void> onEvent(const LnbEventType lnbEventType);

        virtual Return<void> onDiseqcMessage(const hidl_vec<uint8_t>& diseqcMessage);



        shared_ptr<ITunerLnbCallback> mTunerLnbCallback;

    };



private:

    int mId;

    sp<ILnb> mLnb;

};



} // namespace android



#endif // ANDROID_MEDIA_TUNERFLNB_H