Wie kopiere ich Text in die Zwischenablage auf Android?

Question

Kann mir bitte jemand sagen, wie ich den Text, der in einem bestimmten TextView enthalten ist, in die Zwischenablage kopieren kann, wenn eine Schaltfläche gedrückt wird?

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.mainpage);
    textView = (TextView) findViewById(R.id.textview);
    copyText = (Button) findViewById(R.id.bCopy);
    copyText.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            // TODO - generierter Methodenstub

            ClipboardManager clipboard = (ClipboardManager) getSystemService(CLIPBOARD_SERVICE);
            String getstring = textView.getText().toString();

            // Hilfe, um fortzufahren :)
        }
    });
}

Ich möchte den Text im TextView textView in die Zwischenablage kopieren, wenn die Schaltfläche bCopy gedrückt wird.

Answer 1

Verwenden Sie ClipboardManager

ClipboardManager clipboard = (ClipboardManager) getSystemService(Context.CLIPBOARD_SERVICE); 
    ClipData clip = ClipData.newPlainText(label, text);
    clipboard.setPrimaryClip(clip);

Stellen Sie sicher, dass Sie android.content.ClipboardManager importiert haben und NICHT android.text.ClipboardManager. Letzteres ist veraltet. Überprüfen Sie diesen Link für weitere Informationen.

Answer 2

Hier ist die Methode zum Kopieren von Text in die Zwischenablage:

private void setClipboard(Context context, String text) {
  if(android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.HONEYCOMB) {
    android.text.ClipboardManager clipboard = (android.text.ClipboardManager) context.getSystemService(Context.CLIPBOARD_SERVICE);
    clipboard.setText(text);
  } else {
    android.content.ClipboardManager clipboard = (android.content.ClipboardManager) context.getSystemService(Context.CLIPBOARD_SERVICE);
    android.content.ClipData clip = android.content.ClipData.newPlainText("Kopierter Text", text);
    clipboard.setPrimaryClip(clip);
  }
}

Diese Methode funktioniert auf allen Android-Geräten.

Answer 3

Als praktische Kotlin-Erweiterung:

fun Context.copyToClipboard(text: CharSequence){
    val clipboard = getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
    val clip = ClipData.newPlainText("label",text)
    clipboard.setPrimaryClip(clip)
}

Aktualisierung:

Wenn Sie ContextCompat verwenden, sollten Sie Folgendes verwenden:

ContextCompat.getSystemService(this, ClipboardManager::class.java)

Answer 4

Gestern habe ich diese Klasse erstellt. Nehmen Sie sie, sie ist für alle API-Levels

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;

import android.annotation.SuppressLint;
import android.content.ClipData;
import android.content.ClipboardManager;
import android.content.ContentResolver;
import android.content.Context;
import android.content.Intent;
import android.content.res.AssetFileDescriptor;
import android.net.Uri;
import android.util.Log;
import de.lochmann.nsafirewall.R;

public class MyClipboardManager {

    @SuppressLint("NewApi")
    @SuppressWarnings("deprecation")
    public boolean copyToClipboard(Context context, String text) {
        try {
            int sdk = android.os.Build.VERSION.SDK_INT;
            if (sdk < android.os.Build.VERSION_CODES.HONEYCOMB) {
                android.text.ClipboardManager clipboard = (android.text.ClipboardManager) context
                        .getSystemService(context.CLIPBOARD_SERVICE);
                clipboard.setText(text);
            } else {
                android.content.ClipboardManager clipboard = (android.content.ClipboardManager) context
                        .getSystemService(context.CLIPBOARD_SERVICE);
                android.content.ClipData clip = android.content.ClipData
                        .newPlainText(
                                context.getResources().getString(
                                        R.string.message), text);
                clipboard.setPrimaryClip(clip);
            }
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    @SuppressLint("NewApi")
    public String readFromClipboard(Context context) {
        int sdk = android.os.Build.VERSION.SDK_INT;
        if (sdk < android.os.Build.VERSION_CODES.HONEYCOMB) {
            android.text.ClipboardManager clipboard = (android.text.ClipboardManager) context
                    .getSystemService(context.CLIPBOARD_SERVICE);
            return clipboard.getText().toString();
        } else {
            ClipboardManager clipboard = (ClipboardManager) context
                    .getSystemService(Context.CLIPBOARD_SERVICE);

            // Ruft eine Content-Resolver-Instanz ab
            ContentResolver cr = context.getContentResolver();

            // Ruft die Zwischenablage-Daten aus der Zwischenablage ab
            ClipData clip = clipboard.getPrimaryClip();
            if (clip != null) {

                String text = null;
                String title = null;

                // Ruft das erste Element aus den Zwischenablagendaten ab
                ClipData.Item item = clip.getItemAt(0);

                // Versucht, den Inhalt des Elements als URI zu einer Notiz abzurufen
                Uri uri = item.getUri();

                // Falls der Inhalt der Zwischenablage kein Verweis auf eine Notiz war, wird dies in Text konvertiert.
                if (text == null) {
                    text = coerceToText(context, item).toString();
                }

                return text;
            }
        }
        return "";
    }

    @SuppressLint("NewApi")
    public CharSequence coerceToText(Context context, ClipData.Item item) {
        // Wenn dieses Element einen expliziten Textwert hat, wird dieser einfach zurückgegeben.
        CharSequence text = item.getText();
        if (text != null) {
            return text;
        }

        // Wenn dieses Element einen URI-Wert hat, wird versucht, diesen zu verwenden.
        Uri uri = item.getUri();
        if (uri != null) {

            // Zuerst wird überprüft, ob der URI als einfacher Textstrom (jeder Subtyp) geöffnet werden kann.
            // Wenn ja, ist dies die beste textuelle Repräsentation dafür.
            FileInputStream stream = null;
            try {
                // Fordert einen Strom des gewünschten Typs an.
                AssetFileDescriptor descr = context.getContentResolver()
                        .openTypedAssetFileDescriptor(uri, "text/*", null);
                stream = descr.createInputStream();
                InputStreamReader reader = new InputStreamReader(stream,
                        "UTF-8");

                // Kopiert den Stream in einen lokalen String und gibt ihn zurück.
                StringBuilder builder = new StringBuilder(128);
                char[] buffer = new char[8192];
                int len;
                while ((len = reader.read(buffer)) > 0) {
                    builder.append(buffer, 0, len);
                }
                return builder.toString();

            } catch (FileNotFoundException e) {
                // Es konnte kein Inhalt-URI als Text geöffnet werden... kein wirklicher Fehler, einfach zu ignorieren.

            } catch (IOException e) {
                // Es ist etwas Schlechtes passiert.
                Log.w("ClippedData", "Fehler beim Laden des Texts", e);
                return e.toString();

            } finally {
                if (stream != null) {
                    try {
                        stream.close();
                    } catch (IOException e) {
                    }
                }
            }

            // Falls der URI nicht als Stream geöffnet werden kann, dient der URI selbst wahrscheinlich als ziemlich gute textuelle Repräsentation.
            return uri.toString();
        }

        // Schließlich, wenn wir nur ein Intent haben, können wir es einfach in Text umwandeln. Nicht das benutzerfreundlichste, aber es ist etwas.
        Intent intent = item.getIntent();
        if (intent != null) {
            return intent.toUri(Intent.URI_INTENT_SCHEME);
        }

        // Sollte nicht hier landen, aber nur für den Fall...
        return "";
    }

}

Answer 5

Für Jetpack Compose

val localClipboardManager = LocalClipboardManager.current
localClipboardManager.setText(AnnotatedString("Ihr Text hier"))