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

Commit 00ef56d8 authored by Hongguang's avatar Hongguang
Browse files

Support lazy tuner HAL 

The tuner server will register its resources to TunerResourceManager
every time when it's started. The TunerResourceManager will update its
resources accordingly.

The TunerResourceManager is only be started when the device has tuner
feature. All tuner functions should return error immediately if the
devcie does't have TunerResourceManager.

Release TunerClient if no one uses it. Stop using staitc TunerService
to release tunerserver the because TunerClient is ready signleton.

Disable lazy tunerserver if the device is running normal tuner HAL.

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

media/java/android/media/tv/tuner/Tuner.java

+10 −3
Original line number Diff line number Diff line
@@ -344,6 +344,16 @@ public class Tuner implements AutoCloseable { 
    @RequiresPermission(android.Manifest.permission.ACCESS_TV_TUNER)

    public Tuner(@NonNull Context context, @Nullable String tvInputSessionId,

            @TvInputService.PriorityHintUseCaseType int useCase) {

        mContext = context;

        mTunerResourceManager = mContext.getSystemService(TunerResourceManager.class);



        // The Tuner Resource Manager is only started when the device has the tuner feature.

        if (mTunerResourceManager == null) {

            throw new IllegalStateException(

                    "Tuner instance is created, but the device doesn't have tuner feature");

        }



        // This code will start tuner server if the device is running on the lazy tuner HAL.

        nativeSetup();

        sTunerVersion = nativeGetTunerVersion();

        if (sTunerVersion == TunerVersionChecker.TUNER_VERSION_UNKNOWN) {
@@ -353,9 +363,6 @@ public class Tuner implements AutoCloseable { 
                    + TunerVersionChecker.getMajorVersion(sTunerVersion) + "."

                    + TunerVersionChecker.getMinorVersion(sTunerVersion) + ".");

        }

        mContext = context;

        mTunerResourceManager = (TunerResourceManager)

                context.getSystemService(Context.TV_TUNER_RESOURCE_MGR_SERVICE);

        if (mHandler == null) {

            mHandler = createEventHandler();

        }

media/jni/Android.bp

+1 −1
Original line number Diff line number Diff line
@@ -160,7 +160,7 @@ cc_library_shared { 


cc_library_shared {

    name: "libmedia_tv_tuner",



    min_sdk_version: "",

    srcs: [

        "android_media_tv_Tuner.cpp",

        "tuner/DemuxClient.cpp",

media/jni/android_media_tv_Tuner.cpp

+40 −24
Original line number Diff line number Diff line
@@ -1238,7 +1238,8 @@ FrontendClientCallbackImpl::~FrontendClientCallbackImpl() { 
}



/////////////// Tuner ///////////////////////

sp<TunerClient> JTuner::mTunerClient;

sp<TunerClient> JTuner::sTunerClient = nullptr;

std::mutex JTuner::sTunerClientMutex;



JTuner::JTuner(JNIEnv *env, jobject thiz) : mClass(nullptr) {

    jclass clazz = env->GetObjectClass(thiz);
@@ -1246,10 +1247,15 @@ JTuner::JTuner(JNIEnv *env, jobject thiz) : mClass(nullptr) { 


    mClass = (jclass)env->NewGlobalRef(clazz);

    mObject = env->NewWeakGlobalRef(thiz);

    if (mTunerClient == nullptr) {

        mTunerClient = new TunerClient();

    {

        std::scoped_lock<std::mutex> lock(sTunerClientMutex);

        if (sTunerClient == nullptr) {

            sTunerClient = new TunerClient();

        } else {

            sTunerClient->incStrong(this);

        }

        ALOGV("JTuner refs count: %d", sTunerClient->getStrongCount());

    }



    mSharedFeId = (int)Constant::INVALID_FRONTEND_ID;

}
@@ -1271,18 +1277,28 @@ JTuner::~JTuner() { 
    mFeClient = nullptr;

    mFeClientCb = nullptr;

    mDemuxClient = nullptr;

    {

        std::scoped_lock<std::mutex> lock(sTunerClientMutex);

        int32_t refCnt = sTunerClient->getStrongCount();

        ALOGV("~JTuner refs count: %d", refCnt);

        if (refCnt == 1) {

            sTunerClient = nullptr;

        } else {

            sTunerClient->decStrong(this);

        }

    }

    mClass = nullptr;

    mObject = nullptr;

}



jint JTuner::getTunerVersion() {

    ALOGV("JTuner::getTunerVersion()");

    return (jint)mTunerClient->getHalTunerVersion();

    return (jint)sTunerClient->getHalTunerVersion();

}



jobject JTuner::getFrontendIds() {

    ALOGV("JTuner::getFrontendIds()");

    vector<int32_t> ids = mTunerClient->getFrontendIds();

    vector<int32_t> ids = sTunerClient->getFrontendIds();

    if (ids.size() == 0) {

        ALOGW("Frontend isn't available");

        return nullptr;
@@ -1305,7 +1321,7 @@ jobject JTuner::getFrontendIds() { 


jobject JTuner::openFrontendByHandle(int feHandle) {

    // TODO: Handle reopening frontend with different handle

    sp<FrontendClient> feClient = mTunerClient->openFrontend(feHandle);

    sp<FrontendClient> feClient = sTunerClient->openFrontend(feHandle);

    if (feClient == nullptr) {

        ALOGE("Failed to open frontend");

        return nullptr;
@@ -1511,7 +1527,7 @@ jobject JTuner::getDtmbFrontendCaps(JNIEnv *env, FrontendCapabilities &caps) { 


jobject JTuner::getFrontendInfo(int id) {

    shared_ptr<FrontendInfo> feInfo;

    feInfo = mTunerClient->getFrontendInfo(id);

    feInfo = sTunerClient->getFrontendInfo(id);

    if (feInfo == nullptr) {

        return nullptr;

    }
@@ -1605,21 +1621,21 @@ Result JTuner::getFrontendHardwareInfo(string &info) { 
}



jint JTuner::setMaxNumberOfFrontends(int32_t type, int32_t maxNumber) {

    if (mTunerClient == nullptr) {

    if (sTunerClient == nullptr) {

        ALOGE("tuner is not initialized");

        return (jint)Result::INVALID_STATE;

    }



    return (jint)mTunerClient->setMaxNumberOfFrontends(static_cast<FrontendType>(type), maxNumber);

    return (jint)sTunerClient->setMaxNumberOfFrontends(static_cast<FrontendType>(type), maxNumber);

}



int32_t JTuner::getMaxNumberOfFrontends(int32_t type) {

    if (mTunerClient == nullptr) {

    if (sTunerClient == nullptr) {

        ALOGE("tuner is not initialized");

        return -1;

    }



    return mTunerClient->getMaxNumberOfFrontends(static_cast<FrontendType>(type));

    return sTunerClient->getMaxNumberOfFrontends(static_cast<FrontendType>(type));

}



jint JTuner::removeOutputPid(int32_t pid) {
@@ -1662,13 +1678,13 @@ jobjectArray JTuner::getFrontendStatusReadiness(jintArray types) { 
}



jobject JTuner::openLnbByHandle(int handle) {

    if (mTunerClient == nullptr) {

    if (sTunerClient == nullptr) {

        return nullptr;

    }



    sp<LnbClient> lnbClient;

    sp<LnbClientCallbackImpl> callback = new LnbClientCallbackImpl();

    lnbClient = mTunerClient->openLnb(handle);

    lnbClient = sTunerClient->openLnb(handle);

    if (lnbClient == nullptr) {

        ALOGD("Failed to open lnb, handle = %d", handle);

        return nullptr;
@@ -1692,7 +1708,7 @@ jobject JTuner::openLnbByHandle(int handle) { 
}



jobject JTuner::openLnbByName(jstring name) {

    if (mTunerClient == nullptr) {

    if (sTunerClient == nullptr) {

        return nullptr;

    }
@@ -1700,7 +1716,7 @@ jobject JTuner::openLnbByName(jstring name) { 
    std::string lnbName(env->GetStringUTFChars(name, nullptr));

    sp<LnbClient> lnbClient;

    sp<LnbClientCallbackImpl> callback = new LnbClientCallbackImpl();

    lnbClient = mTunerClient->openLnbByName(lnbName);

    lnbClient = sTunerClient->openLnbByName(lnbName);

    if (lnbClient == nullptr) {

        ALOGD("Failed to open lnb by name, name = %s", lnbName.c_str());

        return nullptr;
@@ -1770,20 +1786,20 @@ int JTuner::setLnb(sp<LnbClient> lnbClient) { 
}



int JTuner::setLna(bool enable) {

    if (mTunerClient == nullptr) {

    if (sTunerClient == nullptr) {

        return (int)Result::NOT_INITIALIZED;

    }

    Result result = mTunerClient->setLna(enable);

    Result result = sTunerClient->setLna(enable);

    return (int)result;

}



Result JTuner::openDemux(int handle) {

    if (mTunerClient == nullptr) {

    if (sTunerClient == nullptr) {

        return Result::NOT_INITIALIZED;

    }



    if (mDemuxClient == nullptr) {

        mDemuxClient = mTunerClient->openDemux(handle);

        mDemuxClient = sTunerClient->openDemux(handle);

        if (mDemuxClient == nullptr) {

            ALOGE("Failed to open demux");

            return Result::UNKNOWN_ERROR;
@@ -1881,10 +1897,10 @@ int JTuner::unlinkCiCam(int id) { 


jobject JTuner::openDescrambler() {

    ALOGV("JTuner::openDescrambler");

    if (mTunerClient == nullptr || mDemuxClient == nullptr) {

    if (sTunerClient == nullptr || mDemuxClient == nullptr) {

        return nullptr;

    }

    sp<DescramblerClient> descramblerClient = mTunerClient->openDescrambler(0/*unused*/);

    sp<DescramblerClient> descramblerClient = sTunerClient->openDescrambler(0 /*unused*/);



    if (descramblerClient == nullptr) {

        ALOGD("Failed to open descrambler");
@@ -1995,12 +2011,12 @@ jobject JTuner::openDvr(DvrType type, jlong bufferSize) { 
}



jobject JTuner::getDemuxCaps() {

    if (mTunerClient == nullptr) {

    if (sTunerClient == nullptr) {

        return nullptr;

    }



    shared_ptr<DemuxCapabilities> caps;

    caps = mTunerClient->getDemuxCaps();

    caps = sTunerClient->getDemuxCaps();

    if (caps == nullptr) {

        return nullptr;

    }

media/jni/android_media_tv_Tuner.h

+2 −1
Original line number Diff line number Diff line
@@ -216,7 +216,8 @@ protected: 
private:

    jclass mClass;

    jweak mObject;

    static sp<TunerClient> mTunerClient;

    static sp<TunerClient> sTunerClient;

    static std::mutex sTunerClientMutex;

    sp<FrontendClient> mFeClient;

    sp<FrontendClientCallbackImpl> mFeClientCb;

    int mFeId;

media/jni/tuner/TunerClient.cpp

+2 −5
Original line number Diff line number Diff line
@@ -27,16 +27,13 @@ using ::aidl::android::hardware::tv::tuner::FrontendType; 


namespace android {



shared_ptr<ITunerService> TunerClient::mTunerService;

int32_t TunerClient::mTunerVersion;



/////////////// TunerClient ///////////////////////



TunerClient::TunerClient() {

    if (mTunerService == nullptr) {

        ::ndk::SpAIBinder binder(AServiceManager_getService("media.tuner"));

    ::ndk::SpAIBinder binder(AServiceManager_waitForService("media.tuner"));

    mTunerService = ITunerService::fromBinder(binder);

    }

    if (mTunerService == nullptr) {

        ALOGE("Failed to get tuner service");

    } else {