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

Commit 5eef5141 authored by Hongguang's avatar Hongguang
Browse files

Support lazy tuner server 

*) Refine code to not use global instance. It makes us easier to debug
reference count.
*) The service will only be started if the tuner feature is declard by
the vendor. So we don't need to check tuner feature and whether tuner
HAL is presented anymore.
*) The service will register its resources to TRM every time when it's
started. The TRM will update its resource mapping accordingly.
*) Use tuner.server.enable to change tuner server to be a normal service
if the HAL is not a lazy HAL.

Bug: 236002754
Test: atest android.media.tv.tuner.cts on both lazy and normal HALs
Change-Id: I564490fd46154bb0a8bcf6b77e2b2d9478471434
parent ed977f7f

services/tuner/Android.bp

+0 −1
Original line number Diff line number Diff line
@@ -17,7 +17,6 @@ aidl_interface { 
        "android.hardware.common.fmq-V1",

        "android.hardware.tv.tuner-V1",

    ],



    backend: {

        java: {

            enabled: false,

services/tuner/TunerDemux.cpp

+8 −66
Original line number Diff line number Diff line
@@ -26,6 +26,7 @@ 
#include <aidl/android/hardware/tv/tuner/Result.h>



#include "TunerDvr.h"

#include "TunerService.h"

#include "TunerTimeFilter.h"



using ::aidl::android::hardware::tv::tuner::IDvr;
@@ -41,23 +42,20 @@ namespace media { 
namespace tv {

namespace tuner {



TunerDemux::TunerDemux(shared_ptr<IDemux> demux, int id) {

TunerDemux::TunerDemux(const shared_ptr<IDemux> demux, const int id,

                       const shared_ptr<TunerService> tuner) {

    mDemux = demux;

    mDemuxId = id;

    mTunerService = tuner;

}



TunerDemux::~TunerDemux() {

    mDemux = nullptr;

    mTunerService = nullptr;

}



::ndk::ScopedAStatus TunerDemux::setFrontendDataSource(

        const shared_ptr<ITunerFrontend>& in_frontend) {

    if (mDemux == nullptr) {

        ALOGE("IDemux is not initialized");

        return ::ndk::ScopedAStatus::fromServiceSpecificError(

                static_cast<int32_t>(Result::UNAVAILABLE));

    }



    int frontendId;

    in_frontend->getFrontendId(&frontendId);
@@ -65,43 +63,26 @@ TunerDemux::~TunerDemux() { 
}



::ndk::ScopedAStatus TunerDemux::setFrontendDataSourceById(int frontendId) {

    if (mDemux == nullptr) {

        ALOGE("IDemux is not initialized");

        return ::ndk::ScopedAStatus::fromServiceSpecificError(

                static_cast<int32_t>(Result::UNAVAILABLE));

    }



    return mDemux->setFrontendDataSource(frontendId);

}



::ndk::ScopedAStatus TunerDemux::openFilter(const DemuxFilterType& in_type, int32_t in_bufferSize,

                                            const shared_ptr<ITunerFilterCallback>& in_cb,

                                            shared_ptr<ITunerFilter>* _aidl_return) {

    if (mDemux == nullptr) {

        ALOGE("IDemux is not initialized");

        return ::ndk::ScopedAStatus::fromServiceSpecificError(

                static_cast<int32_t>(Result::UNAVAILABLE));

    }



    shared_ptr<IFilter> filter;

    shared_ptr<TunerFilter::FilterCallback> filterCb =

            ::ndk::SharedRefBase::make<TunerFilter::FilterCallback>(in_cb);

    shared_ptr<IFilterCallback> cb = filterCb;

    auto status = mDemux->openFilter(in_type, in_bufferSize, cb, &filter);

    if (status.isOk()) {

        *_aidl_return = ::ndk::SharedRefBase::make<TunerFilter>(filter, filterCb, in_type);

        *_aidl_return =

                ::ndk::SharedRefBase::make<TunerFilter>(filter, filterCb, in_type, mTunerService);

    }



    return status;

}



::ndk::ScopedAStatus TunerDemux::openTimeFilter(shared_ptr<ITunerTimeFilter>* _aidl_return) {

    if (mDemux == nullptr) {

        ALOGE("IDemux is not initialized.");

        return ::ndk::ScopedAStatus::fromServiceSpecificError(

                static_cast<int32_t>(Result::UNAVAILABLE));

    }



    shared_ptr<ITimeFilter> filter;

    auto status = mDemux->openTimeFilter(&filter);

    if (status.isOk()) {
@@ -113,35 +94,17 @@ TunerDemux::~TunerDemux() { 


::ndk::ScopedAStatus TunerDemux::getAvSyncHwId(const shared_ptr<ITunerFilter>& tunerFilter,

                                               int32_t* _aidl_return) {

    if (mDemux == nullptr) {

        ALOGE("IDemux is not initialized.");

        return ::ndk::ScopedAStatus::fromServiceSpecificError(

                static_cast<int32_t>(Result::UNAVAILABLE));

    }



    shared_ptr<IFilter> halFilter = (static_cast<TunerFilter*>(tunerFilter.get()))->getHalFilter();

    return mDemux->getAvSyncHwId(halFilter, _aidl_return);

}



::ndk::ScopedAStatus TunerDemux::getAvSyncTime(int32_t avSyncHwId, int64_t* _aidl_return) {

    if (mDemux == nullptr) {

        ALOGE("IDemux is not initialized.");

        return ::ndk::ScopedAStatus::fromServiceSpecificError(

                static_cast<int32_t>(Result::UNAVAILABLE));

    }



    return mDemux->getAvSyncTime(avSyncHwId, _aidl_return);

}



::ndk::ScopedAStatus TunerDemux::openDvr(DvrType in_dvbType, int32_t in_bufferSize,

                                         const shared_ptr<ITunerDvrCallback>& in_cb,

                                         shared_ptr<ITunerDvr>* _aidl_return) {

    if (mDemux == nullptr) {

        ALOGE("IDemux is not initialized.");

        return ::ndk::ScopedAStatus::fromServiceSpecificError(

                static_cast<int32_t>(Result::UNAVAILABLE));

    }



    shared_ptr<IDvrCallback> callback = ::ndk::SharedRefBase::make<TunerDvr::DvrCallback>(in_cb);

    shared_ptr<IDvr> halDvr;

    auto res = mDemux->openDvr(in_dvbType, in_bufferSize, callback, &halDvr);
@@ -153,36 +116,15 @@ TunerDemux::~TunerDemux() { 
}



::ndk::ScopedAStatus TunerDemux::connectCiCam(int32_t ciCamId) {

    if (mDemux == nullptr) {

        ALOGE("IDemux is not initialized.");

        return ::ndk::ScopedAStatus::fromServiceSpecificError(

                static_cast<int32_t>(Result::UNAVAILABLE));

    }



    return mDemux->connectCiCam(ciCamId);

}



::ndk::ScopedAStatus TunerDemux::disconnectCiCam() {

    if (mDemux == nullptr) {

        ALOGE("IDemux is not initialized.");

        return ::ndk::ScopedAStatus::fromServiceSpecificError(

                static_cast<int32_t>(Result::UNAVAILABLE));

    }



    return mDemux->disconnectCiCam();

}



::ndk::ScopedAStatus TunerDemux::close() {

    if (mDemux == nullptr) {

        ALOGE("IDemux is not initialized.");

        return ::ndk::ScopedAStatus::fromServiceSpecificError(

                static_cast<int32_t>(Result::UNAVAILABLE));

    }



    auto res = mDemux->close();

    mDemux = nullptr;



    return res;

    return mDemux->close();

}



}  // namespace tuner

services/tuner/TunerDemux.h

+5 −1
Original line number Diff line number Diff line
@@ -32,10 +32,13 @@ namespace media { 
namespace tv {

namespace tuner {



class TunerService;



class TunerDemux : public BnTunerDemux {



public:

    TunerDemux(shared_ptr<IDemux> demux, int demuxId);

    TunerDemux(const shared_ptr<IDemux> demux, const int demuxId,

               const shared_ptr<TunerService> tuner);

    virtual ~TunerDemux();



    ::ndk::ScopedAStatus setFrontendDataSource(
@@ -60,6 +63,7 @@ public: 
private:

    shared_ptr<IDemux> mDemux;

    int mDemuxId;

    shared_ptr<TunerService> mTunerService;

};



}  // namespace tuner

services/tuner/TunerDescrambler.cpp

+1 −34
Original line number Diff line number Diff line
@@ -46,33 +46,15 @@ TunerDescrambler::~TunerDescrambler() { 


::ndk::ScopedAStatus TunerDescrambler::setDemuxSource(

        const shared_ptr<ITunerDemux>& in_tunerDemux) {

    if (mDescrambler == nullptr) {

        ALOGE("IDescrambler is not initialized");

        return ::ndk::ScopedAStatus::fromServiceSpecificError(

                static_cast<int32_t>(Result::UNAVAILABLE));

    }



    return mDescrambler->setDemuxSource((static_cast<TunerDemux*>(in_tunerDemux.get()))->getId());

}



::ndk::ScopedAStatus TunerDescrambler::setKeyToken(const vector<uint8_t>& in_keyToken) {

    if (mDescrambler == nullptr) {

        ALOGE("IDescrambler is not initialized");

        return ::ndk::ScopedAStatus::fromServiceSpecificError(

                static_cast<int32_t>(Result::UNAVAILABLE));

    }



    return mDescrambler->setKeyToken(in_keyToken);

}



::ndk::ScopedAStatus TunerDescrambler::addPid(

        const DemuxPid& in_pid, const shared_ptr<ITunerFilter>& in_optionalSourceFilter) {

    if (mDescrambler == nullptr) {

        ALOGE("IDescrambler is not initialized");

        return ::ndk::ScopedAStatus::fromServiceSpecificError(

                static_cast<int32_t>(Result::UNAVAILABLE));

    }



    shared_ptr<IFilter> halFilter =

            (in_optionalSourceFilter == nullptr)

                    ? nullptr
@@ -83,12 +65,6 @@ TunerDescrambler::~TunerDescrambler() { 


::ndk::ScopedAStatus TunerDescrambler::removePid(

        const DemuxPid& in_pid, const shared_ptr<ITunerFilter>& in_optionalSourceFilter) {

    if (mDescrambler == nullptr) {

        ALOGE("IDescrambler is not initialized");

        return ::ndk::ScopedAStatus::fromServiceSpecificError(

                static_cast<int32_t>(Result::UNAVAILABLE));

    }



    shared_ptr<IFilter> halFilter =

            (in_optionalSourceFilter == nullptr)

                    ? nullptr
@@ -98,16 +74,7 @@ TunerDescrambler::~TunerDescrambler() { 
}



::ndk::ScopedAStatus TunerDescrambler::close() {

    if (mDescrambler == nullptr) {

        ALOGE("IDescrambler is not initialized.");

        return ::ndk::ScopedAStatus::fromServiceSpecificError(

                static_cast<int32_t>(Result::UNAVAILABLE));

    }



    auto res = mDescrambler->close();

    mDescrambler = nullptr;



    return res;

    return mDescrambler->close();

}



}  // namespace tuner

services/tuner/TunerDvr.cpp

+1 −52
Original line number Diff line number Diff line
@@ -41,32 +41,14 @@ TunerDvr::~TunerDvr() { 
}



::ndk::ScopedAStatus TunerDvr::getQueueDesc(AidlMQDesc* _aidl_return) {

    if (mDvr == nullptr) {

        ALOGE("IDvr is not initialized");

        return ::ndk::ScopedAStatus::fromServiceSpecificError(

                static_cast<int32_t>(Result::UNAVAILABLE));

    }



    return mDvr->getQueueDesc(_aidl_return);

}



::ndk::ScopedAStatus TunerDvr::configure(const DvrSettings& in_settings) {

    if (mDvr == nullptr) {

        ALOGE("IDvr is not initialized");

        return ::ndk::ScopedAStatus::fromServiceSpecificError(

                static_cast<int32_t>(Result::UNAVAILABLE));

    }



    return mDvr->configure(in_settings);

}



::ndk::ScopedAStatus TunerDvr::attachFilter(const shared_ptr<ITunerFilter>& in_filter) {

    if (mDvr == nullptr) {

        ALOGE("IDvr is not initialized");

        return ::ndk::ScopedAStatus::fromServiceSpecificError(

                static_cast<int32_t>(Result::UNAVAILABLE));

    }



    if (in_filter == nullptr) {

        return ::ndk::ScopedAStatus::fromServiceSpecificError(

                static_cast<int32_t>(Result::INVALID_ARGUMENT));
@@ -82,12 +64,6 @@ TunerDvr::~TunerDvr() { 
}



::ndk::ScopedAStatus TunerDvr::detachFilter(const shared_ptr<ITunerFilter>& in_filter) {

    if (mDvr == nullptr) {

        ALOGE("IDvr is not initialized");

        return ::ndk::ScopedAStatus::fromServiceSpecificError(

                static_cast<int32_t>(Result::UNAVAILABLE));

    }



    if (in_filter == nullptr) {

        return ::ndk::ScopedAStatus::fromServiceSpecificError(

                static_cast<int32_t>(Result::INVALID_ARGUMENT));
@@ -103,46 +79,19 @@ TunerDvr::~TunerDvr() { 
}



::ndk::ScopedAStatus TunerDvr::start() {

    if (mDvr == nullptr) {

        ALOGE("IDvr is not initialized");

        return ::ndk::ScopedAStatus::fromServiceSpecificError(

                static_cast<int32_t>(Result::UNAVAILABLE));

    }



    return mDvr->start();

}



::ndk::ScopedAStatus TunerDvr::stop() {

    if (mDvr == nullptr) {

        ALOGE("IDvr is not initialized");

        return ::ndk::ScopedAStatus::fromServiceSpecificError(

                static_cast<int32_t>(Result::UNAVAILABLE));

    }



    return mDvr->stop();

}



::ndk::ScopedAStatus TunerDvr::flush() {

    if (mDvr == nullptr) {

        ALOGE("IDvr is not initialized");

        return ::ndk::ScopedAStatus::fromServiceSpecificError(

                static_cast<int32_t>(Result::UNAVAILABLE));

    }



    return mDvr->flush();

}



::ndk::ScopedAStatus TunerDvr::close() {

    if (mDvr == nullptr) {

        ALOGE("IDvr is not initialized");

        return ::ndk::ScopedAStatus::fromServiceSpecificError(

                static_cast<int32_t>(Result::UNAVAILABLE));

    }



    auto status = mDvr->close();

    mDvr = nullptr;



    return status;

    return mDvr->close();

}



/////////////// IDvrCallback ///////////////////////