Tổng quan về dịch vụ ràng buộc

Dịch vụ ràng buộc là máy chủ trong giao diện máy khách-máy chủ. Dịch vụ này cho phép các thành phần như hoạt động liên kết với dịch vụ, gửi yêu cầu, nhận phản hồi và thực hiện giao tiếp liên quy trình (IPC). Một dịch vụ ràng buộc thường chỉ tồn tại khi nó phục vụ một thành phần của ứng dụng khác và không chạy trong nền vô thời hạn.

Tài liệu này mô tả cách tạo một dịch vụ ràng buộc, bao gồm cả cách liên kết với dịch vụ từ các thành phần khác của ứng dụng. Để biết thêm thông tin về các dịch vụ nói chung, chẳng hạn như cách gửi thông báo từ một dịch vụ và đặt dịch vụ chạy trên nền trước, hãy tham khảo bài viết Tổng quan về dịch vụ.

Thông tin cơ bản

Dịch vụ ràng buộc là một cách triển khai lớp Service cho phép các ứng dụng khác liên kết và tương tác với dịch vụ đó. Để cung cấp liên kết cho một dịch vụ, bạn triển khai phương thức gọi lại onBind(). Phương thức này trả về một đối tượng IBinder xác định giao diện lập trình mà ứng dụng khách có thể sử dụng để tương tác với dịch vụ.

Liên kết với một dịch vụ đã khởi động

Như đã thảo luận trong phần Tổng quan về dịch vụ, bạn có thể tạo một dịch vụ vừa được khởi động vừa được liên kết. Tức là bạn có thể bắt đầu một dịch vụ bằng cách gọi startService(), cho phép dịch vụ chạy vô thời hạn. Bạn cũng có thể cho phép ứng dụng liên kết với dịch vụ bằng cách gọi bindService().

Nếu bạn cho phép dịch vụ của mình được khởi động và liên kết, thì khi dịch vụ khởi động, hệ thống sẽ không huỷ dịch vụ khi tất cả ứng dụng khách huỷ liên kết. Thay vào đó, bạn phải dừng dịch vụ một cách rõ ràng bằng cách gọi stopSelf() hoặc stopService().

Mặc dù bạn thường triển khai onBind() hoặc onStartCommand(), nhưng đôi khi bạn cần triển khai cả hai. Ví dụ: một trình phát nhạc có thể thấy việc cho phép dịch vụ của mình chạy vô thời hạn và cung cấp liên kết là hữu ích. Bằng cách này, một hoạt động có thể bắt đầu dịch vụ để phát nhạc và nhạc sẽ tiếp tục phát ngay cả khi người dùng rời khỏi ứng dụng. Sau đó, khi người dùng quay lại ứng dụng, hoạt động có thể liên kết với dịch vụ để lấy lại quyền kiểm soát chế độ phát.

Để biết thêm thông tin về vòng đời của dịch vụ khi thêm liên kết vào một dịch vụ đã khởi động, hãy xem phần Quản lý vòng đời của dịch vụ ràng buộc.

Ứng dụng khách liên kết với một dịch vụ bằng cách gọi bindService(). Khi thực hiện việc này, ứng dụng phải cung cấp một phương thức triển khai ServiceConnection để giám sát kết nối với dịch vụ. Giá trị trả về của bindService() cho biết dịch vụ được yêu cầu có tồn tại hay không và liệu ứng dụng có được phép truy cập vào dịch vụ đó hay không.

Khi tạo kết nối giữa ứng dụng và dịch vụ, hệ thống Android sẽ gọi onServiceConnected() trên ServiceConnection. Phương thức onServiceConnected() bao gồm đối số IBinder mà sau đó ứng dụng dùng để giao tiếp với dịch vụ ràng buộc.

Bạn có thể kết nối nhiều ứng dụng khách với một dịch vụ cùng lúc. Tuy nhiên, hệ thống sẽ lưu kênh giao tiếp của dịch vụ IBinder vào bộ nhớ đệm. Nói cách khác, hệ thống chỉ gọi phương thức onBind() của dịch vụ để tạo IBinder khi ứng dụng khách đầu tiên liên kết. Sau đó, hệ thống sẽ phân phối cùng một IBinder đó đến tất cả các ứng dụng khách khác liên kết với cùng một dịch vụ đó mà không cần gọi lại onBind().

Khi ứng dụng cuối cùng huỷ liên kết khỏi dịch vụ, hệ thống sẽ huỷ dịch vụ, trừ phi dịch vụ được khởi động bằng startService().

Phần quan trọng nhất trong quá trình triển khai dịch vụ ràng buộc là xác định giao diện mà phương thức gọi lại onBind() trả về. Phần sau đây thảo luận về một số cách bạn có thể xác định giao diện IBinder của dịch vụ.

Tạo dịch vụ ràng buộc

Khi tạo một dịch vụ cung cấp liên kết, bạn phải cung cấp một IBinder cung cấp giao diện lập trình mà ứng dụng có thể dùng để tương tác với dịch vụ. Có ba cách để bạn xác định giao diện:

Mở rộng lớp Binder
Nếu dịch vụ của bạn là riêng tư đối với ứng dụng của riêng bạn và chạy trong cùng một quy trình với ứng dụng khách (điều này là phổ biến), hãy tạo giao diện bằng cách mở rộng lớp Binder và trả về một thực thể của lớp đó từ onBind(). Ứng dụng nhận được Binder và có thể sử dụng ứng dụng đó để truy cập trực tiếp vào các phương thức công khai có sẵn trong quá trình triển khai Binder hoặc Service.

Đây là kỹ thuật ưu tiên khi dịch vụ của bạn chỉ là một trình chạy trong nền cho ứng dụng của riêng bạn. Trường hợp sử dụng duy nhất mà đây không phải là cách ưu tiên để tạo giao diện là khi dịch vụ của bạn được các ứng dụng khác sử dụng hoặc trên các quy trình riêng biệt.

Sử dụng Messenger
Nếu cần giao diện hoạt động trên nhiều quy trình, bạn có thể tạo một giao diện cho dịch vụ bằng Messenger. Theo cách này, dịch vụ sẽ xác định một Handler phản hồi các loại đối tượng Message khác nhau.

Handler này là cơ sở cho Messenger, sau đó có thể chia sẻ IBinder với ứng dụng, cho phép ứng dụng gửi lệnh đến dịch vụ bằng các đối tượng Message. Ngoài ra, ứng dụng có thể xác định Messenger của riêng mình để dịch vụ có thể gửi lại thông báo.

Đây là cách đơn giản nhất để thực hiện giao tiếp liên quy trình (IPC), vì Messenger đưa tất cả yêu cầu vào một luồng duy nhất để bạn không phải thiết kế dịch vụ của mình sao cho an toàn cho luồng.

Sử dụng AIDL
Ngôn ngữ định nghĩa giao diện Android (AIDL) phân tách các đối tượng thành các dữ liệu gốc mà hệ điều hành có thể hiểu và sắp xếp chúng trên các quy trình để thực hiện IPC. Kỹ thuật trước đó, sử dụng Messenger, thực sự dựa trên AIDL làm cấu trúc cơ bản.

Như đã đề cập trong phần trước, Messenger tạo một hàng đợi gồm tất cả các yêu cầu của ứng dụng trong một luồng, vì vậy, dịch vụ sẽ nhận được từng yêu cầu một. Tuy nhiên, nếu muốn dịch vụ của mình xử lý nhiều yêu cầu cùng một lúc, thì bạn có thể sử dụng trực tiếp AIDL. Trong trường hợp này, dịch vụ của bạn phải an toàn cho luồng và có khả năng đa luồng.

Để sử dụng trực tiếp AIDL, hãy tạo một tệp .aidl xác định giao diện lập trình. Các công cụ SDK Android sử dụng tệp này để tạo một lớp trừu tượng triển khai giao diện và xử lý IPC, sau đó bạn có thể mở rộng trong dịch vụ của mình.

Lưu ý: Đối với hầu hết ứng dụng, AIDL không phải là lựa chọn tốt nhất để tạo dịch vụ ràng buộc, vì dịch vụ này có thể yêu cầu khả năng đa luồng và có thể dẫn đến việc triển khai phức tạp hơn. Do đó, tài liệu này không thảo luận về cách sử dụng cho dịch vụ của bạn. Nếu bạn chắc chắn rằng mình cần sử dụng trực tiếp AIDL, hãy xem tài liệu về AIDL.

Mở rộng lớp Binder

Nếu chỉ có ứng dụng cục bộ sử dụng dịch vụ của bạn và ứng dụng đó không cần hoạt động trên nhiều quy trình, thì bạn có thể triển khai lớp Binder của riêng mình để cung cấp cho ứng dụng khách quyền truy cập trực tiếp vào các phương thức công khai trong dịch vụ.

Lưu ý: Cách này chỉ hoạt động nếu ứng dụng và dịch vụ nằm trong cùng một ứng dụng và quy trình, đây là trường hợp phổ biến nhất. Ví dụ: điều này hoạt động hiệu quả đối với một ứng dụng âm nhạc cần liên kết một hoạt động với dịch vụ của chính ứng dụng đó đang phát nhạc ở chế độ nền.

Dưới đây là cách thiết lập:

  1. Trong dịch vụ của bạn, hãy tạo một thực thể của Binder thực hiện một trong những thao tác sau:
    • Chứa các phương thức công khai mà ứng dụng có thể gọi.
    • Trả về thực thể Service hiện tại, có các phương thức công khai mà ứng dụng có thể gọi.
    • Trả về một thực thể của một lớp khác do dịch vụ lưu trữ bằng các phương thức công khai mà ứng dụng có thể gọi.
  2. Trả về thực thể này của Binder từ phương thức gọi lại onBind().
  3. Trong ứng dụng, hãy nhận Binder từ phương thức gọi lại onServiceConnected() và thực hiện lệnh gọi đến dịch vụ ràng buộc bằng các phương thức được cung cấp.

Lưu ý: Dịch vụ và ứng dụng khách phải nằm trong cùng một ứng dụng để ứng dụng khách có thể truyền đối tượng được trả về và gọi API của đối tượng đó một cách chính xác. Dịch vụ và ứng dụng cũng phải nằm trong cùng một quy trình, vì kỹ thuật này không thực hiện bất kỳ hoạt động sắp xếp nào trên các quy trình.

Ví dụ: dưới đây là một dịch vụ cung cấp cho ứng dụng quyền truy cập vào các phương thức trong dịch vụ thông qua một phương thức triển khai Binder:

Kotlin

class LocalService : Service() {
    // Binder given to clients.
    private val binder = LocalBinder()

    // Random number generator.
    private val mGenerator = Random()

    /** Method for clients.  */
    val randomNumber: Int
        get() = mGenerator.nextInt(100)

    /**
     * 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.
     */
    inner class LocalBinder : Binder() {
        // Return this instance of LocalService so clients can call public methods.
        fun getService(): LocalService = this@LocalService
    }

    override fun onBind(intent: Intent): IBinder {
        return binder
    }
}

Java

public class LocalService extends Service {
    // Binder given to clients.
    private final IBinder binder = 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 binder;
    }

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

LocalBinder cung cấp phương thức getService() để ứng dụng truy xuất thực thể hiện tại của LocalService. Điều này cho phép ứng dụng gọi các phương thức công khai trong dịch vụ. Ví dụ: ứng dụng khách có thể gọi getRandomNumber() từ dịch vụ.

Dưới đây là một hoạt động liên kết với LocalService và gọi getRandomNumber() khi người dùng nhấp vào một nút:

Kotlin

class BindingActivity : Activity() {
    private var mService: LocalService? = null
    private var mBound: Boolean = false

    /** Defines callbacks for service binding, passed to bindService().  */
    private val connection = object : ServiceConnection {

        override fun onServiceConnected(className: ComponentName, service: IBinder) {
            // We've bound to LocalService, cast the IBinder and get LocalService instance.
            val binder = service as LocalService.LocalBinder
            mService = binder.getService()
            mBound = true
        }

        override fun onServiceDisconnected(arg0: ComponentName) {
            mService = null
            mBound = false
        }
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.main)
    }

    override fun onStart() {
        super.onStart()
        // Bind to LocalService.
        Intent(this, LocalService::class.java).also { intent ->
            bindService(intent, connection, Context.BIND_AUTO_CREATE)
        }
    }

    override fun onStop() {
        super.onStop()
        unbindService(connection)
        // Release the reference so the service can be garbage-collected once it's
        // destroyed. onServiceDisconnected() isn't called when the client unbinds.
        mService = null
        mBound = false
    }

    /** Called when a button is clicked (the button in the layout file attaches to
     * this method with the android:onClick attribute).  */
    fun onButtonClick(v: View) {
        if (mBound) {
            // Call a method from the LocalService.
            // However, if this call is something that might hang, then put this request
            // in a separate thread to avoid slowing down the activity performance.
            val num: Int = mService?.randomNumber ?: return
            Toast.makeText(this, "number: $num", Toast.LENGTH_SHORT).show()
        }
    }
}

Java

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, connection, Context.BIND_AUTO_CREATE);
    }

    @Override
    protected void onStop() {
        super.onStop();
        unbindService(connection);
        // Release the reference so the service can be garbage-collected once it's
        // destroyed. onServiceDisconnected() isn't called when the client unbinds.
        mService = null;
        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 is something that might hang, then put this request
            // 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 connection = 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) {
            mService = null;
            mBound = false;
        }
    };
}

Mẫu trước cho thấy cách ứng dụng liên kết với dịch vụ bằng cách triển khai ServiceConnection và lệnh gọi lại onServiceConnected(). Phần tiếp theo sẽ cung cấp thêm thông tin về quy trình liên kết này với dịch vụ.

Lưu ý: Trong ví dụ trước, phương thức onStop() huỷ liên kết ứng dụng khách khỏi dịch vụ và giải phóng tệp đối chiếu của ứng dụng khách với dịch vụ đó. Huỷ liên kết ứng dụng khách khỏi dịch vụ vào thời điểm thích hợp, như đã thảo luận trong phần Lưu ý bổ sung.

Để biết thêm mã mẫu, hãy xem lớp LocalService.java và lớp LocalServiceActivities.java trong ApiDemos.

Sử dụng Messenger

Nếu cần dịch vụ của mình giao tiếp với các quy trình từ xa, thì bạn có thể sử dụng Messenger để cung cấp giao diện cho dịch vụ của mình. Kỹ thuật này cho phép bạn thực hiện giao tiếp liên quy trình (IPC) mà không cần sử dụng AIDL.

Việc sử dụng Messenger cho giao diện của bạn sẽ đơn giản hơn so với việc sử dụng AIDL vì Messenger đưa tất cả lệnh gọi đến dịch vụ vào hàng đợi. Giao diện AIDL thuần tuý gửi các yêu cầu đồng thời đến dịch vụ, sau đó dịch vụ này phải xử lý đa luồng.

Đối với hầu hết các ứng dụng, dịch vụ không cần thực hiện đa luồng, vì vậy, việc sử dụng Messenger cho phép dịch vụ xử lý từng lệnh gọi một. Nếu dịch vụ của bạn cần phải đa luồng, hãy sử dụng AIDL để xác định giao diện.

Sau đây là thông tin tóm tắt về cách sử dụng Messenger:

  1. Dịch vụ này triển khai một Handler nhận lệnh gọi lại cho mỗi cuộc gọi từ một ứng dụng.
  2. Dịch vụ này sử dụng Handler để tạo đối tượng Messenger (là tệp đối chiếu với Handler).
  3. Messenger tạo một IBinder mà dịch vụ trả về cho ứng dụng khách từ onBind().
  4. Ứng dụng khách sử dụng IBinder để tạo thực thể cho Messenger (tham chiếu đến Handler của dịch vụ), mà ứng dụng khách sử dụng để gửi các đối tượng Message đến dịch vụ.
  5. Dịch vụ nhận từng Message trong Handler, cụ thể là trong phương thức handleMessage().

Bằng cách này, ứng dụng khách sẽ không có phương thức nào để gọi dịch vụ. Thay vào đó, ứng dụng sẽ gửi thông báo (đối tượng Message) mà dịch vụ nhận được trong Handler.

Dưới đây là một dịch vụ mẫu sử dụng giao diện Messenger:

Kotlin

/** Command to the service to display a message.  */
private const val MSG_SAY_HELLO = 1

class MessengerService : Service() {

    /**
     * Target we publish for clients to send messages to IncomingHandler.
     */
    private lateinit var mMessenger: Messenger

    /**
     * Handler of incoming messages from clients.
     */
    internal class IncomingHandler(
            context: Context,
            private val applicationContext: Context = context.applicationContext
    ) : Handler() {
        override fun handleMessage(msg: Message) {
            when (msg.what) {
                MSG_SAY_HELLO ->
                    Toast.makeText(applicationContext, "hello!", Toast.LENGTH_SHORT).show()
                else -> super.handleMessage(msg)
            }
        }
    }

    /**
     * When binding to the service, we return an interface to our messenger
     * for sending messages to the service.
     */
    override fun onBind(intent: Intent): IBinder? {
        Toast.makeText(applicationContext, "binding", Toast.LENGTH_SHORT).show()
        mMessenger = Messenger(IncomingHandler(this))
        return mMessenger.binder
    }
}

Java

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.
     */
    static class IncomingHandler extends Handler {
        private Context applicationContext;

        IncomingHandler(Context context) {
            applicationContext = context.getApplicationContext();
        }

        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MSG_SAY_HELLO:
                    Toast.makeText(applicationContext, "hello!", Toast.LENGTH_SHORT).show();
                    break;
                default:
                    super.handleMessage(msg);
            }
        }
    }

    /**
     * Target we publish for clients to send messages to IncomingHandler.
     */
    Messenger mMessenger;

    /**
     * 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();
        mMessenger = new Messenger(new IncomingHandler(this));
        return mMessenger.getBinder();
    }
}

Phương thức handleMessage() trong Handler là nơi dịch vụ nhận Message đến và quyết định việc cần làm, dựa trên thành viên what.

Tất cả những gì ứng dụng cần làm là tạo Messenger dựa trên IBinder do dịch vụ trả về và gửi thông báo bằng send(). Ví dụ: đây là một hoạt động liên kết với dịch vụ và gửi thông báo MSG_SAY_HELLO đến dịch vụ:

Kotlin

class ActivityMessenger : Activity() {
    /** Messenger for communicating with the service.  */
    private var mService: Messenger? = null

    /** Flag indicating whether we have called bind on the service.  */
    private var bound: Boolean = false

    /**
     * Class for interacting with the main interface of the service.
     */
    private val mConnection = object : ServiceConnection {

        override fun onServiceConnected(className: ComponentName, service: IBinder) {
            // 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 = Messenger(service)
            bound = true
        }

        override fun onServiceDisconnected(className: ComponentName) {
            // This is called when the connection with the service has been
            // unexpectedly disconnected—that is, its process crashed.
            mService = null
            bound = false
        }
    }

    fun sayHello(v: View) {
        if (!bound) return
        // Create and send a message to the service, using a supported 'what' value.
        val msg: Message = Message.obtain(null, MSG_SAY_HELLO, 0, 0)
        try {
            mService?.send(msg)
        } catch (e: RemoteException) {
            e.printStackTrace()
        }

    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.main)
    }

    override fun onStart() {
        super.onStart()
        // Bind to the service.
        Intent(this, MessengerService::class.java).also { intent ->
            bindService(intent, mConnection, Context.BIND_AUTO_CREATE)
        }
    }

    override fun onStop() {
        super.onStop()
        // Unbind from the service.
        if (bound) {
            unbindService(mConnection)
            mService = null
            bound = false
        }
    }
}

Java

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

    /**
     * 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);
            bound = 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;
            bound = false;
        }
    };

    public void sayHello(View v) {
        if (!bound) 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 (bound) {
            unbindService(mConnection);
            mService = null;
            bound = false;
        }
    }
}

Ví dụ này không cho thấy cách dịch vụ có thể phản hồi ứng dụng. Nếu muốn dịch vụ phản hồi, bạn cũng cần tạo một Messenger trong ứng dụng. Khi nhận được lệnh gọi lại onServiceConnected(), ứng dụng sẽ gửi một Message đến dịch vụ, trong đó có Messenger của ứng dụng trong tham số replyTo của phương thức send().

Bạn có thể xem ví dụ về cách cung cấp tính năng nhắn tin hai chiều trong các mẫu MessengerService.java (dịch vụ) và MessengerServiceActivities.java (ứng dụng).

Liên kết với một dịch vụ

Các thành phần của ứng dụng (ứng dụng khách) có thể liên kết với một dịch vụ bằng cách gọi bindService(). Sau đó, hệ thống Android sẽ gọi phương thức onBind() của dịch vụ, phương thức này sẽ trả về một IBinder để tương tác với dịch vụ.

Liên kết này không đồng bộ và bindService() sẽ trả về ngay lập tức mà không trả về IBinder cho ứng dụng. Để nhận IBinder, ứng dụng phải tạo một thực thể của ServiceConnection và truyền thực thể đó đến bindService(). ServiceConnection bao gồm một phương thức gọi lại mà hệ thống gọi để phân phối IBinder.

Lưu ý: Chỉ các hoạt động, dịch vụ và nhà cung cấp nội dung mới có thể liên kết với một dịch vụ. Bạn không thể liên kết với một dịch vụ từ bộ nhận tín hiệu truyền tin.

Để liên kết với một dịch vụ từ ứng dụng, hãy làm theo các bước sau:

  1. Triển khai ServiceConnection.

    Quá trình triển khai của bạn phải ghi đè hai phương thức gọi lại:

    onServiceConnected()
    Hệ thống gọi phương thức này để phân phối IBinder do phương thức onBind() của dịch vụ trả về.
    onServiceDisconnected()
    Hệ thống Android gọi phương thức này khi kết nối với dịch vụ bị mất đột ngột, chẳng hạn như khi dịch vụ gặp sự cố hoặc bị tắt. Phương thức này không được gọi khi ứng dụng khách huỷ liên kết.
  2. Gọi bindService(), truyền vào phương thức triển khai ServiceConnection.

    Lưu ý: Nếu phương thức này trả về giá trị false, thì ứng dụng của bạn không có kết nối hợp lệ với dịch vụ. Tuy nhiên, hãy gọi unbindService() trong ứng dụng của bạn. Nếu không, ứng dụng của bạn sẽ ngăn dịch vụ tắt khi ở trạng thái rảnh.

  3. Khi hệ thống gọi phương thức gọi lại onServiceConnected(), bạn có thể bắt đầu thực hiện lệnh gọi đến dịch vụ bằng cách sử dụng các phương thức do giao diện xác định.
  4. Để ngắt kết nối khỏi dịch vụ, hãy gọi unbindService().

    Nếu ứng dụng khách của bạn vẫn liên kết với một dịch vụ khi ứng dụng huỷ ứng dụng khách, thì việc huỷ này sẽ khiến ứng dụng khách huỷ liên kết. Tốt hơn là bạn nên huỷ liên kết ứng dụng ngay khi ứng dụng đó tương tác xong với dịch vụ. Việc này cho phép dịch vụ rảnh tắt. Để biết thêm thông tin về thời điểm thích hợp để liên kết và huỷ liên kết, hãy xem phần Lưu ý bổ sung.

Ví dụ sau đây kết nối ứng dụng khách với dịch vụ đã tạo trước đó bằng cách mở rộng lớp Binder, vì vậy, tất cả những gì cần làm là truyền IBinder được trả về đến lớp LocalBinder và yêu cầu thực thể LocalService:

Kotlin

var mService: LocalService? = null

val mConnection = object : ServiceConnection {
    // Called when the connection with the service is established.
    override fun onServiceConnected(className: ComponentName, service: IBinder) {
        // 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.
        val binder = service as LocalService.LocalBinder
        mService = binder.getService()
        mBound = true
    }

    // Called when the connection with the service disconnects unexpectedly.
    override fun onServiceDisconnected(className: ComponentName) {
        Log.e(TAG, "onServiceDisconnected")
        mService = null
        mBound = false
    }
}

Java

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");
        mService = null;
        mBound = false;
    }
};

Với ServiceConnection này, ứng dụng có thể liên kết với một dịch vụ bằng cách truyền dịch vụ đó đến bindService(), như trong ví dụ sau:

Kotlin

Intent(this, LocalService::class.java).also { intent ->
    bindService(intent, connection, Context.BIND_AUTO_CREATE)
}

Java

Intent intent = new Intent(this, LocalService.class);
bindService(intent, connection, Context.BIND_AUTO_CREATE);
  • Tham số đầu tiên của bindService() là một Intent đặt tên rõ ràng cho dịch vụ cần liên kết.

    Thận trọng: Nếu bạn sử dụng một ý định để liên kết với một Service, hãy đảm bảo ứng dụng của bạn an toàn bằng cách sử dụng một ý định rõ ràng. Việc sử dụng ý định ngầm ẩn để bắt đầu một dịch vụ sẽ gây ra mối nguy hiểm về bảo mật, vì bạn không thể chắc chắn dịch vụ nào sẽ phản hồi ý định và người dùng không thể biết dịch vụ nào sẽ bắt đầu. Kể từ Android 5.0 (cấp độ API 21), hệ thống sẽ gửi một ngoại lệ nếu bạn gọi bindService() với ý định ngầm ẩn.

  • Tham số thứ hai là đối tượng ServiceConnection.
  • Tham số thứ ba là một cờ cho biết các tuỳ chọn liên kết – thường là BIND_AUTO_CREATE, để tạo dịch vụ nếu dịch vụ đó chưa hoạt động. Có thể sử dụng các giá trị BIND_DEBUG_UNBIND, BIND_NOT_FOREGROUND hoặc 0 cho không có.

Ghi chú khác

Sau đây là một số lưu ý quan trọng về việc liên kết với một dịch vụ:

  • Luôn chặn các ngoại lệ DeadObjectException được gửi khi kết nối bị hỏng. Đây là ngoại lệ duy nhất được các phương thức từ xa đưa ra.
  • Các đối tượng được tính số lượt tham chiếu trên các quy trình.
  • Bạn thường ghép nối việc liên kết và huỷ liên kết trong các thời điểm khởi động và huỷ bỏ tương ứng trong vòng đời của ứng dụng, như mô tả trong các ví dụ sau:
    • Nếu bạn chỉ cần tương tác với dịch vụ khi hoạt động của bạn hiển thị, hãy liên kết trong onStart() và huỷ liên kết trong onStop().
    • Nếu bạn muốn hoạt động của mình nhận được phản hồi ngay cả khi hoạt động đó bị dừng trong nền, hãy liên kết trong onCreate() và huỷ liên kết trong onDestroy(). Xin lưu ý rằng điều này có nghĩa là hoạt động của bạn cần sử dụng dịch vụ trong toàn bộ thời gian chạy, ngay cả trong nền, vì vậy, khi dịch vụ nằm trong một quy trình khác, bạn sẽ tăng trọng số của quy trình và hệ thống có nhiều khả năng sẽ tắt quy trình đó.

    Lưu ý: Bạn thường không liên kết và huỷ liên kết trong các lệnh gọi lại onResume() và onPause() của hoạt động, vì các lệnh gọi lại này xảy ra ở mọi quá trình chuyển đổi vòng đời. Hạn chế tối đa việc xử lý xảy ra tại các quá trình chuyển đổi này.

    Ngoài ra, nếu nhiều hoạt động trong ứng dụng của bạn liên kết với cùng một dịch vụ và có sự chuyển đổi giữa hai hoạt động đó, thì dịch vụ có thể bị huỷ và tạo lại khi hoạt động hiện tại huỷ liên kết (trong khi tạm dừng) trước khi hoạt động tiếp theo liên kết (trong khi tiếp tục). Quá trình chuyển đổi hoạt động này cho biết cách các hoạt động điều phối vòng đời của activity được mô tả trong phần Vòng đời hoạt động.

Để xem thêm mã mẫu cho biết cách liên kết với một dịch vụ, hãy xem lớp RemoteService.java trong ApiDemos.

Quản lý vòng đời của dịch vụ ràng buộc

Khi một dịch vụ không liên kết với bất kỳ ứng dụng nào, hệ thống Android sẽ huỷ dịch vụ đó (trừ phi dịch vụ đó được bắt đầu bằng startService()). Vì vậy, bạn không cần quản lý vòng đời của dịch vụ nếu đó hoàn toàn là một dịch vụ ràng buộc. Hệ thống Android quản lý dịch vụ này cho bạn dựa trên việc dịch vụ có liên kết với bất kỳ ứng dụng nào hay không.

Tuy nhiên, nếu chọn triển khai phương thức gọi lại onStartCommand(), thì bạn phải dừng dịch vụ một cách rõ ràng, vì dịch vụ hiện được coi là đã bắt đầu. Trong trường hợp này, dịch vụ sẽ chạy cho đến khi tự dừng bằng stopSelf() hoặc một thành phần khác gọi stopService(), bất kể dịch vụ đó có liên kết với bất kỳ ứng dụng nào hay không.

Ngoài ra, nếu dịch vụ của bạn được khởi động và chấp nhận liên kết, thì khi hệ thống gọi phương thức onUnbind(), bạn có thể tuỳ ý trả về true nếu muốn nhận lệnh gọi đến onRebind() vào lần tiếp theo ứng dụng liên kết với dịch vụ. onRebind() trả về giá trị rỗng, nhưng ứng dụng khách vẫn nhận được IBinder trong lệnh gọi lại onServiceConnected(). Hình sau đây minh hoạ logic cho loại vòng đời này.

Vòng đời của một dịch vụ đã bắt đầu và ràng buộc: onStartCommand() và onBind() được gọi; khi tất cả ứng dụng khách huỷ liên kết, onUnbind() được gọi; trong lần liên kết tiếp theo, onRebind() được gọi nếu onUnbind() trả về giá trị true, nếu không thì onBind() được gọi; sau khi dịch vụ dừng, onDestroy() được gọi.
Hình 1. Vòng đời của một dịch vụ được khởi động và cũng cho phép liên kết.

Để biết thêm thông tin về vòng đời của một dịch vụ đã khởi động, hãy xem bài viết Tổng quan về dịch vụ.