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

Commit eae68393 authored by Hongguang's avatar Hongguang Committed by Hongguang Chen
Browse files

New TunerService implemented by AIDL HAL. 

TODO: add backward HIDL HAL support to separate files.

Bug: 191825295
Test: atest android.media.tv.tuner.cts
Change-Id: I8400fd75080971ee897e1e2dc35e2bab45ec1659
parent d94fa740

services/tuner/.clang-format

0 → 100644
+33 −0
Original line number Diff line number Diff line 
---

BasedOnStyle: Google

AllowShortFunctionsOnASingleLine: Inline

AllowShortIfStatementsOnASingleLine: true

AllowShortLoopsOnASingleLine: true

BinPackArguments: true

BinPackParameters: true

CommentPragmas: NOLINT:.*

ContinuationIndentWidth: 8

DerivePointerAlignment: false

IndentWidth: 4

PointerAlignment: Left

TabWidth: 4



# Deviations from the above file:

# "Don't indent the section label"

AccessModifierOffset: -4

# "Each line of text in your code should be at most 100 columns long."

ColumnLimit: 100

# "Constructor initializer lists can be all on one line or with subsequent

# lines indented eight spaces.". clang-format does not support having the colon

# on the same line as the constructor function name, so this is the best

# approximation of that rule, which makes all entries in the list (except the

# first one) have an eight space indentation.

ConstructorInitializerIndentWidth: 6

# There is nothing in go/droidcppstyle about case labels, but there seems to be

# more code that does not indent the case labels in frameworks/base.

IndentCaseLabels: false

# There have been some bugs in which subsequent formatting operations introduce

# weird comment jumps.

ReflowComments: false

# Android does support C++11 now.

Standard: Cpp11
 
 No newline at end of file

services/tuner/OWNERS

+1 −1
Original line number Diff line number Diff line 
nchalko@google.com

hgchen@google.com

quxiangfang@google.com

services/tuner/TunerDemux.cpp

+91 −146
Original line number Diff line number Diff line
@@ -16,23 +16,32 @@ 


#define LOG_TAG "TunerDemux"



#include "TunerDvr.h"

#include "TunerDemux.h"



#include <aidl/android/hardware/tv/tuner/IDvr.h>

#include <aidl/android/hardware/tv/tuner/IDvrCallback.h>

#include <aidl/android/hardware/tv/tuner/IFilter.h>

#include <aidl/android/hardware/tv/tuner/IFilterCallback.h>

#include <aidl/android/hardware/tv/tuner/ITimeFilter.h>

#include <aidl/android/hardware/tv/tuner/Result.h>



#include "TunerDvr.h"

#include "TunerTimeFilter.h"



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

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

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

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

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

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

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

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

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

using ::aidl::android::hardware::tv::tuner::IDvr;

using ::aidl::android::hardware::tv::tuner::IDvrCallback;

using ::aidl::android::hardware::tv::tuner::IFilter;

using ::aidl::android::hardware::tv::tuner::IFilterCallback;

using ::aidl::android::hardware::tv::tuner::ITimeFilter;

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



namespace aidl {

namespace android {

namespace media {

namespace tv {

namespace tuner {



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

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

    mDemux = demux;

    mDemuxId = id;

}
@@ -41,205 +50,141 @@ TunerDemux::~TunerDemux() { 
    mDemux = nullptr;

}



Status TunerDemux::setFrontendDataSource(const std::shared_ptr<ITunerFrontend>& frontend) {

::ndk::ScopedAStatus TunerDemux::setFrontendDataSource(

        const shared_ptr<ITunerFrontend>& in_frontend) {

    if (mDemux == nullptr) {

        ALOGE("IDemux is not initialized");

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

        return ::ndk::ScopedAStatus::fromServiceSpecificError(

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

    }



    int frontendId;

    frontend->getFrontendId(&frontendId);

    Result res = mDemux->setFrontendDataSource(frontendId);

    if (res != Result::SUCCESS) {

        return ::ndk::ScopedAStatus::fromServiceSpecificError(static_cast<int32_t>(res));

    }

    return Status::ok();

    in_frontend->getFrontendId(&frontendId);



    return mDemux->setFrontendDataSource(frontendId);

}



Status TunerDemux::setFrontendDataSourceById(int frontendId) {

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

    if (mDemux == nullptr) {

        ALOGE("IDemux is not initialized");

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

        return ::ndk::ScopedAStatus::fromServiceSpecificError(

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

    }



    Result res = mDemux->setFrontendDataSource(frontendId);

    if (res != Result::SUCCESS) {

        return ::ndk::ScopedAStatus::fromServiceSpecificError(static_cast<int32_t>(res));

    }

    return Status::ok();

    return mDemux->setFrontendDataSource(frontendId);

}



Status TunerDemux::openFilter(

        int type, int subType, int bufferSize, const std::shared_ptr<ITunerFilterCallback>& cb,

        std::shared_ptr<ITunerFilter>* _aidl_return) {

::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 Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));

    }



    DemuxFilterMainType mainType = static_cast<DemuxFilterMainType>(type);

    DemuxFilterType filterType {

        .mainType = mainType,

    };



    switch(mainType) {

        case DemuxFilterMainType::TS:

            filterType.subType.tsFilterType(static_cast<DemuxTsFilterType>(subType));

            break;

        case DemuxFilterMainType::MMTP:

            filterType.subType.mmtpFilterType(static_cast<DemuxMmtpFilterType>(subType));

            break;

        case DemuxFilterMainType::IP:

            filterType.subType.ipFilterType(static_cast<DemuxIpFilterType>(subType));

            break;

        case DemuxFilterMainType::TLV:

            filterType.subType.tlvFilterType(static_cast<DemuxTlvFilterType>(subType));

            break;

        case DemuxFilterMainType::ALP:

            filterType.subType.alpFilterType(static_cast<DemuxAlpFilterType>(subType));

            break;

    }

    Result status;

    sp<IFilter> filterSp;

    sp<IFilterCallback> cbSp = new TunerFilter::FilterCallback(cb);

    mDemux->openFilter(filterType, bufferSize, cbSp,

            [&](Result r, const sp<IFilter>& filter) {

                filterSp = filter;

                status = r;

            });

    if (status != Result::SUCCESS) {

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

    }



    *_aidl_return = ::ndk::SharedRefBase::make<TunerFilter>(filterSp, type, subType);

    return Status::ok();

}



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

    if (mDemux == nullptr) {

        ALOGE("IDemux is not initialized.");

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

        ALOGE("IDemux is not initialized");

        return ::ndk::ScopedAStatus::fromServiceSpecificError(

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

    }



    Result status;

    sp<ITimeFilter> filterSp;

    mDemux->openTimeFilter([&](Result r, const sp<ITimeFilter>& filter) {

        filterSp = filter;

        status = r;

    });

    if (status != Result::SUCCESS) {

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

    shared_ptr<IFilter> filter;

    shared_ptr<IFilterCallback> cb = ::ndk::SharedRefBase::make<TunerFilter::FilterCallback>(in_cb);

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

    if (status.isOk()) {

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

    }



    *_aidl_return = ::ndk::SharedRefBase::make<TunerTimeFilter>(filterSp);

    return Status::ok();

    return status;

}



Status TunerDemux::getAvSyncHwId(const shared_ptr<ITunerFilter>& tunerFilter, int* _aidl_return) {

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

    if (mDemux == nullptr) {

        ALOGE("IDemux is not initialized.");

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

        return ::ndk::ScopedAStatus::fromServiceSpecificError(

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

    }



    uint32_t avSyncHwId;

    Result res;

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

    mDemux->getAvSyncHwId(halFilter,

            [&](Result r, uint32_t id) {

                res = r;

                avSyncHwId = id;

            });

    if (res != Result::SUCCESS) {

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

    shared_ptr<ITimeFilter> filter;

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

    if (status.isOk()) {

        *_aidl_return = ::ndk::SharedRefBase::make<TunerTimeFilter>(filter);

    }



    *_aidl_return = (int)avSyncHwId;

    return Status::ok();

    return status;

}



Status TunerDemux::getAvSyncTime(int avSyncHwId, int64_t* _aidl_return) {

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

                                               int32_t* _aidl_return) {

    if (mDemux == nullptr) {

        ALOGE("IDemux is not initialized.");

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

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

}



    uint64_t time;

    Result res;

    mDemux->getAvSyncTime(static_cast<uint32_t>(avSyncHwId),

            [&](Result r, uint64_t ts) {

                res = r;

                time = ts;

            });

    if (res != Result::SUCCESS) {

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

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

    }



    *_aidl_return = (int64_t)time;

    return Status::ok();

    return mDemux->getAvSyncTime(avSyncHwId, _aidl_return);

}



Status TunerDemux::openDvr(int dvrType, int bufferSize, const shared_ptr<ITunerDvrCallback>& cb,

::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 Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));

        return ::ndk::ScopedAStatus::fromServiceSpecificError(

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

    }



    Result res;

    sp<IDvrCallback> callback = new TunerDvr::DvrCallback(cb);

    sp<IDvr> hidlDvr;

    mDemux->openDvr(static_cast<DvrType>(dvrType), bufferSize, callback,

            [&](Result r, const sp<IDvr>& dvr) {

                hidlDvr = dvr;

                res = r;

            });

    if (res != Result::SUCCESS) {

        *_aidl_return = NULL;

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

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

    if (res.isOk()) {

        *_aidl_return = ::ndk::SharedRefBase::make<TunerDvr>(halDvr, in_dvbType);

    }



    *_aidl_return = ::ndk::SharedRefBase::make<TunerDvr>(hidlDvr, dvrType);

    return Status::ok();

    return res;

}



Status TunerDemux::connectCiCam(int ciCamId) {

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

    if (mDemux == nullptr) {

        ALOGE("IDemux is not initialized.");

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

        return ::ndk::ScopedAStatus::fromServiceSpecificError(

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

    }



    Result res = mDemux->connectCiCam(static_cast<uint32_t>(ciCamId));

    if (res != Result::SUCCESS) {

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

    }

    return Status::ok();

    return mDemux->connectCiCam(ciCamId);

}



Status TunerDemux::disconnectCiCam() {

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

    if (mDemux == nullptr) {

        ALOGE("IDemux is not initialized.");

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

        return ::ndk::ScopedAStatus::fromServiceSpecificError(

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

    }



    Result res = mDemux->disconnectCiCam();

    if (res != Result::SUCCESS) {

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

    }

    return Status::ok();

    return mDemux->disconnectCiCam();

}



Status TunerDemux::close() {

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

    if (mDemux == nullptr) {

        ALOGE("IDemux is not initialized.");

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

        return ::ndk::ScopedAStatus::fromServiceSpecificError(

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

    }



    Result res = mDemux->close();

    mDemux = NULL;

    auto res = mDemux->close();

    mDemux = nullptr;



    if (res != Result::SUCCESS) {

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

    }

    return Status::ok();

    return res;

}



}  // namespace tuner

}  // namespace tv

}  // namespace media

}  // namespace android

}  // namespace aidl

services/tuner/TunerDemux.h

+32 −30
Original line number Diff line number Diff line
@@ -17,53 +17,55 @@ 
#ifndef ANDROID_MEDIA_TUNERDEMUX_H

#define ANDROID_MEDIA_TUNERDEMUX_H



#include <aidl/android/hardware/tv/tuner/IDemux.h>

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

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



using Status = ::ndk::ScopedAStatus;

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

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

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

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

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

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

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

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

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

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

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

using ::aidl::android::hardware::tv::tuner::DemuxFilterType;

using ::aidl::android::hardware::tv::tuner::DvrType;

using ::aidl::android::hardware::tv::tuner::IDemux;



using namespace std;



namespace aidl {

namespace android {

namespace media {

namespace tv {

namespace tuner {



class TunerDemux : public BnTunerDemux {



public:

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

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

    virtual ~TunerDemux();

    Status setFrontendDataSource(const shared_ptr<ITunerFrontend>& frontend) override;

    Status setFrontendDataSourceById(int frontendId) override;

    Status openFilter(

        int mainType, int subtype, int bufferSize, const shared_ptr<ITunerFilterCallback>& cb,



    ::ndk::ScopedAStatus setFrontendDataSource(

            const shared_ptr<ITunerFrontend>& in_frontend) override;

    ::ndk::ScopedAStatus setFrontendDataSourceById(int frontendId) override;

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

                                    const shared_ptr<ITunerFilterCallback>& in_cb,

                                    shared_ptr<ITunerFilter>* _aidl_return) override;

    Status openTimeFilter(shared_ptr<ITunerTimeFilter>* _aidl_return) override;

    Status getAvSyncHwId(const shared_ptr<ITunerFilter>& tunerFilter, int* _aidl_return) override;

    Status getAvSyncTime(int avSyncHwId, int64_t* _aidl_return) override;

    Status openDvr(

        int dvbType, int bufferSize, const shared_ptr<ITunerDvrCallback>& cb,

    ::ndk::ScopedAStatus openTimeFilter(shared_ptr<ITunerTimeFilter>* _aidl_return) override;

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

                                       int32_t* _aidl_return) override;

    ::ndk::ScopedAStatus getAvSyncTime(int32_t in_avSyncHwId, int64_t* _aidl_return) override;

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

                                 const shared_ptr<ITunerDvrCallback>& in_cb,

                                 shared_ptr<ITunerDvr>* _aidl_return) override;

    Status connectCiCam(int ciCamId) override;

    Status disconnectCiCam() override;

    Status close() override;

    ::ndk::ScopedAStatus connectCiCam(int32_t in_ciCamId) override;

    ::ndk::ScopedAStatus disconnectCiCam() override;

    ::ndk::ScopedAStatus close() override;



    int getId() { return mDemuxId; }



private:

    sp<IDemux> mDemux;

    shared_ptr<IDemux> mDemux;

    int mDemuxId;

};



}  // namespace tuner

}  // namespace tv

}  // namespace media

}  // namespace android

}  // namespace aidl



#endif // ANDROID_MEDIA_TUNERDEMUX_H

services/tuner/TunerDescrambler.cpp

+52 −60
Original line number Diff line number Diff line
@@ -16,17 +16,26 @@ 


#define LOG_TAG "TunerDescrambler"



#include "TunerFilter.h"

#include "TunerDemux.h"

#include "TunerDescrambler.h"



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

#include <aidl/android/hardware/tv/tuner/IFilter.h>

#include <aidl/android/hardware/tv/tuner/Result.h>



#include "TunerDemux.h"

#include "TunerFilter.h"



using ::aidl::android::hardware::tv::tuner::IFilter;

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



using namespace std;



namespace aidl {

namespace android {

namespace media {

namespace tv {

namespace tuner {



TunerDescrambler::TunerDescrambler(sp<IDescrambler> descrambler) {

TunerDescrambler::TunerDescrambler(shared_ptr<IDescrambler> descrambler) {

    mDescrambler = descrambler;

}
@@ -34,91 +43,74 @@ TunerDescrambler::~TunerDescrambler() { 
    mDescrambler = nullptr;

}



Status TunerDescrambler::setDemuxSource(const std::shared_ptr<ITunerDemux>& demux) {

::ndk::ScopedAStatus TunerDescrambler::setDemuxSource(

        const shared_ptr<ITunerDemux>& in_tunerDemux) {

    if (mDescrambler == nullptr) {

        ALOGE("IDescrambler is not initialized");

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

        return ::ndk::ScopedAStatus::fromServiceSpecificError(

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

    }



    Result res = mDescrambler->setDemuxSource(static_cast<TunerDemux*>(demux.get())->getId());

    if (res != Result::SUCCESS) {

        return ::ndk::ScopedAStatus::fromServiceSpecificError(static_cast<int32_t>(res));

    }

    return Status::ok();

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

}



Status TunerDescrambler::setKeyToken(const vector<uint8_t>& keyToken) {

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

    if (mDescrambler == nullptr) {

        ALOGE("IDescrambler is not initialized");

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

        return ::ndk::ScopedAStatus::fromServiceSpecificError(

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

    }



    Result res = mDescrambler->setKeyToken(keyToken);

    if (res != Result::SUCCESS) {

        return ::ndk::ScopedAStatus::fromServiceSpecificError(static_cast<int32_t>(res));

    }

    return Status::ok();

    return mDescrambler->setKeyToken(in_keyToken);

}



Status TunerDescrambler::addPid(const TunerDemuxPid& pid,

        const shared_ptr<ITunerFilter>& optionalSourceFilter) {

::ndk::ScopedAStatus TunerDescrambler::addPid(

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

    if (mDescrambler == nullptr) {

        ALOGE("IDescrambler is not initialized");

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

        return ::ndk::ScopedAStatus::fromServiceSpecificError(

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

    }



    sp<IFilter> halFilter = (optionalSourceFilter == NULL)

            ? NULL : static_cast<TunerFilter*>(optionalSourceFilter.get())->getHalFilter();

    Result res = mDescrambler->addPid(getHidlDemuxPid(pid), halFilter);

    if (res != Result::SUCCESS) {

        return ::ndk::ScopedAStatus::fromServiceSpecificError(static_cast<int32_t>(res));

    }

    return Status::ok();

    shared_ptr<IFilter> halFilter =

            (in_optionalSourceFilter == nullptr)

                    ? nullptr

                    : static_cast<TunerFilter*>(in_optionalSourceFilter.get())->getHalFilter();



    return mDescrambler->addPid(in_pid, halFilter);

}



Status TunerDescrambler::removePid(const TunerDemuxPid& pid,

        const shared_ptr<ITunerFilter>& optionalSourceFilter) {

::ndk::ScopedAStatus TunerDescrambler::removePid(

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

    if (mDescrambler == nullptr) {

        ALOGE("IDescrambler is not initialized");

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

        return ::ndk::ScopedAStatus::fromServiceSpecificError(

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

    }



    sp<IFilter> halFilter = (optionalSourceFilter == NULL)

            ? NULL : static_cast<TunerFilter*>(optionalSourceFilter.get())->getHalFilter();

    Result res = mDescrambler->removePid(getHidlDemuxPid(pid), halFilter);

    if (res != Result::SUCCESS) {

        return ::ndk::ScopedAStatus::fromServiceSpecificError(static_cast<int32_t>(res));

    }

    return Status::ok();

    shared_ptr<IFilter> halFilter =

            (in_optionalSourceFilter == nullptr)

                    ? nullptr

                    : static_cast<TunerFilter*>(in_optionalSourceFilter.get())->getHalFilter();



    return mDescrambler->removePid(in_pid, halFilter);

}



Status TunerDescrambler::close() {

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

    if (mDescrambler == nullptr) {

        ALOGE("IDescrambler is not initialized.");

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

        return ::ndk::ScopedAStatus::fromServiceSpecificError(

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

    }



    Result res = mDescrambler->close();

    mDescrambler = NULL;

    auto res = mDescrambler->close();

    mDescrambler = nullptr;



    if (res != Result::SUCCESS) {

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

    }

    return Status::ok();

    return res;

}



DemuxPid TunerDescrambler::getHidlDemuxPid(const TunerDemuxPid& pid) {

    DemuxPid hidlPid;

    switch (pid.getTag()) {

        case TunerDemuxPid::tPid: {

            hidlPid.tPid((uint16_t)pid.get<TunerDemuxPid::tPid>());

            break;

        }

        case TunerDemuxPid::mmtpPid: {

            hidlPid.mmtpPid((uint16_t)pid.get<TunerDemuxPid::mmtpPid>());

            break;

        }

    }

    return hidlPid;

}

}  // namespace tuner

}  // namespace tv

}  // namespace media

}  // namespace android

}  // namespace aidl