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

api/current.txt

+10 −1

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

	public class BitmapShader extends android.graphics.Shader {		public class BitmapShader extends android.graphics.Shader {
	ctor public BitmapShader(android.graphics.Bitmap, android.graphics.Shader.TileMode, android.graphics.Shader.TileMode);		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 {		public class BlurMaskFilter extends android.graphics.MaskFilter {
	@@ -12905,6 +12906,8 @@ package android.graphics {
	public class ComposeShader extends android.graphics.Shader {		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.Xfermode);
	ctor public ComposeShader(android.graphics.Shader, android.graphics.Shader, android.graphics.PorterDuff.Mode);		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 {		public class CornerPathEffect extends android.graphics.PathEffect {
	@@ -12980,6 +12983,8 @@ package android.graphics {
	public class LinearGradient extends android.graphics.Shader {		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[], float[], android.graphics.Shader.TileMode);
	ctor public LinearGradient(float, float, float, float, int, int, 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 {		public class MaskFilter {
	@@ -13498,6 +13503,8 @@ package android.graphics {
	public class RadialGradient extends android.graphics.Shader {		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[], float[], android.graphics.Shader.TileMode);
	ctor public RadialGradient(float, float, float, int, int, 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 {		public final class Rect implements android.os.Parcelable {
	@@ -13637,7 +13644,7 @@ package android.graphics {
	}		}

	public class Shader {		public class Shader {
	ctor public Shader();		ctor public deprecated Shader();
	method public boolean getLocalMatrix(android.graphics.Matrix);		method public boolean getLocalMatrix(android.graphics.Matrix);
	method public void setLocalMatrix(android.graphics.Matrix);		method public void setLocalMatrix(android.graphics.Matrix);
	}		}
	@@ -13682,6 +13689,8 @@ package android.graphics {
	public class SweepGradient extends android.graphics.Shader {		public class SweepGradient extends android.graphics.Shader {
	ctor public SweepGradient(float, float, int[], float[]);		ctor public SweepGradient(float, float, int[], float[]);
	ctor public SweepGradient(float, float, int, int);		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 {		public class Typeface {

api/system-current.txt

+10 −1

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

	public class BitmapShader extends android.graphics.Shader {		public class BitmapShader extends android.graphics.Shader {
	ctor public BitmapShader(android.graphics.Bitmap, android.graphics.Shader.TileMode, android.graphics.Shader.TileMode);		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 {		public class BlurMaskFilter extends android.graphics.MaskFilter {
	@@ -13641,6 +13642,8 @@ package android.graphics {
	public class ComposeShader extends android.graphics.Shader {		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.Xfermode);
	ctor public ComposeShader(android.graphics.Shader, android.graphics.Shader, android.graphics.PorterDuff.Mode);		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 {		public class CornerPathEffect extends android.graphics.PathEffect {
	@@ -13716,6 +13719,8 @@ package android.graphics {
	public class LinearGradient extends android.graphics.Shader {		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[], float[], android.graphics.Shader.TileMode);
	ctor public LinearGradient(float, float, float, float, int, int, 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 {		public class MaskFilter {
	@@ -14234,6 +14239,8 @@ package android.graphics {
	public class RadialGradient extends android.graphics.Shader {		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[], float[], android.graphics.Shader.TileMode);
	ctor public RadialGradient(float, float, float, int, int, 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 {		public final class Rect implements android.os.Parcelable {
	@@ -14373,7 +14380,7 @@ package android.graphics {
	}		}

	public class Shader {		public class Shader {
	ctor public Shader();		ctor public deprecated Shader();
	method public boolean getLocalMatrix(android.graphics.Matrix);		method public boolean getLocalMatrix(android.graphics.Matrix);
	method public void setLocalMatrix(android.graphics.Matrix);		method public void setLocalMatrix(android.graphics.Matrix);
	}		}
	@@ -14418,6 +14425,8 @@ package android.graphics {
	public class SweepGradient extends android.graphics.Shader {		public class SweepGradient extends android.graphics.Shader {
	ctor public SweepGradient(float, float, int[], float[]);		ctor public SweepGradient(float, float, int[], float[]);
	ctor public SweepGradient(float, float, int, int);		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 {		public class Typeface {

api/test-current.txt

+10 −1

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

	public class BitmapShader extends android.graphics.Shader {		public class BitmapShader extends android.graphics.Shader {
	ctor public BitmapShader(android.graphics.Bitmap, android.graphics.Shader.TileMode, android.graphics.Shader.TileMode);		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 {		public class BlurMaskFilter extends android.graphics.MaskFilter {
	@@ -12943,6 +12944,8 @@ package android.graphics {
	public class ComposeShader extends android.graphics.Shader {		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.Xfermode);
	ctor public ComposeShader(android.graphics.Shader, android.graphics.Shader, android.graphics.PorterDuff.Mode);		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 {		public class CornerPathEffect extends android.graphics.PathEffect {
	@@ -13018,6 +13021,8 @@ package android.graphics {
	public class LinearGradient extends android.graphics.Shader {		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[], float[], android.graphics.Shader.TileMode);
	ctor public LinearGradient(float, float, float, float, int, int, 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 {		public class MaskFilter {
	@@ -13536,6 +13541,8 @@ package android.graphics {
	public class RadialGradient extends android.graphics.Shader {		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[], float[], android.graphics.Shader.TileMode);
	ctor public RadialGradient(float, float, float, int, int, 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 {		public final class Rect implements android.os.Parcelable {
	@@ -13675,7 +13682,7 @@ package android.graphics {
	}		}

	public class Shader {		public class Shader {
	ctor public Shader();		ctor public deprecated Shader();
	method public boolean getLocalMatrix(android.graphics.Matrix);		method public boolean getLocalMatrix(android.graphics.Matrix);
	method public void setLocalMatrix(android.graphics.Matrix);		method public void setLocalMatrix(android.graphics.Matrix);
	}		}
	@@ -13720,6 +13727,8 @@ package android.graphics {
	public class SweepGradient extends android.graphics.Shader {		public class SweepGradient extends android.graphics.Shader {
	ctor public SweepGradient(float, float, int[], float[]);		ctor public SweepGradient(float, float, int[], float[]);
	ctor public SweepGradient(float, float, int, int);		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 {		public class Typeface {

core/jni/android/graphics/Shader.cpp

+55 −80

Original line number	Original line	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);		SkShader* shader = reinterpret_cast<SkShader*>(shaderHandle);
	SkSafeUnref(shader);		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,		static jlong BitmapShader_constructor(JNIEnv* env, jobject o, jlong matrixPtr, jobject jbitmap,
	jint tileModeX, jint tileModeY)		jint tileModeX, jint tileModeY) {
	{		const SkMatrix* matrix = reinterpret_cast<const SkMatrix*>(matrixPtr);
	SkBitmap bitmap;		SkBitmap bitmap;
	if (jbitmap) {		if (jbitmap) {
	// Only pass a valid SkBitmap object to the constructor if the Bitmap exists. Otherwise,		// 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<SkImage> image = SkMakeImageFromRasterBitmap(bitmap, kNever_SkCopyPixelsMode);
	sk_sp<SkShader> shader = image->makeShader((SkShader::TileMode)tileModeX,		sk_sp<SkShader> shader = image->makeShader(
	(SkShader::TileMode)tileModeY);		(SkShader::TileMode)tileModeX, (SkShader::TileMode)tileModeY, matrix);

	ThrowIAE_IfNull(env, shader.get());		ThrowIAE_IfNull(env, shader.get());
	return reinterpret_cast<jlong>(shader.release());		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,		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];		SkPoint pts[2];
	pts[0].set(x0, y0);		pts[0].set(x0, y0);
	pts[1].set(x1, y1);		pts[1].set(x1, y1);
	@@ -126,17 +89,17 @@ static jlong LinearGradient_create1(JNIEnv* env, jobject o,

	SkShader* shader = SkGradientShader::MakeLinear(pts,		SkShader* shader = SkGradientShader::MakeLinear(pts,
	reinterpret_cast<const SkColor*>(colorValues), pos, count,		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);		env->ReleaseIntArrayElements(colorArray, const_cast<jint*>(colorValues), JNI_ABORT);
	ThrowIAE_IfNull(env, shader);		ThrowIAE_IfNull(env, shader);
	return reinterpret_cast<jlong>(shader);		return reinterpret_cast<jlong>(shader);
	}		}

	static jlong LinearGradient_create2(JNIEnv* env, jobject o,		static jlong LinearGradient_create2(JNIEnv* env, jobject o, jlong matrixPtr,
	jfloat x0, jfloat y0, jfloat x1, jfloat y1,		jfloat x0, jfloat y0, jfloat x1, jfloat y1, jint color0, jint color1, jint tileMode) {
	jint color0, jint color1, jint tileMode)		const SkMatrix* matrix = reinterpret_cast<const SkMatrix*>(matrixPtr);
	{
	SkPoint pts[2];		SkPoint pts[2];
	pts[0].set(x0, y0);		pts[0].set(x0, y0);
	pts[1].set(x1, y1);		pts[1].set(x1, y1);
	@@ -145,7 +108,8 @@ static jlong LinearGradient_create2(JNIEnv* env, jobject o,
	colors[0] = color0;		colors[0] = color0;
	colors[1] = color1;		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);		ThrowIAE_IfNull(env, s);
	return reinterpret_cast<jlong>(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,		static jlong RadialGradient_create1(JNIEnv* env, jobject, jlong matrixPtr, jfloat x, jfloat y,
	jintArray colorArray, jfloatArray posArray, jint tileMode) {		jfloat radius, jintArray colorArray, jfloatArray posArray, jint tileMode) {
			const SkMatrix* matrix = reinterpret_cast<const SkMatrix*>(matrixPtr);
	SkPoint center;		SkPoint center;
	center.set(x, y);		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,		SkShader* shader = SkGradientShader::MakeRadial(center, radius,
	reinterpret_cast<const SkColor*>(colorValues), pos, count,		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),		env->ReleaseIntArrayElements(colorArray, const_cast<jint*>(colorValues),
	JNI_ABORT);		JNI_ABORT);

	@@ -178,8 +143,9 @@ static jlong RadialGradient_create1(JNIEnv* env, jobject, jfloat x, jfloat y, jf
	return reinterpret_cast<jlong>(shader);		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) {		jint color0, jint color1, jint tileMode) {
			const SkMatrix* matrix = reinterpret_cast<const SkMatrix*>(matrixPtr);
	SkPoint center;		SkPoint center;
	center.set(x, y);		center.set(x, y);

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

	SkShader* s = SkGradientShader::MakeRadial(center, radius, colors, NULL, 2,		SkShader* s = SkGradientShader::MakeRadial(center, radius, colors, NULL, 2,
	(SkShader::TileMode)tileMode).release();		(SkShader::TileMode)tileMode, /* flags */ 0, matrix).release();
	ThrowIAE_IfNull(env, s);		ThrowIAE_IfNull(env, s);
	return reinterpret_cast<jlong>(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) {		jintArray jcolors, jfloatArray jpositions) {
			const SkMatrix* matrix = reinterpret_cast<const SkMatrix*>(matrixPtr);
	size_t count = env->GetArrayLength(jcolors);		size_t count = env->GetArrayLength(jcolors);
	const jint* colors = env->GetIntArrayElements(jcolors, NULL);		const jint* colors = env->GetIntArrayElements(jcolors, NULL);

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

	SkShader* shader = SkGradientShader::MakeSweep(x, y,		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),		env->ReleaseIntArrayElements(jcolors, const_cast<jint*>(colors),
	JNI_ABORT);		JNI_ABORT);
	ThrowIAE_IfNull(env, shader);		ThrowIAE_IfNull(env, shader);
	return reinterpret_cast<jlong>(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) {		int color0, int color1) {
			const SkMatrix* matrix = reinterpret_cast<const SkMatrix*>(matrixPtr);
	SkColor colors[2];		SkColor colors[2];
	colors[0] = color0;		colors[0] = color0;
	colors[1] = color1;		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);		ThrowIAE_IfNull(env, s);
	return reinterpret_cast<jlong>(s);		return reinterpret_cast<jlong>(s);
	}		}

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

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

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

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

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

	static const JNINativeMethod gBitmapShaderMethods[] = {		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[] = {		static const JNINativeMethod gLinearGradientMethods[] = {
	{ "nativeCreate1", "(FFFF[I[FI)J", (void*)LinearGradient_create1 },		{ "nativeCreate1", "(JFFFF[I[FI)J", (void*)LinearGradient_create1 },
	{ "nativeCreate2", "(FFFFIII)J", (void*)LinearGradient_create2 },		{ "nativeCreate2", "(JFFFFIII)J", (void*)LinearGradient_create2 },
	};		};

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

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

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

	int register_android_graphics_Shader(JNIEnv* env)		int register_android_graphics_Shader(JNIEnv* env)

graphics/java/android/graphics/BitmapShader.java

+43 −10

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

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

	/**		/**
	* Call this to create a new shader that will draw with a bitmap.		* 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 tileX The tiling mode for x to draw the bitmap in.
	* @param tileY The tiling mode for y 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;		mBitmap = bitmap;
	mTileX = tileX;		mTileX = tileX;
	mTileY = tileY;		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;		return copy;
	}		}

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