Einführung in diesen Abschnitt:

Im vorherigen Abschnitt haben wir die 13 Arten von Drawable in Android erklärt. Hast du sie in deinen eigenen Projekten angewendet? In diesem Abschnitt werden wir einige Verwendungen von Bitmap erkunden. Bevor wir beginnen, wollen wir die Konzepte einiger Begriffe unterscheiden:

  • Drawable: Ein universelles Grafikobjekt, das verwendet wird, um Bilder in gängigen Formaten zu speichern. Es kann sich um Bilder wie PNG, JPG oder die visuellen Objekte der 13 zuvor gelernten Drawable-Typen handeln! Wir können es uns als einen ... vorstellen, der verwendet wird, um ein Gemälde zu halten —Bilderrahmen!
  • Bitmap (Bitmap): Wir können es uns als eineStaffeleivorstellen, wir legen zuerst das Gemälde darauf, dann können wir einige Verarbeitungen durchführen, wie das Abrufen von Bilddateiinformationen, Drehen, Zuschneiden, Vergrößern und Verkleinern usw.
  • Canvas (Leinwand): Wie der Name schon sagt,Leinwand, wir können darauf zeichnen (malen). Du kannst entwederPaint (Pinsel), um verschiedene Formen zu zeichnen oder Text zu schreiben, oder du kannstPath (Pfad), um mehrere Punkte zu zeichnen und sie dann zu verschiedenen Formen zu verbinden!
  • Matrix (Matrix): Wird für die Verarbeitung von Grafikeffekten, Farbmatrix (ColorMatrix) und die Verwendung von Matrix zum Verschieben, Skalieren, Drehen, Verzerren von Bildern usw. verwendet.

Und alle oben genannten sind die zugrunde liegenden Grafikklassen in Android:android.graphicsDie uns bereitgestellten Schnittstellen! Okay, genug geredet, fangen wir mit diesem Abschnitt an! PS: Offizielle Dokumentation:Bitmap


1. Bitmap, BitmapFactory, BitmapFactory.Options verstehen

Wie der Titel schon sagt, könnte ich dir einfach direkt die Beziehung zwischen diesen drei Dingen sagen, aber ich möchte einfach nurtsunderesein, ich will den Code anschauen!Wenn du den Quellcode der Bitmap-Klasse öffnest, siehst du ungefähr so etwas im Konstruktor von Bitmap:

Was es im Grunde bedeutet, ist: Der Konstruktor von Bitmap ist privat, er kann nicht von außen instanziiert werden, nur über JNI! Natürlich wird es uns definitiv eine Schnittstelle zum Erstellen von Bitmap bereitstellen, und diese Schnittstellenklasse ist:BitmapFactory! Los, öffne die BitmapFactory-Klasse. Klicke links auf die Struktur, um zu sehen, dass BitmapFactory uns diese Methoden bereitstellt. Die meisten davon sind decodeXxx und erstellen Bitmap auf verschiedene Arten!

Dann entdecken wir außerdem, dass jede Methode einen Parameter vom Typ Options hat. Klicke hinein, um einen Blick darauf zu werfen: Also stellen wir fest, dass dieses Ding eine statische innere Klasse ist:BitmapFacotry.Options! Und sie wird verwendet, um Optionen beim Dekodieren festzulegen!

Wir können hier die Werte einiger Parameter festlegen, zum Beispiel inJustDecodeBounds auf true setzen, um OOM (out of memory) zu vermeiden. Was? Du kennst OOM nicht? Kein Problem, wir erklären es dir gleich genau. Zum Schluss kommen wir zurück zu unserem Bitmap! Nun, Bitmap hat ziemlich viele Methoden, also werden wir sie nicht einzeln erklären; wir werden ein paar auswählen, die häufiger verwendet werden, um sie zu erklären! Chinesische Dokumentation:Android-Chinesische API (136) —— Bitmap


2. Häufige Methoden von Bitmap

Instanzmethoden

  • public boolean compress(Bitmap.CompressFormat format, int quality, OutputStream stream) Komprimiert die Bitmap in den angegebenen OutputStream. Du kannst es dir so vorstellen, als würdest du die Bitmap in einer Datei speichern!format: Format, PNG, JPG usw.;quality: Kompressionsqualität, 0-100, 0 bedeutet die Komprimierung mit der niedrigsten Qualität, 100 ist die maximale Qualität (PNG ist verlustfrei und ignoriert die Qualitätseinstellung)stream: Ausgabestream. Der Rückgabewert gibt an, ob die Kompression in den angegebenen Stream erfolgreich war!
  • void recycle(): Gibt den vom Bitmap belegten Speicherplatz frei und markiert das Bitmap als Dead
  • boolean isRecycled(): Bestimmt, ob der Bitmap-Speicher freigegeben wurde
  • int getWidth(): Ruft die Breite des Bitmaps ab
  • int getHeight(): Ruft die Höhe des Bitmaps ab
  • boolean isMutable(): Ob das Bild veränderbar ist
  • int getScaledWidth(Canvas canvas): Ruft die Breite des Bildes nach der angegebenen Dichteumrechnung ab
  • int getScaledHeight(Canvas canvas): Ruft die Höhe des Bildes nach der angegebenen Dichteumrechnung ab

Statische Methoden:

  • Bitmap createBitmap(Bitmap src): Erstellt ein unveränderliches neues Bild, wobei src als Original verwendet wird
  • Bitmap createScaledBitmap(Bitmap src, int dstWidth, int dstHeight, boolean filter): Verwendet src als Originalbild, um ein neues Bild zu erstellen, wobei die Höhe und Breite des neuen Bildes und ob geändert werden soll angegeben werden.
  • Bitmap createBitmap(int width, int height, Config config): Erstellt ein Bitmap des angegebenen Formats und der angegebenen Größe
  • Bitmap createBitmap(Bitmap source, int x, int y, int width, int height) Verwendet source als Originalbild, um ein neues Bild zu erstellen, wobei die Startkoordinaten sowie die Höhe und Breite des neuen Bildes angegeben werden.
  • public static Bitmap createBitmap(Bitmap source, int x, int y, int width, int height, Matrix m, boolean filter)

BitmapFactory.OptionEinstellbare Parameter:

  • boolean inJustDecodeBounds——Wenn auf true gesetzt, wird das Bild nicht abgerufen, kein Speicher zugewiesen, aber die Höhen- und Breiteninformationen des Bildes werden zurückgegeben.
  • int inSampleSize——Der Skalierungsfaktor des Bildes. Bei Einstellung auf 4 sind sowohl Breite als auch Höhe 1/4 des Originals, sodass das Bild 1/16 des Originals ist.
  • int outWidth——Ruft den Breitenwert des Bildes ab
  • int outHeight——Ruft den Höhenwert des Bildes ab
  • int inDensity——Das für die Bitmap verwendete Pixel-Kompressionsverhältnis
  • int inTargetDensity——Das für die Ziel-Bitmap verwendete Pixel-Kompressionsverhältnis (die zu erzeugende Bitmap)
  • boolean inScaled——Wenn auf true gesetzt, wird das Bild von inDensity auf inTargetDensity komprimiert.

Okay, genug eingefügt. Wenn du sie verwenden musst, sieh in der Dokumentation selbst nach~


3. Ein Bitmap-Bild abrufen

Es gibt zwei Möglichkeiten, eine Bitmap aus Ressourcen abzurufen: über BitmapDrawable oder BitmapFactory. Demonstrieren wir es unten: Zuerst müssen wir dies abrufen

BitmapDrawable-Methode:

Sie können ein BitmapDrawable-Objekt erstellen, zum Beispiel ein BitmapDrawable über einen Stream konstruieren:

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

BitmapFactory-Methode:

Sie sind alle statische Methoden, rufen Sie sie direkt auf. Sie können ein Bitmap über Ressourcen-ID, Pfad, Datei, Datenstrom usw. erhalten.

//通过资源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. Bitmap-bezogene Informationen abrufen:

Nun, solange wir das Bitmap-Objekt haben, können wir verwandte Methoden aufrufen, um die entsprechenden Parameter zu erhalten. getByteCount liefert die Größe, getHeight und getWidth usw. Ich werde sie hier nicht aufführen; schauen Sie sie selbst in der Dokumentation nach!


5. Eine Ecke eines Bildes ausschneiden

Manchmal möchten Sie vielleicht eine Ecke eines Bildes ausschneiden. Sie können sie einfach direkt mit createBitmap() von Bitmap ausschneiden. Die Parameter sind der Reihenfolge nach: das zu verarbeitende Bitmap-Objekt, die Startkoordinaten x, y sowie die Breite und Höhe des Ausschnitts.

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);

Effekt-Screenshot:

Originalbild:

Die ausgeschnittene Ecke:


6. Skalieren eines Bitmaps

Hier verwenden wir nicht Matrix, um das Bitmap zu verarbeiten; stattdessen verwenden wir direkt die von BitmapcreateScaledBitmapbereitgestellte Funktion, um es umzusetzen. Die Parameter sind in dieser Reihenfolge: das zu verarbeitende Bitmap-Objekt, die skalierte Breite und Höhe,


7. Verwenden von Bitmap zum Aufnehmen eines Screenshots

Effekt-Screenshot:

Implementierungscode:

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();
        }
    }
}

Codeanalyse:

Der Code ist sehr einfach. Die Zeile final View contentView = getWindow().getDecorView(); ruft die View des aktuellen XML-Wurzelknotens ab! Dann stellt man die Größe des Screenshots ein, ruft contentView.draw(new Canvas(bitmap)); auf, und das war's. Danach konvertiert man das Bitmap in einen Stream, schreibt ihn auf die SD-Karte, fertig. Natürlich, wie man am Ergebnis sieht, erfasst der Screenshot nur den Inhalt der App! Wenn du den gesamten Bildschirm erfassen möchtest, google es selbst~!


Zusammenfassung dieses Abschnitts:

Dieser Abschnitt erklärt die grundlegende Verwendung von Bitmap, BitmapFactory und seiner statischen inneren Klasse Options sowie von BitmapDrawable. Eigentlich reicht es für Bitmap aus, zu wissen, wie man es erstellt; seine Erweiterungen werden normalerweise über Matrix und Canvas implementiert. Bei Bitmap sind wir häufiger mit dem OOM-Problem befasst. Im nächsten Abschnitt lernen wir, wie man Bitmap-OOM-Probleme vermeidet! Danke~