Diese Seite wurde von der Cloud Translation API übersetzt.

Kopieren und einfügen

Android bietet ein leistungsstarkes auf der Zwischenablage basierendes Framework zum Kopieren und Einfügen. Sie unterstützt einfache und komplexe Datentypen wie Textzeichenfolgen, komplexe Datenstrukturen, Text- und Binärstreams Daten und Anwendungs-Assets. Einfache Textdaten werden direkt in der Zwischenablage gespeichert, während komplexe -Daten werden als Referenz gespeichert, die die Einfügen-Anwendung mit einem Content-Provider auflöst. Wird kopiert und Einfügen funktioniert sowohl innerhalb einer Anwendung als auch zwischen Anwendungen, Framework.

Da in einem Teil des Frameworks Contentanbieter verwendet werden, wird davon ausgegangen, dass Sie mit die Android Content Provider API, die in Contentanbieter:

Nutzende erwarten Feedback, wenn sie Inhalte in die Zwischenablage kopieren. ermöglicht das Kopieren und Einfügen, Android zeigt Nutzern beim Kopieren unter Android 13 (API-Level 33) eine Standardbenutzeroberfläche an. und höher. Aufgrund dieser Funktion besteht die Gefahr, dass Benachrichtigungen doppelt gesendet werden. Weitere Informationen in diesem Grenzfall Doppelte Benachrichtigungen vermeiden .

Eine Animation, die die Benachrichtigung in der Zwischenablage von Android 13 zeigt — </ph> **Abbildung 1**: Benutzeroberfläche, die unter Android angezeigt wird, wenn Inhalte in die Zwischenablage eingefügt werden ab 13 Jahren.

Nutzern beim Kopieren in Android 12L (API-Level 32) und niedriger manuell Feedback geben. Weitere Informationen finden Sie unter Empfehlungen in diesem Dokument.

Das Framework für die Zwischenablage

Wenn Sie das Zwischenablage-Framework verwenden, fügen Sie Daten in ein Clip-Objekt ein und platzieren Sie dann das Clip-Objekt. in die systemweite Zwischenablage. Das Clip-Objekt kann eine von drei Formen annehmen:

Text: Eine Textzeichenfolge. Setzen Sie die Zeichenfolge direkt in das Clip-Objekt, das Sie dann auf dem Zwischenablage öffnen. Um den String einzufügen, rufen Sie das Clip-Objekt aus der Zwischenablage ab und kopieren Sie den in den Speicher Ihrer Anwendung einfügt.
URI: Ein Uri-Objekt, das eine beliebige URI-Format. Dies dient hauptsächlich zum Kopieren komplexer Daten von einem Contentanbieter. Zum Kopieren Daten ein Uri-Objekt in ein Clip-Objekt und platzieren Sie das Clip-Objekt auf dem Zwischenablage öffnen. Zum Einfügen der Daten rufen Sie das „clip“-Objekt und das Uri-Objekt ab. in eine Datenquelle aufzulösen, z. B. einen Contentanbieter, und kopieren die Daten aus dem Quelle in den Speicher Ihrer Anwendung.
Intent: Ein Intent. Dieses unterstützt das Kopieren von Anwendungsverknüpfungen. Um Daten zu kopieren, erstellen Sie eine Intent, fügen Sie in einem Clip-Objekt und platziere das Clip-Objekt in der Zwischenablage. Um die Daten einzufügen, rufen Sie das Clip-Objekt und kopieren Sie dann das Intent-Objekt in das Speicherbereich.

In der Zwischenablage ist jeweils nur ein Clipobjekt enthalten. Wenn eine Anwendung ein Clip-Objekt auf der in der Zwischenablage ist das vorherige Clip-Objekt nicht mehr sichtbar.

Wenn Sie es Nutzern ermöglichen möchten, Daten in Ihre Anwendung einzufügen, müssen Sie nicht alle Arten von Daten. Sie können die Daten in der Zwischenablage überprüfen, bevor Sie Nutzenden die Möglichkeit geben, sie einzufügen. Neben einem bestimmten Datenformular enthält das Clip-Objekt auch Metadaten, die angeben, welche MIME-Daten Typen verfügbar. Anhand dieser Metadaten kannst du entscheiden, ob deine App sinnvolle Funktionen bietet. mit den Daten aus der Zwischenablage. Wenn Sie beispielsweise eine Anwendung haben, die hauptsächlich Text verarbeitet, Clip-Objekte, die einen URI oder Intent enthalten, ignoriert werden.

Vielleicht möchten Sie Nutzern auch erlauben, Text unabhängig von der Form der Daten in der Zwischenablage einzufügen. Bis Erzwingen Sie die Daten in der Zwischenablage als Textdarstellung und fügen Sie diesen Text dann ein. Dies ist wie im Abschnitt Zwischenablage in Text erzwingen beschrieben.

Clipboard-Kurse

In diesem Abschnitt werden die Klassen beschrieben, die vom Framework für die Zwischenablage verwendet werden.

Zwischenablage-Manager

Die Zwischenablage des Android-Systems wird durch das globale Klasse ClipboardManager. Instanziieren Sie diese Klasse nicht direkt. Rufen Sie stattdessen einen Verweis darauf ab, indem Sie getSystemService(CLIPBOARD_SERVICE)

ClipData, ClipData.Item und ClipDescription

Um der Zwischenablage Daten hinzuzufügen, erstellen Sie ein ClipData-Objekt, das Folgendes enthält: eine Beschreibung der Daten und der Daten selbst. Die Zwischenablage enthält jeweils ein ClipData-Element . Ein ClipData enthält einen ClipDescription-Objekt und mindestens ClipData.Item-Objekte.

Ein ClipDescription-Objekt enthält Metadaten zum Clip. Insbesondere enthält ein Array der verfügbaren MIME-Typen für die Daten des Clips. Außerdem Ab Android 12 (API-Level 31) enthalten die Metadaten Informationen dazu, ob das Objekt enthält stilisierten Text und über die Texttyp im Objekt. Wenn Sie einen Clip in die Zwischenablage einfügen, können Sie diese Informationen in Anwendungen einfügen. ob sie die Clipdaten verarbeiten können.

Ein ClipData.Item-Objekt enthält die Text-, URI- oder Intent-Daten:

Text: Ein CharSequence.
URI: Ein Uri. Sie enthält normalerweise den URI eines Contentanbieters, auch wenn jeder URI Zulässig sind. Von der Anwendung, die die Daten bereitstellt, wird der URI in die Zwischenablage eingefügt. Anwendungen die die Daten einfügen möchten, rufen Sie den URI aus der Zwischenablage ab und greifen damit auf den Inhalt zu. Datenanbieter oder einer anderen Datenquelle abzurufen, und rufen Sie die Daten ab.
Intent: Ein Intent. Mit diesem Datentyp können Sie eine Anwendungsverknüpfung in den Zwischenablage öffnen. Nutzer können die Verknüpfung dann zur späteren Verwendung in ihre Anwendungen einfügen.

Du kannst einem Clip mehrere ClipData.Item-Objekte hinzufügen. Damit können Nutzende mehrere ausgewählte Elemente als einzelnen Clip einfügen. Wenn Sie beispielsweise ein Listen-Widget haben, mehrere Elemente gleichzeitig auswählen, können Sie alle Elemente auf einmal in die Zwischenablage kopieren. Aufgabe erstellen Sie eine separate ClipData.Item für jedes Listenelement. Fügen Sie dann ClipData.Item-Objekte für das ClipData-Objekt.

ClipData-Convenience-Methoden

Die Klasse ClipData bietet statische Convenience-Methoden zum Erstellen eines ClipData-Objekt mit einem einzelnen ClipData.Item-Objekt und einem einfachen ClipDescription-Objekt:

newPlainText(label, text): Gibt ein ClipData-Objekt zurück, dessen einzelnes ClipData.Item-Objekt enthält eine Textzeichenfolge. Das Label des ClipDescription-Objekts ist festgelegt auf label. Der einzige MIME-Typ in ClipDescription ist MIMETYPE_TEXT_PLAIN.
Verwenden Sie newPlainText(), um einen Clip aus einer Textzeichenfolge zu erstellen.
newUri(resolver, label, URI): Gibt ein ClipData-Objekt zurück, dessen einzelnes ClipData.Item-Objekt enthält einen URI. Das Label des ClipDescription-Objekts ist festgelegt auf label. Wenn es sich bei dem URI um einen Inhalts-URI handelt, Uri.getScheme() gibt content: zurück, wobei die Methode ContentResolver in resolver angegeben, um die verfügbaren MIME-Typen aus der Contentanbieter. Sie werden dann in ClipDescription gespeichert. Für einen URI, der nicht ein content:-URI ist, legt die Methode den MIME-Typ auf MIMETYPE_TEXT_URILIST.
Verwenden Sie newUri(), um einen Clip aus einem URI zu erstellen, insbesondere einem content:-URI.
newIntent(label, intent): Gibt ein ClipData-Objekt zurück, dessen einzelnes ClipData.Item-Objekt enthält ein Intent. Das Label des ClipDescription-Objekts ist festgelegt auf label. Der MIME-Typ ist festgelegt auf MIMETYPE_TEXT_INTENT
Verwende newIntent(), um einen Clip aus einem Intent-Objekt zu erstellen.

Daten aus der Zwischenablage in Text umwandeln

Auch wenn Ihre Anwendung nur Text verarbeitet, können Sie Nicht-Text-Daten aus der Zwischenablage kopieren, indem Sie mit der Funktion ClipData.Item.coerceToText() .

Diese Methode wandelt die Daten in ClipData.Item in Text um und gibt einen CharSequence. Der von ClipData.Item.coerceToText() zurückgegebene Wert basiert auf zur Form der Daten in ClipData.Item:

Text

Wenn es sich bei ClipData.Item um Text handelt, d. h. wenn getText() ist nicht null – CoerceToText() gibt den Text zurück.

URI

Wenn ClipData.Item ein URI ist, also wenn getUri() ist nicht null: coerceToText() versucht, ihn als Inhalts-URI zu verwenden.

Wenn der URI ein Inhalts-URI ist und der Anbieter einen Textstream zurückgeben kann, coerceToText() gibt einen Textstream zurück.
Wenn die URI eine Inhalts-URI ist, der Anbieter aber keinen Textstream anbietet, coerceToText() gibt eine Darstellung des URI zurück. Die Darstellung ist genauso wie die von Uri.toString()
Wenn der URI kein Inhalts-URI ist, gibt coerceToText() eine Darstellung von den URI. Die Darstellung ist die gleiche wie die von Uri.toString()

Intent

Wenn ClipData.Item eine Intent ist, d. h. wenn getIntent() nicht null ist – coerceToText() konvertiert ihn in einen Intent-URI und gibt ihn zurück. Die Darstellung ist die gleiche wie die von Intent.toUri(URI_INTENT_SCHEME)

Das Zwischenablage-Framework ist in Abbildung 2 zusammengefasst. Zum Kopieren von Daten stellt eine Anwendung ein ClipData-Objekt in der globalen Zwischenablage von ClipboardManager. Die ClipData enthält ein oder mehrere ClipData.Item-Objekte und eins ClipDescription-Objekt. Zum Einfügen von Daten erhält eine Anwendung die ClipData, erhält seinen MIME-Typ vom ClipDescription und ruft die Daten aus dem ClipData.Item oder von dem Contentanbieter, auf den verwiesen wird ClipData.Item

Ein Bild, das ein Blockdiagramm des Frameworks zum Kopieren und Einfügen zeigt — </ph> **Abbildung 2**: Das Android-Framework für die Zwischenablage

In die Zwischenablage kopieren

Um Daten in die Zwischenablage zu kopieren, rufen Sie einen Handle zum globalen ClipboardManager-Objekt ab. Erstellen Sie ein ClipData-Objekt und fügen Sie ein ClipDescription sowie mindestens ein Objekt hinzu ClipData.Item Objekte hinzufügen. Fügen Sie dann das fertige ClipData-Objekt zum ClipboardManager-Objekt. Dies wird im Folgenden näher beschrieben:

Wenn Sie Daten mithilfe eines Inhalts-URI kopieren möchten, richten Sie einen Contentanbieter ein.

Systemzwischenablage abrufen:

Kotlin

when(menuItem.itemId) {
    ...
    R.id.menu_copy -> { // if the user selects copy
        // Gets a handle to the clipboard service.
        val clipboard = getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
    }
}

Java

...
// If the user selects copy.
case R.id.menu_copy:

// Gets a handle to the clipboard service.
ClipboardManager clipboard = (ClipboardManager)
        getSystemService(Context.CLIPBOARD_SERVICE);

Kopieren Sie die Daten in ein neues ClipData-Objekt:

Für Text

Kotlin

// Creates a new text clip to put on the clipboard.
val clip: ClipData = ClipData.newPlainText("simple text", "Hello, World!")

Java

// Creates a new text clip to put on the clipboard.
ClipData clip = ClipData.newPlainText("simple text", "Hello, World!");

Für einen URI

Dieses Snippet erstellt einen URI, indem eine Datensatz-ID in den Content-URI für codiert wird. und den Anbieter. Diese Technik wird in der Abschnitt Codierung einer Kennung im URI

Kotlin

// Creates a Uri using a base Uri and a record ID based on the contact's last
// name. Declares the base URI string.
const val CONTACTS = "content://com.example.contacts"

// Declares a path string for URIs, used to copy data.
const val COPY_PATH = "/copy"

// Declares the Uri to paste to the clipboard.
val copyUri: Uri = Uri.parse("$CONTACTS$COPY_PATH/$lastName")
...
// Creates a new URI clip object. The system uses the anonymous
// getContentResolver() object to get MIME types from provider. The clip object's
// label is "URI", and its data is the Uri previously created.
val clip: ClipData = ClipData.newUri(contentResolver, "URI", copyUri)

Java

// Creates a Uri using a base Uri and a record ID based on the contact's last
// name. Declares the base URI string.
private static final String CONTACTS = "content://com.example.contacts";

// Declares a path string for URIs, used to copy data.
private static final String COPY_PATH = "/copy";

// Declares the Uri to paste to the clipboard.
Uri copyUri = Uri.parse(CONTACTS + COPY_PATH + "/" + lastName);
...
// Creates a new URI clip object. The system uses the anonymous
// getContentResolver() object to get MIME types from provider. The clip object's
// label is "URI", and its data is the Uri previously created.
ClipData clip = ClipData.newUri(getContentResolver(), "URI", copyUri);

Gezielte Absichten

Dieses Snippet erstellt ein Intent für eine Anwendung und platziert im Clip-Objekt an:

Kotlin

// Creates the Intent.
val appIntent = Intent(this, com.example.demo.myapplication::class.java)
...
// Creates a clip object with the Intent in it. Its label is "Intent"
// and its data is the Intent object created previously.
val clip: ClipData = ClipData.newIntent("Intent", appIntent)

Java

// Creates the Intent.
Intent appIntent = new Intent(this, com.example.demo.myapplication.class);
...
// Creates a clip object with the Intent in it. Its label is "Intent"
// and its data is the Intent object created previously.
ClipData clip = ClipData.newIntent("Intent", appIntent);

Fügen Sie das neue Clipobjekt in die Zwischenablage ein:

Kotlin

// Set the clipboard's primary clip.
clipboard.setPrimaryClip(clip)

Java

// Set the clipboard's primary clip.
clipboard.setPrimaryClip(clip);

Beim Kopieren in die Zwischenablage Feedback geben

Nutzer erwarten visuelles Feedback, wenn eine App Inhalte in die Zwischenablage kopiert. Fertig für Nutzer unter Android 13 und höher automatisch, muss aber vorher manuell implementiert werden. Versionen.

Ab Android 13 zeigt das System eine standardmäßige visuelle Bestätigung an, wenn Inhalte hinzugefügt werden in die Zwischenablage. Die neue Bestätigung hat folgende Auswirkungen:

Bestätigt, dass der Inhalt erfolgreich kopiert wurde.
Zeigt eine Vorschau des kopierten Inhalts an.

In Android 12L (API-Level 32) und niedriger sind Nutzer möglicherweise nicht sicher, ob sie ihre Daten erfolgreich kopiert haben oder was sie kopiert haben. Diese Funktion standardisiert die verschiedenen Benachrichtigungen, die Apps nach dem und bietet Nutzern mehr Kontrolle über die Zwischenablage.

Doppelte Benachrichtigungen vermeiden

In Android 12L (API-Level 32) und niedriger empfehlen wir, Nutzer zu benachrichtigen, wenn sie erfolgreich kopieren durch visuelles In-App-Feedback, mithilfe eines Widgets wie Toast oder Snackbar nach dem Kopieren.

Um zu vermeiden, dass Informationen doppelt angezeigt werden, empfehlen wir dringend, Toasts zu entfernen. oder Snackbars, die nach einem In-App-Text für Android 13 und höher angezeigt werden.

Snackbar nach einem In-App-Text posten — </ph> **Abbildung 4**: Wenn Sie unter Android 13 eine Snackbar zur Bestätigung des Textes einblenden, sieht der Nutzer doppelte Nachrichten.

Nach einer In-App-Kopie Toast posten. — </ph> **Abbildung 5**: Wenn Sie in Android 13 einen Bestätigungs-Toast anzeigen, sieht der Nutzer doppelte Nachrichten.

Hier ist ein Beispiel für die Implementierung:

fun textCopyThenPost(textCopied:String) {
    val clipboardManager = getSystemService(CLIPBOARD_SERVICE) as ClipboardManager
    // When setting the clipboard text.
    clipboardManager.setPrimaryClip(ClipData.newPlainText   ("", textCopied))
    // Only show a toast for Android 12 and lower.
    if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.S_V2)
        Toast.makeText(context, “Copied”, Toast.LENGTH_SHORT).show()
}

Sensible Inhalte in die Zwischenablage einfügen

Wenn Nutzer in Ihrer App sensible Inhalte wie Passwörter oder Kreditkartendaten in die Zwischenablage kopieren können Kartendaten müssen Sie ClipDescription in ClipData eine Flagge hinzufügen bevor Sie ClipboardManager.setPrimaryClip() aufrufen. Durch Hinzufügen dieses Flags wird verhindert, dass sensible Daten von kopierten Inhalten unter Android 13 und höher in der visuellen Bestätigung.

Vorschau von kopiertem Text, ohne sensible Inhalte zu kennzeichnen — </ph> **Abbildung 6**: Vorschau von kopiertem Text ohne Markierung für sensible Inhalte.

Vorschau von kopiertem Text, in der sensible Inhalte gemeldet werden. — </ph> **Abbildung 7**: Vorschau von kopiertem Text mit Markierung für sensible Inhalte.

Fügen Sie dem ClipDescription ein boolesches Extra hinzu, um sensible Inhalte zu kennzeichnen. Alle Apps müssen Folgendes tun unabhängig vom Ziel-API-Level.

// If your app is compiled with the API level 33 SDK or higher.
clipData.apply {
    description.extras = PersistableBundle().apply {
        putBoolean(ClipDescription.EXTRA_IS_SENSITIVE, true)
    }
}

// If your app is compiled with a lower SDK.
clipData.apply {
    description.extras = PersistableBundle().apply {
        putBoolean("android.content.extra.IS_SENSITIVE", true)
    }
}

Aus der Zwischenablage einfügen

Fügen Sie wie bereits beschrieben Daten aus der Zwischenablage ein, indem Sie das globale Zwischenablage-Objekt abrufen. das Clip-Objekt abrufen, seine Daten betrachten und nach Möglichkeit die Daten aus dem Clip-Objekt kopieren. in Ihrem eigenen Speicher. In diesem Abschnitt wird ausführlich erläutert, wie Sie die drei Formen der Zwischenablage einfügen können. Daten.

</ph> Wichtig:Folgen Sie bei bearbeitbaren TextView-Objekten den Hinzuzufügendes Dokument mit umfangreichem Inhalt empfangen Einfügen beliebiger Inhalte. Im folgenden Abschnitt wird die Entwicklung eines einer benutzerdefinierten Benutzeroberfläche zum Einfügen von Inhalten.

Nur Text einfügen

Wenn Sie Nur-Text einfügen möchten, rufen Sie die globale Zwischenablage ab und prüfen Sie, ob nur Text zurückgegeben werden kann. Dann holen Sie und kopieren Sie den Text mithilfe von getText() in Ihren eigenen Speicher, wie unter gehen Sie so vor:

Rufen Sie das globale ClipboardManager-Objekt mit getSystemService(CLIPBOARD_SERVICE). Deklarieren Sie außerdem eine globale Variable, eingefügten Text:

Kotlin

var clipboard = getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
var pasteData: String = ""

Java

ClipboardManager clipboard = (ClipboardManager) getSystemService(Context.CLIPBOARD_SERVICE);
String pasteData = "";

Legen Sie fest, ob Sie die Funktion zum Einfügen aktivieren oder deaktivieren müssen. Option in der aktuellen Aktivitäten. Vergewissere dich, dass die Zwischenablage einen Clip enthält und du die Art der Daten verarbeiten kannst. durch den Clip dargestellt wird:

Kotlin

// Gets the ID of the "paste" menu item.
val pasteItem: MenuItem = menu.findItem(R.id.menu_paste)

// If the clipboard doesn't contain data, disable the paste menu item.
// If it does contain data, decide whether you can handle the data.
pasteItem.isEnabled = when {
    !clipboard.hasPrimaryClip() -> {
        false
    }
    !(clipboard.primaryClipDescription.hasMimeType(MIMETYPE_TEXT_PLAIN)) -> {
        // Disables the paste menu item, since the clipboard has data but it
        // isn't plain text.
        false
    }
    else -> {
        // Enables the paste menu item, since the clipboard contains plain text.
        true
    }
}

Java

// Gets the ID of the "paste" menu item.
MenuItem pasteItem = menu.findItem(R.id.menu_paste);

// If the clipboard doesn't contain data, disable the paste menu item.
// If it does contain data, decide whether you can handle the data.
if (!(clipboard.hasPrimaryClip())) {

    pasteItem.setEnabled(false);

} else if (!(clipboard.getPrimaryClipDescription().hasMimeType(MIMETYPE_TEXT_PLAIN))) {

    // Disables the paste menu item, since the clipboard has data but
    // it isn't plain text.
    pasteItem.setEnabled(false);
} else {

    // Enables the paste menu item, since the clipboard contains plain text.
    pasteItem.setEnabled(true);
}

Kopieren Sie die Daten aus der Zwischenablage. Dieser Punkt im Code ist nur erreichbar, wenn der "Einfügen" Menüelement aktiviert ist, sodass Sie davon ausgehen können, dass die Zwischenablage nur einfache Text. Sie wissen noch nicht, ob sie eine Textzeichenfolge oder einen URI enthält, der auf Nur-Text verweist. Das folgende Code-Snippet testet dies, es wird jedoch nur der Code für die Verarbeitung von Nur-Text angezeigt:

Kotlin

when (menuItem.itemId) {
    ...
    R.id.menu_paste -> {    // Responds to the user selecting "paste".
        // Examines the item on the clipboard. If getText() doesn't return null,
        // the clip item contains the text. Assumes that this application can only
        // handle one item at a time.
        val item = clipboard.primaryClip.getItemAt(0)

        // Gets the clipboard as text.
        pasteData = item.text

        return if (pasteData != null) {
            // If the string contains data, then the paste operation is done.
            true
        } else {
            // The clipboard doesn't contain text. If it contains a URI,
            // attempts to get data from it.
            val pasteUri: Uri? = item.uri

            if (pasteUri != null) {
                // If the URI contains something, try to get text from it.

                // Calls a routine to resolve the URI and get data from it.
                // This routine isn't presented here.
                pasteData = resolveUri(pasteUri)
                true
            } else {

                // Something is wrong. The MIME type was plain text, but the
                // clipboard doesn't contain text or a Uri. Report an error.
                Log.e(TAG,"Clipboard contains an invalid data type")
                false
            }
        }
    }
}

Java

// Responds to the user selecting "paste".
case R.id.menu_paste:

// Examines the item on the clipboard. If getText() does not return null,
// the clip item contains the text. Assumes that this application can only
// handle one item at a time.
 ClipData.Item item = clipboard.getPrimaryClip().getItemAt(0);

// Gets the clipboard as text.
pasteData = item.getText();

// If the string contains data, then the paste operation is done.
if (pasteData != null) {
    return true;

// The clipboard doesn't contain text. If it contains a URI, attempts to get
// data from it.
} else {
    Uri pasteUri = item.getUri();

    // If the URI contains something, try to get text from it.
    if (pasteUri != null) {

        // Calls a routine to resolve the URI and get data from it.
        // This routine isn't presented here.
        pasteData = resolveUri(Uri);
        return true;
    } else {

        // Something is wrong. The MIME type is plain text, but the
        // clipboard doesn't contain text or a Uri. Report an error.
        Log.e(TAG, "Clipboard contains an invalid data type");
        return false;
    }
}

Daten aus einem Inhalts-URI einfügen

Wenn das ClipData.Item-Objekt einen Inhalts-URI enthält und Sie feststellen, dass Sie einen seiner MIME-Typen zu verarbeiten, ein ContentResolver zu erstellen und den entsprechenden Content aufzurufen Provider-Methode, um die Daten abzurufen.

Im Folgenden wird beschrieben, wie Sie Daten von einem Contentanbieter basierend auf einem Inhalts-URI abrufen. in der Zwischenablage. Er prüft, ob ein MIME-Typ, den die Anwendung verwenden kann, im Dienstanbieter.

Geben Sie eine globale Variable an, die den MIME-Typ enthält:

Kotlin

// Declares a MIME type constant to match against the MIME types offered
// by the provider.
const val MIME_TYPE_CONTACT = "vnd.android.cursor.item/vnd.example.contact"

Java

// Declares a MIME type constant to match against the MIME types offered by
// the provider.
public static final String MIME_TYPE_CONTACT = "vnd.android.cursor.item/vnd.example.contact";

Rufen Sie die globale Zwischenablage ab. Hol dir auch einen Content Resolver, damit du auf die Inhalte zugreifen kannst Anbieter:

Kotlin

// Gets a handle to the Clipboard Manager.
val clipboard = getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager

// Gets a content resolver instance.
val cr = contentResolver

Java

// Gets a handle to the Clipboard Manager.
ClipboardManager clipboard = (ClipboardManager) getSystemService(Context.CLIPBOARD_SERVICE);

// Gets a content resolver instance.
ContentResolver cr = getContentResolver();

Rufen Sie den primären Clip aus der Zwischenablage ab und rufen Sie seinen Inhalt als URI ab:

Kotlin

// Gets the clipboard data from the clipboard.
val clip: ClipData? = clipboard.primaryClip

clip?.run {

    // Gets the first item from the clipboard data.
    val item: ClipData.Item = getItemAt(0)

    // Tries to get the item's contents as a URI.
    val pasteUri: Uri? = item.uri

Java

// Gets the clipboard data from the clipboard.
ClipData clip = clipboard.getPrimaryClip();

if (clip != null) {

    // Gets the first item from the clipboard data.
    ClipData.Item item = clip.getItemAt(0);

    // Tries to get the item's contents as a URI.
    Uri pasteUri = item.getUri();

Testen Sie, ob der URI ein Inhalts-URI ist, indem Sie Folgendes aufrufen: getType(Uri) Diese Methode gibt null zurück, wenn Uri nicht auf einen gültigen Contentanbieter verweist.

Kotlin

    // If the clipboard contains a URI reference...
    pasteUri?.let {

        // ...is this a content URI?
        val uriMimeType: String? = cr.getType(it)

Java

    // If the clipboard contains a URI reference...
    if (pasteUri != null) {

        // ...is this a content URI?
        String uriMimeType = cr.getType(pasteUri);

Testen Sie, ob der Contentanbieter einen MIME-Typ unterstützt, den die Anwendung versteht. Wenn und zwar, rufen Sie ContentResolver.query() um die Daten zu erhalten. Der Rückgabewert ist ein Cursor

Kotlin

        // If the return value isn't null, the Uri is a content Uri.
        uriMimeType?.takeIf {

            // Does the content provider offer a MIME type that the current
            // application can use?
            it == MIME_TYPE_CONTACT
        }?.apply {

            // Get the data from the content provider.
            cr.query(pasteUri, null, null, null, null)?.use { pasteCursor ->

                // If the Cursor contains data, move to the first record.
                if (pasteCursor.moveToFirst()) {

                    // Get the data from the Cursor here.
                    // The code varies according to the format of the data model.
                }

                // Kotlin `use` automatically closes the Cursor.
            }
        }
    }
}

Java

        // If the return value isn't null, the Uri is a content Uri.
        if (uriMimeType != null) {

            // Does the content provider offer a MIME type that the current
            // application can use?
            if (uriMimeType.equals(MIME_TYPE_CONTACT)) {

                // Get the data from the content provider.
                Cursor pasteCursor = cr.query(uri, null, null, null, null);

                // If the Cursor contains data, move to the first record.
                if (pasteCursor != null) {
                    if (pasteCursor.moveToFirst()) {

                    // Get the data from the Cursor here.
                    // The code varies according to the format of the data model.
                    }
                }

                // Close the Cursor.
                pasteCursor.close();
             }
         }
     }
}

Intent einfügen

Wenn Sie einen Intent einfügen möchten, rufen Sie zuerst die globale Zwischenablage ab. ClipData.Item-Objekt untersuchen um zu prüfen, ob sie ein Intent enthält. Rufen Sie dann getIntent() auf, um die in Ihrem eigenen Speicher. Das folgende Snippet veranschaulicht dies:

Kotlin

// Gets a handle to the Clipboard Manager.
val clipboard = getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager

// Checks whether the clip item contains an Intent by testing whether
// getIntent() returns null.
val pasteIntent: Intent? = clipboard.primaryClip?.getItemAt(0)?.intent

if (pasteIntent != null) {

    // Handle the Intent.

} else {

    // Ignore the clipboard, or issue an error if
    // you expect an Intent to be on the clipboard.
}

Java

// Gets a handle to the Clipboard Manager.
ClipboardManager clipboard = (ClipboardManager) getSystemService(Context.CLIPBOARD_SERVICE);

// Checks whether the clip item contains an Intent, by testing whether
// getIntent() returns null.
Intent pasteIntent = clipboard.getPrimaryClip().getItemAt(0).getIntent();

if (pasteIntent != null) {

    // Handle the Intent.

} else {

    // Ignore the clipboard, or issue an error if
    // you expect an Intent to be on the clipboard.
}

Systembenachrichtigung, die angezeigt wird, wenn deine App auf Daten in der Zwischenablage zugreift

Unter Android 12 (API-Level 31) und höher zeigt das System normalerweise eine Toast-Nachricht an, wenn Ihre App Anrufe getPrimaryClip() Der Text innerhalb der Nachricht hat das folgende Format:

APP pasted from your clipboard

Das System zeigt keine Toast-Meldung an, wenn Ihre App eine der folgenden Aktionen ausführt:

Zugriffe ClipData aus deiner eigenen App.
Wiederholter Zugriff auf ClipData von einer bestimmten App aus Der Toast wird nur angezeigt, wenn dass Ihre App zum ersten Mal auf die Daten dieser App zugreift.
Ruft Metadaten für das Clipobjekt ab, z. B. durch den Aufruf getPrimaryClipDescription() statt getPrimaryClip().

Mit Contentanbietern komplexe Daten kopieren

Contentanbieter unterstützen das Kopieren komplexer Daten wie Datenbankeinträge oder Dateistreams. Zum Kopieren fügen Sie einen Inhalts-URI in die Zwischenablage ein. Beim Einfügen von Anwendungen wird dieser URI dann aus dem und verwenden sie zum Abrufen von Datenbankdaten oder Dateistream-Deskriptoren.

Da die Einfügen-Anwendung nur über den Inhalts-URI für Ihre Daten verfügt, muss sie wissen, welche das abzurufende Datenelement. Sie können diese Informationen bereitstellen, indem Sie eine Kennung für die Daten codieren. in der URI selbst. Alternativ können Sie einen eindeutigen URI angeben, mit dem die zu kopierenden Daten zurückgegeben werden. Welche Methode hängt von der Organisation Ihrer Daten ab.

In den folgenden Abschnitten wird beschrieben, wie Sie URIs einrichten, komplexe Daten und Dateidateien bereitstellen. Streams. In den Beschreibungen wird davon ausgegangen, dass Sie mit den allgemeinen Prinzipien des Contentanbieters vertraut sind. Design.

Kennung im URI codieren

Eine nützliche Technik zum Kopieren von Daten in die Zwischenablage mit einem URI ist die Codierung einer Kennung für die Daten zum URI selbst. Ihr Contentanbieter kann dann die ID aus dem URI abrufen und um die Daten abzurufen. Die Anwendung zum Einfügen muss nicht wissen, dass die ID existiert. Es Sie brauchen nur Ihre "Referenz" – den URI und die Kennung – aus dem und die Daten abrufen.

Normalerweise codieren Sie eine Kennung für einen Inhalts-URI, indem Sie sie am Ende des URI verketten. Angenommen, Sie definieren den Anbieter-URI als folgenden String:

"content://com.example.contacts"

Wenn Sie einen Namen für diesen URI codieren möchten, verwenden Sie das folgende Code-Snippet:

Kotlin

val uriString = "content://com.example.contacts/Smith"

// uriString now contains content://com.example.contacts/Smith.

// Generates a uri object from the string representation.
val copyUri = Uri.parse(uriString)

Java

String uriString = "content://com.example.contacts" + "/" + "Smith";

// uriString now contains content://com.example.contacts/Smith.

// Generates a uri object from the string representation.
Uri copyUri = Uri.parse(uriString);

Falls Sie bereits einen Contentanbieter verwenden, können Sie einen neuen URI-Pfad hinzufügen, der die der URI zum Kopieren bestimmt ist. Angenommen, Sie haben bereits die folgenden URI-Pfade:

"content://com.example.contacts/people"
"content://com.example.contacts/people/detail"
"content://com.example.contacts/people/images"

Sie können einen weiteren Pfad zum Kopieren von URIs hinzufügen:

"content://com.example.contacts/copying"

Sie können dann eine „Kopie“ erkennen, URI durch Musterabgleich und verarbeiten den URI mit folgendem Code: für das Kopieren und Einfügen.

Normalerweise verwendest du die Codierungstechnik, wenn du bereits mit einem Contentanbieter, internen oder einer internen Tabelle, um Ihre Daten zu organisieren. In diesen Fällen haben Sie mehrere Daten, die Sie kopieren möchten, und vermutlich eine eindeutige Kennzeichnung für jedes Stück. Als Antwort auf eine Abfrage des kopieren und einfügen, können Sie die Daten anhand ihrer ID ermitteln und zurückgeben.

Wenn Sie nicht mehrere Daten haben, müssen Sie wahrscheinlich keine ID codieren. Sie können einen für Ihren Anbieter eindeutigen URI verwenden. Als Antwort auf eine Abfrage gibt Ihr Anbieter den Daten, die sie derzeit enthält.

Datenstrukturen kopieren

Richten Sie einen Contentanbieter zum Kopieren und Einfügen komplexer Daten als Unterklasse der ContentProvider Komponente. Codieren Sie den URI aus der Zwischenablage so, dass er auf den gewünschten Eintrag verweist. bereitstellen. Berücksichtigen Sie außerdem den aktuellen Status Ihrer Anwendung:

Wenn Sie bereits einen Contentanbieter haben, können Sie seine Funktionen erweitern. Es kann sein, dass Sie nur seine query()-Methode ändern, um URIs von Anwendungen zu verarbeiten, Daten einfügen möchten. Sie möchten wahrscheinlich die Methode so ändern, dass eine Kopie verarbeitet wird. URI Muster zu ändern.
Wenn Ihre Anwendung eine interne Datenbank verwaltet, sollten Sie diese Datenbank verschieben in einen Contentanbieter importieren, um das Kopieren zu erleichtern.
Wenn Sie keine Datenbank verwenden, können Sie einen einfachen Contentanbieter implementieren, Der einzige Zweck besteht darin, Anwendungen Daten anzubieten, die aus der Zwischenablage eingefügt werden.

Überschreiben Sie im Contentanbieter mindestens die folgenden Methoden:

query(): Beim Einfügen von Anwendungen wird davon ausgegangen, dass sie Ihre Daten abrufen können, indem sie diese Methode mit dem URI verwenden, den Sie in die Zwischenablage einfügen. Damit das Kopieren unterstützt wird, lassen Sie diese Methode URIs erkennen, die eine spezielle „kopieren“ Pfad. Ihre Anwendung kann dann eine Kopie erstellen, URI, die auf dem Zwischenablage mit dem Kopierpfad und einem Zeiger auf den exakten Datensatz, den Sie kopieren möchten.
getType(): Mit dieser Methode müssen die MIME-Typen für die Daten zurückgegeben werden, die Sie kopieren möchten. Die Methode newUri() ruft getType() auf, um die MIME-Typen in die neue ClipData einzufügen -Objekt enthält.
Eine Beschreibung der MIME-Typen für komplexe Daten finden Sie unter Contentanbieter:

Sie brauchen keine anderen Contentanbietermethoden wie insert() oder update(). Eine Anwendung zum Einfügen muss nur Ihre unterstützten MIME-Typen abrufen und Daten von Ihrem Anbieter kopieren. Wenn Sie diese Methoden bereits haben, beeinträchtigen sie die Kopiervorgänge nicht.

Die folgenden Snippets veranschaulichen, wie Sie Ihre Anwendung zum Kopieren komplexer Daten einrichten:

Deklarieren Sie in den globalen Konstanten für Ihre Anwendung einen Basis-URI-String und einen Pfad, der gibt URI-Strings an, mit denen Sie Daten kopieren. Deklarieren Sie auch einen MIME-Typ für die kopierte Daten.

Kotlin

// Declares the base URI string.
private const val CONTACTS = "content://com.example.contacts"

// Declares a path string for URIs that you use to copy data.
private const val COPY_PATH = "/copy"

// Declares a MIME type for the copied data.
const val MIME_TYPE_CONTACT = "vnd.android.cursor.item/vnd.example.contact"

Java

// Declares the base URI string.
private static final String CONTACTS = "content://com.example.contacts";

// Declares a path string for URIs that you use to copy data.
private static final String COPY_PATH = "/copy";

// Declares a MIME type for the copied data.
public static final String MIME_TYPE_CONTACT = "vnd.android.cursor.item/vnd.example.contact";

Richten Sie in der Aktivität, aus der Nutzer Daten kopieren, den Code so ein, dass Daten in die Zwischenablage kopiert werden. Fügen Sie den URI als Antwort auf eine Kopieranfrage in die Zwischenablage ein.

Kotlin

class MyCopyActivity : Activity() {
    ...
when(item.itemId) {
    R.id.menu_copy -> { // The user has selected a name and is requesting a copy.
        // Appends the last name to the base URI.
        // The name is stored in "lastName".
        uriString = "$CONTACTS$COPY_PATH/$lastName"

        // Parses the string into a URI.
        val copyUri: Uri? = Uri.parse(uriString)

        // Gets a handle to the clipboard service.
        val clipboard = getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager

        val clip: ClipData = ClipData.newUri(contentResolver, "URI", copyUri)

        // Sets the clipboard's primary clip.
        clipboard.setPrimaryClip(clip)
    }
}

Java

public class MyCopyActivity extends Activity {
    ...
// The user has selected a name and is requesting a copy.
case R.id.menu_copy:

    // Appends the last name to the base URI.
    // The name is stored in "lastName".
    uriString = CONTACTS + COPY_PATH + "/" + lastName;

    // Parses the string into a URI.
    Uri copyUri = Uri.parse(uriString);

    // Gets a handle to the clipboard service.
    ClipboardManager clipboard = (ClipboardManager)
        getSystemService(Context.CLIPBOARD_SERVICE);

    ClipData clip = ClipData.newUri(getContentResolver(), "URI", copyUri);

    // Sets the clipboard's primary clip.
    clipboard.setPrimaryClip(clip);

Erstellen Sie im globalen Bereich Ihres Contentanbieters einen URI-Abgleichstool und fügen Sie ein URI-Muster hinzu, das stimmt mit URIs überein, die Sie in der Zwischenablage gespeichert haben.

Kotlin

// A Uri Match object that simplifies matching content URIs to patterns.
private val sUriMatcher = UriMatcher(UriMatcher.NO_MATCH).apply {

    // Adds a matcher for the content URI. It matches.
    // "content://com.example.contacts/copy/*"
    addURI(CONTACTS, "names/*", GET_SINGLE_CONTACT)
}

// An integer to use in switching based on the incoming URI pattern.
private const val GET_SINGLE_CONTACT = 0
...
class MyCopyProvider : ContentProvider() {
    ...
}

Java

public class MyCopyProvider extends ContentProvider {
    ...
// A Uri Match object that simplifies matching content URIs to patterns.
private static final UriMatcher sURIMatcher = new UriMatcher(UriMatcher.NO_MATCH);

// An integer to use in switching based on the incoming URI pattern.
private static final int GET_SINGLE_CONTACT = 0;
...
// Adds a matcher for the content URI. It matches
// "content://com.example.contacts/copy/*"
sUriMatcher.addURI(CONTACTS, "names/*", GET_SINGLE_CONTACT);

Richten Sie den query() . Diese Methode kann je nach Codierung unterschiedliche URI-Muster verarbeiten, aber nur wird das Muster für den Kopiervorgang in die Zwischenablage angezeigt.

Kotlin

// Sets up your provider's query() method.
override fun query(
        uri: Uri,
        projection: Array<out String>?,
        selection: String?,
        selectionArgs: Array<out String>?,
        sortOrder: String?
): Cursor? {
    ...
    // When based on the incoming content URI:
    when(sUriMatcher.match(uri)) {

        GET_SINGLE_CONTACT -> {

            // Queries and returns the contact for the requested name. Decodes
            // the incoming URI, queries the data model based on the last name,
            // and returns the result as a Cursor.
        }
    }
    ...
}

Java

// Sets up your provider's query() method.
public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
    String sortOrder) {
    ...
    // Switch based on the incoming content URI.
    switch (sUriMatcher.match(uri)) {

    case GET_SINGLE_CONTACT:

        // Queries and returns the contact for the requested name. Decodes the
        // incoming URI, queries the data model based on the last name, and
        // returns the result as a Cursor.
    ...
}

Richten Sie die Methode getType() so ein, dass ein geeigneter MIME-Typ für kopierte Dateien zurückgegeben wird. Daten:

Kotlin

// Sets up your provider's getType() method.
override fun getType(uri: Uri): String? {
    ...
    return when(sUriMatcher.match(uri)) {
        GET_SINGLE_CONTACT -> MIME_TYPE_CONTACT
        ...
    }
}

Java

// Sets up your provider's getType() method.
public String getType(Uri uri) {
    ...
    switch (sUriMatcher.match(uri)) {
    case GET_SINGLE_CONTACT:
        return (MIME_TYPE_CONTACT);
    ...
    }
}

Im Abschnitt Daten aus einem Inhalts-URI einfügen wird beschrieben, wie Sie einen Inhalts-URI aus der Zwischenablage und verwenden Sie ihn zum Abrufen und Einfügen von Daten.

Datenstreams kopieren

Sie können große Mengen an Text und Binärdaten als Streams kopieren und einfügen. Die Daten können Formen haben, wie zum Beispiel:

Auf dem Gerät gespeicherte Dateien
Streams von Sockets
Große Datenmengen, die im zugrunde liegenden Datenbanksystem eines Anbieters gespeichert sind

Ein Contentanbieter für Datenstreams bietet Zugriff auf seine Daten mit einem Dateideskriptorobjekt. zum Beispiel AssetFileDescriptor, anstelle eines Cursor-Objekts. Die eingefügte Anwendung liest den Datenstream anhand dieser Datei-Deskriptor.

So richten Sie Ihre Anwendung so ein, dass ein Datenstream mit einem Anbieter kopiert wird:

Richten Sie einen Inhalts-URI für den Datenstream ein, den Sie in die Zwischenablage einfügen. Optionen Dazu gehören: <ph type="x-smartling-placeholder">
- Codieren Sie eine Kennung für den Datenstream zum URI, wie in den Codieren Sie eine Kennung im URI-Abschnitt und pflegen Sie einen in Ihrem Anbieter, die IDs und den entsprechenden Streamnamen enthält.
- Codieren Sie den Streamnamen direkt auf dem URI.
- Verwenden Sie einen eindeutigen URI, der immer den aktuellen Stream vom Anbieter zurückgibt. Wenn Sie diese Option verwenden, denken Sie daran, Ihren Anbieter so zu aktualisieren, dass er auf einen anderen Stream verweist. wenn Sie den Stream mithilfe des URI in die Zwischenablage kopieren.
Geben Sie für jeden Datenstream-Typ, den Sie anbieten möchten, einen MIME-Typ an. Anwendungen werden eingefügt um zu ermitteln, ob sie die Daten in die Zwischenablage einfügen können.
Implementieren Sie eine der ContentProvider-Methoden, die einen Dateideskriptor für zurückgibt. einem Stream. Wenn Sie Kennungen für den Content-URI codieren, können Sie mit dieser Methode bestimmen, zum Öffnen des Streams.
Wenn Sie den Datenstream in die Zwischenablage kopieren möchten, erstellen Sie den Inhalts-URI und platzieren Sie ihn im Zwischenablage öffnen.

Zum Einfügen eines Datenstreams ruft eine Anwendung den Clip aus der Zwischenablage ab, ruft den URI ab und verwendet in einem Aufruf der Dateideskriptormethode ContentResolver, die den Stream öffnet. Die Die ContentResolver-Methode ruft die entsprechende ContentProvider-Methode auf. und übergeben Sie den Inhalts-URI. Ihr Anbieter gibt den Dateideskriptor an den ContentResolver-Methode. Die eingefügte Anwendung hat dann die Aufgabe, die Daten aus dem Stream.

Die folgende Liste zeigt die wichtigsten Methoden zur Dateibeschreibung für einen Inhaltsanbieter. Jedes davon hat eine entsprechende ContentResolver-Methode mit dem String "Deskriptor" an den Methodennamen angehängt. Beispiel: ContentResolver Analog zu openAssetFile() ist openAssetFileDescriptor()

openTypedAssetFile()

Diese Methode gibt einen Asset-Dateideskriptor zurück, aber nur dann, wenn der angegebene MIME-Typ vom Anbieter unterstützt wird. Der Aufrufer – die Anwendung, die das Einfügen durchführt – ein MIME-Typ-Muster. Der Contentanbieter der Anwendung, der eine URI in den Die Zwischenablage gibt ein AssetFileDescriptor-Datei-Handle zurück, wenn sie Folgendes angeben kann: MIME-Typ und löst eine Ausnahme aus, wenn dies nicht möglich ist.

Diese Methode verarbeitet Unterabschnitte von Dateien. Sie können damit Assets lesen, Contentanbieter in die Zwischenablage kopiert hat.

openAssetFile()

Diese Methode ist eine allgemeinere Form von openTypedAssetFile(). Es wird nicht gefiltert für zulässige MIME-Typen, kann aber Unterabschnitte von Dateien lesen.

openFile()

Dies ist eine allgemeinere Form von openAssetFile(). Unterabschnitte von Dateien.

Optional können Sie die Methode openPipeHelper() mit Ihrer Datei-Deskriptor-Methode. Dadurch kann die eingefügte Anwendung die Streamdaten in einem einen senkrechten Hintergrundthread hinzu. Implementieren Sie zur Verwendung dieser Methode den ContentProvider.PipeDataWriter .

Effektive Funktionen zum Kopieren und Einfügen entwerfen

Beachten Sie die folgenden Punkte, um effektive Kopier- und Einfügefunktionen für Ihre Anwendung zu entwerfen:

Es befindet sich jeweils nur ein Clip in der Zwischenablage. Ein neuer Kopiervorgang durch eine beliebige im System den vorherigen Clip überschreibt. Da die Nutzenden zwischen von der Anwendung entfernt und vor der Rückgabe kopiert haben, können Sie nicht auf die Zwischenablage enthält den Clip, den der Nutzer zuvor in Ihrer Anwendung kopiert hat.
Mehrere ClipData.Item-Objekte pro Clip dienen zum Zweck, Kopieren und Einfügen von Mehrfachauswahlen anstelle verschiedener Formen von auf eine einzelne Auswahl verweisen. Normalerweise möchten Sie alle ClipData.Item Elemente in einem Clip dasselbe Format haben. Das heißt, sie müssen alle einfache Text-, Inhalts- URI oder Intent und nicht gemischt.
Wenn Sie Daten angeben, können Sie verschiedene MIME-Darstellungen anbieten. MIME-Typen hinzufügen zuerst den ClipDescription und implementieren die MIME-Typen dann in Ihres Contentanbieters.
Wenn Sie Daten aus der Zwischenablage abrufen, überprüft Ihre Anwendung die verfügbaren MIME-Typen und entscheiden Sie dann, welchen Sie verwenden möchten. Selbst wenn es eine in der Zwischenablage gespeichert ist und der Nutzer ein Einfügen anfordert, ist Ihre Anwendung nicht erforderlich, zum Einfügen. Fügen Sie den Text ein, wenn der MIME-Typ kompatibel ist. Sie könnten die Daten erzwingen, aus der Zwischenablage in Text mit coerceToText() umwandeln. Wenn Ihre Anwendung mehr als einen der verfügbaren MIME-Typen verwenden, können Sie den Nutzern die Auswahl des MIME-Typs überlassen.