Membuat pengguna memasang aplikasimu hanyalah setengah dari pertarunganmu. Membuat mereka menggunakannya secara reguler adalah setengahnya lagi. Ini cukup mungkin bahwa penggunamu sudah sepenuhnya lupa mengenai aplikasimu setelah memakainya sekali atau dua kali. Dengan semua aplikasi baru lainnya yang berkompetisi untuk mendapatkan perhatian.
Dengan menggunakan push notifications, kamu bisa mengingatkan pengguna mengenai aplikasimu tiap saat. Lalu, meningkatkan kesempatan aplikasimu tetap terpasang di perangkat mereka.
Google Cloud Messaging, disingkat GCM, adalah layanan gratis yang bisa kamu gunakan untuk mengirim push notifications ke penggunamu. di panduan ini, kamu akan belajar cara menggunakannya untuk membuat sebuah aplikasi Android yang bisa menerima push notifications, dan sebuah server-side Python sederhana yang bisa membuat dan mengirimnya.
Kenapa Menggunakan Google Cloud Messaging?
Untuk kebanyakan komunikasi klien-server, klien-nya akan membuat permintaan untuk menerima dari dari server. Dengan kata lain, klien menarik data dari server. Pada kasus push notifications, server-nya yang membuat transfer data.
Ini biasanya diselesaikan dengan menjaga koneksi TCP/IP terus-menerus - koneksi yang tetap terbuka tanpa batas waktu - di antara server dan klien. Ini mungkin terdengar bagus, tapi jika kamu memiliki aplikasi populer, menjaga ribuan koneksi antara server dan perangkat penggunamu bisa jadi sangat mahal.
Google Cloud Messaging adalah sebuah jasa yang menyelesaikan masalah ini dengan berperan sebagai penengah antara server dan pengguna perangkat. Dengan GCM, Google's Cloud Connection Server, sering disebut CCS, mengatur koneksi terus-menerus untukmu. Dia juga memastikan bahwa push notification diantar dengan aman dan andal.
Prasyarat
Untuk terus melanjutkan, kamu membutuhkan:
- Versi terbaru dari Android Studio
- Python 2.7.6 atau lebih tinggi
- Perangkat yang menjalankan Android 4.4 atau lebih tinggi dengan Google Play Services terpasang.
1. Mengatur Proyek Android Studio
Nyalakan Android Studio dan buat sebuah proyek dengan sebuah
Activity kosong. Jika kamu menggunakan yang bawaan, proyeknya seharusnya memiliki sebuah Java class di MainActivity.java.Langkah 1: Menambahkan Dependencies
Di proyek ini, kita akan menggunakan Google Services gradle plugin untuk mengonfigurasi GCM Masukkan dia ke proyek dengan menambahkan baris berikut di bagian
dependencies dari build.gradle proyek:
1
| classpath 'com.google.gms:google-services:1.5.0' |
Selanjutnya, terapkan plugin-nya di modul
app build.gradle:
1
| apply plugin: 'com.google.gms.google-services' |
Untuk bisa menggunakan GCM API, tambahkan
com.google.android.gms:play-services Sebagai compiledependency di berkas yang sama:
1
| compile "com.google.android.gms:play-services:8.3.0" |
Jika kamu mengklik tombol Sync Now, kamu harusnya melihat error berikut:
Klik tautan Install Repository and sync project untuk memperbaiki error-nya.
Langkah 2: Memperbaharui Manifest
Dalam berkan proyek AndroidManifest.xml, buat dan gunakan sebuah izin C2D_MESSAGE kostum berdasarkan nama paket proyekmu. Pastikan bahwa
protectionLevel dari izin diatur ke signature.
1
2
3
4
5
| <permission android:name="com.github.hathibelagal.pn.permission.C2D_MESSAGE" android:protectionLevel="signature" /><uses-permission android:name="com.github.hathibelagal.pn.permission.C2D_MESSAGE" /> |
Notifikasi diterima dalam bentuk broadcasts. Untuk menangani broadcast tersebut, aplikasi kita membutuhkan sebuah
BroadcastReceiver. Namun, kita tidak perlu membuatnya secara manual. Kita bisa menggunakan class GcmReceiver sebagai BroadcastReceiver.BroadcastReceiver harus memiliki intent-filter yang merespon aksi com.google.android.c2dm.intent.RECEIVE dan nama category -nya harus sesuai dengan nama paket proyek. Tambahkan kode berikut ke manifest-nya:
1
2
3
4
5
6
7
8
9
| <receiver android:name="com.google.android.gms.gcm.GcmReceiver" android:exported="true" android:permission="com.google.android.c2dm.permission.SEND" > <intent-filter> <action android:name="com.google.android.c2dm.intent.RECEIVE" /> <category android:name="com.github.hathibelagal.pn" /> </intent-filter></receiver> |
2. Mendapatkan Server API Key dan Sender ID
Sementara berkomunikasi dengan Cloud Connection Server, kita harus mengidentifikasi diri kita sendiri menggunakan API key di sisi server dan sender ID di sisi klien. Untuk mendapat API key dan sender ID, buat sebuah proyek baru di dalam developers console.
Mulai dengan mengklik tombol Pick a platform. Lalu, klik tombol Enable service for my Android App. Saat kamu melakukannya, kamu akan diminta untuk memasukkan sebuah nama dan nama paket untuk aplikasi Android-mu. Pastikan bahwa nama paket Android yang kamu sediakan cocok dengan nama paket yang kamu masukkan saat kamu membuat proyek Android Studio.
Selanjutnya, klik tombol Choose and configure services di bawah. Kamu sekarang bisa memilih layanan Google yang ingin kamu tambahkan ke aplikasi.
Sekarang, klik tombol Cloud Messaging lalu klik Enable Google Cloud Messaging. Setelah beberapa detik, kamu akan ditampilkan dengan server API key dan sender ID. Buat sebuah catatan dari server API key dan tekan Close.
plugin Google Services yang kita tambahkan sebelumnya membutuhkan berkas konfigurasi agar bekerja dengan benar. Buat berkasnya dengan mengklik tombol Generate configuration files.
Setelah berkasnya dibuat, unduh dia dan letakkan di dalam direktori aplikasi proyek Android Studio.
3. Mendaftarkan Kliennya
GCM mengidentifikasi perangkat Android menggunakan token registrasi. Maka, aplikasi kita harus bisa mendaftarkan dirinya untuk tiap perangkat Android di mana dia terpasang.
Langkah 1: Membuat sebuah Layanan Pendaftaran
Pendaftarannya harus diselesaikan di latarbelakang karena proses ini akan menghabiskan beberapa waktu tergantung dari konektivitas jaringan. Karena pendaftarannya tidak membutuhkan input apapun dari pengguna,
IntentService cocok untuk tugas ini.
Buat sebuah class Java baru bernama RegistrationService.java, buat dia jadi ssubclass dari
IntentServicedan timpa dengan metode onHandleIntent -nya.
01
02
03
04
05
06
07
08
09
10
| public class RegistrationService extends IntentService { public RegistrationService() { super("RegistrationService"); } @Override protected void onHandleIntent(Intent intent) { }} |
Di dalam metode
onHandIntent, kita bisa menggunakan Instance ID API untuk menghasilkan atau mengambil token pendaftaran. Pertama, buat instance dari class InstanceID, menggunakan metode getInstance -nya.
1
| InstanceID myID = InstanceID.getInstance(this); |
Sekarang kita bisa menggunakan metode
getToken dari objek InstanceID untuk mendapatkan token pendaftaran dalam bentuk sebuah String. getToken mengharapkan sender ID sebagai argumen-nya. Karena kita telah menambahkan berkas google-services.json ke proyek kita, kita bisa melewatkan sender ID ke metode-nya menggunakan R.string.gcm_defaultSenderID.
1
2
3
4
5
| String registrationToken = myID.getToken( getString(R.string.gcm_defaultSenderId), GoogleCloudMessaging.INSTANCE_ID_SCOPE, null); |
Jika kamu ingin melihat konten dari token pendaftaran untuk urusan debugging, kamu bisa log dia sebagai pesan debug menggunakan metode
Log.d.
1
| Log.d("Registration Token", registrationToken); |
Pada titik ini, kamu bisa mengirim token registrasi ke server situsmu dan menyimpannya ke database di sana. Namun, kamu tidak perlu melakukan ini jika kamu tidak berencana merujuk penggunamu satu persatu. Jika kamu ingin mengirm pesan yang sama ke setiap pengguna, kamu harus mengikuti pendekatan publish-subscribe.
Sekarang saya akan menunjukkanmu cara berlangganan
topic bernama my_little_topic. Dia hanya membutuhkan dua baris kode. Pertama, buat sebuah instance baru dari class GcmPubSub menggunakan metode getInstance. Selanjtunya, panggil metode subscribe dan lewatkan token pedaftaran padanya bersama dengan nama dari topik.
1
2
| GcmPubSub subscription = GcmPubSub.getInstance(this);subscription.subscribe(registrationToken, "/topics/my_little_topic", null); |
Aplikasi kita sekarang bisa menerima semua push notification yang dipublikasikabn ke my_little_topic.
Terakhir, definisikan layanan di AndroidManifest.xml.
1
2
| <service android:name=".RegistrationService" android:exported="false" /> |
Layanan pendaftaran selesai.
Langkah 2: Membuat sebuah InstanceIDListenerService
Token pendaftaran disegarkan secara periodik. Karena itu, setiap aplikasi Android yang menggunakan GCM harus memiliki sebuah
InstanceIDListenerService yang bisa menangani penyegaran tersebut. Maka, buat sebuah berkas Java bernama TokenRefreshListenerService.java dan buat dia jadi sebuah subclass dari InstanceIDListenerService. Di dalam metode onTokenRefresh dari class. Karena kita perlu memulai proses registrasi lagi dengan memulai layanan pendaftaran menggunakan meotde Intent dan startService.
tambahkan kode berikut ke TokenRefreshListenerService.java:
1
2
3
4
5
6
7
| public class TokenRefreshListenerService extends InstanceIDListenerService { @Override public void onTokenRefresh() { Intent i = new Intent(this, RegistrationService.class); startService(i); }} |
Layanan ini juga harus bisa merespon aksi
com.google.android.gms.iid.InstanceID. Maka, sementara mendefinisikan layanan di AndroidManifest.xml, tambahkan intent-filter yang tepat.
1
2
3
4
5
6
7
| <service android:name=".TokenRefreshListenerService" android:exported="false"> <intent-filter> <action android:name="com.google.android.gms.iid.InstanceID" /> </intent-filter></service> |
Langkah 3: Memulai Layanan Pendaftaran.
Untuk memastikan proses registrasi-nya berlanjut sesaat setelah aplikasi dimulai. Kita harus memulai classs
RegistrationService di alam metode onCreate dari MainActivity. Untuk melakukannya, buat sebuah Intent dan gunakan metode startService.
1
2
| Intent i = new Intent(this, RegistrationService.class);startService(i); |
4. Menampilkan Push Notifications
GCM secara otomatis akan menampilkan push notification ke tray sesaat setelah mereka diterima. Namun, itu hanya terjadi jika aplikasi yang terasosiasi memiliki
GCMListenerService.
Buat sebuah class Java baru bernama NotificationsListenerService dan buat dia jadi subclass dari
GCMListenerService. Kecuali kamu ingin menangani data yang didorong olehmu sendiri, kamu tidak perlu menulis kode apapun di dalam class ini. Kita bisa meninggalkan class-nya kosong sekarang.
1
2
3
| public class NotificationsListenerService extends GcmListenerService {} |
Sementara mendefinisikan layanannya di AndroidManifest.xml, pastikan bahwa kamu menambahkan sebuah
intent-filter yang mengizinkan dia untuk merespon ke aksi com.google.android.c2dm.intent.RECEIVE.
1
2
3
4
5
6
7
| <service android:name=".NotificationsListenerService" android:exported="false" > <intent-filter> <action android:name="com.google.android.c2dm.intent.RECEIVE" /> </intent-filter></service> |
5. Menambahkan Ikon Push Notification
Setiap push notification harus memiliki ikon yang terasosiasi dengannya. Jika kamu tidak memiliki satu yang bagus, kamu bisa mendapatkan satu dari Google's Material Design Icons Library.
Setelah kamu mengunduh ikonnya, letakkan dia dia folder res dari proyekmu. Saya akan menggunakan ic_cloud_white_48dp sebagai ikonnya.
6. Menjalankan Aplikasi Android-nya
Aplikasi Android kita sekarang selesai. Saat kamu mengompilasi dan menjalankannya pada perangkat Android, kamu akan bisa melihat token pendaftaran di logcat.
Tekan tombol kembali di perangkatmu untuk keluar dari aplikasinya. Ini dibutuhkan karena GCM akan menampilkan push notifications secara otomatis hanya jika pengguna tidak menggunakan aplikasinya. Jika kamu ingin push notification-nya ditampilkan bahkan ketika aplikasinya berjalan. Kamu harus membuat notifikasinya di dalam
NotificationsListenerService menggunakan Notification.Builder class.7. Mengirim Push Notifications
Di bagian akhir dari panduan ini, kita akan membuat sebuah skrip Python sederhana yang bisa membuat dan mengirim push notification ke semua perangkat Android di mana aplikasi ktia terpasang.
Kamu bisa menjalankan skrip ini dari komputer lokal maupun server jauh di mana kamu memiliki akses SSH.
Langkah 1: Membuat Skrip
Buat sebuah berkas baru bernama send.py dan buka dengan editore teks favoritmu.
Pada bagian atar berkas, impor modul
urllib2 dan urllib. Kita akan menggunakan modul ini untuk mengirim data ke Google's Cloud Connection Server. Impor modul json dengan benar karena data yang kita kirim harus dalam JSON yang valid Terakhir. untuk mengakses argumen baris perintah, impor modul sys.
1
2
3
4
| from urllib2 import *import urllibimport jsonimport sys |
SElanjutnya, buat sebuah variabel yang menyimpan server API key yang kamu ambil dari catatan sebelumnya. Key-nya harus menjadi bagian dari setiap permintaan HTTP yang ktia buat ke CCS.
1
| MY_API_KEY="ABCDEF123456789ABCDE--12A" |
Setiap notifikasi harus memiliki judul dan badan. Ketimbang memogram mereka di skrip kita. Mari terima judul dan badan sebagai argumen baris perintah menggunakan array
argv.
1
2
| messageTitle = sys.argv[1]messageBody = sys.argv[2] |
Buat sebuah Python dictionary object baru untuk mewakili data yang harus dikirim ke CCS. Untuk aplikasi Android kita, agar bisa menerima notifikasi, dia harus dipublikasikan ke topik bernama my_litte_topic. Maka, tambahkan sebuah key bernama to ke dictionary dan atur nilainya ke /topics/my_little_topic.
Untuk mewakili konten dari notifikasi, tambahkan sebuah key bernama notification ke dictionary dan atur nilainya ke objek dictionary lainnya yang mengadung tiga kunci:
- body
- title
- icon
Pastikan bahwa nilai dari key
icon sama dengan nama dari icon yang bisa diambil dari proyek Android-mu.
1
2
3
4
5
6
7
8
| data={ "to" : "/topics/my_little_topic", "notification" : { "body" : messageBody, "title" : messageTitle, "icon" : "ic_cloud_white_48dp" }} |
Konversi dictionary-nya ke JSON string menggunakan fungsi
dumps dari modul json:
1
| dataAsJSON = json.dumps(data) |
Semua yang kita butuhkan sekarang adalah mengirim JSON string ke https://gcm-http.googleapis.com/gcm/send. Untuk melakukannya, buat sebuah objek
Request baru dan atur dataAsJSON sebagai datanya. Selanjutnya, atur header Authorization ke MY_API_KEY dan header Content-type ke application/json.
1
2
3
4
5
6
7
| request = Request( dataAsJSON, { "Authorization" : "key="+MY_API_KEY, "Content-type" : "application/json" }) |
Terakhir, untuk mengeksekusi permintaan dan mengambil responnya, lewatkan permintaan objek ke fungsi
urlopen dan panggil metode read -nya.
1
| print urlopen(request).read() |
Skrip Python-nya sekarang selesai dan siap dipakai.
Langkah 2: Menjalankan Skrip-nya
Pada titik ini, kita siap untuk mengirim push notification ke semua perangkat di mana aplikasi kita terpasang. Buka terminal dan masuk ke direktori di mana kamu membuat send.py
Lewatkan nama dari skrip ke executable
python bersama dengan sebuah string untuk judul notifikasi dan satu lagi untuk badan notifikasi-nya. Berikut adalah contoh yang bisa kamu gunakan:
1
| python send.py "My first push notification" "GCM API is wonderful!" |
Jika tidak ada error, kamu harusnya melihat respon seperti ini:
1
| {"message_id":12345676892321} |
Jika kamu mengecek perangkat Androidmu, kamu harusnya meliaht sebuah notifikasi baru di notification tray.
Kesimpulan
Sekarang kamu tahu cara mengirim push notifications ke penggunamu. PAda pelajaran ini, kamu belajar cara membuat aplikasi Android yang bisa mendaftarkan dirinya sendiri, dan menerima notifikasi yang dipublikasikan ke sebuah topik tertentu. Kamu juga belajar cara membuat skrip Python yang bisa mempublikasikan notifikasi.
Bahkan push notification bisa jadi cara bagus untuk berkomunikasi dengan penggunamu. Saya sarankan kamu menggunakan mereka di waktu luang dan hanya jika ada hal berguna untuk dikatakan. Karena mengirm terlalu banyak bisa jadi cara tercepat untuk membuat aplikasimu dihapus.
Untuk memperlajari lebih banyak mengenai Google Cloud Messaging, mengaculah ke Cloud Messaging Guide.
