Merge "Move files to libmedia2_jni_core" (d6b4dfb7) · Commits · e / os / android_frameworks_base

media/jni/Android.bp

+1 −2

Original line number	Diff line number	Diff line
		@@ -88,8 +88,6 @@ cc_library_shared {
		name: "libmedia2_jni",

		srcs: [
		"android_media_Media2HTTPConnection.cpp",
		"android_media_Media2HTTPService.cpp",
		"android_media_Media2DataSource.cpp",
		"android_media_MediaMetricsJNI.cpp",
		"android_media_MediaPlayer2.cpp",
		@@ -142,6 +140,7 @@ cc_library_shared {
		"libstagefright_player2",
		"libstagefright_rtsp",
		"libstagefright_timedtext2",
		"libmedia2_jni_core",
		],

		group_static_libs: true,

media/jni/android_media_Media2HTTPConnection.cpp

deleted100644 → 0

+0 −182

Original line number	Diff line number	Diff line
		/*
		* Copyright 2017, 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.
		*/

		//#define LOG_NDEBUG 0
		#define LOG_TAG "Media2HTTPConnection-JNI"
		#include <utils/Log.h>

		#include <mediaplayer2/JavaVMHelper.h>
		#include <media/stagefright/foundation/ADebug.h>
		#include <nativehelper/ScopedLocalRef.h>

		#include "android_media_Media2HTTPConnection.h"
		#include "android_util_Binder.h"

		#include "log/log.h"
		#include "jni.h"
		#include <nativehelper/JNIHelp.h>

		namespace android {

		static const size_t kBufferSize = 32768;

		JMedia2HTTPConnection::JMedia2HTTPConnection(JNIEnv *env, jobject thiz) {
		mMedia2HTTPConnectionObj = env->NewGlobalRef(thiz);
		CHECK(mMedia2HTTPConnectionObj != NULL);

		ScopedLocalRef<jclass> media2HTTPConnectionClass(
		env, env->GetObjectClass(mMedia2HTTPConnectionObj));
		CHECK(media2HTTPConnectionClass.get() != NULL);

		mConnectMethod = env->GetMethodID(
		media2HTTPConnectionClass.get(),
		"connect",
		"(Ljava/lang/String;Ljava/lang/String;)Z");
		CHECK(mConnectMethod != NULL);

		mDisconnectMethod = env->GetMethodID(
		media2HTTPConnectionClass.get(),
		"disconnect",
		"()V");
		CHECK(mDisconnectMethod != NULL);

		mReadAtMethod = env->GetMethodID(
		media2HTTPConnectionClass.get(),
		"readAt",
		"(J[BI)I");
		CHECK(mReadAtMethod != NULL);

		mGetSizeMethod = env->GetMethodID(
		media2HTTPConnectionClass.get(),
		"getSize",
		"()J");
		CHECK(mGetSizeMethod != NULL);

		mGetMIMETypeMethod = env->GetMethodID(
		media2HTTPConnectionClass.get(),
		"getMIMEType",
		"()Ljava/lang/String;");
		CHECK(mGetMIMETypeMethod != NULL);

		mGetUriMethod = env->GetMethodID(
		media2HTTPConnectionClass.get(),
		"getUri",
		"()Ljava/lang/String;");
		CHECK(mGetUriMethod != NULL);

		ScopedLocalRef<jbyteArray> tmp(
		env, env->NewByteArray(kBufferSize));
		mByteArrayObj = (jbyteArray)env->NewGlobalRef(tmp.get());
		CHECK(mByteArrayObj != NULL);
		}

		JMedia2HTTPConnection::~JMedia2HTTPConnection() {
		JNIEnv *env = JavaVMHelper::getJNIEnv();
		env->DeleteGlobalRef(mMedia2HTTPConnectionObj);
		env->DeleteGlobalRef(mByteArrayObj);
		}

		bool JMedia2HTTPConnection::connect(
		const char uri, const KeyedVector<String8, String8> headers) {
		String8 tmp("");
		if (headers != NULL) {
		for (size_t i = 0; i < headers->size(); ++i) {
		tmp.append(headers->keyAt(i));
		tmp.append(String8(": "));
		tmp.append(headers->valueAt(i));
		tmp.append(String8("\r\n"));
		}
		}

		JNIEnv* env = JavaVMHelper::getJNIEnv();
		jstring juri = env->NewStringUTF(uri);
		jstring jheaders = env->NewStringUTF(tmp.string());

		jboolean ret =
		env->CallBooleanMethod(mMedia2HTTPConnectionObj, mConnectMethod, juri, jheaders);

		env->DeleteLocalRef(juri);
		env->DeleteLocalRef(jheaders);

		return (bool)ret;
		}

		void JMedia2HTTPConnection::disconnect() {
		JNIEnv* env = JavaVMHelper::getJNIEnv();
		env->CallVoidMethod(mMedia2HTTPConnectionObj, mDisconnectMethod);
		}

		ssize_t JMedia2HTTPConnection::readAt(off64_t offset, void *data, size_t size) {
		JNIEnv* env = JavaVMHelper::getJNIEnv();

		if (size > kBufferSize) {
		size = kBufferSize;
		}

		jint n = env->CallIntMethod(
		mMedia2HTTPConnectionObj, mReadAtMethod, (jlong)offset, mByteArrayObj, (jint)size);

		if (n > 0) {
		env->GetByteArrayRegion(
		mByteArrayObj,
		0,
		n,
		(jbyte *)data);
		}

		return n;
		}

		off64_t JMedia2HTTPConnection::getSize() {
		JNIEnv* env = JavaVMHelper::getJNIEnv();
		return (off64_t)(env->CallLongMethod(mMedia2HTTPConnectionObj, mGetSizeMethod));
		}

		status_t JMedia2HTTPConnection::getMIMEType(String8 *mimeType) {
		JNIEnv* env = JavaVMHelper::getJNIEnv();
		jstring jmime = (jstring)env->CallObjectMethod(mMedia2HTTPConnectionObj, mGetMIMETypeMethod);
		jboolean flag = env->ExceptionCheck();
		if (flag) {
		env->ExceptionClear();
		return UNKNOWN_ERROR;
		}

		const char *str = env->GetStringUTFChars(jmime, 0);
		if (str != NULL) {
		*mimeType = String8(str);
		} else {
		*mimeType = "application/octet-stream";
		}
		env->ReleaseStringUTFChars(jmime, str);
		return OK;
		}

		status_t JMedia2HTTPConnection::getUri(String8 *uri) {
		JNIEnv* env = JavaVMHelper::getJNIEnv();
		jstring juri = (jstring)env->CallObjectMethod(mMedia2HTTPConnectionObj, mGetUriMethod);
		jboolean flag = env->ExceptionCheck();
		if (flag) {
		env->ExceptionClear();
		return UNKNOWN_ERROR;
		}

		const char *str = env->GetStringUTFChars(juri, 0);
		*uri = String8(str);
		env->ReleaseStringUTFChars(juri, str);
		return OK;
		}

		} // namespace android

media/jni/android_media_Media2HTTPConnection.h

deleted100644 → 0

+0 −58

Original line number	Diff line number	Diff line
		/*
		* Copyright 2017, 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_MEDIA2HTTPCONNECTION_H_
		#define _ANDROID_MEDIA_MEDIA2HTTPCONNECTION_H_

		#include "jni.h"

		#include <media/MediaHTTPConnection.h>
		#include <media/stagefright/foundation/ABase.h>

		namespace android {

		struct JMedia2HTTPConnection : public MediaHTTPConnection {
		JMedia2HTTPConnection(JNIEnv *env, jobject thiz);

		virtual bool connect(
		const char uri, const KeyedVector<String8, String8> headers) override;

		virtual void disconnect() override;
		virtual ssize_t readAt(off64_t offset, void *data, size_t size) override;
		virtual off64_t getSize() override;
		virtual status_t getMIMEType(String8 *mimeType) override;
		virtual status_t getUri(String8 *uri) override;

		protected:
		virtual ~JMedia2HTTPConnection();

		private:
		jobject mMedia2HTTPConnectionObj;
		jmethodID mConnectMethod;
		jmethodID mDisconnectMethod;
		jmethodID mReadAtMethod;
		jmethodID mGetSizeMethod;
		jmethodID mGetMIMETypeMethod;
		jmethodID mGetUriMethod;

		jbyteArray mByteArrayObj;

		DISALLOW_EVIL_CONSTRUCTORS(JMedia2HTTPConnection);
		};

		} // namespace android

		#endif // _ANDROID_MEDIA_MEDIA2HTTPCONNECTION_H_

media/jni/android_media_Media2HTTPService.cpp

deleted100644 → 0

+0 −61

Original line number	Diff line number	Diff line
		/*
		* Copyright 2017, 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.
		*/

		//#define LOG_NDEBUG 0
		#define LOG_TAG "Media2HTTPService-JNI"
		#include <utils/Log.h>

		#include "android_media_Media2HTTPConnection.h"
		#include "android_media_Media2HTTPService.h"

		#include "log/log.h"
		#include "jni.h"
		#include <nativehelper/JNIHelp.h>

		#include <mediaplayer2/JavaVMHelper.h>
		#include <media/stagefright/foundation/ADebug.h>
		#include <nativehelper/ScopedLocalRef.h>

		namespace android {

		JMedia2HTTPService::JMedia2HTTPService(JNIEnv *env, jobject thiz) {
		mMedia2HTTPServiceObj = env->NewGlobalRef(thiz);
		CHECK(mMedia2HTTPServiceObj != NULL);

		ScopedLocalRef<jclass> media2HTTPServiceClass(env, env->GetObjectClass(mMedia2HTTPServiceObj));
		CHECK(media2HTTPServiceClass.get() != NULL);

		mMakeHTTPConnectionMethod = env->GetMethodID(
		media2HTTPServiceClass.get(),
		"makeHTTPConnection",
		"()Landroid/media/Media2HTTPConnection;");
		CHECK(mMakeHTTPConnectionMethod != NULL);
		}

		JMedia2HTTPService::~JMedia2HTTPService() {
		JNIEnv *env = JavaVMHelper::getJNIEnv();
		env->DeleteGlobalRef(mMedia2HTTPServiceObj);
		}

		sp<MediaHTTPConnection> JMedia2HTTPService::makeHTTPConnection() {
		JNIEnv* env = JavaVMHelper::getJNIEnv();
		jobject media2HTTPConnectionObj =
		env->CallObjectMethod(mMedia2HTTPServiceObj, mMakeHTTPConnectionMethod);

		return new JMedia2HTTPConnection(env, media2HTTPConnectionObj);
		}

		} // namespace android

media/jni/android_media_Media2HTTPService.h

deleted100644 → 0

+0 −45

Original line number	Diff line number	Diff line
		/*
		* Copyright 2017, 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_MEDIA2HTTPSERVICE_H_
		#define _ANDROID_MEDIA_MEDIA2HTTPSERVICE_H_

		#include "jni.h"

		#include <media/MediaHTTPService.h>
		#include <media/stagefright/foundation/ABase.h>

		namespace android {

		struct JMedia2HTTPService : public MediaHTTPService {
		JMedia2HTTPService(JNIEnv *env, jobject thiz);

		virtual sp<MediaHTTPConnection> makeHTTPConnection() override;

		protected:
		virtual ~JMedia2HTTPService();

		private:
		jobject mMedia2HTTPServiceObj;

		jmethodID mMakeHTTPConnectionMethod;

		DISALLOW_EVIL_CONSTRUCTORS(JMedia2HTTPService);
		};

		} // namespace android

		#endif // _ANDROID_MEDIA_MEDIA2HTTPSERVICE_H_