Como copiar texto para Clip Board no Android?

313

Alguém pode me dizer como copiar o texto presente em uma determinada visualização de texto para a área de transferência quando um botão é pressionado?

    @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 Auto-generated method stub

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

                //Help to continue :)

            }
        });
    }

}

Quero copiar o texto no TextView textView para a área de transferência quando o botão bCopyfor pressionado.

Darshan Gowda
fonte
2
Possível duplicata de Como copiar texto programaticamente no meu aplicativo Android?
Shabbir Dhangot
stackoverflow.com/q/48791271/9274175 Por favor, responda a esta pergunta sobre coppy
Yash Kale

Respostas:

590

use ClipboardManager

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

verifique se você importou android.content.ClipboardManagere NÃO android.text.ClipboardManager. O último está obsoleto. Verifique este link para obter mais informações.

stinepike
fonte
3
Isto é para API11 + que não está funcionando apenas para GB e abaixo
Javier
48
Para que serve o "rótulo"?
desenvolvedor android
19
@androiddeveloper Explicação do parâmetro "label": stackoverflow.com/questions/33207809/…
smg 20/17
3
@smg Então é mais para desenvolvedores? Mas como diz que é mostrado para os usuários?
desenvolvedor android
7
Em androidx torna-se realmenteClipboardManager clipboard = getSystemService(getContext(), ClipboardManager.class);
HoratioCain
72

Aqui, o método para copiar texto para a área de transferência:

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("Copied Text", text);
    clipboard.setPrimaryClip(clip);
  }
}

Este método está funcionando em todos os dispositivos Android.

vuhung3990
fonte
2
Não entendo o que significa "contexto". Você pode adicionar um exemplo de como chamar esse método corretamente? Obrigado.
E_Blue
1
Além disso, parece que o valor de "contexto" não é usado. Então, por que deve ser passado como parâmetro?
E_Blue
hey cara, o contexto é necessária em fragmento de chamar getSystemService
vuhung3990
@E_Blue context.getSystemService (Context.CLIPBOARD_SERVICE) ??? realmente???
androidStud
1
O @E_Blue parece que você é um desenvolvedor Android ingênuo que está perguntando sobre o contexto. Bem, isso também não é um problema, mas apenas preste atenção ao seu tom e faça alguns estudos / pesquisas sobre as coisas também.
androidStud
57

Ontem fiz essa aula. Aceite, é para todos os níveis da API

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

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

            // Gets the clipboard data from the clipboard
            ClipData clip = clipboard.getPrimaryClip();
            if (clip != null) {

                String text = null;
                String title = 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 pointing to a note
                Uri uri = item.getUri();

                // If the contents of the clipboard wasn't a reference to a
                // note, then
                // this converts whatever it is to text.
                if (text == null) {
                    text = coerceToText(context, item).toString();
                }

                return text;
            }
        }
        return "";
    }

    @SuppressLint("NewApi")
    public CharSequence coerceToText(Context context, ClipData.Item item) {
        // If this Item has an explicit textual value, simply return that.
        CharSequence text = item.getText();
        if (text != null) {
            return text;
        }

        // If this Item has a URI value, try using that.
        Uri uri = item.getUri();
        if (uri != null) {

            // First see if the URI can be opened as a plain text stream
            // (of any sub-type). If so, this is the best textual
            // representation for it.
            FileInputStream stream = null;
            try {
                // Ask for a stream of the desired type.
                AssetFileDescriptor descr = context.getContentResolver()
                        .openTypedAssetFileDescriptor(uri, "text/*", null);
                stream = descr.createInputStream();
                InputStreamReader reader = new InputStreamReader(stream,
                        "UTF-8");

                // Got it... copy the stream into a local string and return it.
                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) {
                // Unable to open content URI as text... not really an
                // error, just something to ignore.

            } catch (IOException e) {
                // Something bad has happened.
                Log.w("ClippedData", "Failure loading text", e);
                return e.toString();

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

            // If we couldn't open the URI as a stream, then the URI itself
            // probably serves fairly well as a textual representation.
            return uri.toString();
        }

        // Finally, if all we have is an Intent, then we can just turn that
        // into text. Not the most user-friendly thing, but it's something.
        Intent intent = item.getIntent();
        if (intent != null) {
            return intent.toUri(Intent.URI_INTENT_SCHEME);
        }

        // Shouldn't get here, but just in case...
        return "";
    }

}
COMO
fonte
Você pode adicionar as instruções de importação necessárias para fazer essa classe funcionar?
merlin2011
@ merlin2011 fiz isso, acho que esqueci o método coerceToText (...). Sry for that
AS
O que faz "coerceToText"? Além disso, é possível copiar / colar outros tipos de dados na área de transferência (exemplo: bitmap)?
desenvolvedor android
1
@AS por que você escreveu o método corceToText? ! já está disponível com a API, consulte developer.android.com/reference/android/content/…
Hardik
Mas acho que há tempo para que os desenvolvedores parem de dar suporte ao material antes da API17. Não restam muitas unidades dos tipos mais antigos e eles não tendem a baixar novos aplicativos? Por exemplo, eu uso unidades mais antigas para navegação no meu veleiro, e todo o resto é limpo. Eu não me importo de atirar essas unidades por engano?
Jan Bergström
23

Como uma extensão útil do kotlin:

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

Atualizar:

Se você estiver usando o ContextCompat, deverá usar:

ContextCompat.getSystemService(this, ClipboardManager::class.java)
crgarridos
fonte
1
API agora mudou para clipboardManager = getSystemService (contexto, ClipboardManager :: class.java)
Per Christian Henden
realmente mudou para context.getSystemService(ClipboardManager::class.java)você está apontando para uma assinatura ContextCompat, não é? Obrigado pelo feedback
crgarridos
13

Apenas use isso. Funciona apenas para a API Android> = 11 antes que você precise usar um ClipData.

ClipboardManager _clipboard = (ClipboardManager) _activity.getSystemService(Context.CLIPBOARD_SERVICE);
_clipboard.setText(YOUR TEXT);

Espero que tenha ajudado :)

[ATUALIZAÇÃO 19/03/2015] Assim como Ujjwal Singh disse que o método setTextestá obsoleto agora, você deve usar, assim como os documentos o recomendam, setPrimaryClip (clipData)

Ektos974
fonte
1
Esse é o nome da minha variável. Se você está em sua atividade apenas usar (ClipboardManager) this.getSystemService(Context.CLIPBOARD_SERVICE); _clipboard.setText(YOUR TEXT);
Ektos974
1
Descontinuado - não use setTextuse ClipData+setPrimaryClip
Ujjwal Singh
1
Para mim também está mostrando erro ao usar setPrimaryClip
Praneeth
11

Isso pode ser feito no Kotlin assim:

var clipboard = getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
var clip = ClipData.newPlainText("label", file.readText())
clipboard.primaryClip = clip

Onde file.readText()está sua string de entrada.

Nikhil Katekhaye
fonte
7

use este código

   private ClipboardManager myClipboard;
   private ClipData myClip;
   TextView textView;
   Button copyText;

@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);
    myClipboard = (ClipboardManager)getSystemService(CLIPBOARD_SERVICE);

    copyText.setOnClickListener(new View.OnClickListener() {


        @Override
        public void onClick(View v) {
            // TODO Auto-generated method stub


           String text = textView.getText().toString();
           myClip = ClipData.newPlainText("text", text);
           myClipboard.setPrimaryClip(myClip);
           Toast.makeText(getApplicationContext(), "Text Copied", 
           Toast.LENGTH_SHORT).show(); 
        }
    });
}
SKG
fonte
Muito obrigado, é muito fácil de usar.
Iamkdblue 17/0118
7

use esta função para copiar para a área de transferência

public void copyToClipboard(String copyText) {
    int sdk = android.os.Build.VERSION.SDK_INT;
    if (sdk < android.os.Build.VERSION_CODES.HONEYCOMB) {
        android.text.ClipboardManager clipboard = (android.text.ClipboardManager)
                getSystemService(Context.CLIPBOARD_SERVICE);
        clipboard.setText(copyText);
    } else {
        android.content.ClipboardManager clipboard = (android.content.ClipboardManager)
                getSystemService(Context.CLIPBOARD_SERVICE);
        android.content.ClipData clip = android.content.ClipData
                .newPlainText("Your OTP", copyText);
        clipboard.setPrimaryClip(clip);
    }
    Toast toast = Toast.makeText(getApplicationContext(),
            "Your OTP is copied", Toast.LENGTH_SHORT);
    toast.setGravity(Gravity.BOTTOM | Gravity.RIGHT, 50, 50);
    toast.show();
    //displayAlert("Your OTP is copied");
}
Vimal Gajera
fonte
6
@SuppressLint({ "NewApi", "NewApi", "NewApi", "NewApi" })
@SuppressWarnings("deprecation")
@TargetApi(11)
public void onClickCopy(View v) {   // User-defined onClick Listener
    int sdk_Version = android.os.Build.VERSION.SDK_INT;
    if(sdk_Version < android.os.Build.VERSION_CODES.HONEYCOMB) {
        android.text.ClipboardManager clipboard = (android.text.ClipboardManager) getSystemService(Context.CLIPBOARD_SERVICE);
        clipboard.setText(textView.getText().toString());   // Assuming that you are copying the text from a TextView
        Toast.makeText(getApplicationContext(), "Copied to Clipboard!", Toast.LENGTH_SHORT).show();
    }
    else { 
        android.content.ClipboardManager clipboard = (android.content.ClipboardManager) getSystemService(Context.CLIPBOARD_SERVICE); 
        android.content.ClipData clip = android.content.ClipData.newPlainText("Text Label", textView.getText().toString());
        clipboard.setPrimaryClip(clip);
        Toast.makeText(getApplicationContext(), "Copied to Clipboard!", Toast.LENGTH_SHORT).show();
    }   
}
Himanshu Aggarwal
fonte
2

int sdk = android.os.Build.VERSION.SDK_INT;

    if (sdk < android.os.Build.VERSION_CODES.HONEYCOMB) {
        android.text.ClipboardManager clipboard = (android.text.ClipboardManager) DetailView.this
                .getSystemService(Context.CLIPBOARD_SERVICE);
        clipboard.setText("" + yourMessage.toString());
        Toast.makeText(AppCstVar.getAppContext(),
                "" + getResources().getString(R.string.txt_copiedtoclipboard),
                Toast.LENGTH_SHORT).show();
    } else {
        android.content.ClipboardManager clipboard = (android.content.ClipboardManager) DetailView.this
                .getSystemService(Context.CLIPBOARD_SERVICE);
        android.content.ClipData clip = android.content.ClipData
                .newPlainText("message", "" + yourMessage.toString());
        clipboard.setPrimaryClip(clip);
        Toast.makeText(AppCstVar.getAppContext(),
                "" + getResources().getString(R.string.txt_copiedtoclipboard),
                Toast.LENGTH_SHORT).show();
    }
Pankaj Singh
fonte
2

use este método:

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

no local de setPrimaryClip, também podemos usar os seguintes métodos:

void    clearPrimaryClip()

Limpa qualquer clipe principal atual na área de transferência.

ClipData    getPrimaryClip()

Retorna o clipe principal atual na área de transferência.

ClipDescription getPrimaryClipDescription()

Retorna uma descrição do clipe principal atual na área de transferência, mas não uma cópia de seus dados.

CharSequence    getText()

Este método está obsoleto. Use getPrimaryClip () em vez disso. Isso recupera o clipe principal e tenta coagi-lo a uma string.

boolean hasPrimaryClip()

Retorna true se houver atualmente um clipe principal na área de transferência.

Pradeep Kumar
fonte
1
    String stringYouExtracted = referraltxt.getText().toString();
    android.content.ClipboardManager clipboard = (android.content.ClipboardManager) getActivity().getSystemService(Context.CLIPBOARD_SERVICE);
    android.content.ClipData clip = android.content.ClipData.newPlainText("Copied Text", stringYouExtracted);

clipboard.setPrimaryClip(clip);
        Toast.makeText(getActivity(), "Copy coupon code copied to clickboard!", Toast.LENGTH_SHORT).show();
Keshav Gera
fonte
0

Tente o seguinte código. Ele suportará a API mais recente:

ClipboardManager clipboard = (ClipboardManager) context.getSystemService(Context.CLIPBOARD_SERVICE);
                        if (clipboard.hasPrimaryClip()) {
                            android.content.ClipDescription description = clipboard.getPrimaryClipDescription();
                            android.content.ClipData data = clipboard.getPrimaryClip();
                            if (data != null && description != null && description.hasMimeType(ClipDescription.MIMETYPE_TEXT_PLAIN))
                            {
                                String url= (String) clipboard.getText();
                                searchText.setText(url);
                                System.out.println("data="+data+"description="+description+"url="+url);
                            }}
Ranjith Guru
fonte
0

Método auxiliar Kotlin para anexar textos de clique para copiar em um TextView

Coloque esse método em algum lugar da classe Util. Esse método anexa o listener de cliques no textview ao Copy Content of textView para um clipText ao clicar no textView

/**
 * Param:  cliplabel, textview, context
 */
fun attachClickToCopyText(textView: TextView?, clipLabel: String, context: Context?) {
    if (textView != null && null != context) {
        textView.setOnClickListener {
            val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
            val clip = ClipData.newPlainText(clipLabel, textView!!.text)
            clipboard.primaryClip = clip
            Snackbar.make(textView,
                    "Copied $clipLabel", Snackbar.LENGTH_LONG).show()
        }
    }

}
Hitesh Sahu
fonte
0

Você pode executar esta função de copiar para a área de transferência ao clicar no evento do botão. então coloque essas linhas de código dentro do seu botão onClickListerner

android.content.ClipboardManager clipboardManager = (android.content.ClipboardManager)getSystemService(Context.CLIPBOARD_SERVICE);
android.content.ClipData clipData = android.content.ClipData.newPlainText("Text Label", ViewPass.getText().toString());
clipboardManager.setPrimaryClip(clipData);
Toast.makeText(getApplicationContext(),"Copied from Clipboard!",Toast.LENGTH_SHORT).show();
Malith Ileperuma
fonte
0

Basta escrever este código:

clipboard.setText(getstring);
raza raza
fonte
Você esqueceu de inicializar clipboard. Mas obrigado por setText. Está obsoleto, então use val clip = ClipData.newPlainText(null, text) clipboard.setPrimaryClip(clip).
CoolMind
-1

Para Kotlin

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