Introducción de esta sección:

En la sección anterior explicamos los 13 tipos de Drawable en Android, ¿los has aplicado a tu propio proyecto? En esta sección exploraremos algunos usos de Bitmap (mapa de bits), y antes de comenzar con el contenido, primero distinguamos los conceptos de algunos términos:

  • Drawable: Objeto gráfico general, utilizado para cargar imágenes en formatos comunes, ya sean imágenes como PNG, JPG, o los objetos visuales de los 13 tipos de Drawable aprendidos anteriormente. Podemos entenderlo como un —marco!
  • Bitmap (mapa de bits): Podemos considerarlo como uncaballete, primero colocamos la pintura sobre él, y luego podemos realizar algunos procesamientos, como obtener información del archivo de imagen, rotar, recortar, ampliar o reducir, etc.
  • Canvas (lienzo): Como su nombre indica,lienzo, podemos pintar (dibujar) sobre él; ya sea conPaint (pincel), para dibujar varias formas o escribir, o también conPath (trayectoria)para dibujar varios puntos y luego conectarlos formando varias figuras.
  • Matrix (matriz): Se utiliza para el procesamiento de efectos gráficos, la matriz de color (ColorMatrix), y también se usa Matrix para la traslación, el escalado, la rotación y la inclinación de imágenes, etc.

Y todos los anteriores son las clases gráficas de bajo nivel en Android:android.graphicslas interfaces que nos proporcionan. Bueno, no hablemos más y comencemos con el contenido de esta sección. PD: Documentación oficial:Bitmap


1. Conocer Bitmap, BitmapFactory, BitmapFacotry.Options

Como dice el título, originalmente podría explicar directamente la relación entre estas tres cosas, pero quiero sertsundere, ¡y quiero ver el código!Si abres el código fuente de la clase Bitmap, verás un fragmento así en su método constructor:

Lo que probablemente quiere decir es: el constructor de Bitmap es privado, no se puede instanciar desde fuera, solo se puede instanciar a través de JNI. Por supuesto, también nos proporcionará una interfaz para crear Bitmap, y esa clase de interfaz es:BitmapFactory¡Vamos, vamos! Abre la clase BitmapFactory; haz clic en Structure a la izquierda y verás que BitmapFactory nos proporciona estos métodos, la mayoría son decodeXxx, que crean Bitmap de diversas formas.

Luego descubrimos que cada método tiene un parámetro de tipo Options; haz clic para verlo: y entonces descubrimos que esto es una clase interna estática:BitmapFacotry.Options!

Y se utiliza para configurar las opciones al decodificar. Podemos establecer los valores de algunos parámetros, por ejemplo, establecer inJustDecodeBounds como true para evitar OOM (desbordamiento de memoria). ¿Qué? ¿No sabes qué es OOM? No importa, te lo explicaré claramente en un momento. Finalmente volvamos a nuestro Bitmap. Bien, hay muchos métodos en Bitmap, no los explicaré uno por uno; elegiré algunos de los más usados para explicar. Documentación en chino:API de Android en chino (136) —— Bitmap


2. Métodos comunes de Bitmap

Métodos de instancia

  • public boolean compress(Bitmap.CompressFormat format, int quality, OutputStream stream) Comprime el mapa de bits en el OutputStream especificado; se puede entender como guardar el Bitmap en un archivo.format: Formato: PNG, JPG, etc.;quality: Calidad de compresión, 0-100; 0 indica la calidad de imagen más baja, 100 la calidad máxima (PNG es sin pérdidas e ignora el ajuste de calidad)stream: Flujo de salida. El valor de retorno indica si se ha comprimido correctamente en el flujo especificado.
  • void recycle(): Recupera el espacio de memoria ocupado por el mapa de bits y lo marca como Dead
  • boolean isRecycled(): Determina si la memoria del mapa de bits ha sido liberada
  • int getWidth(): Obtiene el ancho del mapa de bits
  • int getHeight(): Obtiene la altura del mapa de bits
  • boolean isMutable(): Indica si la imagen es modificable
  • int getScaledWidth(Canvas canvas): Obtiene el ancho de la imagen después de la conversión de densidad especificada
  • int getScaledHeight(Canvas canvas): Obtiene la altura de la imagen después de la conversión de densidad especificada

Métodos estáticos:

  • Bitmap createBitmap(Bitmap src): Con src como imagen original, genera una nueva imagen inmutable
  • Bitmap createScaledBitmap(Bitmap src, int dstWidth,int dstHeight, boolean filter): Con src como imagen original, crea una nueva imagen, especificando la altura y el ancho de la nueva imagen, así como si cambia.
  • Bitmap createBitmap(int width, int height, Config config): Crea un mapa de bits con el formato y tamaño especificados
  • Bitmap createBitmap(Bitmap source, int x, int y, int width, int height): Con source como imagen original, crea una nueva imagen, especificando las coordenadas iniciales y la altura y el ancho de la nueva imagen.
  • public static Bitmap createBitmap(Bitmap source, int x, int y, int width, int height, Matrix m, boolean filter)

BitmapFactory.OptionParámetros configurables:

  • boolean inJustDecodeBounds— Si se establece como true, no obtiene la imagen, no asigna memoria, pero devuelve la información de ancho y alto de la imagen.
  • int inSampleSize— Factor de escala de la imagen. Si se establece en 4, tanto el ancho como la altura son 1/4 de los originales, y la imagen es 1/16 de la original.
  • int outWidth— Obtiene el valor del ancho de la imagen
  • int outHeight— Obtiene el valor de la altura de la imagen
  • int inDensity— Ratio de compresión de píxeles para el mapa de bits
  • int inTargetDensity— Ratio de compresión de píxeles para el mapa de bits de destino (el mapa de bits a generar)
  • boolean inScaled— Cuando se establece como true, se realiza la compresión de imagen, de inDensity a inTargetDensity.

Bien, ya he mostrado bastante; si quieres usarlo, consulta la documentación tú mismo~


3. Obtener el Bitmap (mapa de bits)

Hay dos formas de obtener un mapa de bits de los recursos: a través de BitmapDrawable o BitmapFactory; a continuación se demuestra. Primero tenemos que obtener el

Método BitmapDrawable:

Puedes construir un objeto BitmapDrawable, por ejemplo, construyendo un BitmapDrawable a partir de un flujo:

BitmapDrawable bmpMeizi = new BitmapDrawable(getAssets().open("pic_meizi.jpg"));
Bitmap mBitmap = bmpMeizi.getBitmap();
img_bg.setImageBitmap(mBitmap);

Método BitmapFactory:

Son todos métodos estáticos; se llaman directamente y se puede obtener el mapa de bits mediante ID de recurso, ruta, archivo, flujo de datos, etc.

//通过资源ID
private Bitmap getBitmapFromResource(Resources res, int resId) {
      return BitmapFactory.decodeResource(res, resId);
}

//文件
private Bitmap getBitmapFromFile(String pathName) {
      return BitmapFactory.decodeFile(pathName);
}

//字节数组
public Bitmap Bytes2Bimap(byte[] b) {
    if (b.length != 0) {
        return BitmapFactory.decodeByteArray(b, 0, b.length);
    } else {
        return null;
    }
}

//输入流
private Bitmap getBitmapFromStream(InputStream inputStream) {
      return BitmapFactory.decodeStream(inputStream);
}

4. Obtener la información relevante de Bitmap:

Esto, en cuanto obtengamos el objeto Bitmap, podemos llamar a los métodos correspondientes para obtener los parámetros; getByteCount obtiene el tamaño, getHeight y getWidth, etc. No los escribiré aquí; ¡consulta la documentación!


5. Recortar una esquina de la imagen

A veces, puede que quieras recortar una esquina de la imagen; simplemente usa createBitmap() de Bitmap para recortarla. Los parámetros en orden son: el objeto bitmap a procesar, las coordenadas iniciales x, y, y el ancho y alto a recortar.

Bitmap bitmap1 = BitmapFactory.decodeResource(getResources(), R.mipmap.pic_meizi);
Bitmap bitmap2 = Bitmap.createBitmap(bitmap1,100,100,200,200);
img_bg = (ImageView) findViewById(R.id.img_bg);
img_bg.setImageBitmap(bitmap2);

Imagen del efecto en ejecución:

Original:

La esquina recortada:


6. Escalar el Bitmap

Aquí no usamos Matrix para el Bitmap, sino que usamos directamente el que Bitmap nos proporcionacreateScaledBitmappara implementarlo. Los parámetros en orden son: el objeto bitmap a procesar, el ancho y alto después del escalado,


7. Usar Bitmap para capturar la pantalla

Imagen del efecto en ejecución:

Código de implementación:

public class MainActivity extends AppCompatActivity {
    static ByteArrayOutputStream byteOut = null;
    private Bitmap bitmap = null;
    private Button btn_cut;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        btn_cut = (Button) findViewById(R.id.btn_cut);
        btn_cut.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                captureScreen();
            }
        });
    }

    public void captureScreen() {
        Runnable action = new Runnable() {
            @Override
            public void run() {
                final View contentView = getWindow().getDecorView();
                try{
                    Log.e("HEHE",contentView.getHeight()+":"+contentView.getWidth());
                    bitmap = Bitmap.createBitmap(contentView.getWidth(),
                            contentView.getHeight(), Bitmap.Config.ARGB_4444);
                    contentView.draw(new Canvas(bitmap));
                    ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
                    bitmap.compress(Bitmap.CompressFormat.JPEG, 100, byteOut);
                    savePic(bitmap, "sdcard/short.png");
                }catch (Exception e){e.printStackTrace();}
                finally {
                    try{
                        if (null != byteOut)
                            byteOut.close();
                        if (null != bitmap && !bitmap.isRecycled()) {
//                            bitmap.recycle();
                            bitmap = null;
                        }
                    }catch (IOException e){e.printStackTrace();}

                }
            }
        };
        try {
            action.run();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private void savePic(Bitmap b, String strFileName) {
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream(strFileName);
            if (null != fos) {
                boolean success= b.compress(Bitmap.CompressFormat.PNG, 100, fos);
                fos.flush();
                fos.close();
                if(success)
                    Toast.makeText(MainActivity.this, "截屏成功", Toast.LENGTH_SHORT).show();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Análisis del código:

El código es muy simple: la línea final View contentView = getWindow().getDecorView(); obtiene la View del nodo raíz del XML actual. Luego se establece el tamaño de la captura, se llama a contentView.draw(new Canvas(bitmap)); y listo. Después se convierte el bitmap en un flujo, se escribe en la tarjeta SD y ya está. Por supuesto, también se puede ver en el resultado que la captura solo captura el contenido de esa app. Si quieres capturar la pantalla completa, búscalo en Google~!


Resumen de esta sección:

En esta sección explicaremos el uso básico de Bitmap, BitmapFactory y su clase interna estática Options, así como BitmapDrawable. En realidad, solo necesitamos saber cómo crear un Bitmap; su extensión generalmente se logra mediante Matrix y Canvas. Con Bitmap, lo que más nos preocupa es el problema de OOM. En la próxima sección aprenderemos cómo evitar el problema de OOM en Bitmap. ¡Gracias~