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

paletas de colores android studio

Question

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

Tengo problemas para hacer esto sin crear un objeto nuevo en cada llamada de Draw. ¿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.

¿Nadie?

Answer 1

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

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

Answer 2

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 3

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

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

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.

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

• principio y final del color para la capa inferior: un LinearGradient,
• principio y final del color para 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 usar 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();

Al principio también me preocupaba la idea de crear un nuevo LinearGradient en cada actualización de animación, pero luego lancé el perfil de GPU en el dispositivo con "En pantalla como barras". Todo está bien y funcionando dentro de un margen seguro.