Cómo pintar un degradado de color en Android en un lienzo con el cambio de color?

Question

Necesito pintar el fondo de mi lienzo de un color con sombreado/degradado aplicado, pero cada llamada a un disco me gustaría potencialmente cambiar el color.

Tengo problemas para hacer esto sin crear un objeto nuevo cada llamada deDraw. ¿Alguien tiene alguna idea? Si uso drawPaint() y establezco un nuevo shader() en mi pintura, entonces he creado un nuevo objeto shader y si creo un nuevo GradientDrawable() tengo también. Quiero evitar GC.

Pensé que podría reutilizar un objeto GradientDrawable() y llamar al método .setColor(), pero esto solo restablece los datos de gradiente asociados y pinta el dibujable como ese color sólido.

¿Alguien?

Answer 1

Lamentablemente debe crear un nuevo LinearGradient cada vez. Tenga en cuenta que no tiene que usar un GradientDrawable, puede dibujar la forma usted mismo con una pintura en la que configure el sombreador.

Answer 2

Creo que lo que quieres hacer es esto. Cree un LayerDrawable y luego inserte dos Drawables en él. El primer Drawable que inserte debe tener su color configurado para el color que desea que tenga su fondo y el segundo debe ser un Gradiente configurado para ser negro y la transición de alfa 0 a alpha 255.

Para obtener más información información, consulte: http://developer.android.com/guide/topics/resources/drawable-resource.html#LayerList

Answer 3

Esta pregunta todavía es válida casi a mediados de 2017. Quería crear una transición sin problemas para los cambios de color de mi vista personalizada. Usé shaders con LinearGradients.

Mi intención era hacer una transición fluida entre el estado de mi vista y el de mi vista.

Mi caso es aún más complicado debido a la construcción y el propósito de la vista. Es un control deslizante. Entonces mi vista consiste en casi 2 capas idénticas dibujadas una encima de la segunda usando lienzo. El tercer elemento es un puntero.

Ambas capas usan LinearGradients, el puntero usa un solo color.

Resumiendo todo lo que tengo que hacer una transición entre 5 colores al mismo tiempo:

• de inicio y final de color para la capa inferior - uno LinearGradient,
• inicio y el final del color de la capa superior - segundo LinearGradient ,
• color del puntero - color normal;

La solución a esto es tener 5 ValueAnimators separados. Lo más importante es utilizar ValueAnimator.ofArgb():

private ValueAnimator frontStartColorAnimator; 
private ValueAnimator frontEndColorAnimator; 
private ValueAnimator bottomStartColorAnimator; 
private ValueAnimator bottomEndColorAnimator; 
private ValueAnimator pointerColorAnimator; 
private AnimatorSet colorsAnimatorSet; 

... 

frontStartColorAnimator = ValueAnimator.ofArgb(frontLayerStartColor, frontLayerDisabledStartColor); 
frontStartColorAnimator.setDuration(animationDuration); 
frontStartColorAnimator.setInterpolator(new LinearInterpolator()); 
frontStartColorAnimator.addUpdateListener(animation 
      -> shaderFrontLayerStartColor = (int) animation.getAnimatedValue()); 

frontEndColorAnimator = ValueAnimator.ofArgb(frontLayerEndColor, frontLayerDisabledEndColor); 
frontEndColorAnimator.setDuration(animationDuration); 
frontEndColorAnimator.setInterpolator(new LinearInterpolator()); 
frontEndColorAnimator.addUpdateListener(animation -> { 
     shaderFrontLayerEndColor = (int) animation.getAnimatedValue(); 
     frontLayerPaint.setShader(new LinearGradient(0, 0, getWidth(), 0, shaderFrontLayerStartColor, 
       shaderFrontLayerEndColor, Shader.TileMode.CLAMP)); 
    }); 

bottomStartColorAnimator = ValueAnimator.ofArgb(bottomLayerStartColor, bottomLayerDisabledStartColor); 
bottomStartColorAnimator.setDuration(animationDuration); 
bottomStartColorAnimator.setInterpolator(new LinearInterpolator()); 
bottomStartColorAnimator.addUpdateListener(animation -> 
      shaderBottomLayerStartColor = (int) animation.getAnimatedValue()); 

bottomEndColorAnimator = ValueAnimator.ofArgb(bottomLayerEndColor, bottomLayerDisabledEndColor); 
bottomEndColorAnimator.setDuration(animationDuration); 
bottomEndColorAnimator.setInterpolator(new LinearInterpolator()); 
bottomEndColorAnimator.addUpdateListener(animation -> { 
     shaderBottomLayerEndColor = (int) animation.getAnimatedValue(); 
     backLayerPaint.setShader(new LinearGradient(0, 0, 0, getHeight(), shaderBottomLayerStartColor, 
       shaderBottomLayerEndColor, Shader.TileMode.CLAMP)); 
    }); 

pointerColorAnimator = ValueAnimator.ofArgb(pointerEnabledColor, pointerDisabledColor); 
pointerColorAnimator.setDuration(animationDuration); 
pointerColorAnimator.setInterpolator(new LinearInterpolator()); 
pointerColorAnimator.addUpdateListener(animation -> { 
     pointerColor = (int) animation.getAnimatedValue(); 
     pointerPaint.setColor(pointerColor); 
    }); 

colorsAnimatorSet = new AnimatorSet(); 
colorsAnimatorSet.playTogether(frontStartColorAnimator, frontEndColorAnimator, 
      bottomStartColorAnimator, bottomEndColorAnimator, pointerColorAnimator); 

... 

colorsAnimatorSet.start(); 

También estaba preocupado al principio sobre la creación de un nuevo LinearGradient en cada actualización de la animación pero luego puse en marcha perfiles GPU en el dispositivo con "On pantalla como barras" . Todo está bien y funcionando dentro de un margen seguro.