more splitting of Surface/SurfaceControl. Surface.java is now implemented in... (17f638b3) · Commits · e / os / android_frameworks_base

core/java/android/view/Surface.java

+3 −1

Original line number	Original line	Diff line number	Diff line
	@@ -127,6 +127,8 @@ public class Surface implements Parcelable {
	@SuppressWarnings("unused")		@SuppressWarnings("unused")
	private int mSurface;		private int mSurface;
	@SuppressWarnings("unused")		@SuppressWarnings("unused")
			private int mSurfaceControl;
			@SuppressWarnings("unused")
	private int mSaveCount;		private int mSaveCount;
	@SuppressWarnings("unused")		@SuppressWarnings("unused")
	private Canvas mCanvas;		private Canvas mCanvas;
	@@ -270,7 +272,7 @@ public class Surface implements Parcelable {

	@Override		@Override
	public String toString() {		public String toString() {
	return "Surface(native-token=" + mSurface + ")";		return "Surface(native-token=" + mSurfaceControl + ")";
	}		}

	private Surface(Parcel source) throws OutOfResourcesException {		private Surface(Parcel source) throws OutOfResourcesException {

core/jni/android_view_Surface.cpp

+118 −92

Original line number	Original line	Diff line number	Diff line
	@@ -45,6 +45,7 @@ struct sso_t {
	static sso_t sso;		static sso_t sso;

	struct so_t {		struct so_t {
			jfieldID surfaceControl;
	jfieldID surface;		jfieldID surface;
	jfieldID saveCount;		jfieldID saveCount;
	jfieldID canvas;		jfieldID canvas;
	@@ -121,6 +122,27 @@ static void SurfaceSession_kill(JNIEnv* env, jobject clazz)

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

			static sp<SurfaceControl> getSurfaceControl(JNIEnv* env, jobject clazz)
			{
			SurfaceControl* const p =
			(SurfaceControl*)env->GetIntField(clazz, so.surfaceControl);
			return sp<SurfaceControl>(p);
			}

			static void setSurfaceControl(JNIEnv* env, jobject clazz,
			const sp<SurfaceControl>& surface)
			{
			SurfaceControl* const p =
			(SurfaceControl*)env->GetIntField(clazz, so.surfaceControl);
			if (surface.get()) {
			surface->incStrong(clazz);
			}
			if (p) {
			p->decStrong(clazz);
			}
			env->SetIntField(clazz, so.surfaceControl, (int)surface.get());
			}

	static sp<Surface> getSurface(JNIEnv* env, jobject clazz)		static sp<Surface> getSurface(JNIEnv* env, jobject clazz)
	{		{
	Surface* const p = (Surface*)env->GetIntField(clazz, so.surface);		Surface* const p = (Surface*)env->GetIntField(clazz, so.surface);
	@@ -153,12 +175,12 @@ static void Surface_init(
	SurfaceComposerClient* client =		SurfaceComposerClient* client =
	(SurfaceComposerClient*)env->GetIntField(session, sso.client);		(SurfaceComposerClient*)env->GetIntField(session, sso.client);

	sp<Surface> surface(client->createSurface(pid, dpy, w, h, format, flags));		sp<SurfaceControl> surface(client->createSurface(pid, dpy, w, h, format, flags));
	if (surface == 0) {		if (surface == 0) {
	doThrow(env, OutOfResourcesException);		doThrow(env, OutOfResourcesException);
	return;		return;
	}		}
	setSurface(env, clazz, surface);		setSurfaceControl(env, clazz, surface);
	}		}

	static void Surface_initParcel(JNIEnv* env, jobject clazz, jobject argParcel)		static void Surface_initParcel(JNIEnv* env, jobject clazz, jobject argParcel)
	@@ -168,27 +190,33 @@ static void Surface_initParcel(JNIEnv* env, jobject clazz, jobject argParcel)
	doThrow(env, "java/lang/NullPointerException", NULL);		doThrow(env, "java/lang/NullPointerException", NULL);
	return;		return;
	}		}
	const sp<Surface>& rhs = Surface::readFromParcel(parcel);		sp<Surface> rhs = new Surface(*parcel);
	setSurface(env, clazz, rhs);		setSurface(env, clazz, rhs);
	}		}

	static void Surface_clear(JNIEnv* env, jobject clazz, uintptr_t *ostack)		static void Surface_clear(JNIEnv* env, jobject clazz, uintptr_t *ostack)
	{		{
	const sp<Surface>& surface = getSurface(env, clazz);		const sp<SurfaceControl>& surface(getSurfaceControl(env, clazz));
	if (Surface::isValid(surface)) {		if (SurfaceControl::isValid(surface)) {
	surface->clear();		surface->clear();
	}		}
			setSurfaceControl(env, clazz, 0);
	setSurface(env, clazz, 0);		setSurface(env, clazz, 0);
	}		}

	static void Surface_release(JNIEnv* env, jobject clazz, uintptr_t *ostack)		static void Surface_release(JNIEnv* env, jobject clazz, uintptr_t *ostack)
	{		{
			setSurfaceControl(env, clazz, 0);
	setSurface(env, clazz, 0);		setSurface(env, clazz, 0);
	}		}

	static jboolean Surface_isValid(JNIEnv* env, jobject clazz)		static jboolean Surface_isValid(JNIEnv* env, jobject clazz)
	{		{
	const sp<Surface>& surface = getSurface(env, clazz);		const sp<SurfaceControl>& surfaceControl(getSurfaceControl(env, clazz));
			if (surfaceControl != 0) {
			return SurfaceControl::isValid(surfaceControl) ? JNI_TRUE : JNI_FALSE;
			}
			const sp<Surface>& surface(getSurface(env, clazz));
	return Surface::isValid(surface) ? JNI_TRUE : JNI_FALSE;		return Surface::isValid(surface) ? JNI_TRUE : JNI_FALSE;
	}		}

	@@ -209,7 +237,7 @@ static inline SkBitmap::Config convertPixelFormat(PixelFormat format)

	static jobject Surface_lockCanvas(JNIEnv* env, jobject clazz, jobject dirtyRect)		static jobject Surface_lockCanvas(JNIEnv* env, jobject clazz, jobject dirtyRect)
	{		{
	const sp<Surface>& surface = getSurface(env, clazz);		const sp<Surface>& surface(getSurface(env, clazz));
	if (!Surface::isValid(surface))		if (!Surface::isValid(surface))
	return 0;		return 0;

	@@ -278,7 +306,7 @@ static void Surface_unlockCanvasAndPost(
	return;		return;
	}		}

	const sp<Surface>& surface = getSurface(env, clazz);		const sp<Surface>& surface(getSurface(env, clazz));
	if (!Surface::isValid(surface))		if (!Surface::isValid(surface))
	return;		return;

	@@ -345,137 +373,127 @@ static void Surface_unfreezeDisplay(
	static void Surface_setLayer(		static void Surface_setLayer(
	JNIEnv* env, jobject clazz, jint zorder)		JNIEnv* env, jobject clazz, jint zorder)
	{		{
	const sp<Surface>& surface = getSurface(env, clazz);		const sp<SurfaceControl>& surface(getSurfaceControl(env, clazz));
	if (Surface::isValid(surface)) {		if (surface == 0) return;
	if (surface->setLayer(zorder) < 0) {		status_t err = surface->setLayer(zorder);
			if (err<0 && err!=NO_INIT)
	doThrow(env, "java/lang/IllegalArgumentException", NULL);		doThrow(env, "java/lang/IllegalArgumentException", NULL);
	}		}
	}
	}

	static void Surface_setPosition(		static void Surface_setPosition(
	JNIEnv* env, jobject clazz, jint x, jint y)		JNIEnv* env, jobject clazz, jint x, jint y)
	{		{
	const sp<Surface>& surface = getSurface(env, clazz);		const sp<SurfaceControl>& surface(getSurfaceControl(env, clazz));
	if (Surface::isValid(surface)) {		if (surface == 0) return;
	if (surface->setPosition(x, y) < 0) {		status_t err = surface->setPosition(x, y);
			if (err<0 && err!=NO_INIT)
	doThrow(env, "java/lang/IllegalArgumentException", NULL);		doThrow(env, "java/lang/IllegalArgumentException", NULL);
	}		}
	}
	}

	static void Surface_setSize(		static void Surface_setSize(
	JNIEnv* env, jobject clazz, jint w, jint h)		JNIEnv* env, jobject clazz, jint w, jint h)
	{		{
	const sp<Surface>& surface = getSurface(env, clazz);		const sp<SurfaceControl>& surface(getSurfaceControl(env, clazz));
	if (Surface::isValid(surface)) {		if (surface == 0) return;
	if (surface->setSize(w, h) < 0) {		status_t err = surface->setSize(w, h);
			if (err<0 && err!=NO_INIT)
	doThrow(env, "java/lang/IllegalArgumentException", NULL);		doThrow(env, "java/lang/IllegalArgumentException", NULL);
	}		}
	}
	}

	static void Surface_hide(		static void Surface_hide(
	JNIEnv* env, jobject clazz)		JNIEnv* env, jobject clazz)
	{		{
	const sp<Surface>& surface = getSurface(env, clazz);		const sp<SurfaceControl>& surface(getSurfaceControl(env, clazz));
	if (Surface::isValid(surface)) {		if (surface == 0) return;
	if (surface->hide() < 0) {		status_t err = surface->hide();
			if (err<0 && err!=NO_INIT)
	doThrow(env, "java/lang/IllegalArgumentException", NULL);		doThrow(env, "java/lang/IllegalArgumentException", NULL);
	}		}
	}
	}

	static void Surface_show(		static void Surface_show(
	JNIEnv* env, jobject clazz)		JNIEnv* env, jobject clazz)
	{		{
	const sp<Surface>& surface = getSurface(env, clazz);		const sp<SurfaceControl>& surface(getSurfaceControl(env, clazz));
	if (Surface::isValid(surface)) {		if (surface == 0) return;
	if (surface->show() < 0) {		status_t err = surface->show();
			if (err<0 && err!=NO_INIT)
	doThrow(env, "java/lang/IllegalArgumentException", NULL);		doThrow(env, "java/lang/IllegalArgumentException", NULL);
	}		}
	}
	}

	static void Surface_freeze(		static void Surface_freeze(
	JNIEnv* env, jobject clazz)		JNIEnv* env, jobject clazz)
	{		{
	const sp<Surface>& surface = getSurface(env, clazz);		const sp<SurfaceControl>& surface(getSurfaceControl(env, clazz));
	if (Surface::isValid(surface)) {		if (surface == 0) return;
	if (surface->freeze() < 0) {		status_t err = surface->freeze();
			if (err<0 && err!=NO_INIT)
	doThrow(env, "java/lang/IllegalArgumentException", NULL);		doThrow(env, "java/lang/IllegalArgumentException", NULL);
	}		}
	}
	}

	static void Surface_unfreeze(		static void Surface_unfreeze(
	JNIEnv* env, jobject clazz)		JNIEnv* env, jobject clazz)
	{		{
	const sp<Surface>& surface = getSurface(env, clazz);		const sp<SurfaceControl>& surface(getSurfaceControl(env, clazz));
	if (Surface::isValid(surface)) {		if (surface == 0) return;
	if (surface->unfreeze() < 0) {		status_t err = surface->unfreeze();
			if (err<0 && err!=NO_INIT)
	doThrow(env, "java/lang/IllegalArgumentException", NULL);		doThrow(env, "java/lang/IllegalArgumentException", NULL);
	}		}
	}
	}

	static void Surface_setFlags(		static void Surface_setFlags(
	JNIEnv* env, jobject clazz, jint flags, jint mask)		JNIEnv* env, jobject clazz, jint flags, jint mask)
	{		{
	const sp<Surface>& surface = getSurface(env, clazz);		const sp<SurfaceControl>& surface(getSurfaceControl(env, clazz));
	if (Surface::isValid(surface)) {		if (surface == 0) return;
	if (surface->setFlags(flags, mask) < 0) {		status_t err = surface->setFlags(flags, mask);
			if (err<0 && err!=NO_INIT)
	doThrow(env, "java/lang/IllegalArgumentException", NULL);		doThrow(env, "java/lang/IllegalArgumentException", NULL);
	}		}
	}
	}

	static void Surface_setTransparentRegion(		static void Surface_setTransparentRegion(
	JNIEnv* env, jobject clazz, jobject argRegion)		JNIEnv* env, jobject clazz, jobject argRegion)
	{		{
	const sp<Surface>& surface = getSurface(env, clazz);		const sp<SurfaceControl>& surface(getSurfaceControl(env, clazz));
	if (Surface::isValid(surface)) {		if (surface == 0) return;
	SkRegion* nativeRegion = (SkRegion*)env->GetIntField(argRegion, no.native_region);		SkRegion* nativeRegion = (SkRegion*)env->GetIntField(argRegion, no.native_region);
	if (surface->setTransparentRegionHint(Region(*nativeRegion)) < 0) {		status_t err = surface->setTransparentRegionHint(Region(*nativeRegion));
			if (err<0 && err!=NO_INIT)
	doThrow(env, "java/lang/IllegalArgumentException", NULL);		doThrow(env, "java/lang/IllegalArgumentException", NULL);
	}		}
	}
	}

	static void Surface_setAlpha(		static void Surface_setAlpha(
	JNIEnv* env, jobject clazz, jfloat alpha)		JNIEnv* env, jobject clazz, jfloat alpha)
	{		{
	const sp<Surface>& surface = getSurface(env, clazz);		const sp<SurfaceControl>& surface(getSurfaceControl(env, clazz));
	if (Surface::isValid(surface)) {		if (surface == 0) return;
	if (surface->setAlpha(alpha) < 0) {		status_t err = surface->setAlpha(alpha);
			if (err<0 && err!=NO_INIT)
	doThrow(env, "java/lang/IllegalArgumentException", NULL);		doThrow(env, "java/lang/IllegalArgumentException", NULL);
	}		}
	}
	}

	static void Surface_setMatrix(		static void Surface_setMatrix(
	JNIEnv* env, jobject clazz,		JNIEnv* env, jobject clazz,
	jfloat dsdx, jfloat dtdx, jfloat dsdy, jfloat dtdy)		jfloat dsdx, jfloat dtdx, jfloat dsdy, jfloat dtdy)
	{		{
	const sp<Surface>& surface = getSurface(env, clazz);		const sp<SurfaceControl>& surface(getSurfaceControl(env, clazz));
	if (Surface::isValid(surface)) {		if (surface == 0) return;
	if (surface->setMatrix(dsdx, dtdx, dsdy, dtdy) < 0) {		status_t err = surface->setMatrix(dsdx, dtdx, dsdy, dtdy);
			if (err<0 && err!=NO_INIT)
	doThrow(env, "java/lang/IllegalArgumentException", NULL);		doThrow(env, "java/lang/IllegalArgumentException", NULL);
	}		}
	}
	}

	static void Surface_setFreezeTint(		static void Surface_setFreezeTint(
	JNIEnv* env, jobject clazz,		JNIEnv* env, jobject clazz,
	jint tint)		jint tint)
	{		{
	const sp<Surface>& surface = getSurface(env, clazz);		const sp<SurfaceControl>& surface(getSurfaceControl(env, clazz));
	if (Surface::isValid(surface)) {		if (surface == 0) return;
	if (surface->setFreezeTint(tint) < 0) {		status_t err = surface->setFreezeTint(tint);
			if (err<0 && err!=NO_INIT)
	doThrow(env, "java/lang/IllegalArgumentException", NULL);		doThrow(env, "java/lang/IllegalArgumentException", NULL);
	}		}
	}
	}		// ----------------------------------------------------------------------------

	static void Surface_copyFrom(		static void Surface_copyFrom(
	JNIEnv* env, jobject clazz, jobject other)		JNIEnv* env, jobject clazz, jobject other)
	@@ -488,16 +506,23 @@ static void Surface_copyFrom(
	return;		return;
	}		}

	const sp<Surface>& surface = getSurface(env, clazz);		/*
	const sp<Surface>& rhs = getSurface(env, other);		* This is used by the WindowManagerService just after constructing
	if (!Surface::isSameSurface(surface, rhs)) {		* a Surface and is necessary for returning the Surface reference to
			* the caller. At this point, we should only have a SurfaceControl.
			*
			*/

			const sp<SurfaceControl>& surface = getSurfaceControl(env, clazz);
			const sp<SurfaceControl>& rhs = getSurfaceControl(env, other);
			if (!SurfaceControl::isSameSurface(surface, rhs)) {
	// we reassign the surface only if it's a different one		// we reassign the surface only if it's a different one
	// otherwise we would loose our client-side state.		// otherwise we would loose our client-side state.
	setSurface(env, clazz, rhs);		setSurfaceControl(env, clazz, rhs);
			setSurface(env, clazz, rhs->getSurface());
	}		}
	}		}


	static void Surface_readFromParcel(		static void Surface_readFromParcel(
	JNIEnv* env, jobject clazz, jobject argParcel)		JNIEnv* env, jobject clazz, jobject argParcel)
	{		{
	@@ -507,9 +532,9 @@ static void Surface_readFromParcel(
	return;		return;
	}		}

	const sp<Surface>& surface = getSurface(env, clazz);		const sp<Surface>& control(getSurface(env, clazz));
	const sp<Surface>& rhs = Surface::readFromParcel(parcel);		sp<Surface> rhs = new Surface(*parcel);
	if (!Surface::isSameSurface(surface, rhs)) {		if (!Surface::isSameSurface(control, rhs)) {
	// we reassign the surface only if it's a different one		// we reassign the surface only if it's a different one
	// otherwise we would loose our client-side state.		// otherwise we would loose our client-side state.
	setSurface(env, clazz, rhs);		setSurface(env, clazz, rhs);
	@@ -527,8 +552,8 @@ static void Surface_writeToParcel(
	return;		return;
	}		}

	const sp<Surface>& surface = getSurface(env, clazz);		const sp<SurfaceControl>& control(getSurfaceControl(env, clazz));
	Surface::writeToParcel(surface, parcel);		SurfaceControl::writeSurfaceToParcel(control, parcel);
	}		}

	// ----------------------------------------------------------------------------		// ----------------------------------------------------------------------------
	@@ -580,6 +605,7 @@ static JNINativeMethod gSurfaceMethods[] = {
	void nativeClassInit(JNIEnv* env, jclass clazz)		void nativeClassInit(JNIEnv* env, jclass clazz)
	{		{
	so.surface = env->GetFieldID(clazz, "mSurface", "I");		so.surface = env->GetFieldID(clazz, "mSurface", "I");
			so.surfaceControl = env->GetFieldID(clazz, "mSurfaceControl", "I");
	so.saveCount = env->GetFieldID(clazz, "mSaveCount", "I");		so.saveCount = env->GetFieldID(clazz, "mSaveCount", "I");
	so.canvas = env->GetFieldID(clazz, "mCanvas", "Landroid/graphics/Canvas;");		so.canvas = env->GetFieldID(clazz, "mCanvas", "Landroid/graphics/Canvas;");

include/ui/Surface.h

+44 −51

Original line number	Original line	Diff line number	Diff line
	@@ -75,13 +75,19 @@ private:
	};		};

	// ---------------------------------------------------------------------------		// ---------------------------------------------------------------------------
			class Surface;

	class SurfaceControl : public RefBase		class SurfaceControl : public RefBase
	{		{
	public:		public:
	static bool isValid(const sp<SurfaceControl>& surface) {		static bool isValid(const sp<SurfaceControl>& surface) {
	return (surface != 0) && surface->mToken>=0 && surface->mClient!=0;		return (surface != 0) && surface->isValid();
	}		}
			bool isValid() {
			return mToken>=0 && mClient!=0;
			}
			static bool isSameSurface(
			const sp<SurfaceControl>& lhs, const sp<SurfaceControl>& rhs);

	SurfaceID ID() const { return mToken; }		SurfaceID ID() const { return mToken; }
	uint32_t getFlags() const { return mFlags; }		uint32_t getFlags() const { return mFlags; }
	@@ -90,10 +96,6 @@ public:
	// release surface data from java		// release surface data from java
	void clear();		void clear();

	static sp<SurfaceControl> readFromParcel(Parcel* parcel);
	static status_t writeToParcel(const sp<SurfaceControl>& surface, Parcel* parcel);
	static bool isSameSurface(const sp<SurfaceControl>& lhs, const sp<SurfaceControl>& rhs);

	status_t setLayer(int32_t layer);		status_t setLayer(int32_t layer);
	status_t setPosition(int32_t x, int32_t y);		status_t setPosition(int32_t x, int32_t y);
	status_t setSize(uint32_t w, uint32_t h);		status_t setSize(uint32_t w, uint32_t h);
	@@ -107,7 +109,17 @@ public:
	status_t setMatrix(float dsdx, float dtdx, float dsdy, float dtdy);		status_t setMatrix(float dsdx, float dtdx, float dsdy, float dtdy);
	status_t setFreezeTint(uint32_t tint);		status_t setFreezeTint(uint32_t tint);

			static status_t writeSurfaceToParcel(
			const sp<SurfaceControl>& control, Parcel* parcel);

			sp<Surface> getSurface() const;

	private:		private:
			// can't be copied
			SurfaceControl& operator = (SurfaceControl& rhs);
			SurfaceControl(const SurfaceControl& rhs);


	friend class SurfaceComposerClient;		friend class SurfaceComposerClient;

	// camera and camcorder need access to the ISurface binder interface for preview		// camera and camcorder need access to the ISurface binder interface for preview
	@@ -115,15 +127,15 @@ private:
	friend class MediaRecorder;		friend class MediaRecorder;
	// mediaplayer needs access to ISurface for display		// mediaplayer needs access to ISurface for display
	friend class MediaPlayer;		friend class MediaPlayer;
			// for testing
	friend class Test;		friend class Test;
	const sp<ISurface>& getISurface() const { return mSurface; }		const sp<ISurface>& getISurface() const { return mSurface; }

	// can't be copied
	SurfaceControl& operator = (SurfaceControl& rhs);
	SurfaceControl(const SurfaceControl& rhs);

	friend class Surface;		friend class Surface;
	SurfaceControl(const sp<SurfaceComposerClient>& client,
			SurfaceControl(
			const sp<SurfaceComposerClient>& client,
	const sp<ISurface>& surface,		const sp<ISurface>& surface,
	const ISurfaceFlingerClient::surface_data_t& data,		const ISurfaceFlingerClient::surface_data_t& data,
	uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,		uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
	@@ -142,6 +154,8 @@ private:
	uint32_t mFlags;		uint32_t mFlags;
	const bool mOwner;		const bool mOwner;
	mutable Mutex mLock;		mutable Mutex mLock;

			mutable sp<Surface> mSurfaceData;
	};		};

	// ---------------------------------------------------------------------------		// ---------------------------------------------------------------------------
	@@ -160,45 +174,40 @@ public:
	uint32_t reserved[2];		uint32_t reserved[2];
	};		};

			Surface(const Parcel& data);

	static bool isValid(const sp<Surface>& surface) {		static bool isValid(const sp<Surface>& surface) {
	return (surface != 0) && surface->mToken>=0 && surface->mClient!=0;		return (surface != 0) && surface->isValid();
	}		}
			bool isValid() {
			return mToken>=0 && mClient!=0;
			}
			static bool isSameSurface(
			const sp<Surface>& lhs, const sp<Surface>& rhs);
	SurfaceID ID() const { return mToken; }		SurfaceID ID() const { return mToken; }
			uint32_t getFlags() const { return mFlags; }
			uint32_t getIdentity() const { return mIdentity; }

	// release surface data from java
	void clear();

	status_t lock(SurfaceInfo* info, bool blocking = true);		status_t lock(SurfaceInfo* info, bool blocking = true);
	status_t lock(SurfaceInfo* info, Region* dirty, bool blocking = true);		status_t lock(SurfaceInfo* info, Region* dirty, bool blocking = true);
	status_t unlockAndPost();		status_t unlockAndPost();

	uint32_t getFlags() const { return mFlags; }

	// setSwapRectangle() is mainly used by EGL		// setSwapRectangle() is mainly used by EGL
	void setSwapRectangle(const Rect& r);		void setSwapRectangle(const Rect& r);
	const Rect& swapRectangle() const;		const Rect& swapRectangle() const;

	static sp<Surface> readFromParcel(Parcel* parcel);		private:
	static status_t writeToParcel(const sp<Surface>& surface, Parcel* parcel);		// can't be copied
	static bool isSameSurface(const sp<Surface>& lhs, const sp<Surface>& rhs);		Surface& operator = (Surface& rhs);
			Surface(const Surface& rhs);

	status_t setLayer(int32_t layer);		Surface(const sp<SurfaceControl>& control);
	status_t setPosition(int32_t x, int32_t y);		void init();
	status_t setSize(uint32_t w, uint32_t h);		~Surface();
	status_t hide();
	status_t show(int32_t layer = -1);
	status_t freeze();
	status_t unfreeze();
	status_t setFlags(uint32_t flags, uint32_t mask);
	status_t setTransparentRegionHint(const Region& transparent);
	status_t setAlpha(float alpha=1.0f);
	status_t setMatrix(float dsdx, float dtdx, float dsdy, float dtdy);
	status_t setFreezeTint(uint32_t tint);

	uint32_t getIdentity() const { return mIdentity; }
	private:
	friend class SurfaceComposerClient;		friend class SurfaceComposerClient;
			friend class SurfaceControl;

	// camera and camcorder need access to the ISurface binder interface for preview		// camera and camcorder need access to the ISurface binder interface for preview
	friend class Camera;		friend class Camera;
	@@ -210,21 +219,7 @@ private:

	status_t getBufferLocked(int index);		status_t getBufferLocked(int index);

	// can't be copied
	Surface& operator = (Surface& rhs);
	Surface(const Surface& rhs);

	Surface(const sp<SurfaceComposerClient>& client,
	const sp<ISurface>& surface,
	const ISurfaceFlingerClient::surface_data_t& data,
	uint32_t w, uint32_t h, PixelFormat format, uint32_t flags,
	bool owner = true);

	Surface(Surface const* rhs);

	~Surface();

	void destroy();

	Region dirtyRegion() const;		Region dirtyRegion() const;
	void setDirtyRegion(const Region& region) const;		void setDirtyRegion(const Region& region) const;
	@@ -262,8 +257,6 @@ private:
	mutable Rect mSwapRectangle;		mutable Rect mSwapRectangle;
	mutable uint8_t mBackbufferIndex;		mutable uint8_t mBackbufferIndex;
	mutable Mutex mSurfaceLock;		mutable Mutex mSurfaceLock;

	sp<SurfaceControl> mSurfaceControl;
	};		};

	}; // namespace android		}; // namespace android

include/ui/SurfaceComposerClient.h

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -62,7 +62,7 @@ public:
	// surface creation / destruction		// surface creation / destruction

	//! Create a surface		//! Create a surface
	sp<Surface> createSurface(		sp<SurfaceControl> createSurface(
	int pid, //!< pid of the process the surfacec is for		int pid, //!< pid of the process the surfacec is for
	DisplayID display, //!< Display to create this surface on		DisplayID display, //!< Display to create this surface on
	uint32_t w, //!< width in pixel		uint32_t w, //!< width in pixel

libs/surfaceflinger/Android.mk

+0 −1

Original line number	Original line	Diff line number	Diff line
	@@ -8,7 +8,6 @@ LOCAL_SRC_FILES:= \
	BootAnimation.cpp \		BootAnimation.cpp \
	BlurFilter.cpp.arm \		BlurFilter.cpp.arm \
	BufferAllocator.cpp \		BufferAllocator.cpp \
	CPUGauge.cpp \
	Layer.cpp \		Layer.cpp \
	LayerBase.cpp \		LayerBase.cpp \
	LayerBuffer.cpp \		LayerBuffer.cpp \