Pemberitahuan

Pemberitahuan adalah pesan yang bisa Anda tampilkan kepada pengguna di luar UI normal aplikasi. Bila Anda memberi tahu sistem untuk mengeluarkan pemberitahuan, pemberitahuan akan muncul lebih dahulu sebagai ikon dalam area pemberitahuan. Untuk melihat detail pemberitahuan, pengguna membuka laci pemberitahuan. Baik area pemberitahuan maupun laci pemberitahuan adalah area-area yang dikontrol sistem yang bisa dilihat pengguna kapan saja.

Gambar 1. Pemberitahuan di area pemberitahuan.

Gambar 2. Pemberitahuan di laci pemberitahuan.

Catatan: Kecuali disebutkan, panduan ini mengacu pada kelas NotificationCompat.Builder dalam Support Library versi 4. Kelas Notification.Builder telah ditambahkan pada Android 3.0 (API level 11).

Pertimbangan Desain

Pemberitahuan, sebagai bagian penting dari antarmuka pengguna Android, memiliki panduan desainnya sendiri. Perubahan desain materi yang diperkenalkan dalam Android 5.0 (API level 21) adalah sangat penting, dan Anda harus meninjau pelatihan Desain Bahan untuk informasi selengkapnya. Untuk mengetahui cara mendesain pemberitahuan dan interaksinya, bacalah panduan desain Pemberitahuan.

Membuat Pemberitahuan

Anda menetapkan informasi dan tindakan UI bagi pemberitahuan dalam objek NotificationCompat.Builder. Untuk membuat pemberitahuan itu sendiri, panggil NotificationCompat.Builder.build(), yang akan mengembalikan objek Notification berisi spesifikasi Anda. Untuk mengeluarkan pemberitahuan, Anda meneruskan objek Notification ke sistem dengan memanggil NotificationManager.notify().

Isi pemberitahuan yang diperlukan

Objek Notification harus berisi yang berikut ini:

Isi dan pengaturan pemberitahuan opsional

Semua isi dan pengaturan pemberitahuan lainnya bersifat opsional. Untuk mengetahui selengkapnya tentang semua itu, lihat dokumentasi acuan untuk NotificationCompat.Builder.

Tindakan pemberitahuan

Walaupun bersifat opsional, Anda harus menambahkan setidaknya satu tindakan pada pemberitahuan. Tindakan memungkinkan pengguna beralih langsung dari pemberitahuan ke Activity dalam aplikasi Anda, tempat pengguna bisa melihat satu atau beberapa kejadian atau melakukan pekerjaan lebih jauh.

Pemberitahuan bisa menyediakan beberapa tindakan sekaligus. Anda harus selalu mendefinisikan tindakan yang akan diaktifkan bila pengguna mengklik pemberitahuan; biasanya tindakan ini akan membuka Activity dalam aplikasi Anda. Anda juga bisa menambahkan tombol pada pemberitahuan yang melakukan tindakan tambahan seperti mendiamkan alarm atau segera merespons pesan teks; fitur ini tersedia mulai Android 4.1. Jika menggunakan tombol tindakan tambahan, Anda juga harus membuat fungsionalitasnya tersedia dalam Activity di aplikasi Anda; lihat bagian Menangani kompatibilitas untuk detail selengkapnya.

Dalam Notification, tindakan itu sendiri didefinisikan oleh PendingIntent berisi Intent yang memulai Activity dalam aplikasi Anda. Untuk mengaitkan PendingIntent dengan gestur, panggil metode NotificationCompat.Builder yang sesuai. Misalnya, jika ingin memulai Activity bila pengguna mengklik teks pemberitahuan pada laci pemberitahuan, tambahkan PendingIntent dengan memanggil setContentIntent().

Memulai Activity bila pengguna mengklik pemberitahuan adalah skenario tindakan yang paling umum. Anda juga bisa memulai Activity bila pengguna menghilangkan pemberitahuan. Dalam Android 4.1 dan yang lebih baru, Anda bisa memulai Activity dari tombol tindakan. Untuk mengetahui selengkapnya, bacalah panduan acuan untuk NotificationCompat.Builder.

Prioritas pemberitahuan

Jika diinginkan, Anda bisa mengatur prioritas pemberitahuan. Prioritas berfungsi sebagai petunjuk bagi UI perangkat tentang cara menampilkan pemberitahuan. Untuk mengatur prioritas pemberitahuan, panggil NotificationCompat.Builder.setPriority() dan teruskan salah satu konstanta prioritas NotificationCompat. Ada lima level prioritas, mulai dari PRIORITY_MIN (-2) hingga PRIORITY_MAX (2); jika tidak diatur, prioritas default akan ditetapkan PRIORITY_DEFAULT (0).

Untuk informasi tentang mengatur level prioritas, lihat "Mengatur dan mengelola prioritas pemberitahuan dengan benar" dalam panduan Desain Pemberitahuan.

Membuat pemberitahuan sederhana

Cuplikan berikut mengilustrasikan pemberitahuan sederhana yang menetapkan aktivitas untuk dibuka bila pengguna mengklik pemberitahuan. Perhatikan bahwa kode ini membuat objek TaskStackBuilder dan menggunakannya untuk membuat PendingIntent untuk tindakan. Pola ini dijelaskan secara lebih detail di bagian Mempertahankan Navigasi saat Memulai Aktivitas:

NotificationCompat.Builder mBuilder =
        new NotificationCompat.Builder(this)
        .setSmallIcon(R.drawable.notification_icon)
        .setContentTitle("My notification")
        .setContentText("Hello World!");
// Creates an explicit intent for an Activity in your app
Intent resultIntent = new Intent(this, ResultActivity.class);

// The stack builder object will contain an artificial back stack for the
// started Activity.
// This ensures that navigating backward from the Activity leads out of
// your application to the Home screen.
TaskStackBuilder stackBuilder = TaskStackBuilder.create(this);
// Adds the back stack for the Intent (but not the Intent itself)
stackBuilder.addParentStack(ResultActivity.class);
// Adds the Intent that starts the Activity to the top of the stack
stackBuilder.addNextIntent(resultIntent);
PendingIntent resultPendingIntent =
        stackBuilder.getPendingIntent(
            0,
            PendingIntent.FLAG_UPDATE_CURRENT
        );
mBuilder.setContentIntent(resultPendingIntent);
NotificationManager mNotificationManager =
    (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
// mId allows you to update the notification later on.
mNotificationManager.notify(mId, mBuilder.build());

Demikian saja. Pengguna Anda kini telah diberi tahu.

Menerapkan layout yang diperluas pada pemberitahuan

Agar pemberitahuan muncul dalam tampilan yang diperluas, buat dahulu objek NotificationCompat.Builder dengan opsi tampilan normal yang Anda inginkan. Berikutnya, panggil Builder.setStyle() dengan objek layout yang diperluas sebagai argumennya.

Ingatlah bahwa pemberitahuan yang diperluas tidak tersedia pada platform-platform sebelum Android 4.1. Untuk mengetahui cara menangani pemberitahuan untuk Android 4.1 dan untuk platform-platform sebelumnya, bacalah bagian Menangani kompatibilitas.

Misalnya, cuplikan kode berikut memperagakan cara mengubah pemberitahuan yang dibuat dalam cuplikan sebelumnya untuk menggunakan layout yang diperluas:

NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(this)
    .setSmallIcon(R.drawable.notification_icon)
    .setContentTitle("Event tracker")
    .setContentText("Events received")
NotificationCompat.InboxStyle inboxStyle =
        new NotificationCompat.InboxStyle();
String[] events = new String[6];
// Sets a title for the Inbox in expanded layout
inboxStyle.setBigContentTitle("Event tracker details:");
...
// Moves events into the expanded layout
for (int i=0; i < events.length; i++) {

    inboxStyle.addLine(events[i]);
}
// Moves the expanded layout object into the notification object.
mBuilder.setStyle(inBoxStyle);
...
// Issue the notification here.

Menangani kompatibilitas

Tidak semua fitur pemberitahuan tersedia untuk versi tertentu, walaupun metode untuk mengaturnya ada dalam kelas pustaka dukungan NotificationCompat.Builder. Misalnya, tombol tindakan, yang bergantung pada pemberitahuan yang diperluas, hanya muncul pada Android 4.1 dan lebih tinggi, karena pemberitahuan yang diperluas itu sendiri hanya tersedia pada Android 4.1 dan yang lebih tinggi.

Untuk memastikan kompatibilitas terbaik, buatlah pemberitahuan dengan NotificationCompat dan subkelasnya, khususnya NotificationCompat.Builder. Selain itu, ikutilah proses ini bila Anda mengimplementasikan pemberitahuan:

  1. Sediakan semua fungsionalitas pemberitahuan kepada semua pengguna, terlepas dari versi yang mereka gunakan. Caranya, pastikan semua fungsionalitas tersedia dari Activity dalam aplikasi Anda. Anda mungkin perlu menambahkan sebuah Activity baru untuk melakukannya.

    Misalnya, jika Anda ingin menggunakan addAction() untuk menyediakan kontrol yang menghentikan dan memulai pemutaran media, implementasikan dahulu kontrol ini pada Activity dalam aplikasi Anda.

  2. Pastikan semua pengguna bisa memperoleh fungsionalitas dalam Activity, dengan memulainya bila pengguna mengklik pemberitahuan. Caranya, buatlah PendingIntent untuk Activity. Panggil setContentIntent() untuk menambahkan PendingIntent pada pemberitahuan.
  3. Kini tambahkan fitur pemberitahuan diperluas yang ingin Anda gunakan pada pemberitahuan. Ingatlah bahwa setiap fungsionalitas yang Anda tambahkan juga harus tersedia dalam Activity yang akan dimulai bila pengguna mengklik pemberitahuan.

Mengelola Pemberitahuan

Bila perlu mengeluarkan pemberitahuan beberapa kali untuk tipe kejadian yang sama, hindari membuat pemberitahuan yang sama sekali baru. Sebagai gantinya, Anda harus mempertimbangkan untuk memperbarui pemberitahuan sebelumnya, baik dengan mengubah sebagian nilainya atau dengan menambahkan nilai, atau keduanya.

Misalnya, Gmail akan memberi tahu pengguna bila ada email baru dengan menambah hitungan pesan tidak terbaca dan dengan menambahkan rangkuman tiap email ke pemberitahuan. Ini disebut dengan "stacking" (menumpuk) pemberitahuan; hal ini dijelaskan lebih detail dalam panduan Desain Pemberitahuan.

Catatan: Fitur Gmail ini mensyaratkan layout "kotak masuk" diperluas, yang merupakan bagian dari fitur pemberitahuan diperluas yang tersedia mulai Android 4.1.

Bagian berikut menjelaskan cara memperbarui pemberitahuan dan cara menghapusnya.

Memperbarui pemberitahuan

Untuk menyiapkan pemberitahuan agar bisa diperbarui, keluarkan pemberitahuan bersama ID pemberitahuan dengan memanggil NotificationManager.notify(). Untuk memperbarui pemberitahuan ini setelah Anda mengeluarkan, memperbarui, atau membuat objek NotificationCompat.Builder, buat objek Notification darinya, dan keluarkan Notification bersama ID yang sama dengan yang Anda gunakan sebelumnya. Jika pemberitahuan sebelumnya tetap terlihat, sistem akan memperbaruinya dari konten objek Notification. Jika pemberitahuan sebelumnya telah dihilangkan, sebuah pemberitahuan baru akan dibuat.

Cuplikan berikut memperagakan pemberitahuan yang diperbarui untuk mencerminkan jumlah kejadian yang telah terjadi. Cuplikan ini menumpuk pemberitahuan, yang menampilkan rangkuman:

mNotificationManager =
        (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
// Sets an ID for the notification, so it can be updated
int notifyID = 1;
mNotifyBuilder = new NotificationCompat.Builder(this)
    .setContentTitle("New Message")
    .setContentText("You've received new messages.")
    .setSmallIcon(R.drawable.ic_notify_status)
numMessages = 0;
// Start of a loop that processes data and then notifies the user
...
    mNotifyBuilder.setContentText(currentText)
        .setNumber(++numMessages);
    // Because the ID remains unchanged, the existing notification is
    // updated.
    mNotificationManager.notify(
            notifyID,
            mNotifyBuilder.build());
...

Menghapus pemberitahuan

Pemberitahuan tetap terlihat hingga salah satu kejadian berikut terjadi:

  • Pengguna menghilangkan pemberitahuan satu per satu atau dengan menggunakan "Clear All" (jika pemberitahuan bisa dihapus).
  • Pengguna mengklik pemberitahuan, dan Anda memanggil setAutoCancel() bila Anda telah membuat pemberitahuan.
  • Anda memanggil cancel() untuk ID pemberitahuan tertentu. Metode ini juga menghapus pemberitahuan yang berjalan.
  • Anda memanggil cancelAll(), yang menghapus semua pemberitahuan yang dikeluarkan sebelumnya.

Mempertahankan Navigasi saat Memulai Aktivitas

Bila memulai Activity dari pemberitahuan, Anda harus mempertahankan pengalaman navigasi yang diharapkan pengguna. Mengklik Back harus membawa pengguna kembali melalui aliran pekerjaan normal aplikasi ke layar Home, dan mengklik Recents harus menampilkan Activity sebagai tugas terpisah. Untuk mempertahankan pengalaman navigasi, Anda harus memulai Activity dalam tugas baru. Cara menyiapkan PendingIntent untuk memberi Anda tugas baru bergantung pada sifat Activity yang Anda mulai. Ada dua situasi umum:

Aktivitas rutin
Anda memulai Activity yang merupakan bagian dari aliran pekerjaan normal aplikasi. Dalam situasi ini, siapkan PendingIntent untuk memulai tugas baru, dan sediakan PendingIntent bersama back-stack yang meniru perilaku Back biasa.

Pemberitahuan dari aplikasi Gmail memperagakan hal ini. Bila Anda mengklik pemberitahuan untuk satu pesan email, Anda akan melihat pesan itu sendiri. Menyentuh Back akan membawa Anda kembali melalui Gmail ke layar Home, persis seperti jika memasuki Gmail dari layar Home bukannya memasukinya dari pemberitahuan.

Hal ini terjadi terlepas dari aplikasi tempat Anda berada saat menyentuh pemberitahuan. Misalnya, jika Anda dalam Gmail sedang menulis pesan, dan Anda mengklik pemberitahuan untuk satu email, Anda akan segera dibawa ke email itu. Menyentuh Back akan membawa Anda ke kotak masuk kemudian layar Home, bukannya membawa Anda ke pesan yang sedang ditulis.

Aktivitas khusus
Pengguna hanya melihat Activity ini jika dimulai dari pemberitahuan. Dalam beberapa hal, Activity akan memperluas pemberitahuan dengan menyediakan informasi yang akan sulit untuk ditampilkan dalam pemberitahuan itu sendiri. Untuk situasi ini, siapkan PendingIntent untuk dimulai dalam tugas baru. Tidak perlu membuat back-stack, karena Activity yang dimulai bukan bagian dari aliran aktivitas aplikasi. Mengklik Back tetap akan membawa pengguna ke layar Home.

Menyiapkan PendingIntent aktivitas biasa

Untuk menyiapkan PendingIntent yang memulai entri langsung Activity, ikuti langkah-langkah ini:

  1. Definisikan hierarki Activity aplikasi Anda dalam manifes.
    1. Tambahkan dukungan untuk Android 4.0.3 dan yang terdahulu. Caranya, tetapkan induk Activity yang Anda mulai dengan menambahkan elemen <meta-data> sebagai anak <activity>.

      Untuk elemen ini, atur android:name="android.support.PARENT_ACTIVITY". Atur android:value="<parent_activity_name>" dengan <parent_activity_name> sebagai nilai android:name untuk elemen induk <activity> . Lihat XML berikut sebagai contoh.

    2. Juga tambahkan dukungan untuk Android 4.1 dan yang lebih baru. Caranya, tambahkan atribut android:parentActivityName pada elemen <activity> dari Activity yang Anda mulai.

    XML akhir akan terlihat seperti ini:

    <activity
        android:name=".MainActivity"
        android:label="@string/app_name" >
        <intent-filter>
            <action android:name="android.intent.action.MAIN" />
            <category android:name="android.intent.category.LAUNCHER" />
        </intent-filter>
    </activity>
    <activity
        android:name=".ResultActivity"
        android:parentActivityName=".MainActivity">
        <meta-data
            android:name="android.support.PARENT_ACTIVITY"
            android:value=".MainActivity"/>
    </activity>
    
  2. Buat back-stack berdasarkan Intent yang memulai Activity:
    1. Buat Intent untuk memulai Activity.
    2. Buat stack-builder (pembangun tumpukan) dengan memanggil TaskStackBuilder.create().
    3. Tambahkan back-stack ke stack-builder dengan memanggil addParentStack(). Untuk setiap Activity dalam hierarki yang telah Anda definisikan dalam manifes, back-stack berisi objek Intent yang memulai Activity. Metode ini juga menambahkan flag yang memulai back-stack dalam tugas baru.

      Catatan: Walaupun argumen untuk addParentStack() adalah acuan ke Activity yang dimulai, panggilan metode tidak akan menambahkan Intent yang memulai Activity. Sebagai gantinya, hal itu ditangani dalam langkah berikutnya.

    4. Tambahkan Intent yang memulai Activity dari pemberitahuan, dengan memanggil addNextIntent(). Teruskan Intent yang Anda buat dalam langkah pertama sebagai argumen ke addNextIntent().
    5. Jika perlu, tambahkan argumen ke objek Intent pada back-stack dengan memanggil TaskStackBuilder.editIntentAt(). Kadang-kadang perlu memastikan apakah Activity target menampilkan data bermakna saat pengguna menelusurinya dengan menggunakan Back.
    6. Dapatkan PendingIntent untuk back-stack ini dengan memanggil getPendingIntent(). Anda nanti bisa menggunakan PendingIntent ini sebagai argumen untuk setContentIntent().

Cuplikan kode berikut memperagakan prosesnya:

...
Intent resultIntent = new Intent(this, ResultActivity.class);
TaskStackBuilder stackBuilder = TaskStackBuilder.create(this);
// Adds the back stack
stackBuilder.addParentStack(ResultActivity.class);
// Adds the Intent to the top of the stack
stackBuilder.addNextIntent(resultIntent);
// Gets a PendingIntent containing the entire back stack
PendingIntent resultPendingIntent =
        stackBuilder.getPendingIntent(0, PendingIntent.FLAG_UPDATE_CURRENT);
...
NotificationCompat.Builder builder = new NotificationCompat.Builder(this);
builder.setContentIntent(resultPendingIntent);
NotificationManager mNotificationManager =
    (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
mNotificationManager.notify(id, builder.build());

Menyiapkan PendingIntent aktivitas khusus

Bagian berikut menjelaskan cara menyiapkan aktivitas khusus PendingIntent.

Activity khusus tidak memerlukan back-stack, sehingga Anda tidak perlu mendefinisikan hierarki Activity-nya dalam manifes, dan Anda tidak perlu memanggil addParentStack() untuk membuat back-stack. Sebagai gantinya, gunakan manifes untuk menyiapkan opsi tugas Activity, dan buat PendingIntent dengan memanggil getActivity():

  1. Dalam manifes, tambahkan atribut berikut pada elemen <activity> untuk Activity
    android:name="activityclass"
    Nama kelas mutlak (fully qualified) aktivitas.
    android:taskAffinity=""
    Dikombinasikan dengan flag FLAG_ACTIVITY_NEW_TASK yang Anda atur dalam kode, ini memastikan bahwa Activity ini tidak masuk ke dalam tugas default aplikasi. Setiap tugas yang ada yang memiliki afinitas default aplikasi tidak terpengaruh.
    android:excludeFromRecents="true"
    Mengecualikan tugas baru dari Recents, sehingga pengguna tidak bisa tanpa sengaja mengarahkan kembali.

    Cuplikan ini menampilkan elemen:

    <activity
        android:name=".ResultActivity"
    ...
        android:launchMode="singleTask"
        android:taskAffinity=""
        android:excludeFromRecents="true">
    </activity>
    ...
    
  2. Buat dan keluarkan pemberitahuan:
    1. Buat Intent yang memulai Activity.
    2. Atur Activity untuk dimulai dalam tugas kosong yang baru dengan memanggil setFlags() dengan flag FLAG_ACTIVITY_NEW_TASK dan FLAG_ACTIVITY_CLEAR_TASK.
    3. Atur setiap opsi lain yang Anda perlukan untuk Intent.
    4. Buat PendingIntent dari Intent dengan memanggil getActivity(). Anda nanti bisa menggunakan PendingIntent ini sebagai argumen untuk setContentIntent().

    Cuplikan kode berikut memperagakan prosesnya:

    // Instantiate a Builder object.
    NotificationCompat.Builder builder = new NotificationCompat.Builder(this);
    // Creates an Intent for the Activity
    Intent notifyIntent =
            new Intent(this, ResultActivity.class);
    // Sets the Activity to start in a new, empty task
    notifyIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK
                            | Intent.FLAG_ACTIVITY_CLEAR_TASK);
    // Creates the PendingIntent
    PendingIntent notifyPendingIntent =
            PendingIntent.getActivity(
            this,
            0,
            notifyIntent,
            PendingIntent.FLAG_UPDATE_CURRENT
    );
    
    // Puts the PendingIntent into the notification builder
    builder.setContentIntent(notifyPendingIntent);
    // Notifications are issued by sending them to the
    // NotificationManager system service.
    NotificationManager mNotificationManager =
        (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
    // Builds an anonymous Notification object from the builder, and
    // passes it to the NotificationManager
    mNotificationManager.notify(id, builder.build());
    

Menampilkan Kemajuan dalam Pemberitahuan

Pemberitahuan bisa menyertakan indikator kemajuan beranimasi yang menampilkan status operasi yang berjalan kepada pengguna. Jika Anda bisa memperkirakan lamanya operasi berlangsung dan berapa banyak yang sudah selesai pada suatu waktu, gunakan bentuk indikator yang "pasti" (baris kemajuan). Jika Anda tidak bisa memperkirakan lamanya operasi, gunakan bentuk indikator "tidak pasti" (indikator aktivitas).

Indikator kemajuan ditampilkan bersama implementasi platform kelas ProgressBar.

Untuk menggunakan indikator kemajuan pada platform mulai dari Android 4.0, panggil setProgress(). Untuk versi sebelumnya, Anda harus membuat layout pemberitahuan custom sendiri yang menyertakan tampilan ProgressBar.

Bagian berikut ini menjelaskan cara menampilkan kemajuan dalam pemberitahuan dengan menggunakan setProgress().

Menampilkan indikator kemajuan berdurasi tetap

Untuk menampilkan baris kemajuan pasti, tambahkan baris itu ke pemberitahuan dengan memanggil setProgress(max, progress, false), kemudian keluarkan pemberitahuan. Selagi operasi berlangsung, tambah progress, dan perbarui pemberitahuan. Di akhir operasi, progress harus sama dengan max. Satu cara umum memanggil setProgress() adalah mengatur max ke 100, kemudian tambah progress sebagai nilai "persen selesai"untuk operasi itu.

Anda bisa membiarkan baris kemajuan ditampilkan saat operasi selesai, atau menghilangkannya. Dalam hal apa pun, ingatlah memperbarui teks pemberitahuan untuk menampilkan bahwa operasi telah selesai. Untuk menghapus baris kemajuan, panggil setProgress(0, 0, false). Misalnya:

...
mNotifyManager =
        (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
mBuilder = new NotificationCompat.Builder(this);
mBuilder.setContentTitle("Picture Download")
    .setContentText("Download in progress")
    .setSmallIcon(R.drawable.ic_notification);
// Start a lengthy operation in a background thread
new Thread(
    new Runnable() {
        @Override
        public void run() {
            int incr;
            // Do the "lengthy" operation 20 times
            for (incr = 0; incr <= 100; incr+=5) {
                    // Sets the progress indicator to a max value, the
                    // current completion percentage, and "determinate"
                    // state
                    mBuilder.setProgress(100, incr, false);
                    // Displays the progress bar for the first time.
                    mNotifyManager.notify(0, mBuilder.build());
                        // Sleeps the thread, simulating an operation
                        // that takes time
                        try {
                            // Sleep for 5 seconds
                            Thread.sleep(5*1000);
                        } catch (InterruptedException e) {
                            Log.d(TAG, "sleep failure");
                        }
            }
            // When the loop is finished, updates the notification
            mBuilder.setContentText("Download complete")
            // Removes the progress bar
                    .setProgress(0,0,false);
            mNotifyManager.notify(ID, mBuilder.build());
        }
    }
// Starts the thread by calling the run() method in its Runnable
).start();

Menampilkan indikator aktivitas berlanjut

Untuk menampilkan indikator aktivitas tidak pasti, tambahkan aktivitas ke pemberitahuan dengan setProgress(0, 0, true) (dua argumen pertama akan diabaikan), dan keluarkan pemberitahuan. Hasilnya adalah indikator yang memiliki gaya yang sama dengan baris kemajuan, hanya saja animasinya terus berjalan.

Keluarkan pemberitahuan di awal operasi. Animasi akan berjalan hingga Anda memodifikasi pemberitahuan. Bila operasi selesai, panggil setProgress(0, 0, false) kemudian perbarui pemberitahuan untuk menghapus indikator aktivitas. Selalu lakukan ini; jika makan animasi akan terus berjalan sekalipun operasi telah selesai. Juga ingatlah mengubah teks pemberitahuan untuk menunjukkan bahwa operasi telah selesai.

Untuk melihat cara kerja indikator aktivitas, lihat cuplikan terdahulu. Cari lokasi baris-baris berikut:

// Sets the progress indicator to a max value, the current completion
// percentage, and "determinate" state
mBuilder.setProgress(100, incr, false);
// Issues the notification
mNotifyManager.notify(0, mBuilder.build());

Ganti baris yang telah Anda temukan dengan baris berikut:

 // Sets an activity indicator for an operation of indeterminate length
mBuilder.setProgress(0, 0, true);
// Issues the notification
mNotifyManager.notify(0, mBuilder.build());

Metadata Pemberitahuan

Pemberitahuan dapat disortir sesuai metadata yang Anda tetapkan dengan metode NotificationCompat.Builder berikut:

  • setCategory() memberi tahu sistem cara menangani pemberitahuan aplikasi Anda bila perangkat berada dalam mode Priority (misalnya, jika pemberitahuan menyatakan suatu panggilan masuk, pesan instan, atau alarm).
  • setPriority() menyebabkan pemberitahuan dengan bidang prioritas diatur ke PRIORITY_MAX atau PRIORITY_HIGH muncul dalam jendela kecil mengambang jika pemberitahuan juga memiliki suara atau getaran.
  • addPerson() memungkinkan Anda menambahkan daftar orang ke pemberitahuan. Aplikasi Anda bisa menggunakannya untuk memberi isyarat pada sistem bahwa sistem harus mengelompokkan bersama pemberitahuan dari orang-orang yang ditetapkan, atau memberi peringkat lebih penting pada pemberitahuan untuk orang-orang ini.

Gambar 3. Aktivitas layar penuh yang menampilkan pemberitahuan pendahuluan

Pemberitahuan Pendahuluan

Dengan Android 5.0 (API level 21), pemberitahuan bisa muncul dalam jendela kecil mengambang (yang disebut juga dengan pemberitahuan pendahuluan) saat perangkat aktif (yakni, perangkat dibuka kuncinya dan layarnya menyala). Pemberitahuan ini muncul seperti bentuk ringkas pemberitahuan Anda, hanya saja pemberitahuan pendahuluan juga menampilkan tombol tindakan. Pengguna bisa menindaklanjuti atau mengabaikan, pemberitahuan pendahuluan tanpa meninggalkan aplikasi saat ini.

Contoh-contoh kondisi yang dapat memicu pemberitahuan pendahuluan antara lain:

  • Aktivitas pengguna berada dalam mode layar penuh (aplikasi menggunakan fullScreenIntent), atau
  • Pemberitahuan memiliki prioritas tinggi dan menggunakan nada dering atau getaran

Pemberitahuan Layar Kunci

Dengan rilis Android 5.0 (API level 21), pemberitahuan kini dapat muncul pada layar kunci. Aplikasi Anda bisa menggunakan fungsionalitas ini untuk menyediakan kontrol pemutaran media dan tindakan umum lainnya. Pengguna bisa memilih lewat Settings apakah akan menampilkan pemberitahuan pada layar kunci, dan Anda bisa mendesain apakah pemberitahuan aplikasi akan terlihat pada layar kunci.

Mengatur Visibilitas

Aplikasi Anda bisa mengatur level detail terlihat pada pemberitahuan yang ditampilkan di layar kunci aman. Anda memanggil setVisibility() dan menetapkan salah satu nilai berikut:

  • VISIBILITY_PUBLIC menampilkan isi lengkap pemberitahuan.
  • VISIBILITY_SECRET tidak menampilkan bagian apa pun dari pemberitahuan ini pada layar kunci.
  • VISIBILITY_PRIVATE menampilkan informasi dasar, misalnya ikon dan judul isi pemberitahuan, namun menyembunyikan isi lengkap pemberitahuan.

Bila VISIBILITY_PRIVATE telah diatur, Anda juga bisa menyediakan versi alternatif isi pemberitahuan yang menyembunyikan detail tertentu. Misalnya, aplikasi SMS dapat menampilkan pemberitahuan yang menampilkan Anda memiliki 3 pesan teks baru, namun menyembunyikan isi dan pengirim pesan. Untuk menyediakan pemberitahuan alternatif ini, buat dahulu pemberitahuan pengganti menggunakan NotificationCompat.Builder. Bila Anda membuat objek pemberitahuan privat, lampirkan pemberitahuan pengganti melalui metode setPublicVersion() .

Mengontrol Pemutaran Media pada Layar Kunci

Dalam Android 5.0 (API level 21) layar kunci tidak lagi menampilkan kontrol media berdasarkan RemoteControlClient, yang sekarang telah dihilangkan. Sebagai gantinya, gunakan template Notification.MediaStyle dengan metode addAction() , yang mengubah tindakan menjadi ikon yang bisa diklik.

Catatan: Template dan metode addAction() tidak disertakan dalam pustaka dukungan, sehingga fitur-fitur ini berjalan pada Android 5.0 dan yang lebih tinggi saja.

Untuk menampilkan kontrol pemutaran media di layar kunci dalam Android 5.0, atur visibilitas ke VISIBILITY_PUBLIC, seperti dijelaskan di atas. Kemudian tambahkan tindakan dan atur template Notification.MediaStyle, seperti dijelaskan dalam contoh kode berikut:

Notification notification = new Notification.Builder(context)
    // Show controls on lock screen even when user hides sensitive content.
    .setVisibility(Notification.VISIBILITY_PUBLIC)
    .setSmallIcon(R.drawable.ic_stat_player)
    // Add media control buttons that invoke intents in your media service
    .addAction(R.drawable.ic_prev, "Previous", prevPendingIntent) // #0
    .addAction(R.drawable.ic_pause, "Pause", pausePendingIntent)  // #1
    .addAction(R.drawable.ic_next, "Next", nextPendingIntent)     // #2
    // Apply the media style template
    .setStyle(new Notification.MediaStyle()
    .setShowActionsInCompactView(1 /* #1: pause button */)
    .setMediaSession(mMediaSession.getSessionToken())
    .setContentTitle("Wonderful music")
    .setContentText("My Awesome Band")
    .setLargeIcon(albumArtBitmap)
    .build();

Catatan: Dihilangkannya RemoteControlClient memiliki implikasi lebih jauh untuk mengontrol media. Lihat Kontrol Pemutaran Media untuk informasi selengkapnya tentang API baru untuk mengelola sesi media dan mengontrol pemutaran.

Layout Pemberitahuan Custom

Kerangka kerja pemberitahuan memungkinkan Anda mendefinisikan layout pemberitahuan custom, yang mendefinisikan penampilan pemberitahuan dalam objek RemoteViews. Pemberitahuan dengan layout custom serupa pemberitahuan normal, namun dibuat berdasarkan RemoteViews yang didefinisikan dalam file layout XML.

Tinggi yang tersedia untuk layout pemberitahuan custom bergantung pada tampilan pemberitahuan. Layout tampilan normal dibatasi hingga 64 dp, dan layout tampilan yang diperluas dibatasi hingga 256 dp.

Untuk mendefinisikan layout pemberitahuan custom, mulailah dengan membuat instance objek RemoteViews yang memekarkan file layout XML. Kemudian, sebagai ganti memanggil metode seperti setContentTitle(), panggil setContent(). Untuk mengatur detail isi pemberitahuan custom, gunakan metode dalam RemoteViews untuk mengatur nilai anak tampilan:

  1. Buat layout XML untuk pemberitahuan di file terpisah. Anda bisa menggunakan nama file apa saja yang diinginkan, namun Anda harus menggunakan ekstensi .xml
  2. Dalam aplikasi Anda, gunakan metode RemoteViews untuk mendefinisikan ikon dan teks pemberitahuan. Masukkan objek RemoteViews ini ke dalam NotificationCompat.Builder Anda dengan memanggil setContent(). Hindari mengatur Drawable latar belakang pada objek RemoteViews Anda, karena warna teks bisa menjadi tidak terbaca.

Kelas RemoteViews juga menyertakan metode yang bisa Anda gunakan untuk menambahkan Chronometer atau ProgressBar dengan mudah ke layout pemberitahuan Anda. Untuk informasi selengkapnya tentang cara membuat layout custom pemberitahuan Anda, lihat dokumentasi acuan RemoteViews.

Perhatian: Bila Anda menggunakan layout pemberitahuan custom, berhati-hatilah untuk memastikan bahwa layout custom itu bekerja pada berbagai orientasi dan resolusi perangkat. Walaupun berlaku bagi semua layout View, nasihat ini khususnya penting untuk pemberitahuan karena ruang di laci pemberitahuan sangat terbatas. Jangan buat layout custom terlalu kompleks, dan pastikan mengujinya di berbagai konfigurasi.

Menggunakan sumber daya gaya untuk teks pemberitahuan custom

Selalu gunakan sumber daya gaya untuk teks pemberitahuan custom. Warna latar belakang pemberitahuan bisa bervariasi di berbagai perangkat dan versi, dan menggunakan sumber daya gaya membantu Anda menangani hal ini. Mulai Android 2.3, sistem mendefinisikan sebuah gaya untuk teks layout pemberitahuan standar. Jika Anda menggunakan gaya yang sama dalam aplikasi yang menargetkan Android 2.3 atau yang lebih tinggi, Anda akan memastikan bahwa teks terlihat pada latar belakang tampilan.