Menyalin dan Menempelkan

Android menyediakan framework berbasis papan klip yang canggih untuk penyalinan dan penempelan. Framework ini mendukung jenis data sederhana serta kompleks, termasuk string teks, struktur data kompleks, teks dan data aliran biner, dan bahkan aset aplikasi. Data teks sederhana disimpan langsung di papan klip, sedangkan data kompleks disimpan sebagai referensi yang diselesaikan oleh aplikasi yang menempelkan dengan penyedia konten. Fitur menyalin dan menempelkan berfungsi di dalam aplikasi dan di antara aplikasi yang menerapkan framework ini.

Karena bagian dari framework ini menggunakan penyedia konten, topik ini mengasumsikan bahwa Anda memiliki pengetahuan dasar Android Content Provider API, yang dijelaskan dalam topik Penyedia Konten.

Framework Papan Klip

Saat Anda menggunakan framework papan klip, Anda akan menempatkan data ke dalam objek klip, lalu menempatkan objek klip pada papan klip di seluruh sistem. Objek klip dapat menggunakan salah satu dari tiga bentuk berikut:

Teks
String teks. Anda menempatkan string langsung ke objek klip, yang kemudian Anda tempatkan ke papan klip. Untuk menempelkan string, dapatkan objek klip dari papan klip dan salin string ke dalam penyimpanan aplikasi Anda.
URI
Objek Uri yang merepresentasikan bentuk URI apa pun. Objek ini utamanya untuk menyalin data yang rumit dari penyedia konten. Untuk menyalin data, tempatkan objek Uri ke dalam objek klip dan tempatkan objek klip ke papan klip. Untuk menempelkan data, dapatkan objek klip, dapatkan objek Uri, selesaikan ke sumber data seperti penyedia konten, dan salin data dari sumber ke penyimpanan aplikasi Anda.
Intent
Intent. Ini mendukung penyalinan pintasan aplikasi. Untuk menyalin data, buat Intent, tempatkan ke objek klip, lalu tempatkan objek klip ke papan klip. Untuk menempelkan data, dapatkan objek klip, kemudian salin objek Intent ke area memori aplikasi Anda.

Papan klip hanya menyimpan satu objek klip dalam satu waktu. Saat aplikasi menempatkan objek klip di papan klip, objek klip sebelumnya akan terhapus.

Jika Anda ingin mengizinkan pengguna untuk menempelkan data ke aplikasi, Anda tidak perlu menangani semua jenis data. Anda dapat memeriksa data di papan klip sebelum memberi pengguna opsi untuk menempelkannya. Selain memiliki bentuk data tertentu, objek klip juga berisi metadata yang memberi tahu Anda satu atau beberapa jenis MIME yang tersedia. Metadata ini membantu Anda memutuskan apakah aplikasi Anda dapat melakukan sesuatu yang berguna dengan data papan klip. Misalnya, jika memiliki aplikasi yang utamanya menangani teks, Anda mungkin perlu mengabaikan objek klip yang berisi URI atau Intent.

Anda juga dapat mengizinkan pengguna untuk menempelkan teks, apa pun bentuk datanya pada papan klip. Untuk melakukannya, Anda dapat mengonversi data papan klip menjadi teks, lalu menempelkan teks tersebut. Hal ini dijelaskan di bagian Mengonversi papan klip ke teks.

Class Papan Klip

Bagian ini menjelaskan class yang digunakan oleh framework papan klip.

ClipboardManager

Di sistem Android, papan klip sistem direpresentasikan oleh class ClipboardManager global. Anda tidak membuat instance class ini secara langsung, tetapi Anda akan mendapatkan referensi untuknya dengan memanggil getSystemService(CLIPBOARD_SERVICE).

ClipData, ClipData.Item, dan ClipDescription

Untuk menambahkan data ke papan klip, Anda harus membuat objek ClipData yang berisi deskripsi data dan data itu sendiri. Papan klip hanya menyimpan satu ClipData dalam satu waktu. ClipData berisi objek ClipDescription dan satu atau beberapa objek ClipData.Item.

Objek ClipDescription berisi metadata tentang klip. Secara khusus, objek ini berisi berbagai jenis MIME yang tersedia untuk data klip. Saat Anda menempatkan klip pada papan klip, array ini akan tersedia untuk aplikasi penempelan, yang dapat memeriksanya guna melihat apakah klip tersebut dapat menangani jenis MIME yang tersedia.

Objek ClipData.Item berisi data teks, URI, atau Intent:

Teks
CharSequence.
URI
Uri. Ini biasanya berisi URI penyedia konten, meskipun URI apa pun diizinkan. Aplikasi yang menyediakan data menempatkan URI pada papan klip. Aplikasi yang ingin menempelkan data akan mendapatkan URI dari papan klip dan menggunakannya untuk mengakses penyedia konten (atau sumber data lainnya), lalu mengambil data.
Intent
Intent. Jenis data ini memungkinkan Anda untuk menyalin pintasan aplikasi ke papan klip. Pengguna kemudian dapat menempelkan pintasan ke dalam aplikasi mereka untuk digunakan nanti.

Anda dapat menambahkan lebih dari satu objek ClipData.Item ke klip. Hal ini memungkinkan pengguna untuk menyalin dan menempelkan beberapa pilihan sebagai satu klip. Misalnya, jika memiliki widget daftar yang memungkinkan pengguna memilih lebih dari satu item dalam satu waktu, Anda dapat menyalin semua item ke papan klip sekaligus. Untuk melakukannya, buat ClipData.Item terpisah untuk setiap item daftar, lalu tambahkan objek ClipData.Item ke objek ClipData.

Metode kemudahan ClipData

Class ClipData menyediakan metode kemudahan statis untuk membuat objek ClipData dengan satu objek ClipData.Item dan objek ClipDescription sederhana:

newPlainText(label, text)
Menampilkan objek ClipData yang objek ClipData.Item tunggalnya berisi string teks. Label objek ClipDescription disetel ke label. Jenis MIME tunggal dalam ClipDescription adalah MIMETYPE_TEXT_PLAIN.

Gunakan newPlainText() untuk membuat klip dari string teks.

newUri(resolver, label, URI)
Menampilkan objek ClipData yang objek ClipData.Item tunggalnya berisi URI. Label objek ClipDescription disetel ke label. Jika URI-nya adalah URI konten (Uri.getScheme() menampilkan content:), metode ini akan menggunakan objek ContentResolver yang disediakan dalam resolver untuk mengambil jenis MIME yang tersedia dari penyedia konten dan menyimpannya dalam ClipDescription. Untuk URI yang bukan URI content:, metode akan menyetel jenis MIME ke MIMETYPE_TEXT_URILIST.

Gunakan newUri() untuk membuat klip dari URI, khususnya URI content:.

newIntent(label, intent)
Menampilkan objek ClipData yang objek ClipData.Item tunggalnya berisi Intent. Label objek ClipDescription disetel ke label. Jenis MIME disetel ke MIMETYPE_TEXT_INTENT.

Gunakan newIntent() untuk membuat klip dari objek Intent.

Mengonversi data papan klip ke teks

Meskipun aplikasi hanya menangani teks, Anda dapat menyalin data non-teks dari papan klip dengan mengonversinya menggunakan metode ClipData.Item.coerceToText().

Metode ini mengonversi data dalam ClipData.Item menjadi teks dan menampilkan CharSequence. Nilai yang ditampilkan ClipData.Item.coerceToText() didasarkan pada bentuk data dalam ClipData.Item:

Teks
Jika ClipData.Item adalah teks (getText() bukan null), coerceToText() akan menampilkan teks.
URI
Jika ClipData.Item adalah URI (getUri() bukan null), coerceToText() akan mencoba menggunakannya sebagai URI konten:
  • Jika URI adalah URI konten dan penyedia dapat menampilkan aliran teks, coerceToText() akan menampilkan aliran teks.
  • Jika URI adalah URI konten, tetapi penyedia tidak menawarkan aliran teks, coerceToText() akan menampilkan representasi URI. Representasinya sama dengan yang ditampilkan oleh Uri.toString().
  • Jika URI bukan URI konten, coerceToText() akan menampilkan representasi URI. Representasinya sama dengan yang ditampilkan oleh Uri.toString().
Intent
Jika ClipData.Item adalah Intent (getIntent() bukan null), coerceToText() akan mengonversinya menjadi URI Intent dan menampilkannya. Representasinya sama dengan yang ditampilkan oleh Intent.toUri(URI_INTENT_SCHEME).

Framework papan klip diringkas dalam Gambar 1. Untuk menyalin data, aplikasi akan menempatkan objek ClipData pada papan klip global ClipboardManager. ClipData berisi satu atau beberapa objek ClipData.Item dan satu objek ClipDescription. Untuk menempelkan data, aplikasi akan mendapatkan ClipData, mendapatkan jenis MIME dari ClipDescription, dan mendapatkan data dari ClipData.Item atau penyedia konten yang direferensikan oleh ClipData.Item.

Diagram blok framework salin dan tempel

Gambar 1. Framework papan klip Android

Menyalin ke Papan Klip

Seperti yang dijelaskan sebelumnya, untuk menyalin data ke papan klip, Anda akan mendapatkan handle ke objek ClipboardManager global, membuat objek ClipData, menambahkan ClipDescription dan satu atau beberapa objek ClipData.Item untuknya, serta menambahkan objek ClipData yang sudah selesai ke objek ClipboardManager. Hal tersebut dijelaskan secara detail dalam prosedur berikut:

  1. Jika Anda menyalin data menggunakan URI konten, siapkan penyedia konten.

    Aplikasi contoh Note Pad adalah contoh penggunaan penyedia konten untuk menyalin dan menempelkan. Class NotePadProvider menerapkan penyedia konten. Class NotePad mendefinisikan kontrak antara penyedia dan aplikasi lain, termasuk jenis MIME yang didukung.

  2. Dapatkan papan klip sistem:

    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);
    
  3. Salin data ke objek ClipData baru:

    • Untuk teks

      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!");
      
    • Untuk URI

      Cuplikan ini mengonstruksi URI dengan mengenkode ID catatan ke URI konten untuk penyedia. Teknik ini dibahas secara lebih detail di bagian Mengenkode ID pada URI:

      Kotlin

      // Creates a Uri based on 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 that you use 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 based on 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 that you use 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);
      
    • Untuk Intent

      Cuplikan ini mengonstruksi Intent untuk aplikasi, lalu menempatkannya dalam objek klip:

      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);
      
  4. Tempatkan objek klip baru di papan klip:

    Kotlin

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

    Java

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

Menempelkan dari Papan Klip

Seperti yang dijelaskan sebelumnya, Anda menempelkan data dari papan klip dengan mendapatkan objek papan klip global, mendapatkan objek klip, melihat datanya, dan jika dimungkinkan, menyalin data dari objek klip ke penyimpanan Anda sendiri. Bagian ini menjelaskan secara detail cara melakukannya untuk tiga bentuk data papan klip.

Menempelkan teks biasa

Untuk menempelkan teks biasa, terlebih dahulu dapatkan papan klip global dan verifikasi bahwa papan klip tersebut dapat menampilkan teks biasa. Setelah itu, dapatkan objek klip dan salin teks ke penyimpanan Anda menggunakan getText(), seperti yang dijelaskan dalam prosedur berikut:

  1. Dapatkan objek ClipboardManager global menggunakan getSystemService(CLIPBOARD_SERVICE). Selain itu, deklarasikan juga variabel global untuk memuat teks yang ditempelkan:

    Kotlin

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

    Java

    ClipboardManager clipboard = (ClipboardManager) getSystemService(Context.CLIPBOARD_SERVICE);
    String pasteData = "";
    
  2. Berikutnya, tentukan apakah Anda harus mengaktifkan atau menonaktifkan opsi "paste" di menu Aktivitas saat ini. Anda harus memverifikasi bahwa papan klip berisi klip dan Anda dapat menangani jenis data yang direpresentasikan oleh klip:

    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 if you can handle the data.
    pasteItem.isEnabled = when {
        !clipboard.hasPrimaryClip() -> {
            false
        }
        !(clipboard.primaryClipDescription.hasMimeType(MIMETYPE_TEXT_PLAIN)) -> {
            // This disables the paste menu item, since the clipboard has data but it is not plain text
            false
        }
        else -> {
            // This 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 if you can handle the data.
    if (!(clipboard.hasPrimaryClip())) {
    
        pasteItem.setEnabled(false);
    
    } else if (!(clipboard.getPrimaryClipDescription().hasMimeType(MIMETYPE_TEXT_PLAIN))) {
    
        // This disables the paste menu item, since the clipboard has data but it is not plain text
        pasteItem.setEnabled(false);
    } else {
    
        // This enables the paste menu item, since the clipboard contains plain text.
        pasteItem.setEnabled(true);
    }
    
  3. Salin data dari papan klip. Titik ini dalam program hanya dapat dijangkau jika item menu "paste" diaktifkan, sehingga Anda dapat mengasumsikan bahwa papan klip berisi teks biasa. Anda belum tahu apakah papan klip berisi string teks atau URI yang mengarah ke teks biasa. Cuplikan berikut mengujinya, tetapi hanya menunjukkan kode untuk menangani teks biasa:

    Kotlin

    when (menuItem.itemId) {
        ...
        R.id.menu_paste -> {    // Responds to the user selecting "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.
            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 does not 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 is not
                    // presented here.
                    pasteData = resolveUri(pasteUri)
                    true
                } else {
    
                    // Something is wrong. The MIME type was plain text, but the clipboard does not
                    // contain either 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 does not 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 is not
            // presented here.
            pasteData = resolveUri(Uri);
            return true;
        } else {
    
            // Something is wrong. The MIME type was plain text, but the clipboard does not contain either
            // text or a Uri. Report an error.
            Log.e(TAG, "Clipboard contains an invalid data type");
            return false;
        }
    }
    

Menempelkan data dari URI konten

Jika objek ClipData.Item berisi URI konten dan Anda telah menentukan bahwa Anda dapat menangani salah satu jenis MIME-nya, buat ContentResolver, lalu panggil metode penyedia konten yang sesuai untuk mengambil data.

Prosedur berikut menjelaskan cara mendapatkan data dari penyedia konten berdasarkan URI konten di papan klip. Prosedur ini akan memeriksa apakah jenis MIME yang dapat digunakan aplikasi tersedia dari penyedia:

  1. Deklarasikan variabel global untuk memuat jenis MIME:

    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";
    
  2. Dapatkan papan klip global. Dapatkan juga resolver konten agar Anda dapat mengakses penyedia konten:

    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();
    
  3. Dapatkan klip utama dari papan klip, dan dapatkan kontennya sebagai URI:

    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();
    
  4. Uji untuk melihat apakah URI merupakan URI konten dengan memanggil getType(Uri). Metode ini akan menampilkan null jika Uri tidak mengarah ke penyedia konten yang valid:

    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);
    
  5. Uji untuk melihat apakah penyedia konten mendukung jenis MIME yang dikenali oleh aplikasi saat ini. Jika ya, panggil ContentResolver.query() untuk mendapatkan data. Nilai yang ditampilkan adalah Cursor:

    Kotlin

            // If the return value is not 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 will vary according to the
                        // format of the data model.
                    }
    
                    // Kotlin `use` will automatically close the Cursor
                }
            }
        }
    }
    

    Java

            // If the return value is not 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 will vary according to the
                        // format of the data model.
                        }
                    }
    
                    // close the Cursor
                    pasteCursor.close();
                 }
             }
         }
    }
    

Menempelkan Intent

Untuk menempelkan Intent, terlebih dahulu dapatkan papan klip global. Periksa objek ClipData.Item untuk melihat apakah berisi Intent. Setelah itu, panggil getIntent() untuk menyalin Intent ke penyimpanan Anda sendiri. Cuplikan berikut menunjukkan hal tersebut:

Kotlin

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

// Checks to see if the clip item contains an Intent, by testing to see if 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 your application was expecting an Intent to be
    // on the clipboard
}

Java

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

// Checks to see if the clip item contains an Intent, by testing to see if 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 your application was expecting an Intent to be
    // on the clipboard
}

Menggunakan Penyedia Konten untuk Menyalin Data Kompleks

Penyedia konten mendukung penyalinan data kompleks seperti catatan database atau aliran file. Untuk menyalin data, Anda akan menempatkan URI konten di papan klip. Menempelkan aplikasi lalu mendapatkan URI ini dari papan klip dan menggunakannya untuk mengambil data database atau deskriptor aliran file.

Karena aplikasi penempelan hanya memiliki URI konten untuk data Anda, aplikasi harus mengetahui bagian data yang akan diambil. Anda dapat memberikan informasi ini dengan mengenkode ID untuk data di URI itu sendiri, atau Anda dapat memberikan URI unik yang akan menampilkan data yang ingin Anda salin. Teknik mana yang Anda pilih bergantung pada pengaturan data Anda.

Bagian berikut menjelaskan cara menyiapkan URI, cara menyediakan data kompleks, dan cara menyediakan aliran file. Deskripsinya mengasumsikan bahwa Anda sudah memahami prinsip umum desain penyedia konten.

Mengenkode ID pada URI

Teknik yang baik untuk menyalin data ke papan klip dengan URI adalah dengan mengenkode ID untuk data di URI itu sendiri. Penyedia konten Anda kemudian bisa mendapatkan ID dari URI dan menggunakannya untuk mengambil data. Aplikasi penempelan tidak harus mengetahui bahwa ID ada; yang perlu dilakukan hanyalah mendapatkan "reference" Anda (URI ditambah ID) dari papan klip, memberikannya kepada penyedia konten, dan mendapatkan kembali datanya.

Anda biasanya mengenkode ID ke URI konten dengan menggabungkannya ke bagian akhir URI. Misalnya, anggaplah Anda mendefinisikan URI penyedia Anda sebagai string berikut:

"content://com.example.contacts"

Jika Anda ingin mengenkode nama ke URI ini, Anda akan menggunakan cuplikan berikut:

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

Jika sudah menggunakan penyedia konten, Anda mungkin perlu menambahkan jalur URI baru yang mengindikasikan bahwa URI ini adalah untuk menyalin. Misalnya, anggaplah Anda sudah memiliki jalur URI berikut:

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

Anda dapat menambahkan jalur lain spesifik untuk menyalin URI:

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

Anda kemudian dapat mendeteksi URI "salin" dengan pencocokan pola dan menanganinya dengan kode yang spesifik untuk menyalin dan menempelkan.

Anda biasanya menggunakan teknik encoding jika sudah menggunakan penyedia konten, database internal, atau tabel internal untuk mengatur data Anda. Dalam hal ini, Anda memiliki beberapa bagian data yang ingin disalin, dan mungkin merupakan ID unik untuk setiap bagian. Sebagai respons atas kueri dari aplikasi penempelan, Anda dapat melihat data berdasarkan ID dan menampilkannya.

Jika tidak memiliki beberapa data, Anda mungkin tidak perlu mengenkode ID. Anda cukup menggunakan URI unik untuk penyedia Anda. Merespons kueri, penyedia Anda akan menampilkan data yang dimuatnya saat ini.

Mendapatkan catatan tunggal berdasarkan ID digunakan dalam aplikasi contoh Note Pad untuk membuka catatan dari daftar catatan. Contoh menggunakan kolom _id dari database SQL, tetapi Anda dapat menggunakan ID karakter atau numerik yang Anda inginkan.

Menyalin struktur data

Anda menyiapkan penyedia konten untuk menyalin dan menempelkan data kompleks sebagai subclass komponen ContentProvider. Anda juga harus mengenkode URI yang Anda tempatkan pada papan klip sehingga mengarah tepat ke catatan yang ingin Anda berikan. Selain itu, Anda juga harus mempertimbangkan status aplikasi yang ada:

  • Jika sudah memiliki penyedia konten, Anda dapat menambahkan fungsinya. Anda hanya perlu memodifikasi metode query() untuk menangani URI yang berasal dari aplikasi yang ingin menempelkan data. Anda mungkin perlu memodifikasi metode untuk menangani pola URI "salin".
  • Jika aplikasi Anda memiliki database internal, Anda dapat memindahkan database ini ke penyedia konten untuk mempermudah penyalinan database tersebut.
  • Jika saat ini tidak menggunakan database, Anda dapat menerapkan penyedia konten sederhana yang tujuannya adalah menawarkan data ke aplikasi yang ditempel dari papan klip.

Di penyedia konten, Anda dapat mengganti setidaknya metode berikut:

query()
Menempelkan aplikasi akan mengasumsikan bahwa aplikasi tersebut bisa mendapatkan data Anda menggunakan metode ini dengan URI yang Anda tempatkan di papan klip. Untuk mendukung penyalinan, Anda harus memiliki metode ini guna mendeteksi URI yang berisi jalur khusus "salin". Aplikasi Anda selanjutnya dapat membuat URI “salin” untuk ditempatkan di papan klip, yang berisi jalur penyalinan dan penunjuk tepat ke data yang ingin disalin.
getType()
Metode ini harus menampilkan satu atau beberapa jenis MIME untuk data yang ingin Anda salin. Metode newUri() memanggil getType() untuk menempatkan jenis MIME ke objek ClipData baru.

Jenis MIME untuk data kompleks dijelaskan dalam topik Penyedia Konten.

Perhatikan bahwa Anda tidak harus memiliki salah satu metode penyedia konten lain seperti insert() atau update(). Aplikasi penempelan hanya perlu mendapatkan jenis MIME yang didukung dan menyalin data dari penyedia Anda. Jika Anda sudah memilikinya, metode tersebut tidak akan mengganggu operasi penyalinan.

Cuplikan berikut menunjukkan cara menyiapkan aplikasi untuk menyalin data kompleks:

  1. Dalam konstanta global untuk aplikasi Anda, deklarasikan string URI dasar dan jalur yang mengidentifikasi string URI yang Anda gunakan untuk menyalin data. Selain itu, deklarasikan juga jenis MIME untuk data yang disalin:

    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";
    
  2. Di Aktivitas tempat pengguna menyalin data, siapkan kode untuk menyalin data ke papan klip. Merespons permintaan penyalinan, tempatkan URI pada papan klip:

    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)
    
            // Set 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);
    
        // Set the clipboard's primary clip.
        clipboard.setPrimaryClip(clip);
    
  3. Dalam cakupan global penyedia konten, buat matcher URI dan tambahkan pola URI yang akan cocok dengan URI yang Anda tempatkan di papan klip:

    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);
    
  4. Siapkan metode query(). Metode ini dapat menangani pola URI yang berbeda, bergantung pada cara Anda mengodekannya, tetapi hanya pola untuk operasi penyalinan papan klip yang akan ditampilkan:

    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 -> {
    
                // query and return the contact for the requested name. Here you would decode
                // the incoming URI, query the data model based on the last name, and return 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:
    
            // query and return the contact for the requested name. Here you would decode
            // the incoming URI, query the data model based on the last name, and return the result
            // as a Cursor.
    
        ...
    
    }
    
  5. Siapkan metode getType() untuk menampilkan jenis MIME yang sesuai untuk data yang disalin:

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

Bagian Menempelkan data dari URI konten menjelaskan cara mendapatkan URI konten dari papan klip dan menggunakannya untuk mendapatkan dan menempelkan data.

Menyalin aliran data

Anda dapat menyalin dan menempelkan teks dan data biner dalam jumlah besar sebagai aliran. Data dapat memiliki bentuk seperti berikut:

  • File yang disimpan di perangkat yang sebenarnya.
  • Aliran dari soket.
  • Data dalam jumlah besar yang disimpan dalam sistem database yang mendasari milik penyedia.

Penyedia konten untuk aliran data memberikan akses ke datanya dengan objek deskriptor file seperti AssetFileDescriptor, bukan objek Cursor. Aplikasi penempelan membaca aliran data menggunakan deskriptor file ini.

Untuk menyiapkan aplikasi Anda guna menyalin aliran data dengan penyedia, ikuti langkah berikut:

  1. Siapkan URI konten untuk aliran data yang Anda tempatkan di papan klip. Opsi untuk melakukan langkah ini mencakup hal berikut:
    • Enkode ID untuk aliran data ke URI, seperti yang dijelaskan di bagian Mengenkode ID pada URI , lalu simpan tabel di penyedia Anda yang berisi ID dan nama aliran yang sesuai.
    • Lakukan enkode nama aliran langsung di URI.
    • Gunakan URI unik yang selalu menampilkan aliran saat ini dari penyedia. Jika menggunakan opsi ini, Anda harus ingat untuk mengupdate penyedia agar mengarah ke aliran yang berbeda setiap kali Anda menyalin aliran ke papan klip melalui URI.
  2. Berikan jenis MIME untuk setiap jenis aliran data yang akan Anda tawarkan. Aplikasi penempelan memerlukan informasi ini untuk menentukan apakah penempelan data di papan klip dapat dilakukan.
  3. Terapkan salah satu metode ContentProvider yang menampilkan deskriptor file untuk aliran. Jika Anda mengenkode ID pada URI konten, gunakan metode ini untuk menentukan aliran yang akan dibuka.
  4. Untuk menyalin aliran data ke papan klip, buat URI konten dan tempatkan di papan klip.

Untuk menempelkan aliran data, aplikasi akan mendapatkan klip dari papan klip, mendapatkan URI, dan menggunakannya dalam panggilan ke metode deskriptor file ContentResolver yang membuka aliran. Metode ContentResolver memanggil metode ContentProvider yang sesuai, lalu meneruskannya ke URI konten. Penyedia Anda menampilkan deskriptor file ke metode ContentResolver. Aplikasi penempelan kemudian bertanggung jawab untuk membaca data dari aliran.

Daftar berikut menunjukkan metode deskriptor file yang paling penting untuk penyedia konten. Masing-masing memiliki metode ContentResolver yang sesuai dengan string "Descriptor" yang ditambahkan ke nama metode; misalnya, analog ContentResolver dari openAssetFile() adalah openAssetFileDescriptor():

openTypedAssetFile()
Metode ini seharusnya menampilkan deskriptor file aset, tetapi hanya jika jenis MIME yang diberikan didukung oleh penyedia. Pemanggil (aplikasi yang menempelkan) menyediakan pola jenis MIME. Penyedia konten (dari aplikasi yang telah menyalin URI ke papan klip) menampilkan tuas file AssetFileDescriptor jika dapat memberikan jenis MIME tersebut, atau memunculkan pengecualian bahwa tindakan tersebut tidak dapat dilakukan.

Metode ini menangani subbagian file. Anda dapat menggunakannya untuk membaca aset yang telah disalin oleh penyedia konten ke papan klip.

openAssetFile()
Metode ini adalah bentuk yang lebih umum dari openTypedAssetFile(). Metode ini tidak memfilter jenis MIME yang diizinkan, tetapi dapat membaca subbagian file.
openFile()
Ini adalah bentuk yang lebih umum dari openAssetFile(), dan tidak dapat membaca subbagian file.

Secara opsional, Anda dapat menggunakan openPipeHelper() dengan metode deskriptor file Anda. Cara ini memungkinkan aplikasi penempelan membaca data aliran di thread latar belakang menggunakan pipe. Untuk menggunakan metode ini, Anda perlu menerapkan antarmuka ContentProvider.PipeDataWriter. Contoh untuk melakukannya dapat dilihat di aplikasi contoh Note Pad, dalam metode openTypedAssetFile() NotePadProvider.java.

Mendesain Fungsi Salin/Tempel yang Efektif

Untuk mendesain fungsi salin dan tempel yang efektif bagi aplikasi Anda, ingat beberapa hal berikut:

  • Kapan pun, hanya akan ada satu klip di papan klip. Operasi penyalinan baru oleh aplikasi apa pun dalam sistem akan menimpa klip sebelumnya. Karena pengguna mungkin menavigasi keluar dari aplikasi Anda dan melakukan penyalinan sebelum kembali, Anda tidak dapat mengasumsikan bahwa papan klip berisi klip yang sebelumnya disalin pengguna dalam aplikasi Anda.
  • Tujuan yang dimaksud dengan adanya beberapa objek ClipData.Item per klip adalah untuk mendukung penyalinan dan penempelan beberapa pilihan dibandingkan dengan adanya berbagai bentuk referensi untuk satu pilihan. Anda biasanya ingin semua objek ClipData.Item dalam klip memiliki bentuk yang sama, itulah sebabnya objek tersebut harus berupa teks sederhana, URI konten, atau Intent, tetapi bukan gabungan di antaranya.
  • Saat memberikan data, Anda dapat menawarkan representasi MIME yang berbeda. Tambahkan jenis MIME yang didukung ke ClipDescription, lalu terapkan jenis MIME di penyedia konten Anda.
  • Saat Anda mendapatkan data dari papan klip, aplikasi Anda bertanggung jawab untuk memeriksa jenis MIME yang tersedia dan kemudian memutuskan data mana, jika ada, yang akan digunakan. Meskipun terdapat klip di papan klip dan pengguna meminta penempelan, aplikasi Anda tidak diharuskan untuk melakukan penyalinan. Anda harus melakukan penyalinan jika jenis MIME kompatibel. Anda dapat memilih untuk memaksa data di papan klip ke teks menggunakan coerceToText() jika menginginkannya. Jika aplikasi Anda mendukung lebih dari satu jenis MIME yang tersedia, Anda dapat mengizinkan pengguna untuk memilih mana yang akan digunakan.