Merge "Remove ParcelSurfaceTexture and update MediaPlayer" (761a6c95) · Commits · e / os / android_frameworks_base

core/jni/Android.mk

+0 −1

Original line number	Diff line number	Diff line
		@@ -104,7 +104,6 @@ LOCAL_SRC_FILES:= \
		android/graphics/NinePatchImpl.cpp \
		android/graphics/NinePatchPeeker.cpp \
		android/graphics/Paint.cpp \
		android/graphics/ParcelSurfaceTexture.cpp \
		android/graphics/Path.cpp \
		android/graphics/PathMeasure.cpp \
		android/graphics/PathEffect.cpp \

core/jni/AndroidRuntime.cpp

+0 −2

Original line number	Diff line number	Diff line
		@@ -105,7 +105,6 @@ extern int register_android_graphics_ColorFilter(JNIEnv* env);
		extern int register_android_graphics_DrawFilter(JNIEnv* env);
		extern int register_android_graphics_Matrix(JNIEnv* env);
		extern int register_android_graphics_Paint(JNIEnv* env);
		extern int register_android_graphics_ParcelSurfaceTexture(JNIEnv* env);
		extern int register_android_graphics_Path(JNIEnv* env);
		extern int register_android_graphics_PathMeasure(JNIEnv* env);
		extern int register_android_graphics_Picture(JNIEnv*);
		@@ -1125,7 +1124,6 @@ static const RegJNIRec gRegJNI[] = {
		REG_JNI(register_android_graphics_Movie),
		REG_JNI(register_android_graphics_NinePatch),
		REG_JNI(register_android_graphics_Paint),
		REG_JNI(register_android_graphics_ParcelSurfaceTexture),
		REG_JNI(register_android_graphics_Path),
		REG_JNI(register_android_graphics_PathMeasure),
		REG_JNI(register_android_graphics_PathEffect),

core/jni/android/graphics/ParcelSurfaceTexture.cpp

deleted100644 → 0

+0 −165

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2011 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_TAG "ParcelSurfaceTexture"

		#include <gui/SurfaceTextureClient.h>
		#include <surfaceflinger/Surface.h>

		#include <android_runtime/AndroidRuntime.h>
		#include <android_runtime/android_graphics_SurfaceTexture.h>
		#include <android_runtime/android_view_Surface.h>

		#include <utils/Log.h>

		#include <binder/Parcel.h>

		#include "android_util_Binder.h"
		#include "jni.h"
		#include "JNIHelp.h"

		// ----------------------------------------------------------------------------

		namespace android {

		const char* const kParcelSurfaceTextureClassPathName =
		"android/graphics/ParcelSurfaceTexture";

		struct fields_t {
		jfieldID iSurfaceTexture;
		};
		static fields_t fields;

		#define ANDROID_GRAPHICS_ISURFACETEXTURE_JNI_ID "mISurfaceTexture"

		// ----------------------------------------------------------------------------

		static void ParcelSurfaceTexture_setISurfaceTexture(
		JNIEnv* env, jobject thiz, const sp<ISurfaceTexture>& iSurfaceTexture)
		{
		ISurfaceTexture* const p =
		(ISurfaceTexture*)env->GetIntField(thiz, fields.iSurfaceTexture);
		if (iSurfaceTexture.get()) {
		iSurfaceTexture->incStrong(thiz);
		}
		if (p) {
		p->decStrong(thiz);
		}
		env->SetIntField(thiz, fields.iSurfaceTexture, (int)iSurfaceTexture.get());
		}

		sp<ISurfaceTexture> ParcelSurfaceTexture_getISurfaceTexture(
		JNIEnv* env, jobject thiz)
		{
		sp<ISurfaceTexture> iSurfaceTexture(
		(ISurfaceTexture*)env->GetIntField(thiz, fields.iSurfaceTexture));
		return iSurfaceTexture;
		}

		sp<ANativeWindow> android_ParcelSurfaceTexture_getNativeWindow(
		JNIEnv* env, jobject thiz)
		{
		sp<ISurfaceTexture> iSurfaceTexture(
		ParcelSurfaceTexture_getISurfaceTexture(env, thiz));
		sp<SurfaceTextureClient> surfaceTextureClient(iSurfaceTexture != NULL ?
		new SurfaceTextureClient(iSurfaceTexture) : NULL);
		return surfaceTextureClient;
		}

		bool android_ParcelSurfaceTexture_isInstanceOf(JNIEnv* env, jobject thiz)
		{
		jclass parcelSurfaceTextureClass = env->FindClass(
		kParcelSurfaceTextureClassPathName);
		return env->IsInstanceOf(thiz, parcelSurfaceTextureClass);
		}

		// ----------------------------------------------------------------------------

		static void ParcelSurfaceTexture_classInit(JNIEnv* env, jclass clazz)
		{
		fields.iSurfaceTexture =
		env->GetFieldID(clazz, ANDROID_GRAPHICS_ISURFACETEXTURE_JNI_ID, "I");
		if (fields.iSurfaceTexture == NULL) {
		LOGE("can't find android/graphics/ParcelSurfaceTexture.%s",
		ANDROID_GRAPHICS_ISURFACETEXTURE_JNI_ID);
		}
		}

		static void ParcelSurfaceTexture_initFromSurface(
		JNIEnv* env, jobject thiz, jobject jSurface)
		{
		sp<Surface> surface(Surface_getSurface(env, jSurface));
		sp<ISurfaceTexture> iSurfaceTexture(surface->getSurfaceTexture());
		ParcelSurfaceTexture_setISurfaceTexture(env, thiz, iSurfaceTexture);
		}

		static void ParcelSurfaceTexture_initFromSurfaceTexture(
		JNIEnv* env, jobject thiz, jobject jSurfaceTexture)
		{
		sp<ISurfaceTexture> iSurfaceTexture(
		SurfaceTexture_getSurfaceTexture(env, jSurfaceTexture));
		ParcelSurfaceTexture_setISurfaceTexture(env, thiz, iSurfaceTexture);
		}

		static void ParcelSurfaceTexture_finalize(JNIEnv* env, jobject thiz)
		{
		ParcelSurfaceTexture_setISurfaceTexture(env, thiz, 0);
		}

		static void ParcelSurfaceTexture_writeToParcel(
		JNIEnv* env, jobject thiz, jobject jParcel, jint flags)
		{
		Parcel* parcel = parcelForJavaObject(env, jParcel);
		sp<ISurfaceTexture> iSurfaceTexture(
		ParcelSurfaceTexture_getISurfaceTexture(env, thiz));
		sp<IBinder> b(iSurfaceTexture->asBinder());
		parcel->writeStrongBinder(b);
		}

		static void ParcelSurfaceTexture_readFromParcel(
		JNIEnv* env, jobject thiz, jobject jParcel)
		{
		Parcel* parcel = parcelForJavaObject(env, jParcel);
		sp<ISurfaceTexture> iSurfaceTexture(
		interface_cast<ISurfaceTexture>(parcel->readStrongBinder()));
		ParcelSurfaceTexture_setISurfaceTexture(env, thiz, iSurfaceTexture);
		}

		// ----------------------------------------------------------------------------

		static JNINativeMethod gParcelSurfaceTextureMethods[] = {
		{"nativeClassInit", "()V", (void*)ParcelSurfaceTexture_classInit },
		{"nativeInitFromSurface", "(Landroid/view/Surface;)V",
		(void *)ParcelSurfaceTexture_initFromSurface },
		{"nativeInitFromSurfaceTexture", "(Landroid/graphics/SurfaceTexture;)V",
		(void *)ParcelSurfaceTexture_initFromSurfaceTexture },
		{ "nativeFinalize", "()V", (void *)ParcelSurfaceTexture_finalize },
		{ "nativeWriteToParcel", "(Landroid/os/Parcel;I)V",
		(void *)ParcelSurfaceTexture_writeToParcel },
		{ "nativeReadFromParcel", "(Landroid/os/Parcel;)V",
		(void *)ParcelSurfaceTexture_readFromParcel },
		};


		int register_android_graphics_ParcelSurfaceTexture(JNIEnv* env)
		{
		int err = 0;
		err = AndroidRuntime::registerNativeMethods(env, kParcelSurfaceTextureClassPathName,
		gParcelSurfaceTextureMethods, NELEM(gParcelSurfaceTextureMethods));
		return err;
		}

		} // namespace android

graphics/java/android/graphics/ParcelSurfaceTexture.aidl

deleted100644 → 0

+0 −19

Original line number	Diff line number	Diff line
		/**
		* Copyright (c) 2011, 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.graphics;

		parcelable ParcelSurfaceTexture;

graphics/java/android/graphics/ParcelSurfaceTexture.java

deleted100644 → 0

+0 −118

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2011 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.graphics;

		import android.graphics.SurfaceTexture;
		import android.os.Parcel;
		import android.os.Parcelable;
		import android.view.Surface;

		/**
		*
		* @hide Pending review by API council.
		*/
		public final class ParcelSurfaceTexture implements Parcelable {
		/**
		* This field is used by native code, do not access or modify.
		*
		* @hide
		*/
		@SuppressWarnings({"UnusedDeclaration"})
		private int mISurfaceTexture;

		/**
		* Create a new ParcelSurfaceTexture from a Surface
		*
		* @param surface The Surface to create a ParcelSurfaceTexture from.
		*
		* @return Returns a new ParcelSurfaceTexture for the given Surface.
		*/
		public static ParcelSurfaceTexture fromSurface(Surface surface) {
		return new ParcelSurfaceTexture(surface);
		}

		/**
		* Create a new ParcelSurfaceTexture from a SurfaceTexture
		*
		* @param surfaceTexture The SurfaceTexture to transport.
		*
		* @return Returns a new ParcelSurfaceTexture for the given SurfaceTexture.
		*/
		public static ParcelSurfaceTexture fromSurfaceTexture(SurfaceTexture surfaceTexture) {
		return new ParcelSurfaceTexture(surfaceTexture);
		}

		/**
		* @see android.os.Parcelable#describeContents()
		*/
		@Override
		public int describeContents() {
		return 0;
		}

		/**
		* @see android.os.Parcelable#writeToParcel(android.os.Parcel, int)
		*/
		@Override
		public void writeToParcel(Parcel dest, int flags) {
		nativeWriteToParcel(dest, flags);
		}

		public static final Parcelable.Creator<ParcelSurfaceTexture> CREATOR =
		new Parcelable.Creator<ParcelSurfaceTexture>() {
		@Override
		public ParcelSurfaceTexture createFromParcel(Parcel in) {
		return new ParcelSurfaceTexture(in);
		}
		@Override
		public ParcelSurfaceTexture[] newArray(int size) {
		return new ParcelSurfaceTexture[size];
		}
		};

		private ParcelSurfaceTexture(Parcel in) {
		nativeReadFromParcel(in);
		}
		private ParcelSurfaceTexture(Surface surface) {
		nativeInitFromSurface(surface);
		}
		private ParcelSurfaceTexture(SurfaceTexture surfaceTexture) {
		nativeInitFromSurfaceTexture(surfaceTexture);
		}

		@Override
		protected void finalize() throws Throwable {
		try {
		nativeFinalize();
		} finally {
		super.finalize();
		}
		}

		private native void nativeInitFromSurface(Surface surface);
		private native void nativeInitFromSurfaceTexture(SurfaceTexture surfaceTexture);
		private native void nativeFinalize();
		private native void nativeWriteToParcel(Parcel dest, int flags);
		private native void nativeReadFromParcel(Parcel in);

		/*
		* We use a class initializer to allow the native code to cache some
		* field offsets.
		*/
		private static native void nativeClassInit();
		static { nativeClassInit(); }
		}