From c8736b787e58714419c38d29127e8c3203282456 Mon Sep 17 00:00:00 2001 From: shubang Date: Tue, 11 Feb 2020 18:27:53 -0800 Subject: [PATCH] Tuner JNI: frontendCallback Test: mannual Change-Id: I514a4068660e043c7349a0f2d471cf4b11968eed --- media/java/android/media/tv/tuner/Tuner.java | 85 +++++++++++ media/jni/android_media_tv_Tuner.cpp | 151 ++++++++++++++++++- media/jni/android_media_tv_Tuner.h | 1 - 3 files changed, 230 insertions(+), 7 deletions(-) diff --git a/media/java/android/media/tv/tuner/Tuner.java b/media/java/android/media/tv/tuner/Tuner.java index 9b183a3e0e920..57c18928afceb 100644 --- a/media/java/android/media/tv/tuner/Tuner.java +++ b/media/java/android/media/tv/tuner/Tuner.java @@ -34,6 +34,7 @@ import android.media.tv.tuner.filter.Filter.Subtype; import android.media.tv.tuner.filter.Filter.Type; import android.media.tv.tuner.filter.FilterCallback; import android.media.tv.tuner.filter.TimeFilter; +import android.media.tv.tuner.frontend.Atsc3PlpInfo; import android.media.tv.tuner.frontend.FrontendInfo; import android.media.tv.tuner.frontend.FrontendSettings; import android.media.tv.tuner.frontend.FrontendStatus; @@ -511,6 +512,90 @@ public class Tuner implements AutoCloseable { } } + private void onLocked() { + if (mScanCallbackExecutor != null && mScanCallback != null) { + mScanCallbackExecutor.execute(() -> mScanCallback.onLocked()); + } + } + + private void onScanStopped() { + if (mScanCallbackExecutor != null && mScanCallback != null) { + mScanCallbackExecutor.execute(() -> mScanCallback.onScanStopped()); + } + } + + private void onProgress(int percent) { + if (mScanCallbackExecutor != null && mScanCallback != null) { + mScanCallbackExecutor.execute(() -> mScanCallback.onProgress(percent)); + } + } + + private void onFrequenciesReport(int[] frequency) { + if (mScanCallbackExecutor != null && mScanCallback != null) { + mScanCallbackExecutor.execute(() -> mScanCallback.onFrequenciesReport(frequency)); + } + } + + private void onSymbolRates(int[] rate) { + if (mScanCallbackExecutor != null && mScanCallback != null) { + mScanCallbackExecutor.execute(() -> mScanCallback.onSymbolRates(rate)); + } + } + + private void onHierarchy(int hierarchy) { + if (mScanCallbackExecutor != null && mScanCallback != null) { + mScanCallbackExecutor.execute(() -> mScanCallback.onHierarchy(hierarchy)); + } + } + + private void onSignalType(int signalType) { + if (mScanCallbackExecutor != null && mScanCallback != null) { + mScanCallbackExecutor.execute(() -> mScanCallback.onSignalType(signalType)); + } + } + + private void onPlpIds(int[] plpIds) { + if (mScanCallbackExecutor != null && mScanCallback != null) { + mScanCallbackExecutor.execute(() -> mScanCallback.onPlpIds(plpIds)); + } + } + + private void onGroupIds(int[] groupIds) { + if (mScanCallbackExecutor != null && mScanCallback != null) { + mScanCallbackExecutor.execute(() -> mScanCallback.onGroupIds(groupIds)); + } + } + + private void onInputStreamIds(int[] inputStreamIds) { + if (mScanCallbackExecutor != null && mScanCallback != null) { + mScanCallbackExecutor.execute(() -> mScanCallback.onInputStreamIds(inputStreamIds)); + } + } + + private void onDvbsStandard(int dvbsStandandard) { + if (mScanCallbackExecutor != null && mScanCallback != null) { + mScanCallbackExecutor.execute(() -> mScanCallback.onDvbsStandard(dvbsStandandard)); + } + } + + private void onDvbtStandard(int dvbtStandard) { + if (mScanCallbackExecutor != null && mScanCallback != null) { + mScanCallbackExecutor.execute(() -> mScanCallback.onDvbtStandard(dvbtStandard)); + } + } + + private void onAnalogSifStandard(int sif) { + if (mScanCallbackExecutor != null && mScanCallback != null) { + mScanCallbackExecutor.execute(() -> mScanCallback.onAnalogSifStandard(sif)); + } + } + + private void onAtsc3PlpInfos(Atsc3PlpInfo[] atsc3PlpInfos) { + if (mScanCallbackExecutor != null && mScanCallback != null) { + mScanCallbackExecutor.execute(() -> mScanCallback.onAtsc3PlpInfos(atsc3PlpInfos)); + } + } + /** * Opens a filter object based on the given types and buffer size. * diff --git a/media/jni/android_media_tv_Tuner.cpp b/media/jni/android_media_tv_Tuner.cpp index 08c3f988e85e7..f02b597a44243 100644 --- a/media/jni/android_media_tv_Tuner.cpp +++ b/media/jni/android_media_tv_Tuner.cpp @@ -88,6 +88,7 @@ using ::android::hardware::tv::tuner::V1_0::FrontendIsdbtGuardInterval; using ::android::hardware::tv::tuner::V1_0::FrontendIsdbtMode; using ::android::hardware::tv::tuner::V1_0::FrontendIsdbtModulation; using ::android::hardware::tv::tuner::V1_0::FrontendIsdbtSettings; +using ::android::hardware::tv::tuner::V1_0::FrontendScanAtsc3PlpInfo; using ::android::hardware::tv::tuner::V1_0::FrontendType; using ::android::hardware::tv::tuner::V1_0::ITuner; using ::android::hardware::tv::tuner::V1_0::PlaybackSettings; @@ -226,14 +227,152 @@ Return FrontendCallback::onEvent(FrontendEventType frontendEventType) { (jint)frontendEventType); return Void(); } -Return FrontendCallback::onDiseqcMessage(const hidl_vec& /*diseqcMessage*/) { - ALOGD("FrontendCallback::onDiseqcMessage"); - return Void(); -} -Return FrontendCallback::onScanMessage( - FrontendScanMessageType type, const FrontendScanMessage& /*message*/) { +Return FrontendCallback::onScanMessage(FrontendScanMessageType type, const FrontendScanMessage& message) { ALOGD("FrontendCallback::onScanMessage, type=%d", type); + JNIEnv *env = AndroidRuntime::getJNIEnv(); + jclass clazz = env->FindClass("android/media/tv/tuner/Tuner"); + switch(type) { + case FrontendScanMessageType::LOCKED: { + if (message.isLocked()) { + env->CallVoidMethod( + mObject, + env->GetMethodID(clazz, "onLocked", "()V")); + } + break; + } + case FrontendScanMessageType::END: { + if (message.isEnd()) { + env->CallVoidMethod( + mObject, + env->GetMethodID(clazz, "onScanStopped", "()V")); + } + break; + } + case FrontendScanMessageType::PROGRESS_PERCENT: { + env->CallVoidMethod( + mObject, + env->GetMethodID(clazz, "onProgress", "(I)V"), + (jint) message.progressPercent()); + break; + } + case FrontendScanMessageType::FREQUENCY: { + std::vector v = message.frequencies(); + jintArray freqs = env->NewIntArray(v.size()); + env->SetIntArrayRegion(freqs, 0, v.size(), reinterpret_cast(&v[0])); + + env->CallVoidMethod( + mObject, + env->GetMethodID(clazz, "onFrequenciesReport", "([I)V"), + freqs); + break; + } + case FrontendScanMessageType::SYMBOL_RATE: { + std::vector v = message.symbolRates(); + jintArray symbolRates = env->NewIntArray(v.size()); + env->SetIntArrayRegion(symbolRates, 0, v.size(), reinterpret_cast(&v[0])); + + env->CallVoidMethod( + mObject, + env->GetMethodID(clazz, "onSymbolRates", "([I)V"), + symbolRates); + break; + } + case FrontendScanMessageType::HIERARCHY: { + env->CallVoidMethod( + mObject, + env->GetMethodID(clazz, "onHierarchy", "(I)V"), + (jint) message.hierarchy()); + break; + } + case FrontendScanMessageType::ANALOG_TYPE: { + env->CallVoidMethod( + mObject, + env->GetMethodID(clazz, "onSignalType", "(I)V"), + (jint) message.analogType()); + break; + } + case FrontendScanMessageType::PLP_IDS: { + std::vector v = message.plpIds(); + std::vector jintV(v.begin(), v.end()); + jintArray plpIds = env->NewIntArray(v.size()); + env->SetIntArrayRegion(plpIds, 0, jintV.size(), &jintV[0]); + + env->CallVoidMethod( + mObject, + env->GetMethodID(clazz, "onPlpIds", "([I)V"), + plpIds); + break; + } + case FrontendScanMessageType::GROUP_IDS: { + std::vector v = message.groupIds(); + std::vector jintV(v.begin(), v.end()); + jintArray groupIds = env->NewIntArray(v.size()); + env->SetIntArrayRegion(groupIds, 0, jintV.size(), &jintV[0]); + + env->CallVoidMethod( + mObject, + env->GetMethodID(clazz, "onGroupIds", "([I)V"), + groupIds); + break; + } + case FrontendScanMessageType::INPUT_STREAM_IDS: { + std::vector v = message.inputStreamIds(); + std::vector jintV(v.begin(), v.end()); + jintArray streamIds = env->NewIntArray(v.size()); + env->SetIntArrayRegion(streamIds, 0, jintV.size(), &jintV[0]); + + env->CallVoidMethod( + mObject, + env->GetMethodID(clazz, "onInputStreamIds", "([I)V"), + streamIds); + break; + } + case FrontendScanMessageType::STANDARD: { + FrontendScanMessage::Standard std = message.std(); + jint standard; + if (std.getDiscriminator() == FrontendScanMessage::Standard::hidl_discriminator::sStd) { + standard = (jint) std.sStd(); + env->CallVoidMethod( + mObject, + env->GetMethodID(clazz, "onDvbsStandard", "(I)V"), + standard); + } else if (std.getDiscriminator() == FrontendScanMessage::Standard::hidl_discriminator::tStd) { + standard = (jint) std.tStd(); + env->CallVoidMethod( + mObject, + env->GetMethodID(clazz, "onDvbtStandard", "(I)V"), + standard); + } else if (std.getDiscriminator() == FrontendScanMessage::Standard::hidl_discriminator::sifStd) { + standard = (jint) std.sifStd(); + env->CallVoidMethod( + mObject, + env->GetMethodID(clazz, "onAnalogSifStandard", "(I)V"), + standard); + } + break; + } + case FrontendScanMessageType::ATSC3_PLP_INFO: { + jclass plpClazz = env->FindClass("android/media/tv/tuner/frontend/Atsc3PlpInfo"); + jmethodID init = env->GetMethodID(plpClazz, "", "(IZ)V"); + std::vector plpInfos = message.atsc3PlpInfos(); + jobjectArray array = env->NewObjectArray(plpInfos.size(), plpClazz, NULL); + + for (int i = 0; i < plpInfos.size(); i++) { + auto info = plpInfos[i]; + jint plpId = (jint) info.plpId; + jboolean lls = (jboolean) info.bLlsFlag; + + jobject obj = env->NewObject(plpClazz, init, plpId, lls); + env->SetObjectArrayElement(array, i, obj); + } + env->CallVoidMethod( + mObject, + env->GetMethodID(clazz, "onAtsc3PlpInfos", "([Landroid/media/tv/tuner/frontend/Atsc3PlpInfo;)V"), + array); + break; + } + } return Void(); } diff --git a/media/jni/android_media_tv_Tuner.h b/media/jni/android_media_tv_Tuner.h index cfe99b399979c..d899bbd6467fb 100644 --- a/media/jni/android_media_tv_Tuner.h +++ b/media/jni/android_media_tv_Tuner.h @@ -109,7 +109,6 @@ struct FrontendCallback : public IFrontendCallback { FrontendCallback(jweak tunerObj, FrontendId id); virtual Return onEvent(FrontendEventType frontendEventType); - virtual Return onDiseqcMessage(const hidl_vec& diseqcMessage); virtual Return onScanMessage( FrontendScanMessageType type, const FrontendScanMessage& message);