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

Commit 99e0f9b5 authored by Amy Zhang's avatar Amy Zhang Committed by Android (Google) Code Review
Browse files

Merge "Add FilterClientCallback implementation"

parents 28fb53f4 b74185b3

media/jni/tuner/DemuxClient.cpp

+61 −6
Original line number Diff line number Diff line
@@ -44,26 +44,59 @@ void DemuxClient::setHidlDemux(sp<IDemux> demux) { 
    mDemux = demux;

}



Result DemuxClient::setFrontendDataSource(sp<FrontendClient> tunerFrontend) {

Result DemuxClient::setFrontendDataSource(sp<FrontendClient> frontendClient) {

    // TODO: pending aidl interface

    /*if (mTunerDemux != NULL) {

        // TODO: handle error message

        mTunerDemux->setFrontendDataSource(tunerFrontend->getAidlFrontend());

        mTunerDemux->setFrontendDataSource(frontendClient->getAidlFrontend());

        return (int) Result::SUCCESS;

    }*/



    if (mDemux != NULL) {

        Result res = mDemux->setFrontendDataSource(tunerFrontend->getId());

        Result res = mDemux->setFrontendDataSource(frontendClient->getId());

        return res;

    }



    return Result::INVALID_STATE;

}



//FilterClient openFilter(int mainType, int subType, int bufferSize, FilterClientCallback cb);

sp<FilterClient> DemuxClient::openFilter(DemuxFilterType type, int bufferSize,

        sp<FilterClientCallback> cb) {

    // TODO: pending aidl interface



    if (mDemux != NULL) {

        sp<HidlFilterCallback> callback = new HidlFilterCallback(cb);

        sp<IFilter> hidlFilter = openHidlFilter(type, bufferSize, callback);

        if (hidlFilter != NULL) {

            sp<FilterClient> filterClient = new FilterClient();

            filterClient->setHidlFilter(hidlFilter);

            return filterClient;

        }

    }



    // TODO: handle share av memory handle



int DemuxClient::getAvSyncHwId(FilterClient /*tunerFilter*/) {

    return 0;

    return NULL;

}



int DemuxClient::getAvSyncHwId(sp<FilterClient> filterClient) {

    // pending aidl interface



    if (mDemux != NULL) {

        uint32_t avSyncHwId;

        Result res;

        sp<IFilter> halFilter = filterClient->getHalFilter();

        mDemux->getAvSyncHwId(halFilter,

                [&](Result r, uint32_t id) {

                    res = r;

                    avSyncHwId = id;

                });

        if (res == Result::SUCCESS) {

            return (int) avSyncHwId;

        }

    }



    return -1;

}



long DemuxClient::getAvSyncTime(int avSyncHwId) {
@@ -120,4 +153,26 @@ Result DemuxClient::close() { 


    return Result::INVALID_STATE;

}



/////////////// DemuxClient Helper Methods ///////////////////////



sp<IFilter> DemuxClient::openHidlFilter(DemuxFilterType type, int bufferSize,

        sp<HidlFilterCallback> callback) {

    if (mDemux == NULL) {

        return NULL;

    }



    sp<IFilter> hidlFilter;

    Result res;

    mDemux->openFilter(type, bufferSize, callback,

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

                hidlFilter = filter;

                res = r;

            });

    if (res != Result::SUCCESS || hidlFilter == NULL) {

        return NULL;

    }



    return hidlFilter;

}

}  // namespace android

media/jni/tuner/DemuxClient.h

+7 −3
Original line number Diff line number Diff line
@@ -22,10 +22,12 @@ 
#include <android/hardware/tv/tuner/1.1/types.h>



#include "FilterClient.h"

#include "FilterClientCallback.h"

#include "FrontendClient.h"



//using ::aidl::android::media::tv::tuner::ITunerDemux;



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

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



using namespace std;
@@ -44,19 +46,19 @@ public: 
    /**

     * Set a frontend resource as data input of the demux.

     */

    Result setFrontendDataSource(sp<FrontendClient> tunerFrontend);

    Result setFrontendDataSource(sp<FrontendClient> frontendClient);



    /**

     * Open a new filter client.

     */

    //FilterClient openFilter(int mainType, int subType, int bufferSize, FilterClientCallback cb);

    sp<FilterClient> openFilter(DemuxFilterType type, int bufferSize, sp<FilterClientCallback> cb);



    // TODO: handle TimeFilterClient



    /**

     * Get hardware sync ID for audio and video.

     */

    int getAvSyncHwId(FilterClient tunerFilter);

    int getAvSyncHwId(sp<FilterClient> filterClient);



    /**

     * Get current time stamp to use for A/V sync.
@@ -85,6 +87,8 @@ public: 
    Result close();



private:

    sp<IFilter> openHidlFilter(DemuxFilterType type, int bufferSize, sp<HidlFilterCallback> cb);



    /**

     * An AIDL Tuner Demux Singleton assigned at the first time the Tuner Client

     * opens a demux. Default null when demux is not opened.

media/jni/tuner/FilterClient.cpp

+28 −7
Original line number Diff line number Diff line
@@ -14,7 +14,7 @@ 
 * limitations under the License.

 */



#define LOG_TAG "FrontendClient"

#define LOG_TAG "FilterClient"



#include <android-base/logging.h>

#include <utils/Log.h>
@@ -25,10 +25,6 @@ using ::android::hardware::tv::tuner::V1_0::DemuxQueueNotifyBits; 


namespace android {



//shared_ptr<ITunerFilter> FilterClient::mTunerFilter;

sp<IFilter> FilterClient::mFilter;

sp<::android::hardware::tv::tuner::V1_1::IFilter> FilterClient::mFilter_1_1;



/////////////// FilterClient ///////////////////////



// TODO: pending aidl interface
@@ -49,8 +45,6 @@ void FilterClient::setHidlFilter(sp<IFilter> filter) { 
    mFilter_1_1 = ::android::hardware::tv::tuner::V1_1::IFilter::castFrom(mFilter);

}



//Result setCallback(FilterClientCallback filterClientCallback);



int FilterClient::read(uint8_t* buffer, int size) {

    // TODO: pending aidl interface
@@ -199,6 +193,33 @@ Result FilterClient::close() { 
    return Result::INVALID_STATE;

}



/////////////// IFilterCallback ///////////////////////



HidlFilterCallback::HidlFilterCallback(sp<FilterClientCallback> filterClientCallback)

        : mFilterClientCallback(filterClientCallback) {}



Return<void> HidlFilterCallback::onFilterStatus(const DemuxFilterStatus status) {

    if (mFilterClientCallback != NULL) {

        mFilterClientCallback->onFilterStatus(status);

    }

    return Void();

}



Return<void> HidlFilterCallback::onFilterEvent(const DemuxFilterEvent& filterEvent) {

    if (mFilterClientCallback != NULL) {

        mFilterClientCallback->onFilterEvent(filterEvent);

    }

    return Void();

}



Return<void> HidlFilterCallback::onFilterEvent_1_1(const DemuxFilterEvent& filterEvent,

        const DemuxFilterEventExt& filterEventExt) {

    if (mFilterClientCallback != NULL) {

        mFilterClientCallback->onFilterEvent_1_1(filterEvent, filterEventExt);

    }

    return Void();

}



/////////////// FilterClient Helper Methods ///////////////////////



Result FilterClient::getFilterMq() {

media/jni/tuner/FilterClient.h

+38 −9
Original line number Diff line number Diff line
@@ -19,21 +19,25 @@ 


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

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

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

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

#include <fmq/MessageQueue.h>



//#include "FilterClientCallback.h"

#include "FilterClientCallback.h"



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



using ::android::hardware::EventFlag;

using ::android::hardware::MessageQueue;

using ::android::hardware::MQDescriptorSync;

using ::android::hardware::Return;

using ::android::hardware::Void;

using ::android::hardware::hidl_handle;

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

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

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

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

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



using namespace std;
@@ -41,6 +45,32 @@ using MQ = MessageQueue<uint8_t, kSynchronizedReadWrite>; 


namespace android {



// TODO: pending aidl interface

/*class TunerFilterCallback : public BnTunerFilterCallback {



public:

    TunerFilterCallback(sp<FilterClientCallback> filterClientCallback);



    Status onFilterEvent(vector<TunerDemuxFilterEvent> events);

    Status onFilterStatus(int status);



private:

    sp<FilterClientCallback> mFilterClientCallback;

};*/



struct HidlFilterCallback : public IFilterCallback {



public:

    HidlFilterCallback(sp<FilterClientCallback> filterClientCallback);

    virtual Return<void> onFilterEvent_1_1(const DemuxFilterEvent& filterEvent,

            const DemuxFilterEventExt& filterEventExt);

    virtual Return<void> onFilterEvent(const DemuxFilterEvent& filterEvent);

    virtual Return<void> onFilterStatus(const DemuxFilterStatus status);



private:

    sp<FilterClientCallback> mFilterClientCallback;

};



struct FilterClient : public RefBase {



public:
@@ -51,11 +81,6 @@ public: 
    // TODO: remove after migration to Tuner Service is done.

    void setHidlFilter(sp<IFilter> filter);



    /**

     * Set the filter client callback.

     */

    //Result setCallback(FilterClientCallback filterClientCallback);



    /**

     * Read size of data from filter FMQ into buffer.

     *
@@ -142,24 +167,28 @@ private: 
     * opens a filter. Default null when Tuner Service does not exist.

     */

    // TODO: pending on aidl interface

    //static shared_ptr<ITunerFilter> mTunerFilter;

    //shared_ptr<ITunerFilter> mTunerFilter;



    /**

     * A 1.0 Filter HAL interface that is ready before migrating to the TunerFilter.

     * This is a temprary interface before Tuner Framework migrates to use TunerService.

     * Default null when the HAL service does not exist.

     */

    static sp<IFilter> mFilter;

    sp<IFilter> mFilter;



    /**

     * A 1.1 Filter HAL interface that is ready before migrating to the TunerFilter.

     * This is a temprary interface before Tuner Framework migrates to use TunerService.

     * Default null when the HAL service does not exist.

     */

    static sp<::android::hardware::tv::tuner::V1_1::IFilter> mFilter_1_1;

    sp<::android::hardware::tv::tuner::V1_1::IFilter> mFilter_1_1;



    unique_ptr<MQ> mFilterMQ;

    EventFlag* mFilterMQEventFlag;



    sp<FilterClientCallback> mCallback;

    //shared_ptr<TunerFilterCallback> mAidlCallback;

    sp<HidlFilterCallback> mHidlCallback;

};

}  // namespace android

media/jni/tuner/FilterClientCallback.h

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

 * Copyright 2020 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_TV_FILTER_CLIENT_CALLBACK_H_

#define _ANDROID_MEDIA_TV_FILTER_CLIENT_CALLBACK_H_



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

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

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



using namespace std;



namespace android {



struct FilterClientCallback : public RefBase {

    virtual void onFilterEvent_1_1(const DemuxFilterEvent& filterEvent,

            const DemuxFilterEventExt& filterEventExt);

    virtual void onFilterEvent(const DemuxFilterEvent& filterEvent);

    virtual void onFilterStatus(const DemuxFilterStatus status);

};

}  // namespace android



#endif  // _ANDROID_MEDIA_TV_FILTER_CLIENT_CALLBACK_H_
 
 No newline at end of file