Merge "Support for shader mutation" (b20f3209) · Commits · e / os / android_frameworks_base

api/current.txt

+10 −1

Original line number	Diff line number	Diff line
		@@ -12504,6 +12504,7 @@ package android.graphics {

		public class BitmapShader extends android.graphics.Shader {
		ctor public BitmapShader(android.graphics.Bitmap, android.graphics.Shader.TileMode, android.graphics.Shader.TileMode);
		method public void set(android.graphics.Bitmap, android.graphics.Shader.TileMode, android.graphics.Shader.TileMode);
		}

		public class BlurMaskFilter extends android.graphics.MaskFilter {
		@@ -12905,6 +12906,8 @@ package android.graphics {
		public class ComposeShader extends android.graphics.Shader {
		ctor public ComposeShader(android.graphics.Shader, android.graphics.Shader, android.graphics.Xfermode);
		ctor public ComposeShader(android.graphics.Shader, android.graphics.Shader, android.graphics.PorterDuff.Mode);
		method public void set(android.graphics.Shader, android.graphics.Shader, android.graphics.Xfermode);
		method public void set(android.graphics.Shader, android.graphics.Shader, android.graphics.PorterDuff.Mode);
		}

		public class CornerPathEffect extends android.graphics.PathEffect {
		@@ -12980,6 +12983,8 @@ package android.graphics {
		public class LinearGradient extends android.graphics.Shader {
		ctor public LinearGradient(float, float, float, float, int[], float[], android.graphics.Shader.TileMode);
		ctor public LinearGradient(float, float, float, float, int, int, android.graphics.Shader.TileMode);
		method public void set(float, float, float, float, int[], float[], android.graphics.Shader.TileMode);
		method public void set(float, float, float, float, int, int, android.graphics.Shader.TileMode);
		}

		public class MaskFilter {
		@@ -13498,6 +13503,8 @@ package android.graphics {
		public class RadialGradient extends android.graphics.Shader {
		ctor public RadialGradient(float, float, float, int[], float[], android.graphics.Shader.TileMode);
		ctor public RadialGradient(float, float, float, int, int, android.graphics.Shader.TileMode);
		method public void set(float, float, float, int[], float[], android.graphics.Shader.TileMode);
		method public void set(float, float, float, int, int, android.graphics.Shader.TileMode);
		}

		public final class Rect implements android.os.Parcelable {
		@@ -13637,7 +13644,7 @@ package android.graphics {
		}

		public class Shader {
		ctor public Shader();
		ctor public deprecated Shader();
		method public boolean getLocalMatrix(android.graphics.Matrix);
		method public void setLocalMatrix(android.graphics.Matrix);
		}
		@@ -13682,6 +13689,8 @@ package android.graphics {
		public class SweepGradient extends android.graphics.Shader {
		ctor public SweepGradient(float, float, int[], float[]);
		ctor public SweepGradient(float, float, int, int);
		method public void set(float, float, int[], float[]);
		method public void set(float, float, int, int);
		}

		public class Typeface {

api/system-current.txt

+10 −1

Original line number	Diff line number	Diff line
		@@ -13240,6 +13240,7 @@ package android.graphics {

		public class BitmapShader extends android.graphics.Shader {
		ctor public BitmapShader(android.graphics.Bitmap, android.graphics.Shader.TileMode, android.graphics.Shader.TileMode);
		method public void set(android.graphics.Bitmap, android.graphics.Shader.TileMode, android.graphics.Shader.TileMode);
		}

		public class BlurMaskFilter extends android.graphics.MaskFilter {
		@@ -13641,6 +13642,8 @@ package android.graphics {
		public class ComposeShader extends android.graphics.Shader {
		ctor public ComposeShader(android.graphics.Shader, android.graphics.Shader, android.graphics.Xfermode);
		ctor public ComposeShader(android.graphics.Shader, android.graphics.Shader, android.graphics.PorterDuff.Mode);
		method public void set(android.graphics.Shader, android.graphics.Shader, android.graphics.Xfermode);
		method public void set(android.graphics.Shader, android.graphics.Shader, android.graphics.PorterDuff.Mode);
		}

		public class CornerPathEffect extends android.graphics.PathEffect {
		@@ -13716,6 +13719,8 @@ package android.graphics {
		public class LinearGradient extends android.graphics.Shader {
		ctor public LinearGradient(float, float, float, float, int[], float[], android.graphics.Shader.TileMode);
		ctor public LinearGradient(float, float, float, float, int, int, android.graphics.Shader.TileMode);
		method public void set(float, float, float, float, int[], float[], android.graphics.Shader.TileMode);
		method public void set(float, float, float, float, int, int, android.graphics.Shader.TileMode);
		}

		public class MaskFilter {
		@@ -14234,6 +14239,8 @@ package android.graphics {
		public class RadialGradient extends android.graphics.Shader {
		ctor public RadialGradient(float, float, float, int[], float[], android.graphics.Shader.TileMode);
		ctor public RadialGradient(float, float, float, int, int, android.graphics.Shader.TileMode);
		method public void set(float, float, float, int[], float[], android.graphics.Shader.TileMode);
		method public void set(float, float, float, int, int, android.graphics.Shader.TileMode);
		}

		public final class Rect implements android.os.Parcelable {
		@@ -14373,7 +14380,7 @@ package android.graphics {
		}

		public class Shader {
		ctor public Shader();
		ctor public deprecated Shader();
		method public boolean getLocalMatrix(android.graphics.Matrix);
		method public void setLocalMatrix(android.graphics.Matrix);
		}
		@@ -14418,6 +14425,8 @@ package android.graphics {
		public class SweepGradient extends android.graphics.Shader {
		ctor public SweepGradient(float, float, int[], float[]);
		ctor public SweepGradient(float, float, int, int);
		method public void set(float, float, int[], float[]);
		method public void set(float, float, int, int);
		}

		public class Typeface {

api/test-current.txt

+10 −1

Original line number	Diff line number	Diff line
		@@ -12542,6 +12542,7 @@ package android.graphics {

		public class BitmapShader extends android.graphics.Shader {
		ctor public BitmapShader(android.graphics.Bitmap, android.graphics.Shader.TileMode, android.graphics.Shader.TileMode);
		method public void set(android.graphics.Bitmap, android.graphics.Shader.TileMode, android.graphics.Shader.TileMode);
		}

		public class BlurMaskFilter extends android.graphics.MaskFilter {
		@@ -12943,6 +12944,8 @@ package android.graphics {
		public class ComposeShader extends android.graphics.Shader {
		ctor public ComposeShader(android.graphics.Shader, android.graphics.Shader, android.graphics.Xfermode);
		ctor public ComposeShader(android.graphics.Shader, android.graphics.Shader, android.graphics.PorterDuff.Mode);
		method public void set(android.graphics.Shader, android.graphics.Shader, android.graphics.Xfermode);
		method public void set(android.graphics.Shader, android.graphics.Shader, android.graphics.PorterDuff.Mode);
		}

		public class CornerPathEffect extends android.graphics.PathEffect {
		@@ -13018,6 +13021,8 @@ package android.graphics {
		public class LinearGradient extends android.graphics.Shader {
		ctor public LinearGradient(float, float, float, float, int[], float[], android.graphics.Shader.TileMode);
		ctor public LinearGradient(float, float, float, float, int, int, android.graphics.Shader.TileMode);
		method public void set(float, float, float, float, int[], float[], android.graphics.Shader.TileMode);
		method public void set(float, float, float, float, int, int, android.graphics.Shader.TileMode);
		}

		public class MaskFilter {
		@@ -13536,6 +13541,8 @@ package android.graphics {
		public class RadialGradient extends android.graphics.Shader {
		ctor public RadialGradient(float, float, float, int[], float[], android.graphics.Shader.TileMode);
		ctor public RadialGradient(float, float, float, int, int, android.graphics.Shader.TileMode);
		method public void set(float, float, float, int[], float[], android.graphics.Shader.TileMode);
		method public void set(float, float, float, int, int, android.graphics.Shader.TileMode);
		}

		public final class Rect implements android.os.Parcelable {
		@@ -13675,7 +13682,7 @@ package android.graphics {
		}

		public class Shader {
		ctor public Shader();
		ctor public deprecated Shader();
		method public boolean getLocalMatrix(android.graphics.Matrix);
		method public void setLocalMatrix(android.graphics.Matrix);
		}
		@@ -13720,6 +13727,8 @@ package android.graphics {
		public class SweepGradient extends android.graphics.Shader {
		ctor public SweepGradient(float, float, int[], float[]);
		ctor public SweepGradient(float, float, int, int);
		method public void set(float, float, int[], float[]);
		method public void set(float, float, int, int);
		}

		public class Typeface {

core/jni/android/graphics/Shader.cpp

+55 −80

Original line number	Diff line number	Diff line
		@@ -42,53 +42,16 @@ static jint Color_HSVToColor(JNIEnv* env, jobject, jint alpha, jfloatArray hsvAr

		///////////////////////////////////////////////////////////////////////////////////////////////

		static void Shader_destructor(JNIEnv* env, jobject o, jlong shaderHandle, jlong shaderWithLMHandle)
		{
		static void Shader_safeUnref(JNIEnv* env, jobject o, jlong shaderHandle) {
		SkShader* shader = reinterpret_cast<SkShader*>(shaderHandle);
		SkSafeUnref(shader);
		}

		static jlong Shader_setLocalMatrix(JNIEnv* env, jobject o, jlong shaderHandle, jlong matrixHandle)
		{
		// ensure we have a valid matrix to use
		const SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
		if (NULL == matrix) {
		matrix = &SkMatrix::I();
		}

		// The current shader will no longer need a direct reference owned by Shader.java
		// as all the data needed is contained within the newly created LocalMatrixShader.
		SkASSERT(shaderHandle);
		sk_sp<SkShader> currentShader(reinterpret_cast<SkShader*>(shaderHandle));

		// Attempt to peel off an existing proxy shader and get the proxy's matrix. If
		// the proxy existed and it's matrix equals the desired matrix then just return
		// the proxy, otherwise replace it with a new proxy containing the desired matrix.
		//
		// refAsALocalMatrixShader(): if the shader contains a proxy then it unwraps the proxy
		// returning both the underlying shader and the proxy's matrix.
		// newWithLocalMatrix(): will return a proxy shader that wraps the provided shader and
		// concats the provided local matrix with the shader's matrix.
		//
		// WARNING: This proxy replacement only behaves like a setter because the Java
		// API enforces that all local matrices are set using this call and
		// not passed to the constructor of the Shader.
		SkMatrix proxyMatrix;
		sk_sp<SkShader> baseShader = currentShader->makeAsALocalMatrixShader(&proxyMatrix);
		if (baseShader.get()) {
		if (proxyMatrix == *matrix) {
		return reinterpret_cast<jlong>(currentShader.release());
		}
		return reinterpret_cast<jlong>(baseShader->makeWithLocalMatrix(*matrix).release());
		}
		return reinterpret_cast<jlong>(currentShader->makeWithLocalMatrix(*matrix).release());
		}

		///////////////////////////////////////////////////////////////////////////////////////////////

		static jlong BitmapShader_constructor(JNIEnv* env, jobject o, jobject jbitmap,
		jint tileModeX, jint tileModeY)
		{
		static jlong BitmapShader_constructor(JNIEnv* env, jobject o, jlong matrixPtr, jobject jbitmap,
		jint tileModeX, jint tileModeY) {
		const SkMatrix* matrix = reinterpret_cast<const SkMatrix*>(matrixPtr);
		SkBitmap bitmap;
		if (jbitmap) {
		// Only pass a valid SkBitmap object to the constructor if the Bitmap exists. Otherwise,
		@@ -97,8 +60,8 @@ static jlong BitmapShader_constructor(JNIEnv* env, jobject o, jobject jbitmap,
		}

		sk_sp<SkImage> image = SkMakeImageFromRasterBitmap(bitmap, kNever_SkCopyPixelsMode);
		sk_sp<SkShader> shader = image->makeShader((SkShader::TileMode)tileModeX,
		(SkShader::TileMode)tileModeY);
		sk_sp<SkShader> shader = image->makeShader(
		(SkShader::TileMode)tileModeX, (SkShader::TileMode)tileModeY, matrix);

		ThrowIAE_IfNull(env, shader.get());
		return reinterpret_cast<jlong>(shader.release());
		@@ -106,10 +69,10 @@ static jlong BitmapShader_constructor(JNIEnv* env, jobject o, jobject jbitmap,

		///////////////////////////////////////////////////////////////////////////////////////////////

		static jlong LinearGradient_create1(JNIEnv* env, jobject o,
		static jlong LinearGradient_create1(JNIEnv* env, jobject o, jlong matrixPtr,
		jfloat x0, jfloat y0, jfloat x1, jfloat y1,
		jintArray colorArray, jfloatArray posArray, jint tileMode)
		{
		jintArray colorArray, jfloatArray posArray, jint tileMode) {
		const SkMatrix* matrix = reinterpret_cast<const SkMatrix*>(matrixPtr);
		SkPoint pts[2];
		pts[0].set(x0, y0);
		pts[1].set(x1, y1);
		@@ -126,17 +89,17 @@ static jlong LinearGradient_create1(JNIEnv* env, jobject o,

		SkShader* shader = SkGradientShader::MakeLinear(pts,
		reinterpret_cast<const SkColor*>(colorValues), pos, count,
		static_cast<SkShader::TileMode>(tileMode)).release();
		static_cast<SkShader::TileMode>(tileMode), /* flags */ 0, matrix).release();

		env->ReleaseIntArrayElements(colorArray, const_cast<jint*>(colorValues), JNI_ABORT);
		ThrowIAE_IfNull(env, shader);
		return reinterpret_cast<jlong>(shader);
		}

		static jlong LinearGradient_create2(JNIEnv* env, jobject o,
		jfloat x0, jfloat y0, jfloat x1, jfloat y1,
		jint color0, jint color1, jint tileMode)
		{
		static jlong LinearGradient_create2(JNIEnv* env, jobject o, jlong matrixPtr,
		jfloat x0, jfloat y0, jfloat x1, jfloat y1, jint color0, jint color1, jint tileMode) {
		const SkMatrix* matrix = reinterpret_cast<const SkMatrix*>(matrixPtr);

		SkPoint pts[2];
		pts[0].set(x0, y0);
		pts[1].set(x1, y1);
		@@ -145,7 +108,8 @@ static jlong LinearGradient_create2(JNIEnv* env, jobject o,
		colors[0] = color0;
		colors[1] = color1;

		SkShader* s = SkGradientShader::MakeLinear(pts, colors, NULL, 2, (SkShader::TileMode)tileMode).release();
		SkShader* s = SkGradientShader::MakeLinear(pts, colors, NULL, 2,
		(SkShader::TileMode)tileMode, /* flags */ 0, matrix).release();

		ThrowIAE_IfNull(env, s);
		return reinterpret_cast<jlong>(s);
		@@ -153,8 +117,9 @@ static jlong LinearGradient_create2(JNIEnv* env, jobject o,

		///////////////////////////////////////////////////////////////////////////////////////////////

		static jlong RadialGradient_create1(JNIEnv* env, jobject, jfloat x, jfloat y, jfloat radius,
		jintArray colorArray, jfloatArray posArray, jint tileMode) {
		static jlong RadialGradient_create1(JNIEnv* env, jobject, jlong matrixPtr, jfloat x, jfloat y,
		jfloat radius, jintArray colorArray, jfloatArray posArray, jint tileMode) {
		const SkMatrix* matrix = reinterpret_cast<const SkMatrix*>(matrixPtr);
		SkPoint center;
		center.set(x, y);

		@@ -170,7 +135,7 @@ static jlong RadialGradient_create1(JNIEnv* env, jobject, jfloat x, jfloat y, jf

		SkShader* shader = SkGradientShader::MakeRadial(center, radius,
		reinterpret_cast<const SkColor*>(colorValues), pos, count,
		static_cast<SkShader::TileMode>(tileMode)).release();
		static_cast<SkShader::TileMode>(tileMode), /* flags */ 0, matrix).release();
		env->ReleaseIntArrayElements(colorArray, const_cast<jint*>(colorValues),
		JNI_ABORT);

		@@ -178,8 +143,9 @@ static jlong RadialGradient_create1(JNIEnv* env, jobject, jfloat x, jfloat y, jf
		return reinterpret_cast<jlong>(shader);
		}

		static jlong RadialGradient_create2(JNIEnv* env, jobject, jfloat x, jfloat y, jfloat radius,
		static jlong RadialGradient_create2(JNIEnv* env, jobject, jlong matrixPtr, jfloat x, jfloat y, jfloat radius,
		jint color0, jint color1, jint tileMode) {
		const SkMatrix* matrix = reinterpret_cast<const SkMatrix*>(matrixPtr);
		SkPoint center;
		center.set(x, y);

		@@ -188,15 +154,16 @@ static jlong RadialGradient_create2(JNIEnv* env, jobject, jfloat x, jfloat y, jf
		colors[1] = color1;

		SkShader* s = SkGradientShader::MakeRadial(center, radius, colors, NULL, 2,
		(SkShader::TileMode)tileMode).release();
		(SkShader::TileMode)tileMode, /* flags */ 0, matrix).release();
		ThrowIAE_IfNull(env, s);
		return reinterpret_cast<jlong>(s);
		}

		///////////////////////////////////////////////////////////////////////////////

		static jlong SweepGradient_create1(JNIEnv* env, jobject, jfloat x, jfloat y,
		static jlong SweepGradient_create1(JNIEnv* env, jobject, jlong matrixPtr, jfloat x, jfloat y,
		jintArray jcolors, jfloatArray jpositions) {
		const SkMatrix* matrix = reinterpret_cast<const SkMatrix*>(matrixPtr);
		size_t count = env->GetArrayLength(jcolors);
		const jint* colors = env->GetIntArrayElements(jcolors, NULL);

		@@ -208,34 +175,43 @@ static jlong SweepGradient_create1(JNIEnv* env, jobject, jfloat x, jfloat y,
		#endif

		SkShader* shader = SkGradientShader::MakeSweep(x, y,
		reinterpret_cast<const SkColor*>(colors), pos, count).release();
		reinterpret_cast<const SkColor>(colors), pos, count, / flags */ 0, matrix).release();
		env->ReleaseIntArrayElements(jcolors, const_cast<jint*>(colors),
		JNI_ABORT);
		ThrowIAE_IfNull(env, shader);
		return reinterpret_cast<jlong>(shader);
		}

		static jlong SweepGradient_create2(JNIEnv* env, jobject, jfloat x, jfloat y,
		static jlong SweepGradient_create2(JNIEnv* env, jobject, jlong matrixPtr, jfloat x, jfloat y,
		int color0, int color1) {
		const SkMatrix* matrix = reinterpret_cast<const SkMatrix*>(matrixPtr);
		SkColor colors[2];
		colors[0] = color0;
		colors[1] = color1;
		SkShader* s = SkGradientShader::MakeSweep(x, y, colors, NULL, 2).release();
		SkShader* s = SkGradientShader::MakeSweep(x, y, colors, NULL, 2,
		/* flags */ 0, matrix).release();
		ThrowIAE_IfNull(env, s);
		return reinterpret_cast<jlong>(s);
		}

		///////////////////////////////////////////////////////////////////////////////////////////////

		static jlong ComposeShader_create(JNIEnv* env, jobject o,
		jlong shaderAHandle, jlong shaderBHandle, jint xfermodeHandle)
		{
		static jlong ComposeShader_create(JNIEnv* env, jobject o, jlong matrixPtr,
		jlong shaderAHandle, jlong shaderBHandle, jint xfermodeHandle) {
		const SkMatrix* matrix = reinterpret_cast<const SkMatrix*>(matrixPtr);
		SkShader* shaderA = reinterpret_cast<SkShader *>(shaderAHandle);
		SkShader* shaderB = reinterpret_cast<SkShader *>(shaderBHandle);
		SkBlendMode mode = static_cast<SkBlendMode>(xfermodeHandle);
		SkShader* shader = SkShader::MakeComposeShader(sk_ref_sp(shaderA),
		sk_ref_sp(shaderB),
		mode).release();
		sk_sp<SkShader> baseShader(SkShader::MakeComposeShader(
		sk_ref_sp(shaderA), sk_ref_sp(shaderB), mode));

		SkShader* shader;

		if (matrix) {
		shader = baseShader->makeWithLocalMatrix(*matrix).release();
		} else {
		shader = baseShader.release();
		}
		return reinterpret_cast<jlong>(shader);
		}

		@@ -247,31 +223,30 @@ static const JNINativeMethod gColorMethods[] = {
		};

		static const JNINativeMethod gShaderMethods[] = {
		{ "nativeDestructor", "(J)V", (void*)Shader_destructor },
		{ "nativeSetLocalMatrix", "(JJ)J", (void*)Shader_setLocalMatrix }
		{ "nativeSafeUnref", "(J)V", (void*)Shader_safeUnref },
		};

		static const JNINativeMethod gBitmapShaderMethods[] = {
		{ "nativeCreate", "(Landroid/graphics/Bitmap;II)J", (void*)BitmapShader_constructor },
		{ "nativeCreate", "(JLandroid/graphics/Bitmap;II)J", (void*)BitmapShader_constructor },
		};

		static const JNINativeMethod gLinearGradientMethods[] = {
		{ "nativeCreate1", "(FFFF[I[FI)J", (void*)LinearGradient_create1 },
		{ "nativeCreate2", "(FFFFIII)J", (void*)LinearGradient_create2 },
		{ "nativeCreate1", "(JFFFF[I[FI)J", (void*)LinearGradient_create1 },
		{ "nativeCreate2", "(JFFFFIII)J", (void*)LinearGradient_create2 },
		};

		static const JNINativeMethod gRadialGradientMethods[] = {
		{ "nativeCreate1", "(FFF[I[FI)J", (void*)RadialGradient_create1 },
		{ "nativeCreate2", "(FFFIII)J", (void*)RadialGradient_create2 },
		{ "nativeCreate1", "(JFFF[I[FI)J", (void*)RadialGradient_create1 },
		{ "nativeCreate2", "(JFFFIII)J", (void*)RadialGradient_create2 },
		};

		static const JNINativeMethod gSweepGradientMethods[] = {
		{ "nativeCreate1", "(FF[I[F)J", (void*)SweepGradient_create1 },
		{ "nativeCreate2", "(FFII)J", (void*)SweepGradient_create2 },
		{ "nativeCreate1", "(JFF[I[F)J", (void*)SweepGradient_create1 },
		{ "nativeCreate2", "(JFFII)J", (void*)SweepGradient_create2 },
		};

		static const JNINativeMethod gComposeShaderMethods[] = {
		{ "nativeCreate", "(JJI)J", (void*)ComposeShader_create },
		{ "nativeCreate", "(JJJI)J", (void*)ComposeShader_create },
		};

		int register_android_graphics_Shader(JNIEnv* env)

graphics/java/android/graphics/BitmapShader.java

+43 −10

Original line number	Diff line number	Diff line
		@@ -28,10 +28,10 @@ public class BitmapShader extends Shader {
		* @hide
		*/
		@SuppressWarnings({"FieldCanBeLocal", "UnusedDeclaration"})
		public final Bitmap mBitmap;
		public Bitmap mBitmap;

		private TileMode mTileX;
		private TileMode mTileY;
		private int mTileX;
		private int mTileY;

		/**
		* Call this to create a new shader that will draw with a bitmap.
		@@ -40,11 +40,44 @@ public class BitmapShader extends Shader {
		* @param tileX The tiling mode for x to draw the bitmap in.
		* @param tileY The tiling mode for y to draw the bitmap in.
		*/
		public BitmapShader(@NonNull Bitmap bitmap, TileMode tileX, TileMode tileY) {
		public BitmapShader(@NonNull Bitmap bitmap, @NonNull TileMode tileX, @NonNull TileMode tileY) {
		set(bitmap, tileX, tileY);
		}

		private BitmapShader(Bitmap bitmap, int tileX, int tileY) {
		setInternal(bitmap, tileX, tileY);
		}

		/**
		* Reinitialize the BitmapShader's Bitmap and tile modes.
		*
		* @param bitmap The bitmap to use inside the shader
		* @param tileX The tiling mode for x to draw the bitmap in.
		* @param tileY The tiling mode for y to draw the bitmap in.
		*/
		public void set(@NonNull Bitmap bitmap, @NonNull TileMode tileX, @NonNull TileMode tileY) {
		if (tileX == null \|\| tileY == null) {
		throw new IllegalArgumentException();
		}
		setInternal(bitmap, tileX.nativeInt, tileY.nativeInt);
		}

		private void setInternal(Bitmap bitmap, int tileX, int tileY) {
		if (bitmap == null) {
		throw new IllegalArgumentException("Bitmap must be non-null");
		}
		if (bitmap == mBitmap && tileX == mTileX && tileY == mTileY) {
		return;
		}
		discardNativeInstance();
		mBitmap = bitmap;
		mTileX = tileX;
		mTileY = tileY;
		init(nativeCreate(bitmap, tileX.nativeInt, tileY.nativeInt));
		}

		@Override
		long createNativeInstance(long nativeMatrix) {
		return nativeCreate(nativeMatrix, mBitmap, mTileX, mTileY);
		}

		/**
		@@ -57,6 +90,6 @@ public class BitmapShader extends Shader {
		return copy;
		}

		private static native long nativeCreate(Bitmap bitmap, int shaderTileModeX,
		int shaderTileModeY);
		private static native long nativeCreate(long nativeMatrix, Bitmap bitmap,
		int shaderTileModeX, int shaderTileModeY);
		}