Introducción a esta sección:

A partir de esta sección, aprenderemos algunos conocimientos básicos sobre dibujo y animación en Android, sentando las bases para la personalización en la parte avanzada. ¡Y en la primera sección, vamos a profundizar en los Drawable de Android! Android nos proporciona hasta 13 tipos de Drawable, ¡en esta sección los repasaremos uno por uno!


Notas sobre el uso de recursos Drawable

  • Los Drawable se dividen en dos tipos: uno son nuestrosrecursos de imagen normales, en Android Studio generalmente los colocamos en el directorio res/mipmap, ¡a diferencia de Eclipse anterior! Además, si cambiamos el proyecto al modo de proyecto Android, podemos simplemente soltar imágenes en el directorio mipmap, y AS las clasificará automáticamente en hdpi, xhdpi...!recursos Drawable en formato XML, generalmente los colocamos en el directorio res/drawable, como el Selector de cambio de fondo al hacer clic en un botón, que es muy común.
  • En XML, podemos establecer directamente el Drawable mediante @mipmap o @drawable. Por ejemplo: android:background = "@mipmap/iv_icon_zhu" / "@drawable/btn_back_selctor". Y en código Java, podemos obtener el recurso drawable mediante getDrawable(R.mipmap.xxx) de Resource. Si es para establecer el fondo de un control, como ImageView, podemos llamar directamente a control.getDrawale() para obtener también el objeto drawable.
  • Los nombres de los recursos drawable en Android tienen restricciones, deben ser:[a-z0-9_.](es decir, solo pueden ser letras, números yy .), y no pueden comenzar con un número; de lo contrario, la compilación reportará un error: Invalid file name: must contain only [a-z0-9.]! ¡¡¡Minúsculas!!!! ¡¡¡Minúsculas!!! ¡Minúsculas! — Lo importante se dice tres veces~

Bien, los puntos a tener en cuenta son más o menos estos. A continuación, ¡aprendamos sobre los 13 tipos de Drawable que Android nos proporciona!


1.ColorDrawable

Es el tipo de Drawable más simple. Cuando dibujamos un ColorDrawable en el Canvas (lienzo), se usa un color fijo para rellenar el Paint y luego se dibuja un área de un solo color en el lienzo.

1). Definir ColorDrawable en Java:

ColorDrawable drawable = new ColorDrawable(0xffff2200);  
txtShow.setBackground(drawable);  

2). Definir ColorDrawable en XML:

<?xml version="1.0" encoding="utf-8"?>  
<color  
    xmlns:android="http://schemas.android.com/apk/res/android"  
    android:color="#FF0000"/>  

Por supuesto, estos usos anteriores en realidad no se utilizan mucho. Más a menudo creamos un archivo color.xml en el directorio res/values, escribimos allí los valores de color que necesitamos y, cuando los necesitamos, obtenemos el valor correspondiente mediante @color, por ejemplo:

3). Crear un archivo color.xml

Por ejemplo:

<?xml version="1.0" encoding="utf-8"?>  
<resources>  
    <color name="material_grey_100">#fff5f5f5</color>
    <color name="material_grey_300">#ffe0e0e0</color>
    <color name="material_grey_50">#fffafafa</color>
    <color name="material_grey_600">#ff757575</color>
    <color name="material_grey_800">#ff424242</color>
    <color name="material_grey_850">#ff303030</color>
    <color name="material_grey_900">#ff212121</color>
</resources>

Luego, si es en un archivo XML, podemos obtener el valor de color correspondiente mediante @color/xxx. Si es en Java:

int mycolor = getResources().getColor(R.color.mycolor);    
btn.setBackgroundColor(mycolor);  

PD: Además, hay un punto a tener en cuenta: si definimos directamente un valor de color en Java, debemos agregar 0x y no podemos omitir la transparencia:

int mycolor = 0xff123456;    
btn.setBackgroundColor(mycolor); 

4). Usar colores definidos por el sistema:

Por ejemplo: BLACK (negro), BLUE (azul), CYAN (cian), GRAY (gris), GREEN (verde), RED (rojo), WRITE (blanco), YELLOW (amarillo). Uso:btn.setBackgroundColor(Color.BLUE);También se puede obtener el color del sistema y luego configurarlo:

int getcolor = Resources.getSystem().getColor(android.R.color.holo_green_light);  
btn.setBackgroundColor(getcolor);  

Uso en XML:android:background="@android:color/black"

5). Usar el método estático argb para establecer el color:

Android usa un dato de tipo int para representar el valor del color, generalmente hexadecimal, es decir, comienza con 0x. La definición del valor de color se compone de la transparencia alpha y los tres colores primarios RGB (rojo, verde, azul). Comienza con "#" y luego sigue en orden:
Transparencia - Rojo - Verde - Azul;eg:#RGB #ARGB #RRGGBB #AARRGGBB
Cada elemento se representa con un byte (8 bits), por lo que el rango de valores es de 0 a 255. En XML, al establecer un color se puede omitir la transparencia, pero si estás en código Java debes indicar explícitamente el valor de la transparencia. Si se omite, significa completamente transparente y no tendrá efecto. Por ejemplo: 0xFF0000 representa rojo, pero si se escribe directamente así, no se ve nada; en su lugar se debe escribir 0xFFFF0000. Recuerda que al establecer un valor de color en código Java, debes agregar la transparencia al principio. Ejemplo: (los parámetros son en orden: transparencia, valor de rojo, valor de verde, valor de azul)txtShow.setBackgroundColor(Color.argb(0xff, 0x00, 0x00, 0x00));


2.NiewPatchDrawable

Es la imagen .9. Antes, en la sección anterior, nosotros1.6 Cómo jugar con las imágenes .9 (NinePatch)ya os hemos explicado detalladamente cómo crear imágenes .9. ¡Android Framework utiliza un algoritmo de optimización gráfica eficiente al mostrar imágenes NinePatch! No necesitamos un procesamiento especial para lograr la adaptación automática al estirar la imagen. Además, al usar AS, hay que tener en cuenta los siguientes puntos:

  • 1. Las imágenes .9 no se pueden colocar en el directorio mipmap, sino en el directorio drawable.
  • 2. Las imágenes .9 en AS deben tener líneas negras; de lo contrario, la compilación no pasará. Esta mañana mi primo A Jun dijo en el grupo que el diseñador de su empresa le dio una imagen .9 sin líneas negras, diciendo que fue creada con cierto software, y que en Eclipse se podía usar. Sí, era una .9 sin líneas negras, ¡caray! Sin embargo, al cambiarla a AS, ¡directamente no compilaba! Siento que uno de los estándares de AS para reconocer imágenes .9 es que deben tener puntos negros o líneas negras. Además, mi primo dio una forma de eliminar las líneas negras:9patch (.9) cómo eliminar los puntos/líneas negras dibujados por uno mismoNo lo he probado en concreto; si te interesa, puedes probarlo tú mismo. Pero, ¿son realmente tan molestas las líneas negras? No tengo TOC, así que no lo creo. Además, hay otro punto: al descomprimir el APK de otros y obtener recursos .9, descubres que no tienen líneas negras, y también se producirá un error. Si quieres extraer recursos .9 con líneas negras, necesitas descompilar el APK en lugar de simplemente descomprimirlo. La descompilación ya se explicó antes, así que no entraremos en detalles aquí.

A continuación, presentamos dos cosas que no sirven de mucho:

Definir NinePatchDrawable en XML:

<!--pic9.xml-->  
<!--参数依次为:引用的.9图片,是否对位图进行抖动处理-->  
<?xml version="1.0" encoding="utf-8"?>  
<nine-patch  
    xmlns:android="http://schemas.android.com/apk/res/android"  
    android:src="@drawable/dule_pic.html"  
    android:dither="true"/>  

Usar Bitmap para envolver imágenes .9:

<!--pic9.xml-->  
<!--参数依次为:引用的.9图片,是否对位图进行抖动处理-->  
<?xml version="1.0" encoding="utf-8"?>  
<bitmap  
    xmlns:android="http://schemas.android.com/apk/res/android"  
    android:src="@drawable/dule_pic.html"  
    android:dither="true"/>

3.ShapeDrawable

Es el Drawable de formas. Define figuras geométricas básicas como rectángulos, círculos, líneas, etc. El elemento raíz es <shape../>. Hay bastantes nodos; los nodos relacionados son los siguientes:

  • ① <shape>:
  • ~ visible: Establecer si es visible
  • ~ shape: Forma, opciones: rectangle (rectángulo, incluye cuadrado), oval (óvalo, incluye círculo), line (línea), ring (anillo)
  • ~ innerRadiusRatio: Solo válido cuando shape es ring; indica la proporción del radio interior respecto al radio. Si se establece innerRadius, se ignorará.
  • ~ innerRadius: Solo válido cuando shape es ring; indica el tamaño del radio interior del anillo.
  • ~ thicknessRatio: Solo válido cuando shape es ring; indica la proporción del grosor del anillo respecto al radio.
  • ~ thickness: Solo válido cuando shape es ring; indica el grosor del anillo, es decir, la diferencia entre el radio exterior y el radio interior.
  • ~ useLevel: Solo válido cuando shape es ring; indica si se permite mostrar una parte del anillo según el level.
  • ②<size>:
  • ~ width: Ancho de la forma.
  • ~ height: Alto de la forma.
  • ③<gradient<gradient>: Se explicará más adelante con GradientDrawable.
  • ④<solid>
  • ~ color: Color de relleno del fondo. Después de configurar solid, se cubrirán todos los efectos establecidos por gradient!!!!!!
  • ⑤<stroke>
  • ~ width: Ancho del borde.
  • ~ color: Color del borde.
  • ~ dashWidth: Longitud del segmento discontinuo del borde.
  • ~ dashGap: Espaciado entre segmentos discontinuos del borde.
  • ⑥<conner>
  • ~ radius: Radio de las esquinas redondeadas, aplicable a las cuatro esquinas: superior, inferior, izquierda y derecha.
  • ~ topLeftRadius,topRightRadius,BottomLeftRadius,tBottomRightRadius: Los valores de esquina redondeada son, en orden: superior izquierda, superior derecha, inferior izquierda, inferior derecha. ¡Configúralos según sea necesario!
  • ⑦<padding>
  • left, top, right, bottm: son respectivamente los márgenes en las direcciones izquierda, superior, derecha e inferior.

Ejemplo de uso: 2.3.1 Explicación detallada de TextView (cuadro de texto)


4.GradientDrawable

Un Drawable con área de degradado. Puede lograr efectos de degradado lineal, degradado radial y degradado en barrido. Nodo principal: <gradient/>, que tiene los siguientes atributos opcionales:

  • startColor: Color inicial del degradado.
  • centerColor: Color intermedio del degradado.
  • endColor: Color final del degradado.
  • type: Tipo de degradado, opciones (linear,radial,sweep), degradado lineal(se puede configurar el ángulo del degradado), degradado radial (diverge del centro hacia afuera), degradado en barrido
  • centerX: Coordenada x del centro del degradado, con un rango de valores de 0 a 1.
  • centerY: Coordenada Y del centro del degradado, con un rango de valores de 0 a 1.
  • angle:Solo los degradados de tipo linear son válidos, representa el ángulo del degradado, debe ser múltiplo de 45.
  • gradientRadius:Solo los degradados de tipo radial y sweep son válidos; radial debe configurarse, representa el radio del efecto de degradado.
  • useLevel:Determina si se dibuja el efecto de degradado según el nivel.

:Ejemplo de código:(Demostración de los tres efectos de degradado):

:Captura de pantalla del resultado:

:Primero crea tres archivos xml de degradado en drawable:

:(Degradado lineal) gradient_linear.xml:

<?xml version="1.0" encoding="utf-8"?>
<shape
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:shape="oval" >
    <gradient
        android:angle="90"
        android:centerColor="#FFEB82"
        android:endColor="#35B2DE"
        android:startColor="#DEACAB" />

    <stroke
        android:dashGap="5dip"
        android:dashWidth="4dip"
        android:width="3dip"
        android:color="#fff" />
</shape>

:(Degradado radial) gradient_radial.xml:

<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android"
    android:innerRadius="0dip"
    android:shape="ring"
    android:thickness="70dip"
    android:useLevel="false" >

    <gradient
        android:centerColor="#FFEB82"
        android:endColor="#35B2DE"
        android:gradientRadius="70"
        android:startColor="#DEACAB"
        android:type="radial"
        android:useLevel="false" />

</shape> 

:(Degradado en mosaico) gradient_sweep.xml:

<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android"
    android:innerRadiusRatio="8"
    android:shape="ring"
    android:thicknessRatio="3"
    android:useLevel="false" >

    <gradient
        android:centerColor="#FFEB82"
        android:endColor="#35B2DE"
        android:startColor="#DEACAB"
        android:type="sweep"
        android:useLevel="false" />

</shape> 

:Llamar a los tres drawablesactivity_main.xml:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <TextView
        android:id="@+id/txtShow1"
        android:layout_width="200dp"
        android:layout_height="100dp"
        android:background="@drawable/gradient_linear" />

    <TextView
        android:id="@+id/txtShow2"
        android:layout_width="200dp"
        android:layout_height="200dp"
        android:background="@drawable/gradient_radial" />

    <TextView
        android:id="@+id/txtShow3"
        android:layout_width="100dp"
        android:layout_height="100dp"
        android:background="@drawable/gradient_sweep" />

</LinearLayout>  

:Bien, así de simple. Por supuesto, si se quieren dibujar gráficos más complejos, no basta solo con archivos XML; los efectos más complejos requieren código Java. Lo siguiente es un código fuente tomado de Internet:

:Captura de pantalla del resultado:

:Código de implementación:

MainActivity.java:

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(new SampleView(this));
    }

    private static class SampleView extends View {
        private ShapeDrawable[] mDrawables;

        private static Shader makeSweep() {
            return new SweepGradient(150, 25,
                    new int[] { 0xFFFF0000, 0xFF00FF00, 0xFF0000FF, 0xFFFF0000 },
                    null);
        }

        private static Shader makeLinear() {
            return new LinearGradient(0, 0, 50, 50,
                    new int[] { 0xFFFF0000, 0xFF00FF00, 0xFF0000FF },
                    null, Shader.TileMode.MIRROR);
        }

        private static Shader makeTiling() {
            int[] pixels = new int[] { 0xFFFF0000, 0xFF00FF00, 0xFF0000FF, 0};
            Bitmap bm = Bitmap.createBitmap(pixels, 2, 2,
                    Bitmap.Config.ARGB_8888);

            return new BitmapShader(bm, Shader.TileMode.REPEAT,
                    Shader.TileMode.REPEAT);
        }

        private static class MyShapeDrawable extends ShapeDrawable {
            private Paint mStrokePaint = new Paint(Paint.ANTI_ALIAS_FLAG);

            public MyShapeDrawable(Shape s) {
                super(s);
                mStrokePaint.setStyle(Paint.Style.STROKE);
            }

            public Paint getStrokePaint() {
                return mStrokePaint;
            }

            @Override protected void onDraw(Shape s, Canvas c, Paint p) {
                s.draw(c, p);
                s.draw(c, mStrokePaint);
            }
        }

        public SampleView(Context context) {
            super(context);
            setFocusable(true);

            float[] outerR = new float[] { 12, 12, 12, 12, 0, 0, 0, 0 };
            RectF inset = new RectF(6, 6, 6, 6);
            float[] innerR = new float[] { 12, 12, 0, 0, 12, 12, 0, 0 };

            Path path = new Path();
            path.moveTo(50, 0);
            path.lineTo(0, 50);
            path.lineTo(50, 100);
            path.lineTo(100, 50);
            path.close();

            mDrawables = new ShapeDrawable[7];
            mDrawables[0] = new ShapeDrawable(new RectShape());
            mDrawables[1] = new ShapeDrawable(new OvalShape());
            mDrawables[2] = new ShapeDrawable(new RoundRectShape(outerR, null,
                    null));
            mDrawables[3] = new ShapeDrawable(new RoundRectShape(outerR, inset,
                    null));
            mDrawables[4] = new ShapeDrawable(new RoundRectShape(outerR, inset,
                    innerR));
            mDrawables[5] = new ShapeDrawable(new PathShape(path, 100, 100));
            mDrawables[6] = new MyShapeDrawable(new ArcShape(45, -270));

            mDrawables[0].getPaint().setColor(0xFFFF0000);
            mDrawables[1].getPaint().setColor(0xFF00FF00);
            mDrawables[2].getPaint().setColor(0xFF0000FF);
            mDrawables[3].getPaint().setShader(makeSweep());
            mDrawables[4].getPaint().setShader(makeLinear());
            mDrawables[5].getPaint().setShader(makeTiling());
            mDrawables[6].getPaint().setColor(0x88FF8844);

            PathEffect pe = new DiscretePathEffect(10, 4);
            PathEffect pe2 = new CornerPathEffect(4);
            mDrawables[3].getPaint().setPathEffect(
                    new ComposePathEffect(pe2, pe));

            MyShapeDrawable msd = (MyShapeDrawable)mDrawables[6];
            msd.getStrokePaint().setStrokeWidth(4);
        }

        @Override protected void onDraw(Canvas canvas) {

            int x = 10;
            int y = 10;
            int width = 400;
            int height = 100;

            for (Drawable dr : mDrawables) {
                dr.setBounds(x, y, x + width, y + height);
                dr.draw(canvas);
                y += height + 5;
            }
        }
    }
}

:El código usa ShapeDrawable y PathEffect; el primero es un contenedor para formas comunes, incluyendo: ArcShape, OvalShape, PathShape, RectShape, RoundRectShape.
:PathEffect, por su parte, son efectos de trazo, incluyendo: CornerPathEffect, DashPathEffect y DiscretePathEffect, que permiten crear bordes de figuras complejos...
:Sobre este degradado GradoemtDrawable llegamos hasta aquí; si te interesa esta última cosa, puedes ir a:appium/android-apidemos


Resumen de esta sección:

:Bien, en esta sección aprenderemos primero ColorDrawable, NiewPatchDrawable, ShapeDrawable, GradientDrawable.
:Primero estos cuatro Drawables; claro, esto es repetir lo ya hecho, antes ya lo habíamos escrito, pero por la integridad del tutorial, decidimos escribirlo de nuevo. Además, después de terminar el tutorial básico, algunos blogs escritos anteriormente se eliminarán.