Merge "Move files to libmedia2_jni_core" (727fed51) · Commits · e / os / android_frameworks_av

media/libmediaplayer2/Android.bp

+52 −2

Original line number	Diff line number	Diff line
		@@ -8,8 +8,6 @@ cc_library {
		name: "libmediaplayer2",

		srcs: [
		"JAudioTrack.cpp",
		"JavaVMHelper.cpp",
		"MediaPlayer2AudioOutput.cpp",
		"mediaplayer2.cpp",
		],
		@@ -84,3 +82,55 @@ cc_library {
		},
		},
		}

		cc_library {
		name: "libmedia2_jni_core",

		srcs: [
		"JavaVMHelper.cpp",
		"JAudioTrack.cpp",
		"JMedia2HTTPService.cpp",
		"JMedia2HTTPConnection.cpp",
		],

		shared_libs: [
		"android.hidl.token@1.0-utils",
		"liblog",
		"libcutils",
		"libutils",
		"libbinder",
		"libstagefright_foundation",
		"libmediaextractor",
		"libdl",
		"libaudioutils",
		"libaudioclient",
		"libnativehelper",
		],

		include_dirs: [
		"frameworks/av/media/libmedia/include",
		"frameworks/base/core/jni",
		],

		export_include_dirs: [
		"include",
		],

		cflags: [
		"-Werror",
		"-Wno-error=deprecated-declarations",
		"-Wall",
		],

		sanitize: {
		misc_undefined: [
		"unsigned-integer-overflow",
		"signed-integer-overflow",
		],
		cfi: true,
		diag: {
		cfi: true,
		},
		},

		}

media/libmediaplayer2/JMedia2HTTPConnection.cpp

0 → 100644

+180 −0

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 "JMedia2HTTPConnection"
		#include <utils/Log.h>

		#include <mediaplayer2/JavaVMHelper.h>
		#include <mediaplayer2/JMedia2HTTPConnection.h>
		#include <media/stagefright/foundation/ADebug.h>
		#include <nativehelper/ScopedLocalRef.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/libmediaplayer2/JMedia2HTTPService.cpp

0 → 100644

+60 −0

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 "JMedia2HTTPService"
		#include <utils/Log.h>

		#include <jni.h>

		#include <mediaplayer2/JavaVMHelper.h>
		#include <mediaplayer2/JMedia2HTTPService.h>
		#include <mediaplayer2/JMedia2HTTPConnection.h>
		#include <media/stagefright/foundation/ADebug.h>

		#include <nativehelper/JNIHelp.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/libmediaplayer2/include/mediaplayer2/JMedia2HTTPConnection.h

0 → 100644

+58 −0

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 _J_MEDIA2_HTTP_CONNECTION_H_
		#define _J_MEDIA2_HTTP_CONNECTION_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 // _J_MEDIA2_HTTP_CONNECTION_H_

media/libmediaplayer2/include/mediaplayer2/JMedia2HTTPService.h

0 → 100644

+47 −0

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 _J_MEDIA2_HTTP_SERVICE_H_
		#define _J_MEDIA2_HTTP_SERVICE_H_

		#include <jni.h>
		#include <utils/RefBase.h>

		#include <media/MediaHTTPService.h>
		#include <media/MediaHTTPConnection.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 // _J_MEDIA2_HTTP_SERVICE_H_