Halaman ini diterjemahkan oleh Cloud Translation API.

Ringkasan siaran

Aplikasi Android mengirim dan menerima pesan siaran dari sistem Android dan aplikasi Android lainnya, mirip dengan pola desain publish-subscribe. Sistem dan aplikasi biasanya mengirim siaran saat peristiwa tertentu terjadi. Misalnya, sistem Android mengirimkan siaran saat berbagai peristiwa sistem terjadi, seperti booting sistem atau pengisian daya perangkat. Aplikasi juga mengirimkan siaran kustom, misalnya, untuk memberi tahu aplikasi lain tentang sesuatu yang mungkin menarik baginya (misalnya, download data baru).

Aplikasi dapat mendaftar untuk menerima siaran tertentu. Saat siaran dikirim, sistem akan otomatis mengarahkan siaran ke aplikasi yang telah berlangganan untuk menerima jenis siaran tertentu tersebut.

Secara umum, siaran dapat digunakan sebagai sistem pesan di seluruh aplikasi dan di luar alur penggunaan normal. Namun, Anda harus berhati-hati agar tidak menyalahgunakan kesempatan untuk merespons siaran dan menjalankan tugas di latar belakang yang dapat menyebabkan performa sistem lambat.

Tentang siaran sistem

Sistem otomatis mengirim siaran saat berbagai peristiwa sistem terjadi, seperti saat sistem beralih masuk dan keluar dari Mode Pesawat. Semua aplikasi yang berlangganan akan menerima siaran ini.

Objek Intent menggabungkan pesan siaran. String action mengidentifikasi peristiwa yang terjadi, seperti android.intent.action.AIRPLANE_MODE. Intent juga dapat menyertakan informasi tambahan yang digabungkan ke dalam kolom tambahannya. Misalnya, intent Mode Pesawat menyertakan tambahan boolean yang menunjukkan aktif tidaknya Mode Pesawat.

Untuk informasi selengkapnya tentang cara membaca intent dan mendapatkan string tindakan dari intent, lihat Intent dan Filter Intent.

Tindakan siaran sistem

Untuk daftar lengkap tindakan siaran sistem, lihat file BROADCAST_ACTIONS.TXT di Android SDK. Setiap tindakan siaran memiliki kolom konstanta yang terkait dengannya. Misalnya, nilai konstanta ACTION_AIRPLANE_MODE_CHANGED adalah android.intent.action.AIRPLANE_MODE. Dokumentasi untuk setiap tindakan siaran tersedia di kolom konstanta terkaitnya.

Perubahan pada siaran sistem

Seiring berkembangnya platform Android, platform ini secara berkala mengubah cara siaran sistem berperilaku. Perhatikan perubahan berikut untuk mendukung semua versi Android.

Android 14

Saat aplikasi berada dalam status cache, sistem akan mengoptimalkan pengiriman siaran untuk kesehatan sistem. Misalnya, sistem menunda siaran sistem yang kurang penting seperti ACTION_SCREEN_ON saat aplikasi dalam status yang di-cache. Setelah aplikasi beralih dari status yang di-cache ke siklus proses aktif, sistem akan mengirimkan siaran yang ditangguhkan.

Siaran penting yang dideklarasikan dalam manifes akan menghapus aplikasi dari status cache untuk pengiriman untuk sementara.

Android 9

Mulai Android 9 (API level 28), siaran NETWORK_STATE_CHANGED_ACTION tidak menerima informasi tentang lokasi pengguna atau data identitas pribadi.

Jika aplikasi Anda diinstal di perangkat yang menjalankan Android 9.0 (API level 28) atau yang lebih tinggi, sistem tidak menyertakan SSID, BSSID, informasi koneksi, atau hasil pemindaian dalam siaran Wi-Fi. Untuk mendapatkan informasi ini, panggil getConnectionInfo().

Android 8.0

Mulai dari Android 8.0 (API level 26), sistem menerapkan pembatasan tambahan pada penerima yang dinyatakan manifes.

Jika aplikasi Anda menargetkan Android 8.0 atau yang lebih baru, Anda tidak dapat menggunakan manifes untuk mendeklarasikan penerima untuk sebagian besar siaran implisit (siaran yang tidak menargetkan aplikasi Anda secara khusus). Anda masih dapat menggunakan penerima yang terdaftar dalam konteks saat pengguna menggunakan aplikasi Anda secara aktif.

Android 7.0

Android 7.0 (API level 24) dan yang lebih tinggi tidak mengirimkan siaran sistem berikut:

Selain itu, aplikasi yang menargetkan Android 7.0 dan yang lebih tinggi harus mendaftarkan siaran CONNECTIVITY_ACTION menggunakan registerReceiver(BroadcastReceiver, IntentFilter). Menyatakan penerima dalam manifes tidak akan berfungsi.

Menerima siaran

Aplikasi dapat menerima siaran dengan dua cara: melalui penerima yang terdaftar dalam konteks dan penerima yang dinyatakan manifes.

Penerima yang terdaftar dalam konteks

Penerima yang terdaftar dalam konteks akan menerima siaran selama konteks pendaftarannya valid. Ini biasanya antara panggilan ke registerReceiver dan unregisterReceiver. Konteks pendaftaran juga menjadi tidak valid saat sistem menghancurkan konteks yang sesuai. Misalnya, jika mendaftar dalam konteks Activity, Anda akan menerima siaran selama aktivitas tetap aktif. Jika mendaftar dengan konteks Aplikasi, Anda akan menerima siaran selama aplikasi berjalan.

Untuk mendaftarkan penerima dalam konteks, lakukan langkah-langkah berikut:

Dalam file build tingkat modul aplikasi, sertakan library AndroidX Core versi 1.9.0 atau yang lebih tinggi:

Groovy

dependencies {
    def core_version = "1.15.0"

    // Java language implementation
    implementation "androidx.core:core:$core_version"
    // Kotlin
    implementation "androidx.core:core-ktx:$core_version"

    // To use RoleManagerCompat
    implementation "androidx.core:core-role:1.0.0"

    // To use the Animator APIs
    implementation "androidx.core:core-animation:1.0.0"
    // To test the Animator APIs
    androidTestImplementation "androidx.core:core-animation-testing:1.0.0"

    // Optional - To enable APIs that query the performance characteristics of GMS devices.
    implementation "androidx.core:core-performance:1.0.0"

    // Optional - to use ShortcutManagerCompat to donate shortcuts to be used by Google
    implementation "androidx.core:core-google-shortcuts:1.1.0"

    // Optional - to support backwards compatibility of RemoteViews
    implementation "androidx.core:core-remoteviews:1.1.0"

    // Optional - APIs for SplashScreen, including compatibility helpers on devices prior Android 12
    implementation "androidx.core:core-splashscreen:1.2.0-alpha02"
}

Kotlin

dependencies {
    val core_version = "1.15.0"

    // Java language implementation
    implementation("androidx.core:core:$core_version")
    // Kotlin
    implementation("androidx.core:core-ktx:$core_version")

    // To use RoleManagerCompat
    implementation("androidx.core:core-role:1.0.0")

    // To use the Animator APIs
    implementation("androidx.core:core-animation:1.0.0")
    // To test the Animator APIs
    androidTestImplementation("androidx.core:core-animation-testing:1.0.0")

    // Optional - To enable APIs that query the performance characteristics of GMS devices.
    implementation("androidx.core:core-performance:1.0.0")

    // Optional - to use ShortcutManagerCompat to donate shortcuts to be used by Google
    implementation("androidx.core:core-google-shortcuts:1.1.0")

    // Optional - to support backwards compatibility of RemoteViews
    implementation("androidx.core:core-remoteviews:1.1.0")

    // Optional - APIs for SplashScreen, including compatibility helpers on devices prior Android 12
    implementation("androidx.core:core-splashscreen:1.2.0-alpha02")
}

Buat instance BroadcastReceiver:

Kotlin

val myBroadcastReceiver = MyBroadcastReceiver()

Java

MyBroadcastReceiver myBroadcastReceiver = new MyBroadcastReceiver();

Buat instance IntentFilter:

Kotlin

val filter = IntentFilter("com.example.snippets.ACTION_UPDATE_DATA")

Java

IntentFilter filter = new IntentFilter("com.example.snippets.ACTION_UPDATE_DATA");

Pilih apakah penerima siaran harus diekspor dan terlihat oleh aplikasi lain di perangkat. Jika penerima ini memproses siaran yang dikirim dari sistem atau dari aplikasi lain—bahkan aplikasi lain yang Anda miliki—gunakan tanda RECEIVER_EXPORTED. Jika penerima ini hanya memproses siaran yang dikirim oleh aplikasi Anda, gunakan tanda RECEIVER_NOT_EXPORTED.

Beberapa siaran sistem berasal dari aplikasi dengan hak istimewa tinggi, seperti Bluetooth dan telepon, yang merupakan bagian dari framework Android, tetapi tidak berjalan di bawah ID proses unik (UID) sistem. Untuk menerima semua siaran sistem, termasuk siaran dari aplikasi yang memiliki hak istimewa tinggi, tandai penerima Anda dengan RECEIVER_EXPORTED.

Jika Anda menandai penerima dengan RECEIVER_NOT_EXPORTED, penerima dapat menerima beberapa siaran sistem dan siaran dari aplikasi Anda, tetapi tidak menerima siaran dari aplikasi dengan hak istimewa tinggi.

Jika aplikasi Anda memproses beberapa siaran, tetapi hanya beberapa yang harus ditandai RECEIVER_NOT_EXPORTED dan beberapa RECEIVER_EXPORTED, bagi siaran di antara penerima siaran yang berbeda.
Kotlin
```
val listenToBroadcastsFromOtherApps = false
val receiverFlags = if (listenToBroadcastsFromOtherApps) {
    ContextCompat.RECEIVER_EXPORTED
} else {
    ContextCompat.RECEIVER_NOT_EXPORTED
}BroadcastReceiverSnippets.kt
```
Java
```
boolean listenToBroadcastsFromOtherApps = false;
int receiverFlags = listenToBroadcastsFromOtherApps
        ? ContextCompat.RECEIVER_EXPORTED
        : ContextCompat.RECEIVER_NOT_EXPORTED;BroadcastReceiverJavaSnippets.java
```
Perhatian: Jika Anda mengekspor penerima siaran, aplikasi lain dapat mengirim siaran yang tidak dilindungi ke aplikasi Anda.

Daftarkan penerima dengan memanggil registerReceiver():

Kotlin

ContextCompat.registerReceiver(context, myBroadcastReceiver, filter, receiverFlags)

Java

ContextCompat.registerReceiver(context, myBroadcastReceiver, filter, receiverFlags);

Untuk berhenti menerima siaran, panggil unregisterReceiver(android.content.BroadcastReceiver). Pastikan untuk membatalkan pendaftaran penerima saat Anda tidak lagi membutuhkannya atau konteks tidak lagi valid.

Membatalkan pendaftaran penerima siaran

Saat didaftarkan, penerima siaran menyimpan referensi ke Konteks yang Anda gunakan untuk mendaftarkannya. Hal ini berpotensi menyebabkan kebocoran jika cakupan yang terdaftar penerima melebihi cakupan siklus proses Konteks. Misalnya, hal ini dapat terjadi saat Anda mendaftarkan penerima di cakupan Aktivitas, tetapi Anda lupa untuk membatalkan pendaftarannya saat sistem menghancurkan Aktivitas. Oleh karena itu, selalu cabut pendaftaran penerima siaran Anda.

Kotlin

class MyActivity : ComponentActivity() {
    private val myBroadcastReceiver = MyBroadcastReceiver()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // ...
        ContextCompat.registerReceiver(this, myBroadcastReceiver, filter, receiverFlags)
        setContent { MyApp() }
    }

    override fun onDestroy() {
        super.onDestroy()
        // When you forget to unregister your receiver here, you're causing a leak!
        this.unregisterReceiver(myBroadcastReceiver)
    }
}BroadcastReceiverSnippets.kt

Java

class MyActivity extends ComponentActivity {
    MyBroadcastReceiver myBroadcastReceiver;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // ...
        ContextCompat.registerReceiver(this, myBroadcastReceiver, filter, receiverFlags);
        // Set content
    }
}BroadcastReceiverJavaSnippets.java

Mendaftarkan penerima dalam cakupan terkecil

Penerima siaran Anda hanya boleh didaftarkan jika Anda benar-benar tertarik dengan hasilnya. Pilih cakupan penerima yang sekecil mungkin:

Metode siklus proses LifecycleResumeEffect atau onResume/onPause aktivitas: Penerima siaran hanya menerima update saat aplikasi berada dalam status dilanjutkan.
Metode siklus proses LifecycleStartEffect atau onStart/onStop aktivitas: Penerima siaran hanya menerima update saat aplikasi berada dalam status dilanjutkan.
DisposableEffect: Penerima siaran hanya menerima update saat composable berada dalam hierarki komposisi. Cakupan ini tidak dilampirkan ke cakupan siklus proses aktivitas. Pertimbangkan untuk mendaftarkan penerima di konteks aplikasi. Hal ini karena composable secara teori dapat bertahan lebih lama dari cakupan siklus proses aktivitas dan membocorkan aktivitas.
Aktivitas onCreate/onDestroy: Penerima siaran menerima update saat aktivitas berada dalam status dibuat. Pastikan untuk membatalkan pendaftaran di onDestroy(), bukan onSaveInstanceState(Bundle) karena mungkin tidak dipanggil.
Cakupan kustom: Misalnya, Anda dapat mendaftarkan penerima dalam cakupan ViewModel, sehingga penerima tersebut tetap ada setelah pembuatan ulang aktivitas. Pastikan untuk menggunakan konteks aplikasi untuk mendaftarkan penerima, karena penerima dapat bertahan lebih lama dari cakupan siklus proses aktivitas dan membocorkan aktivitas.

Membuat composable stateful dan stateless

Compose memiliki composable stateful dan stateless. Mendaftarkan atau membatalkan pendaftaran penerima siaran di dalam composable akan membuatnya stateful. Composable ini bukan fungsi deterministik yang merender konten yang sama saat meneruskan parameter yang sama. Status internal dapat berubah berdasarkan panggilan ke penerima siaran yang terdaftar.

Sebagai praktik terbaik di Compose, sebaiknya Anda membagi composable menjadi versi stateful dan stateless. Oleh karena itu, sebaiknya Anda mengangkat pembuatan penerima siaran dari Composable untuk membuatnya stateless:

@Composable
fun MyStatefulScreen() {
    val myBroadcastReceiver = remember { MyBroadcastReceiver() }
    val context = LocalContext.current
    LifecycleStartEffect(true) {
        // ...
        ContextCompat.registerReceiver(context, myBroadcastReceiver, filter, flags)
        onStopOrDispose { context.unregisterReceiver(myBroadcastReceiver) }
    }
    MyStatelessScreen()
}

@Composable
fun MyStatelessScreen() {
    // Implement your screen
}BroadcastReceiverSnippets.kt

Penerima yang dinyatakan manifes

Jika Anda mendeklarasikan penerima siaran dalam manifes, sistem akan meluncurkan aplikasi saat siaran dikirim. Jika aplikasi belum berjalan, sistem akan meluncurkan aplikasi.

Untuk menyatakan penerima siaran dalam manifes, lakukan langkah-langkah berikut:

Tentukan elemen <receiver> di manifes aplikasi Anda.

<!-- If this receiver listens for broadcasts sent from the system or from
     other apps, even other apps that you own, set android:exported to "true". -->
<receiver android:name=".MyBroadcastReceiver" android:exported="false">
    <intent-filter>
        <action android:name="com.example.snippets.ACTION_UPDATE_DATA" />
    </intent-filter>
</receiver>AndroidManifest.xml

Filter intent akan menentukan tindakan siaran yang menjadi langganan penerima Anda.

Buat subclass BroadcastReceiver dan implementasikan onReceive(Context, Intent). Penerima siaran dalam contoh berikut mencatat dan menampilkan konten siaran:

Kotlin

class MyBroadcastReceiver : BroadcastReceiver() {

    @Inject
    lateinit var dataRepository: DataRepository

    override fun onReceive(context: Context, intent: Intent) {
        if (intent.action == "com.example.snippets.ACTION_UPDATE_DATA") {
            val data = intent.getStringExtra("com.example.snippets.DATA") ?: "No data"
            // Do something with the data, for example send it to a data repository:
            dataRepository.updateData(data)
        }
    }
}BroadcastReceiverSnippets.kt

Java

public static class MyBroadcastReceiver extends BroadcastReceiver {

    @Inject
    DataRepository dataRepository;

    @Override
    public void onReceive(Context context, Intent intent) {
        if (Objects.equals(intent.getAction(), "com.example.snippets.ACTION_UPDATE_DATA")) {
            String data = intent.getStringExtra("com.example.snippets.DATA");
            // Do something with the data, for example send it to a data repository:
            if (data != null) { dataRepository.updateData(data); }
        }
    }
}BroadcastReceiverJavaSnippets.java

Pengelola paket sistem akan mendaftarkan penerima setelah aplikasi terinstal. Penerima kemudian menjadi titik entri terpisah ke aplikasi Anda, yang berarti sistem dapat memulai aplikasi dan mengirimkan siaran jika aplikasi tidak berjalan.

Sistem membuat objek komponen BroadcastReceiver baru untuk menangani setiap siaran yang diterimanya. Objek ini hanya berlaku selama durasi panggilan ke onReceive(Context, Intent). Setelah kode Anda kembali dari metode ini, sistem menganggap komponen tersebut tidak lagi aktif.

Efek pada status proses

Apakah BroadcastReceiver Anda beroperasi atau tidak memengaruhi proses yang dikandungnya, yang dapat mengubah kemungkinan penghentian sistemnya. Proses latar depan menjalankan metode onReceive() penerima. Sistem menjalankan proses kecuali dalam tekanan memori ekstrem.

Sistem menonaktifkan BroadcastReceiver setelah onReceive(). Signifikansi proses host penerima bergantung pada komponen aplikasinya. Jika proses tersebut hanya menghosting penerima yang dideklarasikan manifes, sistem mungkin akan menghentikannya setelah onReceive() untuk mengosongkan resource bagi proses lain yang lebih penting. Hal ini umum terjadi untuk aplikasi yang belum pernah atau baru-baru ini tidak berinteraksi dengan pengguna.

Dengan demikian, penerima siaran tidak boleh memulai thread latar belakang yang berjalan lama. Sistem dapat menghentikan proses kapan saja setelah onReceive() untuk mendapatkan kembali memori, yang menghentikan thread yang dibuat. Agar proses tetap berjalan, jadwalkan JobService dari penerima menggunakan JobScheduler sehingga sistem mengetahui bahwa proses masih berfungsi. Ringkasan Pekerjaan Latar Belakang memberikan detail selengkapnya.

Mengirim siaran

Android menyediakan dua cara bagi aplikasi untuk mengirim siaran:

Metode sendOrderedBroadcast(Intent, String) mengirim siaran ke satu penerima dalam satu waktu. Karena setiap penerima dieksekusi secara bergantian, penerima dapat menyebarkan hasil ke penerima berikutnya. Hal ini juga dapat sepenuhnya membatalkan siaran agar tidak menjangkau penerima lain. Anda dapat mengontrol urutan penerima yang berjalan. Untuk melakukannya, gunakan atribut android:priority dari filter intent yang cocok. Penerima dengan prioritas yang sama dijalankan dalam urutan acak.
Metode sendBroadcast(Intent) mengirim siaran ke semua penerima dalam urutan yang tidak ditentukan. Ini disebut Siaran Normal. Hal ini lebih efisien, tetapi berarti penerima tidak dapat membaca hasil dari penerima lain, menyebarkan data yang diterima dari siaran, atau membatalkan siaran.

Cuplikan kode berikut menunjukkan cara mengirim siaran dengan membuat Intent dan memanggil sendBroadcast(Intent).

Kotlin

val intent = Intent("com.example.snippets.ACTION_UPDATE_DATA").apply {
    putExtra("com.example.snippets.DATA", newData)
    setPackage("com.example.snippets")
}
context.sendBroadcast(intent)BroadcastReceiverSnippets.kt

Java

Intent intent = new Intent("com.example.snippets.ACTION_UPDATE_DATA");
intent.putExtra("com.example.snippets.DATA", newData);
intent.setPackage("com.example.snippets");
context.sendBroadcast(intent);BroadcastReceiverJavaSnippets.java

Pesan siaran dikemas dalam objek Intent. String action intent harus memberikan sintaksis nama paket Java aplikasi dan mengidentifikasi peristiwa siaran secara unik. Anda dapat melampirkan informasi tambahan ke intent dengan putExtra(String, Bundle). Anda juga dapat membatasi siaran ke serangkaian aplikasi dalam organisasi yang sama dengan memanggil setPackage(String) di intent.

Membatasi siaran dengan izin

Izin memungkinkan Anda membatasi siaran ke sekumpulan aplikasi yang memiliki izin tertentu. Anda dapat menerapkan batasan pada pengirim atau penerima siaran.

Mengirim siaran dengan izin

Saat memanggil sendBroadcast(Intent, String) atau sendOrderedBroadcast(Intent, String, BroadcastReceiver, Handler, int, String, Bundle), Anda dapat menentukan parameter izin. Hanya penerima yang telah meminta izin dengan tag <uses-permission> dalam manifesnya yang dapat menerima siaran. Jika izin berbahaya, Anda harus memberikan izin sebelum penerima dapat menerima siaran. Misalnya, kode berikut mengirimkan siaran dengan izin:

Kotlin

context.sendBroadcast(intent, android.Manifest.permission.ACCESS_COARSE_LOCATION)

Java

context.sendBroadcast(intent, android.Manifest.permission.ACCESS_COARSE_LOCATION);

Untuk menerima siaran, aplikasi penerima harus meminta izin sebagai berikut:

<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />

Anda dapat menentukan izin sistem yang ada seperti BLUETOOTH_CONNECT atau menentukan izin kustom dengan elemen <permission>. Untuk informasi tentang izin dan keamanan secara umum, lihat Izin Sistem.

Menerima siaran dengan izin

Jika Anda menentukan parameter izin saat mendaftarkan penerima siaran (baik dengan registerReceiver(BroadcastReceiver, IntentFilter, String, Handler) atau dalam tag <receiver> dalam manifes), maka hanya penyiar yang telah meminta izin dengan tag <uses-permission> dalam manifesnya yang dapat mengirim Intent ke penerima. Jika izin berbahaya, penyiar juga harus diberi izin.

Misalnya, anggap aplikasi penerima Anda memiliki penerima yang dinyatakan manifes sebagai berikut:

<!-- If this receiver listens for broadcasts sent from the system or from
     other apps, even other apps that you own, set android:exported to "true". -->
<receiver
    android:name=".MyBroadcastReceiverWithPermission"
    android:permission="android.permission.ACCESS_COARSE_LOCATION"
    android:exported="true">
    <intent-filter>
        <action android:name="com.example.snippets.ACTION_UPDATE_DATA" />
    </intent-filter>
</receiver>AndroidManifest.xml

Atau aplikasi penerima Anda memiliki penerima yang terdaftar dalam konteks sebagai berikut:

Kotlin

ContextCompat.registerReceiver(
    context, myBroadcastReceiver, filter,
    android.Manifest.permission.ACCESS_COARSE_LOCATION,
    null, // scheduler that defines thread, null means run on main thread
    receiverFlags
)BroadcastReceiverSnippets.kt

Java

ContextCompat.registerReceiver(
        context, myBroadcastReceiver, filter,
        android.Manifest.permission.ACCESS_COARSE_LOCATION,
        null, // scheduler that defines thread, null means run on main thread
        receiverFlags
);BroadcastReceiverJavaSnippets.java

Kemudian, agar dapat mengirim siaran ke penerima tersebut, aplikasi yang mengirim harus meminta izin sebagai berikut:

<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />

Pertimbangan keamanan

Berikut beberapa pertimbangan keamanan untuk mengirim dan menerima siaran:

Jika banyak aplikasi yang telah terdaftar untuk menerima siaran yang sama dalam manifesnya, hal ini dapat membuat sistem meluncurkan banyak aplikasi, menyebabkan dampak yang signifikan pada performa perangkat dan pengalaman pengguna. Untuk menghindari hal ini, sebaiknya gunakan pendaftaran konteks daripada deklarasi manifes. Terkadang, sistem Android sendiri menerapkan penggunaan penerima yang terdaftar dalam konteks. Misalnya, siaran CONNECTIVITY_ACTION hanya dikirimkan ke penerima yang terdaftar dalam konteks.
Jangan menyiarkan informasi sensitif menggunakan intent implisit. Aplikasi apa pun dapat membaca informasi jika mendaftar untuk menerima siaran. Ada tiga cara untuk mengontrol siapa saja yang dapat menerima siaran Anda:
- Anda dapat menentukan izin saat mengirimkan siaran.
- Di Android 4.0 (API level 14) dan yang lebih baru, Anda dapat menentukan paket dengan setPackage(String) saat mengirim siaran. Sistem membatasi siaran ke sekumpulan aplikasi yang cocok dengan paket.
Saat Anda mendaftarkan penerima, semua aplikasi dapat mengirimkan siaran yang berpotensi berbahaya ke penerima aplikasi Anda. Ada beberapa cara untuk membatasi siaran yang diterima aplikasi Anda:
- Anda dapat menentukan izin saat mendaftarkan penerima siaran.
- Untuk penerima yang dinyatakan manifes, Anda dapat menetapkan atribut android:exported ke "false" di manifes. Penerima tidak menerima siaran dari sumber di luar aplikasi.
Ruang nama untuk tindakan siaran bersifat global. Pastikan nama tindakan dan string lainnya ditulis dalam namespace yang Anda miliki. Jika tidak, Anda mungkin tidak sengaja bertentangan dengan aplikasi lain.
Karena metode onReceive(Context, Intent) penerima berjalan di thread utama, metode tersebut harus dijalankan dan ditampilkan dengan cepat. Jika Anda perlu melakukan pekerjaan yang berjalan lama, berhati-hatilah saat membuat thread atau memulai layanan latar belakang karena sistem dapat menghentikan seluruh proses setelah onReceive() kembali. Untuk informasi selengkapnya, lihat Efek pada status proses Untuk menjalankan tugas yang berjalan lama, sebaiknya:
- Memanggil goAsync() dalam metode onReceive() penerima dan meneruskan BroadcastReceiver.PendingResult ke thread latar belakang. Tindakan ini akan membuat siaran tetap aktif setelah kembali dari onReceive(). Namun, meskipun dengan pendekatan ini, sistem mengharapkan Anda menyelesaikan siaran dengan sangat cepat (kurang dari 10 detik). Hal ini memungkinkan Anda memindahkan tugas ke thread lain untuk menghindari gangguan pada thread utama.
- Menjadwalkan tugas dengan JobScheduler. Untuk informasi selengkapnya, lihat Penjadwalan Tugas Cerdas.
Jangan memulai aktivitas dari penerima siaran karena pengalaman pengguna akan terasa janggal; terutama jika ada lebih dari satu penerima. Sebagai gantinya, pertimbangkan untuk menampilkan notifikasi.