lightbulb_outline Help shape the future of the Google Play Console, Android Studio, and Firebase. Start survey

Layanan Terikat

Layanan terikat adalah server di antarmuka klien-server. Layanan terikat memungkinkan komponen-komponen (seperti aktivitas) untuk diikat ke layanan, mengirim permintaan, menerima respons, dan bahkan melakukan komunikasi antarproses (IPC). Layanan terikat biasanya hidup hanya saat melayani komponen aplikasi lain dan tidak berjalan di latar belakang terus-menerus.

Dokumen ini menampilkan cara membuat layanan terikat, termasuk cara mengikat ke layanan dari komponen aplikasi lain. Akan tetapi, Anda juga harus mengacu dokumen Layanan untuk informasi tambahan tentang layanan secara umum, seperti cara menyampaikan notifikasi dari layanan, mengatur layanan agar berjalan di latar depan, dan lain-lain.

Dasar-Dasar

Layanan terikat adalah implementasi kelas Service yang memungkinkan aplikasi lain diikat padanya dan berinteraksi dengannya. Untuk menyediakan pengikatan bagi sebuah layanan, Anda harus mengimplementasikan metode callback onBind(). Metode ini mengembalikan objek IBinder yang mendefinisikan antarmuka pemrograman yang bisa digunakan klien untuk berinteraksi dengan layanan.

Klien bisa mengikat ke layanan dengan memanggil bindService(). Bila itu dilakukan, klien harus menyediakan implementasi ServiceConnection, yang memantau koneksi dengan layanan. Metode bindService() akan segera mengembalikan sebuah nilai, namun bila sistem Android membuat koneksi antara klien dan layanan, sistem akan memanggil onServiceConnected() pada ServiceConnection, untuk mengirim IBinder yang bisa digunakan klien untuk berkomunikasi dengan layanan.

Beberapa klien bisa terhubung ke layanan dengan serentak. Akan tetapi, sistem akan memanggil metode onBind() layanan Anda untuk mengambil IBinder hanya bila klien pertama mengikat. Sistem lalu memberikan IBinder yang sama ke setiap klien tambahan yang mengikat, tanpa memanggil onBind() lagi.

Bila klien terakhir melepas ikatan dari layanan, sistem akan menghapus layanan (kecuali jika layanan juga dimulai oleh startService()).

Bila Anda mengimplementasikan layanan terikat, yang terpenting adalah mendefinisikan antarmuka yang dikembalikan metode callback onBind() Anda. Ada sedikit cara mendefinisikan antarmuka IBinder layanan Anda dan bagian berikut akan membahas masing-masing teknik.

Membuat Layanan Terikat

Saat membuat layanan yang menyediakan pengikatan, Anda harus menyediakan IBinder yang menyediakan antarmuka pemrograman yang bisa digunakan klien untuk berinteraksi dengan layanan. Ada tiga cara untuk mendefinisikan antarmuka:

Memperluas kelas Binder
Jika layanan Anda bersifat privat untuk aplikasi Anda sendiri dan berjalan dalam proses yang sama dengan klien (biasanya), Anda harus membuat antarmuka dengan memperluas kelas Binder dan mengembalikan instance dari onBind(). Klien akan menerima Binder dan bisa menggunakannya untuk mengakses langsung metode publik yang tersedia dalam implementasi Binder atau bahkan Service.

Inilah teknik yang lebih disukai bila layanan Anda sekadar pekerja latar belakang untuk aplikasi Anda sendiri. Satu-satunya alasan tidak membuat antarmuka dengan cara ini adalah karena layanan Anda akan digunakan oleh aplikasi lain atau pada proses-proses terpisah.

Menggunakan Messenger
Jika antarmuka Anda perlu bekerja lintas proses, Anda bisa membuat antarmuka untuk layanan dengan Messenger. Dengan cara ini, layanan mendefinisikan Handler yang akan merespons beragam tipe objek Message. Handler ini adalah dasar bagi Messenger yang nanti bisa berbagi IBinder dengan klien, sehingga memungkinkan klien mengirim perintah ke layanan dengan menggunakan objek Message. Selain itu, klien bisa mendefinisikan sendiri Messenger sehingga layanan bisa mengirim balik pesan.

Inilah cara termudah melakukan komunikasi antarproses (IPC), karena Messenger akan mengantre semua permintaan ke dalam satu thread sehingga Anda tidak perlu mendesain layanan agar thread-safe.

Menggunakan AIDL
AIDL (Android Interface Definition Language) melakukan semua pekerjaan untuk mengurai objek menjadi primitif yang bisa dipahami dan diarahkan oleh sistem operasi ke berbagai proses untuk melakukan IPC. Teknik sebelumnya, dengan menggunakan Messenger, sebenarnya berdasarkan AIDL sebagai struktur yang mendasarinya. Seperti disebutkan di atas, Messenger membuat antrean semua permintaan klien dalam satu thread, sehingga layanan akan menerima permintaan satu per satu. Akan tetapi, jika ingin layanan Anda menangani beberapa permintaan sekaligus, Anda bisa menggunakan AIDL secara langsung. Dalam hal ini, layanan Anda harus mampu multi-thread dan dibuat thread-safe.

Untuk menggunakan AIDL secara langsung, Anda harus membuat file .aidl yang mendefinisikan antarmuka pemrograman. Alat Android SDK menggunakan file ini untuk menghasilkan kelas abstrak yang mengimplementasikan antarmuka dan menangani IPC, yang nanti bisa Anda perluas dalam layanan.

Catatan: Umumnya aplikasi tidak boleh menggunakan AIDL untuk membuat layanan terikat, karena hal itu mungkin memerlukan kemampuan multi-thread dan bisa mengakibatkan implementasi yang lebih rumit. Dengan demikian, AIDL tidak cocok untuk sebagian besar aplikasi dan dokumen ini tidak membahas cara menggunakannya untuk layanan Anda. Jika Anda yakin perlu menggunakan AIDL secara langsung, lihat dokumen AIDL .

Memperluas kelas Binder

Jika layanan Anda hanya digunakan oleh aplikasi lokal dan tidak perlu bekerja lintas proses, maka Anda bisa mengimplementasikan kelas Binder Anda sendiri yang memberi klien Anda akses langsung ke metode publik dalam layanan.

Catatan: Hal ini hanya berhasil jika klien dan layanan berada dalam aplikasi dan proses yang sama, suatu kondisi yang paling umum. Misalnya, cara ini sangat cocok untuk sebuah aplikasi musik yang perlu mengikat aktivitas ke layanannya sendiri, yakni memutar musik di latar belakang.

Berikut cara menyiapkannya:

  1. Dalam layanan Anda, buat sebuah instance Binder yang:
    • berisi metode publik yang bisa dipanggil klien
    • mengembalikan instance Service saat ini, yang memiliki metode publik yang bisa dipanggil klien
    • atau, mengembalikan instance kelas lain yang di-host di layanan dengan metode publik yang bisa dipanggil klien
  2. Kembalikan instance Binder ini dari metode callback onBind().
  3. Di klien, terima Binder dari metode callback onServiceConnected() dan buat panggilan ke layanan terikat dengan menggunakan metode yang disediakan.

Catatan: Alasan layanan dan klien harus berada dalam aplikasi yang sama adalah agar klien bisa mentransmisikan objek yang dikembalikan dan memanggil API-nya dengan benar. Layanan dan klien juga harus berada dalam proses yang sama, karena teknik ini tidak melakukan pengarahan (marshalling) apa pun untuk lintas proses.

Misalnya, berikut ini adalah layanan yang memberi klien akses ke metode-metode dalam layanan melalui implementasi Binder:

public class LocalService extends Service {
    // Binder given to clients
    private final IBinder mBinder = new LocalBinder();
    // Random number generator
    private final Random mGenerator = new Random();

    /**
     * Class used for the client Binder.  Because we know this service always
     * runs in the same process as its clients, we don't need to deal with IPC.
     */
    public class LocalBinder extends Binder {
        LocalService getService() {
            // Return this instance of LocalService so clients can call public methods
            return LocalService.this;
        }
    }

    @Override
    public IBinder onBind(Intent intent) {
        return mBinder;
    }

    /** method for clients */
    public int getRandomNumber() {
      return mGenerator.nextInt(100);
    }
}

LocalBinder menyediakan metode getService() bagi klien untuk mengambil instance LocalService saat ini. Cara ini memungkinkan klien memanggil metode publik dalam layanan. Misalnya, klien bisa memanggil getRandomNumber() dari layanan.

Inilah aktivitas yang mengikat ke LocalService dan memanggil getRandomNumber() bila tombol diklik:

public class BindingActivity extends Activity {
    LocalService mService;
    boolean mBound = false;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }

    @Override
    protected void onStart() {
        super.onStart();
        // Bind to LocalService
        Intent intent = new Intent(this, LocalService.class);
        bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
    }

    @Override
    protected void onStop() {
        super.onStop();
        // Unbind from the service
        if (mBound) {
            unbindService(mConnection);
            mBound = false;
        }
    }

    /** Called when a button is clicked (the button in the layout file attaches to
      * this method with the android:onClick attribute) */
    public void onButtonClick(View v) {
        if (mBound) {
            // Call a method from the LocalService.
            // However, if this call were something that might hang, then this request should
            // occur in a separate thread to avoid slowing down the activity performance.
            int num = mService.getRandomNumber();
            Toast.makeText(this, "number: " + num, Toast.LENGTH_SHORT).show();
        }
    }

    /** Defines callbacks for service binding, passed to bindService() */
    private ServiceConnection mConnection = new ServiceConnection() {

        @Override
        public void onServiceConnected(ComponentName className,
                IBinder service) {
            // We've bound to LocalService, cast the IBinder and get LocalService instance
            LocalBinder binder = (LocalBinder) service;
            mService = binder.getService();
            mBound = true;
        }

        @Override
        public void onServiceDisconnected(ComponentName arg0) {
            mBound = false;
        }
    };
}

Contoh di atas menampilkan cara klien mengikat ke layanan dengan menggunakan implementasi ServiceConnection dan callback onServiceConnected(). Bagian berikut menyediakan informasi selengkapnya tentang proses pengikatan ke layanan.

Catatan: Dalam contoh di atas, metode onStop() akan melepas klien dari layanan. Klien harus lepas dari layanan pada waktu yang tepat, seperti yang dibahas dalam Catatan Tambahan.

Untuk kode contoh selengkapnya, lihat kelas LocalService.java dan kelas LocalServiceActivities.java dalam ApiDemos.

Menggunakan Messenger

Jika layanan perlu berkomunikasi dengan proses jauh, Anda bisa menggunakan Messenger untuk menyediakan antarmuka bagi layanan Anda. Teknik ini memungkinkan Anda melakukan komunikasi antarproses (IPC) tanpa harus menggunakan AIDL.

Berikut ini rangkuman cara menggunakan Messenger:

Dengan cara ini, tidak ada "metode" untuk dipanggil klien pada layanan. Sebagai gantinya, klien mengirim "pesan" (objek-objek Message) yang diterima layanan dalam Handler-nya.

Berikut ini contoh layanan sederhana yang menggunakan antarmuka Messenger:

public class MessengerService extends Service {
    /** Command to the service to display a message */
    static final int MSG_SAY_HELLO = 1;

    /**
     * Handler of incoming messages from clients.
     */
    class IncomingHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MSG_SAY_HELLO:
                    Toast.makeText(getApplicationContext(), "hello!", Toast.LENGTH_SHORT).show();
                    break;
                default:
                    super.handleMessage(msg);
            }
        }
    }

    /**
     * Target we publish for clients to send messages to IncomingHandler.
     */
    final Messenger mMessenger = new Messenger(new IncomingHandler());

    /**
     * When binding to the service, we return an interface to our messenger
     * for sending messages to the service.
     */
    @Override
    public IBinder onBind(Intent intent) {
        Toast.makeText(getApplicationContext(), "binding", Toast.LENGTH_SHORT).show();
        return mMessenger.getBinder();
    }
}

Perhatikan bahwa metode handleMessage() dalam Handler adalah tempat layanan menerima Message yang masuk dan memutuskan aksi yang harus dilakukan, berdasarkan anggota what.

Klien tinggal membuat Messenger berdasarkan IBinder yang dikembalikan oleh layanan dan mengirim pesan menggunakan send(). Misalnya, inilah aktivitas sederhana yang mengikat ke layanan dan mengirim pesan MSG_SAY_HELLO ke layanan:

public class ActivityMessenger extends Activity {
    /** Messenger for communicating with the service. */
    Messenger mService = null;

    /** Flag indicating whether we have called bind on the service. */
    boolean mBound;

    /**
     * Class for interacting with the main interface of the service.
     */
    private ServiceConnection mConnection = new ServiceConnection() {
        public void onServiceConnected(ComponentName className, IBinder service) {
            // This is called when the connection with the service has been
            // established, giving us the object we can use to
            // interact with the service.  We are communicating with the
            // service using a Messenger, so here we get a client-side
            // representation of that from the raw IBinder object.
            mService = new Messenger(service);
            mBound = true;
        }

        public void onServiceDisconnected(ComponentName className) {
            // This is called when the connection with the service has been
            // unexpectedly disconnected -- that is, its process crashed.
            mService = null;
            mBound = false;
        }
    };

    public void sayHello(View v) {
        if (!mBound) return;
        // Create and send a message to the service, using a supported 'what' value
        Message msg = Message.obtain(null, MessengerService.MSG_SAY_HELLO, 0, 0);
        try {
            mService.send(msg);
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }

    @Override
    protected void onStart() {
        super.onStart();
        // Bind to the service
        bindService(new Intent(this, MessengerService.class), mConnection,
            Context.BIND_AUTO_CREATE);
    }

    @Override
    protected void onStop() {
        super.onStop();
        // Unbind from the service
        if (mBound) {
            unbindService(mConnection);
            mBound = false;
        }
    }
}

Perhatikan bahwa contoh ini tidak menampilkan cara layanan merespons klien. Jika ingin layanan merespons, Anda juga perlu membuat Messenger di klien. Lalu saat menerima callback onServiceConnected(), klien akan mengirim Message ke layanan yang berisi Messenger klien dalam parameter replyTo metode send().

Anda bisa melihat contoh cara menyediakan perpesanan dua arah dalam contoh MessengerService.java (layanan) dan MessengerServiceActivities.java (klien).

Mengikat ke Layanan

Komponen-komponen aplikasi (klien) bisa mengikat ke layanan dengan memanggil bindService(). Sistem Android lalu memanggil metode onBind() layanan, yang mengembalikan IBinder untuk berinteraksi dengan layanan.

Pengikatan ini bersifat asinkron. bindService() segera kembali dan tidak mengembalikan IBinder ke klien. Untuk menerima IBinder, klien harus membuat instance ServiceConnection dan meneruskannya ke bindService(). ServiceConnection berisi metode callback yang dipanggil sistem untuk mengirim IBinder.

Catatan: Hanya aktivitas, layanan, dan penyedia materi yang bisa mengikat ke layanan yang—Anda tidak bisa ikat ke layanan dari penerima siaran.

Jadi, untuk mengikat ke layanan dari klien, Anda harus:

  1. Implementasikan ServiceConnection.

    Implementasi Anda harus mengganti dua metode callback:

    onServiceConnected()
    Sistem memanggil ini untuk mengirim IBinder yang dikembalikan oleh metode onBind() layanan.
    onServiceDisconnected()
    Sistem Android memanggil ini bila koneksi ke layanan putus tanpa terduga, seperti ketika layanan mogok atau dimatikan. Ini tidak dipanggil ketika klien melepas ikatan.
  2. Panggil bindService(), dengan meneruskan implementasi ServiceConnection.
  3. Bila sistem memanggil metode callback onServiceConnected(), Anda bisa mulai membuat panggilan ke layanan, dengan menggunakan metode yang didefinisikan oleh antarmuka.
  4. Untuk memutus koneksi dari layanan, panggil unbindService().

    Jika klien Anda tetap terikat ke layanan saat aplikasi Anda memusnahkan klien, pemusnahan tersebut akan menyebabkan ikatan klien terputus. Praktik yang lebih baik adalah memutus ikatan klien begitu selesai berinteraksi dengan layanan. Hal itu memungkinkan layanan yang menganggur untuk dimatikan. Untuk informasi selengkapnya tentang waktu yang tepat untuk mengikat dan melepas, lihat Catatan Tambahan.

Misalnya, cuplikan berikut menghubungkan klien ke layanan yang dibuat di atas dengan memperluas kelas Binder, sehingga tinggal mentransmisikan IBinder yang dikembalikan ke kelas LocalService dan meminta instance LocalService:

LocalService mService;
private ServiceConnection mConnection = new ServiceConnection() {
    // Called when the connection with the service is established
    public void onServiceConnected(ComponentName className, IBinder service) {
        // Because we have bound to an explicit
        // service that is running in our own process, we can
        // cast its IBinder to a concrete class and directly access it.
        LocalBinder binder = (LocalBinder) service;
        mService = binder.getService();
        mBound = true;
    }

    // Called when the connection with the service disconnects unexpectedly
    public void onServiceDisconnected(ComponentName className) {
        Log.e(TAG, "onServiceDisconnected");
        mBound = false;
    }
};

Dengan ServiceConnection ini, klien bisa mengikat ke layanan dengan meneruskannya ke bindService(). Misalnya:

Intent intent = new Intent(this, LocalService.class);
bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
  • Parameter pertama bindService() adalah sebuah Intent yang secara eksplisit menyebutkan layanan yang akan diikat (walaupun maksud boleh implisit).
  • Parameter kedua adalah objek ServiceConnection.
  • Parameter ketiga adalah tanda (flag) yang menunjukkan opsi pengikatan. Tanda ini biasanya harus BIND_AUTO_CREATE agar dapat membuat layanan jika belum aktif. Nilai-nilai lain yang memungkinkan adalah BIND_DEBUG_UNBIND dan BIND_NOT_FOREGROUND, atau 0 bila tidak satu pun.

Catatan tambahan

Berikut ini beberapa catatan penting tentang mengikat ke layanan:

  • Anda harus selalu menjebak pengecualian DeadObjectException, yang dilontarkan bila koneksi terputus. Inilah satu-satunya pengecualian yang dilontarkan oleh metode jauh.
  • Objek adalah acuan yang dihitung lintas proses.
  • Anda biasanya harus memasangkan pengikatan dan pelepasan ikatan selama memasangkan momen membuat dan menghapus daur hidup klien. Misalnya:
    • Jika Anda hanya perlu berinteraksi dengan layanan saat aktivitas terlihat, Anda harus mengikat selama onStart() dan melepas ikatan selama onStop().
    • Jika Anda ingin aktivitas menerima tanggapan bahkan saat dihentikan di latar belakang, Anda bisa mengikat selama onCreate() dan melepas ikatan selama onDestroy(). Berhati-hatilah karena hal ini menyiratkan aktivitas Anda perlu menggunakan layanan selama dijalankan (sekalipun di latar belakang), jadi jika layanan berada dalam proses lain, Anda meningkatkan bobot proses dan semakin besar kemungkinan sistem akan mematikannya.

    Catatan: Anda biasanya tidak boleh mengikat dan melepas ikatan selama onResume() aktivitas Anda dan onPause(), karena callback ini terjadi pada setiap transisi daur hidup dan Anda harus menjaga pemrosesan yang terjadi pada transisi ini tetap minim. Juga, jika banyak aktivitas dalam aplikasi Anda mengikat ke layanan yang sama dan ada transisi antara dua aktivitas, layanan bisa dimusnahkan dan dibuat lagi sambil aktivitas saat ini melepas ikatan (selama jeda) sebelum aktivitas berikutnya mengikat (selama lanjutkan). (Transisi aktivitas ini untuk cara aktivitas mengoordinasikan daur hidupnya dijelaskan dalam dokumen Aktivitas .)

Untuk contoh kode selengkapnya, yang menampilkan cara mengikat ke layanan, lihat kelas RemoteService.java dalam ApiDemos.

Mengelola Daur Hidup Layanan Terikat

Bila layanan dilepas ikatannya dari semua klien, sistem Android akan menghapusnya (kecuali jika layanan juga dimulai dengan onStartCommand()). Dengan demikian, Anda tidak harus mengelola daur hidup layanan jika layanan itu murni sebuah layanan terikat—yang dikelola sistem Android untuk Anda berdasarkan apakah layanan terikat ke klien atau tidak.

Akan tetapi, Jika Anda memilih untuk mengimplementasikan metode callback onStartCommand(), maka Anda harus menghentikan layanan secara eksplisit, karena layanan sekarang dianggap telah dimulai. Dalam hal ini, layanan akan berjalan hingga menghentikan dirinya sendiri dengan stopSelf() atau komponen lain memanggil stopService(), terlepas dari apakah layanan terikat ke klien atau tidak.

Selain itu, jika layanan Anda telah dimulai dan menerima pengikatan, maka saat sistem memanggil metode onUnbind(), Anda bisa memilih untuk mengembalikan true jika ingin menerima panggilan ke onRebind() bila nanti klien mengikat ke layanan. onRebind() akan mengembalikan void, namun klien tetap menerima IBinder dalam callback onServiceConnected(). Di bawah ini adalah gambar 1 yang mengilustrasikan logika untuk jenis daur hidup ini.

Gambar 1. Daur hidup untuk layanan yang dimulai dan juga memungkinkan pengikatan.

Untuk informasi selengkapnya tentang daur hidup layanan yang telah dimulai, lihat dokumen Layanan.