A partir de 27 de março de 2025, recomendamos usar android-latest-release em vez de aosp-main para criar e contribuir com o AOSP. Para mais informações, consulte Mudanças no AOSP.
Mantenha tudo organizado com as coleções
Salve e categorize o conteúdo com base nas suas preferências.
O Binder é um sistema de comunicação
entre processos que permite que dois processos em um dispositivo Android
se comuniquem. O Binder oferece uma maneira de executar chamadas de função em outro
processo que é completamente transparente para o autor da chamada.
Em termos de binder, o processo de chamada é considerado o cliente, e o endpoint é chamado de proxy do binder ou proxy. Por outro lado, o processo que está sendo chamado é o servidor, e o endpoint dele é chamado de nó de vinculação ou nó.
Cada nó pode expor e implementar a própria interface. E, usando um proxy, o
cliente pode executar métodos em uma interface de nó como se a invocação fosse uma
chamada de função local. O exemplo a seguir mostra um método sendo invocado:
int result = someNodeInterface.foo(a, b); // someNodeInterface is a proxy object
Suponha que o cliente que chama foo() esteja sendo executado no processo A e o servidor que implementa foo() esteja sendo executado no processo B. A Figura 1 mostra como essa chamada é
executada:
Figura 1. Execução de chamada de vinculação.
Para executar um método em outro processo, conforme mostrado na Figura 1,
ocorre o seguinte:
O código do cliente no processo A invoca o código do proxy no processo A. O código
de proxy no processo A cria uma transação que contém os seguintes itens:
Um identificador do nó
Um identificador do método foo() no nó.
Um buffer que contém uma cópia dos argumentos a e b.
A transação é enviada ao driver do kernel binder.
O driver do kernel binder determina que o processo B hospeda o nó.
O kernel copia toda a transação para o espaço de endereço do processo B.
O kernel encontra uma linha de execução no processo B para processar a transação e a transmite a ela.
A linha executa o desempacotamento da transação, encontra o nó e envia a transação para o objeto do nó.
O objeto de nó recebe o identificador da função da transação,
descompacta a e b do buffer de transação e armazena a e b em
variáveis locais.
O objeto de nó chama foo(a, b) no código do servidor no processo B.
O resultado da chamada é retornado em uma transação de resposta, que é transmitida
ao driver do kernel e, em seguida, de volta ao proxy de chamada no processo A.
O proxy retorna esse resultado para o autor da chamada no processo A.
Casos de uso do Binder
O Binder pode ser usado em vários cenários em que a comunicação entre
softwares em processos diferentes precisa ocorrer. Exemplo:
Um app de câmera usa o binder para se comunicar com o servidor de câmera em
outro processo. Em seguida, o servidor de câmera usa o binder para se comunicar com a
HAL da câmera em outro processo.
Um app usa o binder para se comunicar com um servidor do sistema em outro processo. O
servidor do sistema usa o binder para se comunicar com HALs em outros processos.
Um app em um processo usa o binder para se comunicar com um app diferente em
outro processo.
O daemon do sistema responsável por instalar, atualizar e remover
apps (installd) usa o binder para se comunicar com o daemon de
tempo de execução do Android ("artd") e compilar apps.
AIDL e binder
Use a linguagem de definição de interface do Android (AIDL) para definir interfaces de programação que usam binder para IPC. Para mais informações, consulte a
visão geral da AIDL.
O conteúdo e os exemplos de código nesta página estão sujeitos às licenças descritas na Licença de conteúdo. Java e OpenJDK são marcas registradas da Oracle e/ou suas afiliadas.
Última atualização 2025-08-05 UTC.
[[["Fácil de entender","easyToUnderstand","thumb-up"],["Meu problema foi resolvido","solvedMyProblem","thumb-up"],["Outro","otherUp","thumb-up"]],[["Não contém as informações de que eu preciso","missingTheInformationINeed","thumb-down"],["Muito complicado / etapas demais","tooComplicatedTooManySteps","thumb-down"],["Desatualizado","outOfDate","thumb-down"],["Problema na tradução","translationIssue","thumb-down"],["Problema com as amostras / o código","samplesCodeIssue","thumb-down"],["Outro","otherDown","thumb-down"]],["Última atualização 2025-08-05 UTC."],[],[],null,["# Binder overview\n\n*Binder* is a system for interprocess\ncommunication that lets two processes on an Android-powered device\ncommunicate. Binder provides a means to execute function calls in another\nprocess that is completely transparent to the caller.\n\nIn binder terms, the calling process is considered the *client* and its\nendpoint is called the *binder proxy* or *proxy* . Conversely,\nthe process being called is the *server* and its endpoint is called the\n*binder node* or *node*.\n\nEach node can expose and implement its own interface. And, using a proxy, the\nclient can execute methods on a node interface as though invocation was a\nlocal function call. The following example shows a method being invoked: \n\n int result = someNodeInterface.foo(a, b); // someNodeInterface is a proxy object\n\nAssume that the client calling `foo()` is running in process A and the server\nimplementing `foo()` is running in process B. Figure 1 shows how this call is\nexecuted:\n\n**Figure 1.** Binder call execution.\n\nTo execute a method in another process, as shown in figure 1,\nthe following occurs:\n\n1. The client code in process A invokes the proxy code in process A. The proxy code in process A creates a transaction containing the following items:\n - An identifier for the node\n - An identifier for the `foo()` method on the node\n - A buffer containing a copy of the arguments `a` and `b`\n2. The transaction is submitted to the binder kernel driver.\n3. The binder kernel driver determines that process B hosts the node.\n4. The kernel copies the entire transaction into process B's address space.\n5. The kernel finds a thread in process B to handle the transaction and passes the transaction to it.\n6. The thread unpacks the transaction, finds the node, and sends the transaction to the node object.\n7. The node object obtains the function identifier from the transaction, unpacks `a` and `b` from the transaction buffer, and stores `a` and `b` in local variables.\n8. The node object calls `foo(a, b)` on the server code in process B.\n9. The result of the call is returned in a reply transaction, which is passed to the kernel driver and then back to the calling proxy in process A.\n10. The proxy returns that result to the caller in process A.\n\nBinder use cases\n----------------\n\nBinder can be used in a variety of scenarios where communication between\nsoftware in different processes must occur. For example:\n\n- A camera app uses binder to communicate with the camera server in\n another process. The camera server then uses binder to communicate with the\n camera HAL in another process.\n\n- An app uses binder to communicate with a system server in another process. The\n system server uses binder to talk to HALs in other processes.\n\n- An app in one process uses binder to communicate with a different app in\n another process.\n\n- The system daemon responsible for installing, updating, and removing\n apps (`installd`) uses binder to communicate with the Android\n runtime daemon ('artd') to compile apps.\n\nAIDL and binder\n---------------\n\nUse the Android Interface Design Language (AIDL) to define programming\ninterfaces that use binder for IPC. For further information, see the\n[AIDL overview](/docs/core/architecture/aidl).\n| **Note:** HIDL is deprecated; only AIDL is recommended for new implementations."]]