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

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

Merge "Complete Tuner Filter Events aidl interface and... 

Merge "Complete Tuner Filter Events aidl interface and TunerFilterCallback.onFilterEvent" into sc-dev
parents 7936104c 7c2c2efb

services/tuner/TunerFilter.cpp

+292 −18
Original line number Diff line number Diff line
@@ -25,6 +25,8 @@ using ::android::hardware::tv::tuner::V1_0::DemuxMmtpFilterType; 
using ::android::hardware::tv::tuner::V1_0::DemuxTsFilterSettings;

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

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

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



namespace android {



TunerFilter::TunerFilter(
@@ -209,6 +211,99 @@ sp<IFilter> TunerFilter::getHalFilter() { 


/////////////// FilterCallback ///////////////////////



Return<void> TunerFilter::FilterCallback::onFilterStatus(DemuxFilterStatus status) {

    if (mTunerFilterCallback != NULL) {

        mTunerFilterCallback->onFilterStatus((int)status);

    }

    return Void();

}



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

    std::vector<DemuxFilterEventExt::Event> emptyEventsExt;

    DemuxFilterEventExt emptyFilterEventExt {

            .events = emptyEventsExt,

    };

    onFilterEvent_1_1(filterEvent, emptyFilterEventExt);

    return Void();

}



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

        const DemuxFilterEventExt& filterEventExt) {

    if (mTunerFilterCallback != NULL) {

        std::vector<DemuxFilterEvent::Event> events = filterEvent.events;

        std::vector<DemuxFilterEventExt::Event> eventsExt = filterEventExt.events;

        std::vector<TunerFilterEvent> tunerEvent;



        getAidlFilterEvent(events, eventsExt, tunerEvent);

        mTunerFilterCallback->onFilterEvent(tunerEvent);

    }

    return Void();

}



/////////////// FilterCallback Helper Methods ///////////////////////



void TunerFilter::FilterCallback::getAidlFilterEvent(std::vector<DemuxFilterEvent::Event>& events,

        std::vector<DemuxFilterEventExt::Event>& eventsExt,

        std::vector<TunerFilterEvent>& tunerEvent) {

    if (events.empty() && !eventsExt.empty()) {

        auto eventExt = eventsExt[0];

        switch (eventExt.getDiscriminator()) {

            case DemuxFilterEventExt::Event::hidl_discriminator::monitorEvent: {

                getMonitorEvent(eventsExt, tunerEvent);

                break;

            }

            case DemuxFilterEventExt::Event::hidl_discriminator::startId: {

                getRestartEvent(eventsExt, tunerEvent);

                break;

            }

            default: {

                break;

            }

        }

    }



    if (!events.empty()) {

        auto event = events[0];

        switch (event.getDiscriminator()) {

            case DemuxFilterEvent::Event::hidl_discriminator::media: {

                getMediaEvent(events, tunerEvent);

                break;

            }

            case DemuxFilterEvent::Event::hidl_discriminator::section: {

                getSectionEvent(events, tunerEvent);

                break;

            }

            case DemuxFilterEvent::Event::hidl_discriminator::pes: {

                getPesEvent(events, tunerEvent);

                break;

            }

            case DemuxFilterEvent::Event::hidl_discriminator::tsRecord: {

                getTsRecordEvent(events, eventsExt, tunerEvent);

                break;

            }

            case DemuxFilterEvent::Event::hidl_discriminator::mmtpRecord: {

                getMmtpRecordEvent(events, eventsExt, tunerEvent);

                break;

            }

            case DemuxFilterEvent::Event::hidl_discriminator::download: {

                getDownloadEvent(events, tunerEvent);

                break;

            }

            case DemuxFilterEvent::Event::hidl_discriminator::ipPayload: {

                getIpPayloadEvent(events, tunerEvent);

                break;

            }

            case DemuxFilterEvent::Event::hidl_discriminator::temi: {

                getTemiEvent(events, tunerEvent);

                break;

            }

            default: {

                break;

            }

        }

    }

}



void TunerFilter::FilterCallback::getMediaEvent(

        std::vector<DemuxFilterEvent::Event>& events, std::vector<TunerFilterEvent>& res) {

    for (DemuxFilterEvent::Event e : events) {
@@ -225,6 +320,27 @@ void TunerFilter::FilterCallback::getMediaEvent( 
        tunerMedia.mpuSequenceNumber = static_cast<int>(mediaEvent.mpuSequenceNumber);

        tunerMedia.isPesPrivateData = mediaEvent.isPesPrivateData;



        if (mediaEvent.extraMetaData.getDiscriminator() ==

                DemuxFilterMediaEvent::ExtraMetaData::hidl_discriminator::audio) {

            tunerMedia.isAudioExtraMetaData = true;

            tunerMedia.audio = {

                .adFade = static_cast<int8_t>(

                        mediaEvent.extraMetaData.audio().adFade),

                .adPan = static_cast<int8_t>(

                        mediaEvent.extraMetaData.audio().adPan),

                .versionTextTag = static_cast<int8_t>(

                        mediaEvent.extraMetaData.audio().versionTextTag),

                .adGainCenter = static_cast<int8_t>(

                        mediaEvent.extraMetaData.audio().adGainCenter),

                .adGainFront = static_cast<int8_t>(

                        mediaEvent.extraMetaData.audio().adGainFront),

                .adGainSurround = static_cast<int8_t>(

                        mediaEvent.extraMetaData.audio().adGainSurround),

            };

        } else {

            tunerMedia.isAudioExtraMetaData = false;

        }



        if (mediaEvent.avMemory.getNativeHandle() != nullptr) {

            tunerMedia.avMemory = dupToAidl(mediaEvent.avMemory.getNativeHandle());

        }
@@ -235,30 +351,188 @@ void TunerFilter::FilterCallback::getMediaEvent( 
    }

}



Return<void> TunerFilter::FilterCallback::onFilterStatus(DemuxFilterStatus status) {

    mTunerFilterCallback->onFilterStatus((int)status);

    return Void();

void TunerFilter::FilterCallback::getSectionEvent(

        std::vector<DemuxFilterEvent::Event>& events, std::vector<TunerFilterEvent>& res) {

    for (DemuxFilterEvent::Event e : events) {

        DemuxFilterSectionEvent sectionEvent = e.section();

        TunerFilterSectionEvent tunerSection;



        tunerSection.tableId = static_cast<char>(sectionEvent.tableId);

        tunerSection.version = static_cast<char>(sectionEvent.version);

        tunerSection.sectionNum = static_cast<char>(sectionEvent.sectionNum);

        tunerSection.dataLength = static_cast<char>(sectionEvent.dataLength);



        TunerFilterEvent tunerEvent;

        tunerEvent.set<TunerFilterEvent::section>(std::move(tunerSection));

        res.push_back(std::move(tunerEvent));

    }

}



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

    std::vector<DemuxFilterEvent::Event> events = filterEvent.events;

    std::vector<TunerFilterEvent> tunerEvent;

void TunerFilter::FilterCallback::getPesEvent(

        std::vector<DemuxFilterEvent::Event>& events, std::vector<TunerFilterEvent>& res) {

    for (DemuxFilterEvent::Event e : events) {

        DemuxFilterPesEvent pesEvent = e.pes();

        TunerFilterPesEvent tunerPes;



    if (!events.empty()) {

        DemuxFilterEvent::Event event = events[0];

        switch (event.getDiscriminator()) {

            case DemuxFilterEvent::Event::hidl_discriminator::media: {

                getMediaEvent(events, tunerEvent);

        tunerPes.streamId = static_cast<char>(pesEvent.streamId);

        tunerPes.dataLength = static_cast<int>(pesEvent.dataLength);

        tunerPes.mpuSequenceNumber = static_cast<int>(pesEvent.mpuSequenceNumber);



        TunerFilterEvent tunerEvent;

        tunerEvent.set<TunerFilterEvent::pes>(std::move(tunerPes));

        res.push_back(std::move(tunerEvent));

    }

}



void TunerFilter::FilterCallback::getTsRecordEvent(std::vector<DemuxFilterEvent::Event>& events,

        std::vector<DemuxFilterEventExt::Event>& eventsExt, std::vector<TunerFilterEvent>& res) {

    for (int i = 0; i < events.size(); i++) {

        TunerFilterTsRecordEvent tunerTsRecord;

        DemuxFilterTsRecordEvent tsRecordEvent = events[i].tsRecord();



        TunerFilterScIndexMask scIndexMask;

        if (tsRecordEvent.scIndexMask.getDiscriminator()

                == DemuxFilterTsRecordEvent::ScIndexMask::hidl_discriminator::sc) {

            scIndexMask.set<TunerFilterScIndexMask::sc>(

                    static_cast<int>(tsRecordEvent.scIndexMask.sc()));

        } else if (tsRecordEvent.scIndexMask.getDiscriminator()

                == DemuxFilterTsRecordEvent::ScIndexMask::hidl_discriminator::scHevc) {

            scIndexMask.set<TunerFilterScIndexMask::scHevc>(

                    static_cast<int>(tsRecordEvent.scIndexMask.scHevc()));

        }



        if (tsRecordEvent.pid.getDiscriminator() == DemuxPid::hidl_discriminator::tPid) {

            tunerTsRecord.pid = static_cast<char>(tsRecordEvent.pid.tPid());

        } else {

            tunerTsRecord.pid = static_cast<char>(Constant::INVALID_TS_PID);

        }



        tunerTsRecord.scIndexMask = scIndexMask;

        tunerTsRecord.tsIndexMask = static_cast<int>(tsRecordEvent.tsIndexMask);

        tunerTsRecord.byteNumber = static_cast<long>(tsRecordEvent.byteNumber);



        if (eventsExt.size() > i && eventsExt[i].getDiscriminator() ==

                    DemuxFilterEventExt::Event::hidl_discriminator::tsRecord) {

            tunerTsRecord.isExtended = true;

            tunerTsRecord.pts = static_cast<long>(eventsExt[i].tsRecord().pts);

            tunerTsRecord.firstMbInSlice = static_cast<int>(eventsExt[i].tsRecord().firstMbInSlice);

        } else {

            tunerTsRecord.isExtended = false;

        }



        TunerFilterEvent tunerEvent;

        tunerEvent.set<TunerFilterEvent::tsRecord>(std::move(tunerTsRecord));

        res.push_back(std::move(tunerEvent));

    }

}



void TunerFilter::FilterCallback::getMmtpRecordEvent(std::vector<DemuxFilterEvent::Event>& events,

        std::vector<DemuxFilterEventExt::Event>& eventsExt, std::vector<TunerFilterEvent>& res) {

    for (int i = 0; i < events.size(); i++) {

        TunerFilterMmtpRecordEvent tunerMmtpRecord;

        DemuxFilterMmtpRecordEvent mmtpRecordEvent = events[i].mmtpRecord();



        tunerMmtpRecord.scHevcIndexMask = static_cast<int>(mmtpRecordEvent.scHevcIndexMask);

        tunerMmtpRecord.byteNumber = static_cast<long>(mmtpRecordEvent.byteNumber);



        if (eventsExt.size() > i && eventsExt[i].getDiscriminator() ==

                    DemuxFilterEventExt::Event::hidl_discriminator::mmtpRecord) {

            tunerMmtpRecord.isExtended = true;

            tunerMmtpRecord.pts = static_cast<long>(eventsExt[i].mmtpRecord().pts);

            tunerMmtpRecord.mpuSequenceNumber =

                    static_cast<int>(eventsExt[i].mmtpRecord().mpuSequenceNumber);

            tunerMmtpRecord.firstMbInSlice =

                    static_cast<int>(eventsExt[i].mmtpRecord().firstMbInSlice);

            tunerMmtpRecord.tsIndexMask = static_cast<int>(eventsExt[i].mmtpRecord().tsIndexMask);

        } else {

            tunerMmtpRecord.isExtended = false;

        }



        TunerFilterEvent tunerEvent;

        tunerEvent.set<TunerFilterEvent::mmtpRecord>(std::move(tunerMmtpRecord));

        res.push_back(std::move(tunerEvent));

    }

}



void TunerFilter::FilterCallback::getDownloadEvent(

        std::vector<DemuxFilterEvent::Event>& events, std::vector<TunerFilterEvent>& res) {

    for (DemuxFilterEvent::Event e : events) {

        DemuxFilterDownloadEvent downloadEvent = e.download();

        TunerFilterDownloadEvent tunerDownload;



        tunerDownload.itemId = static_cast<int>(downloadEvent.itemId);

        tunerDownload.itemFragmentIndex = static_cast<int>(downloadEvent.itemFragmentIndex);

        tunerDownload.mpuSequenceNumber = static_cast<int>(downloadEvent.mpuSequenceNumber);

        tunerDownload.lastItemFragmentIndex = static_cast<int>(downloadEvent.lastItemFragmentIndex);

        tunerDownload.dataLength = static_cast<char>(downloadEvent.dataLength);



        TunerFilterEvent tunerEvent;

        tunerEvent.set<TunerFilterEvent::download>(std::move(tunerDownload));

        res.push_back(std::move(tunerEvent));

    }

}



void TunerFilter::FilterCallback::getIpPayloadEvent(

        std::vector<DemuxFilterEvent::Event>& events, std::vector<TunerFilterEvent>& res) {

    for (DemuxFilterEvent::Event e : events) {

        DemuxFilterIpPayloadEvent ipPayloadEvent = e.ipPayload();

        TunerFilterIpPayloadEvent tunerIpPayload;



        tunerIpPayload.dataLength = static_cast<char>(ipPayloadEvent.dataLength);



        TunerFilterEvent tunerEvent;

        tunerEvent.set<TunerFilterEvent::ipPayload>(std::move(tunerIpPayload));

        res.push_back(std::move(tunerEvent));

    }

}



void TunerFilter::FilterCallback::getTemiEvent(

        std::vector<DemuxFilterEvent::Event>& events, std::vector<TunerFilterEvent>& res) {

    for (DemuxFilterEvent::Event e : events) {

        DemuxFilterTemiEvent temiEvent = e.temi();

        TunerFilterTemiEvent tunerTemi;



        tunerTemi.pts = static_cast<long>(temiEvent.pts);

        tunerTemi.descrTag = static_cast<int8_t>(temiEvent.descrTag);

        std::vector<uint8_t> descrData = temiEvent.descrData;

        tunerTemi.descrData.resize(descrData.size());

        copy(descrData.begin(), descrData.end(), tunerTemi.descrData.begin());



        TunerFilterEvent tunerEvent;

        tunerEvent.set<TunerFilterEvent::temi>(std::move(tunerTemi));

        res.push_back(std::move(tunerEvent));

    }

}



void TunerFilter::FilterCallback::getMonitorEvent(

        std::vector<DemuxFilterEventExt::Event>& eventsExt, std::vector<TunerFilterEvent>& res) {

    DemuxFilterMonitorEvent monitorEvent = eventsExt[0].monitorEvent();

    TunerFilterMonitorEvent tunerMonitor;



    switch (monitorEvent.getDiscriminator()) {

        case DemuxFilterMonitorEvent::hidl_discriminator::scramblingStatus: {

            tunerMonitor.set<TunerFilterMonitorEvent::scramblingStatus>(

                    static_cast<int>(monitorEvent.scramblingStatus()));

            break;

        }

            default: {

        case DemuxFilterMonitorEvent::hidl_discriminator::cid: {

            tunerMonitor.set<TunerFilterMonitorEvent::cid>(static_cast<int>(monitorEvent.cid()));

            break;

        }

        default: {

            break;

        }

    }



    mTunerFilterCallback->onFilterEvent(tunerEvent);

    return Void();

    TunerFilterEvent tunerEvent;

    tunerEvent.set<TunerFilterEvent::monitor>(std::move(tunerMonitor));

    res.push_back(std::move(tunerEvent));

}



void TunerFilter::FilterCallback::getRestartEvent(

        std::vector<DemuxFilterEventExt::Event>& eventsExt, std::vector<TunerFilterEvent>& res) {

    TunerFilterEvent tunerEvent;

    tunerEvent.set<TunerFilterEvent::startId>(static_cast<int>(eventsExt[0].startId()));

    res.push_back(std::move(tunerEvent));

}

}  // namespace android

services/tuner/TunerFilter.h

+55 −2
Original line number Diff line number Diff line
@@ -20,26 +20,48 @@ 
#include <aidl/android/media/tv/tuner/BnTunerFilter.h>

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

#include <aidlcommonsupport/NativeHandle.h>

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

#include <android/hardware/tv/tuner/1.0/ITuner.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 <media/stagefright/foundation/ADebug.h>



using Status = ::ndk::ScopedAStatus;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

using ::android::hardware::Return;

using ::android::hardware::Void;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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



namespace android {
@@ -65,9 +87,40 @@ public: 
                : mTunerFilterCallback(tunerFilterCallback) {};



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

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

                const DemuxFilterEventExt& filterEventExt);

        virtual Return<void> onFilterStatus(DemuxFilterStatus status);



        void getAidlFilterEvent(std::vector<DemuxFilterEvent::Event>& events,

                std::vector<DemuxFilterEventExt::Event>& eventsExt,

                std::vector<TunerFilterEvent>& tunerEvent);



        void getMediaEvent(

                std::vector<DemuxFilterEvent::Event>& events, std::vector<TunerFilterEvent>& res);

        void getSectionEvent(

                std::vector<DemuxFilterEvent::Event>& events, std::vector<TunerFilterEvent>& res);

        void getPesEvent(

                std::vector<DemuxFilterEvent::Event>& events, std::vector<TunerFilterEvent>& res);

        void getTsRecordEvent(

                std::vector<DemuxFilterEvent::Event>& events,

                std::vector<DemuxFilterEventExt::Event>& eventsExt,

                std::vector<TunerFilterEvent>& res);

        void getMmtpRecordEvent(

                std::vector<DemuxFilterEvent::Event>& events,

                std::vector<DemuxFilterEventExt::Event>& eventsExt,

                std::vector<TunerFilterEvent>& res);

        void getDownloadEvent(

                std::vector<DemuxFilterEvent::Event>& events, std::vector<TunerFilterEvent>& res);

        void getIpPayloadEvent(

                std::vector<DemuxFilterEvent::Event>& events, std::vector<TunerFilterEvent>& res);

        void getTemiEvent(

                std::vector<DemuxFilterEvent::Event>& events, std::vector<TunerFilterEvent>& res);

        void getMonitorEvent(

                std::vector<DemuxFilterEventExt::Event>& eventsExt,

                std::vector<TunerFilterEvent>& res);

        void getRestartEvent(

                std::vector<DemuxFilterEventExt::Event>& eventsExt,

                std::vector<TunerFilterEvent>& res);



        std::shared_ptr<ITunerFilterCallback> mTunerFilterCallback;

    };

services/tuner/aidl/android/media/tv/tuner/TunerAudioExtraMetaData.aidl

0 → 100644
+36 −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.

 */



package android.media.tv.tuner;



/**

 * Extra Meta Data from AD (Audio Descriptor) according to ETSI TS 101 154 V2.1.1.

 *

 * {@hide}

 */

parcelable TunerAudioExtraMetaData {

	byte adFade;



    byte adPan;



    byte versionTextTag;



    byte adGainCenter;



    byte adGainFront;



    byte adGainSurround;

}

services/tuner/aidl/android/media/tv/tuner/TunerFilterDownloadEvent.aidl

0 → 100644
+40 −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.

 */



package android.media.tv.tuner;



/**

 * Filter Event for Download data.

 *

 * {@hide}

 */

parcelable TunerFilterDownloadEvent {

    int itemId;



    /**

     * MPU sequence number of filtered data (only for MMTP)

     */

    int mpuSequenceNumber;



    int itemFragmentIndex;



    int lastItemFragmentIndex;



    /**

     * Data size in bytes of filtered data

     */

    char dataLength;

}

services/tuner/aidl/android/media/tv/tuner/TunerFilterEvent.aidl

+26 −0
Original line number Diff line number Diff line
@@ -16,7 +16,15 @@ 


package android.media.tv.tuner;



import android.media.tv.tuner.TunerFilterDownloadEvent;

import android.media.tv.tuner.TunerFilterIpPayloadEvent;

import android.media.tv.tuner.TunerFilterMediaEvent;

import android.media.tv.tuner.TunerFilterMmtpRecordEvent;

import android.media.tv.tuner.TunerFilterMonitorEvent;

import android.media.tv.tuner.TunerFilterPesEvent;

import android.media.tv.tuner.TunerFilterSectionEvent;

import android.media.tv.tuner.TunerFilterTemiEvent;

import android.media.tv.tuner.TunerFilterTsRecordEvent;



/**

 * Filter events.
@@ -25,4 +33,22 @@ import android.media.tv.tuner.TunerFilterMediaEvent; 
 */

union TunerFilterEvent {

    TunerFilterMediaEvent media;



    TunerFilterSectionEvent section;



    TunerFilterPesEvent pes;



    TunerFilterTsRecordEvent tsRecord;



    TunerFilterMmtpRecordEvent mmtpRecord;



    TunerFilterDownloadEvent download;



    TunerFilterIpPayloadEvent ipPayload;



    TunerFilterTemiEvent temi;



    TunerFilterMonitorEvent monitor;



    int startId;

}