Merge "Tuner JNI: frontendCallback" (34cbb221) · Commits · e / os / android_frameworks_base

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

+85 −0

Original line number	Diff line number	Diff line
		@@ -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.
		*

media/jni/android_media_tv_Tuner.cpp

+145 −6

Original line number	Diff line number	Diff line
		@@ -108,6 +108,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;
		@@ -249,14 +250,152 @@ Return<void> FrontendCallback::onEvent(FrontendEventType frontendEventType) {
		(jint)frontendEventType);
		return Void();
		}
		Return<void> FrontendCallback::onDiseqcMessage(const hidl_vec<uint8_t>& /diseqcMessage/) {
		ALOGD("FrontendCallback::onDiseqcMessage");
		return Void();
		}

		Return<void> FrontendCallback::onScanMessage(
		FrontendScanMessageType type, const FrontendScanMessage& /message/) {
		Return<void> 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<uint32_t> v = message.frequencies();
		jintArray freqs = env->NewIntArray(v.size());
		env->SetIntArrayRegion(freqs, 0, v.size(), reinterpret_cast<jint*>(&v[0]));

		env->CallVoidMethod(
		mObject,
		env->GetMethodID(clazz, "onFrequenciesReport", "([I)V"),
		freqs);
		break;
		}
		case FrontendScanMessageType::SYMBOL_RATE: {
		std::vector<uint32_t> v = message.symbolRates();
		jintArray symbolRates = env->NewIntArray(v.size());
		env->SetIntArrayRegion(symbolRates, 0, v.size(), reinterpret_cast<jint*>(&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<uint8_t> v = message.plpIds();
		std::vector<jint> 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<uint8_t> v = message.groupIds();
		std::vector<jint> 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<uint16_t> v = message.inputStreamIds();
		std::vector<jint> 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, "<init>", "(IZ)V");
		std::vector<FrontendScanAtsc3PlpInfo> 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();
		}

media/jni/android_media_tv_Tuner.h

+0 −1

Original line number	Diff line number	Diff line
		@@ -109,7 +109,6 @@ struct FrontendCallback : public IFrontendCallback {
		FrontendCallback(jweak tunerObj, FrontendId id);

		virtual Return<void> onEvent(FrontendEventType frontendEventType);
		virtual Return<void> onDiseqcMessage(const hidl_vec<uint8_t>& diseqcMessage);
		virtual Return<void> onScanMessage(
		FrontendScanMessageType type, const FrontendScanMessage& message);