Um serviço de acessibilidade é um app que melhora a interface do usuário para ajudar usuários com deficiências ou que podem não conseguir interagir totalmente com um dispositivo. Por exemplo, usuários que estão dirigindo, cuidando de uma criança ou participando de uma festa muito barulhenta podem precisar de feedback extra ou alternativo da interface.
O Android oferece serviços de acessibilidade padrão, incluindo o TalkBack, e os desenvolvedores podem criar e distribuir os próprios serviços. Este documento explica os conceitos básicos da criação de um serviço de acessibilidade.
Um serviço de acessibilidade pode ser empacotado com um app normal ou criado como um projeto Android independente. As etapas para criar o serviço são as mesmas em qualquer situação.
Criar um serviço de acessibilidade
No projeto, crie uma classe que estenda
AccessibilityService
:
Kotlin
package com.example.android.apis.accessibility import android.accessibilityservice.AccessibilityService import android.view.accessibility.AccessibilityEvent class MyAccessibilityService : AccessibilityService() { ... override fun onInterrupt() {} override fun onAccessibilityEvent(event: AccessibilityEvent?) {} ... }
Java
package com.example.android.apis.accessibility; import android.accessibilityservice.AccessibilityService; import android.view.accessibility.AccessibilityEvent; public class MyAccessibilityService extends AccessibilityService { ... @Override public void onAccessibilityEvent(AccessibilityEvent event) { } @Override public void onInterrupt() { } ... }
Se você criar um novo projeto para esse Service
e não pretende ter um app
associado a ele, remova a classe Activity
inicial da
origem.
Declarações e permissões do manifesto
Os apps que oferecem serviços de acessibilidade precisam incluir declarações específicas nos manifestos para serem tratados como um serviço de acessibilidade pelo sistema Android. Esta seção explica as configurações obrigatórias e opcionais dos serviços de acessibilidade.
Declaração de serviço de acessibilidade
Para que seu app seja tratado como um serviço de acessibilidade, inclua um elemento service
,
em vez do elemento activity
, no elemento application
do manifesto. Além disso, inclua um
filtro de intent do serviço de acessibilidade no elemento service
. O manifesto também precisa proteger o serviço,
adicionando a permissão
BIND_ACCESSIBILITY_SERVICE
para garantir que apenas o sistema possa se vincular a ele. Veja um exemplo:
<application> <service android:name=".MyAccessibilityService" android:permission="android.permission.BIND_ACCESSIBILITY_SERVICE" android:label="@string/accessibility_service_label"> <intent-filter> <action android:name="android.accessibilityservice.AccessibilityService" /> </intent-filter> </service> </application>
Configuração do serviço de acessibilidade
Os serviços de acessibilidade precisam fornecer uma configuração que especifique os tipos de
eventos de acessibilidade processados pelo serviço e outras informações
sobre ele. A configuração de um serviço de acessibilidade está contida na
classe
AccessibilityServiceInfo
. Seu serviço pode criar e definir uma configuração usando uma instância dessa
classe e
setServiceInfo()
durante a execução. No entanto, nem todas as opções de configuração estão disponíveis com o uso desse
método.
Você pode incluir um elemento <meta-data>
no manifesto com uma referência a um
arquivo de configuração, o que permite definir todas as opções para seu
serviço de acessibilidade, conforme mostrado no exemplo abaixo:
<service android:name=".MyAccessibilityService"> ... <meta-data android:name="android.accessibilityservice" android:resource="@xml/accessibility_service_config" /> </service>
Esse elemento <meta-data>
se refere a um arquivo XML criado no
diretório de recursos do app:
<project_dir>/res/xml/accessibility_service_config.xml>
. O código a seguir
mostra um exemplo do conteúdo do arquivo de configuração de serviço:
<accessibility-service xmlns:android="http://schemas.android.com/apk/res/android" android:description="@string/accessibility_service_description" android:packageNames="com.example.android.apis" android:accessibilityEventTypes="typeAllMask" android:accessibilityFlags="flagDefault" android:accessibilityFeedbackType="feedbackSpoken" android:notificationTimeout="100" android:canRetrieveWindowContent="true" android:settingsActivity="com.example.android.accessibility.ServiceSettingsActivity" />
Para mais informações sobre os atributos XML que podem ser usados no arquivo de configuração do serviço de acessibilidade, consulte a seguinte documentação de referência:
android:description
android:packageNames
android:accessibilityEventTypes
android:accessibilityFlags
android:accessibilityFeedbackType
android:notificationTimeout
android:canRetrieveWindowContent
android:settingsActivity
Para mais informações sobre quais configurações podem ser definidas dinamicamente
durante a execução, consulte a
documentação de referência
AccessibilityServiceInfo
.
Configurar o serviço de acessibilidade
Considere o seguinte ao definir as variáveis de configuração do serviço de acessibilidade para informar ao sistema como e quando executar:
- A quais tipos de evento você quer que ela responda?
- O serviço precisa estar ativo para todos os apps ou apenas para nomes de pacotes específicos?
- Que tipos diferentes de feedback ele usa?
Você tem duas opções para definir essas variáveis. A opção compatível com versões anteriores
é definir esses valores no código usando
setServiceInfo(android.accessibilityservice.AccessibilityServiceInfo)
.
Para isso, substitua o método
onServiceConnected()
e configure seu serviço, conforme mostrado no exemplo a seguir:
Kotlin
override fun onServiceConnected() { info.apply { // Set the type of events that this service wants to listen to. Others // aren't passed to this service. eventTypes = AccessibilityEvent.TYPE_VIEW_CLICKED or AccessibilityEvent.TYPE_VIEW_FOCUSED // If you only want this service to work with specific apps, set their // package names here. Otherwise, when the service is activated, it // listens to events from all apps. packageNames = arrayOf("com.example.android.myFirstApp", "com.example.android.mySecondApp") // Set the type of feedback your service provides. feedbackType = AccessibilityServiceInfo.FEEDBACK_SPOKEN // Default services are invoked only if no package-specific services are // present for the type of AccessibilityEvent generated. This service is // app-specific, so the flag isn't necessary. For a general-purpose // service, consider setting the DEFAULT flag. // flags = AccessibilityServiceInfo.DEFAULT; notificationTimeout = 100 } this.serviceInfo = info }
Java
@Override public void onServiceConnected() { // Set the type of events that this service wants to listen to. Others // aren't passed to this service. info.eventTypes = AccessibilityEvent.TYPE_VIEW_CLICKED | AccessibilityEvent.TYPE_VIEW_FOCUSED; // If you only want this service to work with specific apps, set their // package names here. Otherwise, when the service is activated, it listens // to events from all apps. info.packageNames = new String[] {"com.example.android.myFirstApp", "com.example.android.mySecondApp"}; // Set the type of feedback your service provides. info.feedbackType = AccessibilityServiceInfo.FEEDBACK_SPOKEN; // Default services are invoked only if no package-specific services are // present for the type of AccessibilityEvent generated. This service is // app-specific, so the flag isn't necessary. For a general-purpose service, // consider setting the DEFAULT flag. // info.flags = AccessibilityServiceInfo.DEFAULT; info.notificationTimeout = 100; this.setServiceInfo(info); }
A segunda opção é configurar o serviço usando um arquivo XML. Algumas
opções de configuração, como
canRetrieveWindowContent
,
só estarão disponíveis se você configurar seu serviço usando XML. As opções de
configuração do exemplo anterior ficam assim quando definidas usando XML:
<accessibility-service android:accessibilityEventTypes="typeViewClicked|typeViewFocused" android:packageNames="com.example.android.myFirstApp, com.example.android.mySecondApp" android:accessibilityFeedbackType="feedbackSpoken" android:notificationTimeout="100" android:settingsActivity="com.example.android.apis.accessibility.TestBackActivity" android:canRetrieveWindowContent="true" />
Se você usa XML, faça referência a ele no manifesto adicionando uma tag
<meta-data>
à
declaração de serviço, apontando para o arquivo XML. Se você armazenar o arquivo XML em
res/xml/serviceconfig.xml
, a nova tag vai ficar assim:
<service android:name=".MyAccessibilityService"> <intent-filter> <action android:name="android.accessibilityservice.AccessibilityService" /> </intent-filter> <meta-data android:name="android.accessibilityservice" android:resource="@xml/serviceconfig" /> </service>
Métodos do serviço de acessibilidade
Um serviço de acessibilidade precisa estender a classe AccessibilityService
e
substituir os seguintes métodos dessa classe. Esses métodos são apresentados
na ordem em que o sistema Android os chama: de quando o serviço é iniciado
(onServiceConnected()
), enquanto ele está em execução
(onAccessibilityEvent()
,
onInterrupt()
)
até quando é encerrado
(onUnbind()
).
onServiceConnected()
: (opcional) o sistema chama esse método quando se conecta ao serviço de acessibilidade. Use esse método para realizar etapas únicas de configuração do serviço, incluindo a conexão com serviços do sistema de feedback do usuário, como o gerenciador de áudio ou a vibração do dispositivo. Se você quiser definir a configuração do serviço durante a execução ou fazer ajustes únicos, esse é um local conveniente para chamarsetServiceInfo()
.onAccessibilityEvent()
: (obrigatório) o sistema chama esse método quando detecta umAccessibilityEvent
que corresponde aos parâmetros de filtragem de eventos especificados pelo serviço de acessibilidade, como quando o usuário toca em um botão ou foca em um controle da interface do usuário em um app para o qual o serviço está fornecendo feedback. Quando o sistema chama esse método, ele transmite oAccessibilityEvent
associado, que o serviço pode interpretar e usar para fornecer feedback ao usuário. Esse método pode ser chamado várias vezes durante o ciclo de vida do serviço.onInterrupt()
: (obrigatório) o sistema chama esse método quando o sistema quer interromper o feedback fornecido pelo serviço, geralmente em resposta a uma ação do usuário, como mover o foco para um controle diferente. Esse método pode ser chamado várias vezes durante o ciclo de vida do serviço.onUnbind()
: (opcional) o sistema chama esse método quando o sistema está prestes a encerrar o serviço de acessibilidade. Use esse método para executar qualquer procedimento único de desligamento, incluindo desalocar serviços do sistema de feedback do usuário, como o gerenciador de áudio ou a vibração do dispositivo.
Esses métodos de callback fornecem a estrutura básica para seu serviço de
acessibilidade. Você pode decidir como processar os dados fornecidos pelo sistema Android na
forma de objetos AccessibilityEvent
e fornecer feedback ao usuário. Para
mais informações sobre como acessar informações de um evento de acessibilidade, consulte Ver
detalhes do evento.
Registrar-se nos eventos de acessibilidade
Uma das funções mais importantes dos parâmetros de configuração do serviço de acessibilidade é permitir que você especifique os tipos de eventos de acessibilidade que o serviço pode processar. A especificação dessas informações permite que os serviços de acessibilidade colaborem entre si e ofereçam a flexibilidade de processar apenas tipos de eventos específicos de apps específicos. A filtragem de eventos pode incluir os seguintes critérios:
Nomes de pacote:especificam os nomes dos pacotes dos apps com eventos de acessibilidade que você quer que o serviço processe. Se esse parâmetro for omitido, o serviço de acessibilidade será considerado disponível para eventos de acessibilidade de serviço de qualquer app. É possível definir esse parâmetro nos arquivos de configuração do serviço de acessibilidade com o atributo
android:packageNames
como uma lista separada por vírgulas ou usar o membroAccessibilityServiceInfo.packageNames
.Tipos de evento:especifique os tipos de eventos de acessibilidade que você quer processar. É possível definir esse parâmetro nos arquivos de configuração do serviço de acessibilidade com o atributo
android:accessibilityEventTypes
como uma lista separada pelo caractere|
, por exemplo,accessibilityEventTypes="typeViewClicked|typeViewFocused"
. Ou você pode configurá-lo usando o membroAccessibilityServiceInfo.eventTypes
.
Ao configurar o serviço de acessibilidade, considere cuidadosamente quais eventos ele pode processar e registre-se apenas para esses eventos. Como os usuários podem ativar mais de um serviço de acessibilidade por vez, seu serviço não pode consumir eventos que não possam processar. Lembre-se de que outros serviços podem lidar com esses eventos para melhorar a experiência do usuário.
Volume de acessibilidade
Dispositivos com o Android 8.0 (nível 26 da API) e versões mais recentes incluem a
categoria de volume STREAM_ACCESSIBILITY
, que permite controlar o volume da saída de áudio
do serviço de acessibilidade independentemente dos outros sons do dispositivo.
Os serviços de acessibilidade podem usar esse tipo de stream definindo a
opção
FLAG_ENABLE_ACCESSIBILITY_VOLUME
. Em seguida, você pode mudar o volume do áudio de acessibilidade do dispositivo chamando
o método
adjustStreamVolume()
na instância de
AudioManager
do dispositivo.
O snippet de código abaixo demonstra como um serviço de acessibilidade pode usar a
categoria de volume STREAM_ACCESSIBILITY
:
Kotlin
import android.media.AudioManager.* class MyAccessibilityService : AccessibilityService() { private val audioManager = getSystemService(AUDIO_SERVICE) as AudioManager override fun onAccessibilityEvent(accessibilityEvent: AccessibilityEvent) { if (accessibilityEvent.source.text == "Increase volume") { audioManager.adjustStreamVolume(AudioManager.STREAM_ACCESSIBILITY, ADJUST_RAISE, 0) } } }
Java
import static android.media.AudioManager.*; public class MyAccessibilityService extends AccessibilityService { private AudioManager audioManager = (AudioManager) getSystemService(AUDIO_SERVICE); @Override public void onAccessibilityEvent(AccessibilityEvent accessibilityEvent) { AccessibilityNodeInfo interactedNodeInfo = accessibilityEvent.getSource(); if (interactedNodeInfo.getText().equals("Increase volume")) { audioManager.adjustStreamVolume(AudioManager.STREAM_ACCESSIBILITY, ADJUST_RAISE, 0); } } }
Para saber mais, assista o vídeo da sessão Novidades de acessibilidade do Android (em inglês) do Google I/O 2017, a partir de 6:35.
Atalho de acessibilidade
Em dispositivos com o Android 8.0 (nível 26 da API) e versões mais recentes, os usuários podem ativar e desativar o serviço de acessibilidade de sua preferência em qualquer tela pressionando e segurando as duas teclas de volume ao mesmo tempo. Embora esse atalho ative e desative o Talkback por padrão, os usuários podem configurar o botão para ativar e desativar qualquer serviço instalado no dispositivo.
Para que os usuários acessem um serviço específico usando o atalho, o serviço precisa solicitar o recurso durante a execução.
Para saber mais, assista o vídeo da sessão Novidades de acessibilidade do Android (em inglês) do Google I/O 2017, a partir de 13:25.
Botão de acessibilidade
Em dispositivos que usam uma área de navegação renderizada por software e executam o Android 8.0 (nível 26 da API) ou versões mais recentes, o lado direito da barra de navegação inclui um botão de acessibilidade. Quando os usuários pressionam esse botão, eles podem invocar um dos vários recursos e serviços de acessibilidade ativados, dependendo do conteúdo mostrado atualmente na tela.
Para permitir que os usuários invoquem determinado serviço usando o botão
de acessibilidade, o serviço precisa adicionar a flag
FLAG_REQUEST_ACCESSIBILITY_BUTTON
ao atributo android:accessibilityFlags
de um objeto AccessibilityServiceInfo
. O serviço pode registrar callbacks usando
registerAccessibilityButtonCallback()
.
O snippet de código a seguir demonstra como configurar um serviço de acessibilidade para responder quando o usuário pressionar o botão de acessibilidade:
Kotlin
private var mAccessibilityButtonController: AccessibilityButtonController? = null private var accessibilityButtonCallback: AccessibilityButtonController.AccessibilityButtonCallback? = null private var mIsAccessibilityButtonAvailable: Boolean = false override fun onServiceConnected() { mAccessibilityButtonController = accessibilityButtonController mIsAccessibilityButtonAvailable = mAccessibilityButtonController?.isAccessibilityButtonAvailable ?: false if (!mIsAccessibilityButtonAvailable) return serviceInfo = serviceInfo.apply { flags = flags or AccessibilityServiceInfo.FLAG_REQUEST_ACCESSIBILITY_BUTTON } accessibilityButtonCallback = object : AccessibilityButtonController.AccessibilityButtonCallback() { override fun onClicked(controller: AccessibilityButtonController) { Log.d("MY_APP_TAG", "Accessibility button pressed!") // Add custom logic for a service to react to the // accessibility button being pressed. } override fun onAvailabilityChanged( controller: AccessibilityButtonController, available: Boolean ) { if (controller == mAccessibilityButtonController) { mIsAccessibilityButtonAvailable = available } } } accessibilityButtonCallback?.also { mAccessibilityButtonController?.registerAccessibilityButtonCallback(it, null) } }
Java
private AccessibilityButtonController accessibilityButtonController; private AccessibilityButtonController .AccessibilityButtonCallback accessibilityButtonCallback; private boolean mIsAccessibilityButtonAvailable; @Override protected void onServiceConnected() { accessibilityButtonController = getAccessibilityButtonController(); mIsAccessibilityButtonAvailable = accessibilityButtonController.isAccessibilityButtonAvailable(); if (!mIsAccessibilityButtonAvailable) { return; } AccessibilityServiceInfo serviceInfo = getServiceInfo(); serviceInfo.flags |= AccessibilityServiceInfo.FLAG_REQUEST_ACCESSIBILITY_BUTTON; setServiceInfo(serviceInfo); accessibilityButtonCallback = new AccessibilityButtonController.AccessibilityButtonCallback() { @Override public void onClicked(AccessibilityButtonController controller) { Log.d("MY_APP_TAG", "Accessibility button pressed!"); // Add custom logic for a service to react to the // accessibility button being pressed. } @Override public void onAvailabilityChanged( AccessibilityButtonController controller, boolean available) { if (controller.equals(accessibilityButtonController)) { mIsAccessibilityButtonAvailable = available; } } }; if (accessibilityButtonCallback != null) { accessibilityButtonController.registerAccessibilityButtonCallback( accessibilityButtonCallback, null); } }
Para saber mais, assista o vídeo da sessão Novidades de acessibilidade do Android (em inglês) do Google I/O 2017, a partir de 16:28.
Gestos de impressão digital
Os serviços de acessibilidade em dispositivos com o Android 8.0 (API de nível 26) ou versões mais recentes podem responder a deslizes direcionais (para cima, para baixo, para a esquerda e para a direita) no sensor de impressão digital de um dispositivo. Para configurar um serviço para receber callbacks sobre essas interações, conclua a seguinte sequência:
- Declare a permissão
USE_BIOMETRIC
e o recursoCAPABILITY_CAN_REQUEST_FINGERPRINT_GESTURES
. - Defina a sinalização
FLAG_REQUEST_FINGERPRINT_GESTURES
no atributoandroid:accessibilityFlags
. - Registre-se para callbacks usando
registerFingerprintGestureCallback()
.
Lembre-se de que nem todos os dispositivos têm sensores de impressão digital. Para identificar
se um dispositivo oferece suporte ao sensor, use o
método
isHardwareDetected()
. Mesmo em um dispositivo que inclua um sensor de impressão digital, o serviço não pode
usar o sensor quando ele estiver em uso para fins de autenticação. Para identificar quando
o sensor está disponível, chame o método
isGestureDetectionAvailable()
e implemente o
callback
onGestureDetectionAvailabilityChanged()
.
O snippet de código a seguir mostra um exemplo de como usar gestos de impressão digital para navegar em um tabuleiro de jogo virtual:
// AndroidManifest.xml <manifest ... > <uses-permission android:name="android.permission.USE_FINGERPRINT" /> ... <application> <service android:name="com.example.MyFingerprintGestureService" ... > <meta-data android:name="android.accessibilityservice" android:resource="@xml/myfingerprintgestureservice" /> </service> </application> </manifest>
// myfingerprintgestureservice.xml <accessibility-service xmlns:android="http://schemas.android.com/apk/res/android" ... android:accessibilityFlags=" ... |flagRequestFingerprintGestures" android:canRequestFingerprintGestures="true" ... />
Kotlin
// MyFingerprintGestureService.kt import android.accessibilityservice.FingerprintGestureController.* class MyFingerprintGestureService : AccessibilityService() { private var gestureController: FingerprintGestureController? = null private var fingerprintGestureCallback: FingerprintGestureController.FingerprintGestureCallback? = null private var mIsGestureDetectionAvailable: Boolean = false override fun onCreate() { gestureController = fingerprintGestureController mIsGestureDetectionAvailable = gestureController?.isGestureDetectionAvailable ?: false } override fun onServiceConnected() { if (mFingerprintGestureCallback != null || !mIsGestureDetectionAvailable) return fingerprintGestureCallback = object : FingerprintGestureController.FingerprintGestureCallback() { override fun onGestureDetected(gesture: Int) { when (gesture) { FINGERPRINT_GESTURE_SWIPE_DOWN -> moveGameCursorDown() FINGERPRINT_GESTURE_SWIPE_LEFT -> moveGameCursorLeft() FINGERPRINT_GESTURE_SWIPE_RIGHT -> moveGameCursorRight() FINGERPRINT_GESTURE_SWIPE_UP -> moveGameCursorUp() else -> Log.e(MY_APP_TAG, "Error: Unknown gesture type detected!") } } override fun onGestureDetectionAvailabilityChanged(available: Boolean) { mIsGestureDetectionAvailable = available } } fingerprintGestureCallback?.also { gestureController?.registerFingerprintGestureCallback(it, null) } } }
Java
// MyFingerprintGestureService.java import static android.accessibilityservice.FingerprintGestureController.*; public class MyFingerprintGestureService extends AccessibilityService { private FingerprintGestureController gestureController; private FingerprintGestureController .FingerprintGestureCallback fingerprintGestureCallback; private boolean mIsGestureDetectionAvailable; @Override public void onCreate() { gestureController = getFingerprintGestureController(); mIsGestureDetectionAvailable = gestureController.isGestureDetectionAvailable(); } @Override protected void onServiceConnected() { if (fingerprintGestureCallback != null || !mIsGestureDetectionAvailable) { return; } fingerprintGestureCallback = new FingerprintGestureController.FingerprintGestureCallback() { @Override public void onGestureDetected(int gesture) { switch (gesture) { case FINGERPRINT_GESTURE_SWIPE_DOWN: moveGameCursorDown(); break; case FINGERPRINT_GESTURE_SWIPE_LEFT: moveGameCursorLeft(); break; case FINGERPRINT_GESTURE_SWIPE_RIGHT: moveGameCursorRight(); break; case FINGERPRINT_GESTURE_SWIPE_UP: moveGameCursorUp(); break; default: Log.e(MY_APP_TAG, "Error: Unknown gesture type detected!"); break; } } @Override public void onGestureDetectionAvailabilityChanged(boolean available) { mIsGestureDetectionAvailable = available; } }; if (fingerprintGestureCallback != null) { gestureController.registerFingerprintGestureCallback( fingerprintGestureCallback, null); } } }
Para saber mais, assista o vídeo da sessão Novidades de acessibilidade do Android (em inglês) do Google I/O 2017, a partir de 9:03.
Conversão de texto em voz multilíngue
No Android 8.0 (nível 26 da API) e versões mais recentes, o serviço de conversão de texto em voz (TTS, na sigla em inglês) do Android
pode identificar e falar frases em vários idiomas em um único bloco de
texto. Para ativar esse recurso automático de troca de idioma em um serviço de
acessibilidade, una todas as strings em objetos
LocaleSpan
, conforme mostrado
no snippet de código abaixo:
Kotlin
val localeWrappedTextView = findViewById<TextView>(R.id.my_french_greeting_text).apply { text = wrapTextInLocaleSpan("Bonjour!", Locale.FRANCE) } private fun wrapTextInLocaleSpan(originalText: CharSequence, loc: Locale): SpannableStringBuilder { return SpannableStringBuilder(originalText).apply { setSpan(LocaleSpan(loc), 0, originalText.length - 1, 0) } }
Java
TextView localeWrappedTextView = findViewById(R.id.my_french_greeting_text); localeWrappedTextView.setText(wrapTextInLocaleSpan("Bonjour!", Locale.FRANCE)); private SpannableStringBuilder wrapTextInLocaleSpan( CharSequence originalText, Locale loc) { SpannableStringBuilder myLocaleBuilder = new SpannableStringBuilder(originalText); myLocaleBuilder.setSpan(new LocaleSpan(loc), 0, originalText.length() - 1, 0); return myLocaleBuilder; }
Para saber mais, assista o vídeo da sessão Novidades de acessibilidade do Android (em inglês) do Google I/O 2017, a partir de 10:59.
Agir em nome dos usuários
Desde 2011, os serviços de acessibilidade podem agir em nome dos usuários, incluindo a alteração do foco de entrada e a seleção (ativação) de elementos da interface do usuário. Em 2012, a variedade de ações foi ampliada para incluir listas de rolagem e interação com campos de texto. Os serviços de acessibilidade também podem realizar ações globais, como navegar para a tela inicial, pressionar o botão "Voltar" e abrir a tela de notificações e a lista de apps recentes. Desde 2012, o Android inclui o foco de acessibilidade, que torna todos os elementos visíveis selecionáveis por um serviço de acessibilidade.
Esses recursos permitem que os desenvolvedores de serviços de acessibilidade criem modos de navegação alternativos, como a navegação por gestos, e ofereçam aos usuários com deficiências um controle aprimorado dos dispositivos Android.
Ouvir gestos
Os serviços de acessibilidade podem detectar gestos específicos e responder agindo em
nome de um usuário. Esse recurso exige que o serviço de acessibilidade
solicite a ativação do recurso Explorar por toque. O serviço pode solicitar essa
ativação definindo o membro
flags
da instância AccessibilityServiceInfo
do serviço como
FLAG_REQUEST_TOUCH_EXPLORATION_MODE
,
conforme mostrado no exemplo a seguir.
Kotlin
class MyAccessibilityService : AccessibilityService() { override fun onCreate() { serviceInfo.flags = AccessibilityServiceInfo.FLAG_REQUEST_TOUCH_EXPLORATION_MODE } ... }
Java
public class MyAccessibilityService extends AccessibilityService { @Override public void onCreate() { getServiceInfo().flags = AccessibilityServiceInfo.FLAG_REQUEST_TOUCH_EXPLORATION_MODE; } ... }
Depois que o serviço solicitar a ativação do Explorar por toque, o usuário precisará permitir
que o recurso seja ativado, caso ainda não esteja. Quando esse recurso está
ativo, o serviço recebe notificações de gestos de acessibilidade pelo
método de callback
onGesture()
do serviço e pode responder agindo em nome do usuário.
Gestos contínuos
Dispositivos com o Android 8.0 (nível 26 da API) oferecem suporte a gestos contínuos ou
gestos programáticos com mais de um objeto
Path
.
Ao especificar uma sequência de traços, é possível especificar que eles pertencem ao
mesmo gesto programático usando o argumento final willContinue
no construtor
GestureDescription.StrokeDescription
, conforme mostrado no snippet de código abaixo:
Kotlin
// Simulates an L-shaped drag path: 200 pixels right, then 200 pixels down. private fun doRightThenDownDrag() { val dragRightPath = Path().apply { moveTo(200f, 200f) lineTo(400f, 200f) } val dragRightDuration = 500L // 0.5 second // The starting point of the second path must match // the ending point of the first path. val dragDownPath = Path().apply { moveTo(400f, 200f) lineTo(400f, 400f) } val dragDownDuration = 500L val rightThenDownDrag = GestureDescription.StrokeDescription( dragRightPath, 0L, dragRightDuration, true ).apply { continueStroke(dragDownPath, dragRightDuration, dragDownDuration, false) } }
Java
// Simulates an L-shaped drag path: 200 pixels right, then 200 pixels down. private void doRightThenDownDrag() { Path dragRightPath = new Path(); dragRightPath.moveTo(200, 200); dragRightPath.lineTo(400, 200); long dragRightDuration = 500L; // 0.5 second // The starting point of the second path must match // the ending point of the first path. Path dragDownPath = new Path(); dragDownPath.moveTo(400, 200); dragDownPath.lineTo(400, 400); long dragDownDuration = 500L; GestureDescription.StrokeDescription rightThenDownDrag = new GestureDescription.StrokeDescription(dragRightPath, 0L, dragRightDuration, true); rightThenDownDrag.continueStroke(dragDownPath, dragRightDuration, dragDownDuration, false); }
Para saber mais, assista o vídeo da sessão Novidades de acessibilidade do Android (em inglês) do Google I/O 2017, a partir de 15:47.
Usar ações de acessibilidade
Os serviços de acessibilidade podem atuar em nome dos usuários para simplificar as interações com apps e ser mais produtivos. A capacidade dos serviços de acessibilidade de realizar ações foi adicionada em 2011 e ampliada significativamente em 2012.
Para agir em nome dos usuários, seu serviço de acessibilidade precisa se registrar
para receber eventos de apps e solicitar permissão para visualizar o conteúdo
dos apps definindo android:canRetrieveWindowContent
como true
no
arquivo de configuração do serviço. Quando os eventos são recebidos pelo
serviço, ele pode recuperar o objeto
AccessibilityNodeInfo
do evento usando
getSource()
.
Com o objeto AccessibilityNodeInfo
, o serviço pode analisar a hierarquia
de visualização para determinar qual ação realizar e agir para o usuário usando
performAction()
.
Kotlin
class MyAccessibilityService : AccessibilityService() { override fun onAccessibilityEvent(event: AccessibilityEvent) { // Get the source node of the event. event.source?.apply { // Use the event and node information to determine what action to // take. // Act on behalf of the user. performAction(AccessibilityNodeInfo.ACTION_SCROLL_FORWARD) // Recycle the nodeInfo object. recycle() } } ... }
Java
public class MyAccessibilityService extends AccessibilityService { @Override public void onAccessibilityEvent(AccessibilityEvent event) { // Get the source node of the event. AccessibilityNodeInfo nodeInfo = event.getSource(); // Use the event and node information to determine what action to take. // Act on behalf of the user. nodeInfo.performAction(AccessibilityNodeInfo.ACTION_SCROLL_FORWARD); // Recycle the nodeInfo object. nodeInfo.recycle(); } ... }
O método performAction()
permite que o serviço realize ações em um
app. Caso o serviço precise executar uma ação global, como
navegar para a tela inicial, tocar no botão "Voltar" ou abrir a
tela de notificações ou a lista de apps recentes, use o
método
performGlobalAction()
.
Usar tipos de foco
Em 2012, o Android lançou um foco da interface do usuário chamado foco de acessibilidade. Os serviços de acessibilidade podem usar esse foco para selecionar qualquer elemento visível da interface do usuário e realizar ações sobre ele. Esse tipo de foco é diferente do foco de entrada, que determina qual elemento da interface do usuário na tela recebe entradas quando o usuário digita caracteres, pressiona Enter em um teclado ou o botão central de um botão direcional.
É possível que um elemento em uma interface do usuário tenha o foco de entrada enquanto outro elemento tem o foco de acessibilidade. O objetivo do foco de acessibilidade é fornecer aos serviços de acessibilidade um método de interação com elementos visíveis em uma tela, independentemente de o elemento ser focalizável de entrada do ponto de vista do sistema. Para garantir que o serviço interaja corretamente com os elementos de entrada dos apps, siga as diretrizes para testar a acessibilidade de um app e teste o serviço durante o uso de um app típico.
Um serviço de acessibilidade pode determinar qual elemento da interface do usuário tem foco
de entrada ou de acessibilidade usando o
método
AccessibilityNodeInfo.findFocus()
. Também é possível pesquisar elementos que possam ser selecionados com o foco de entrada
usando o
método
focusSearch()
. Por fim, o serviço pode definir o foco da acessibilidade usando
o
método
performAction(AccessibilityNodeInfo.ACTION_SET_ACCESSIBILITY_FOCUS)
.
Coletar informações
Os serviços de acessibilidade têm métodos padrão para coletar e representar as principais unidades de informações fornecidas pelo usuário, como detalhes de evento, texto e números.
Ver detalhes de mudanças de janelas
O Android 9 (nível 28 da API) e versões mais recentes permite que os apps acompanhem as atualizações de janelas quando
um app redesenha várias janelas simultaneamente. Quando um evento
TYPE_WINDOWS_CHANGED
ocorrer, use a API
getWindowChanges()
para determinar como as janelas mudam. Durante uma atualização de várias janelas, cada
janela produz o próprio conjunto de eventos. O método getSource()
retorna a visualização raiz da janela associada a cada evento.
Se um app definir títulos do painel
de acessibilidade para os
objetos View
, seu serviço poderá reconhecer quando
a interface do app for atualizada. Quando um evento
TYPE_WINDOW_STATE_CHANGED
ocorrer, use os tipos retornados por
getContentChangeTypes()
para determinar como a janela muda. Por exemplo, o framework pode detectar quando
um painel tem um novo título ou desaparece.
Ver detalhes de evento
O Android oferece informações para serviços de acessibilidade sobre a interação com a interface do usuário
usando objetos AccessibilityEvent
. Nas versões anteriores do Android,
as informações disponíveis em um evento de acessibilidade, além de fornecer detalhes significativos
sobre o controle da interface do usuário selecionado pelos usuários, ofereciam informações
contextuais limitadas. Em muitos casos, essas informações de contexto ausentes podem ser
fundamentais para entender o significado do controle selecionado.
Um exemplo de interface em que o contexto é essencial é um calendário ou um planejador diário. Se o usuário selecionar o horário das 16h em uma lista de segunda a sexta-feira e o serviço de acessibilidade anunciar "16h", mas não anunciar o nome do dia da semana, o dia do mês ou o nome do mês, o feedback resultante será confuso. Nesse caso, o contexto de um controle de interface é fundamental para quem quer agendar uma reunião.
Desde 2011, o Android estende significativamente a quantidade de informações que um serviço de acessibilidade pode receber sobre uma interação com a interface do usuário, criando eventos de acessibilidade com base na hierarquia de visualização. Uma hierarquia de visualização é o conjunto de componentes da interface do usuário que contém o componente (os pais) e os elementos da interface do usuário que podem estar contidos por esse componente (os filhos). Dessa forma, o Android pode oferecer mais detalhes sobre os eventos de acessibilidade, permitindo que os serviços de acessibilidade ofereçam feedback mais útil aos usuários.
Um serviço de acessibilidade recebe informações sobre um evento da interface do usuário usando
um AccessibilityEvent
transmitido pelo sistema para o método de callback
onAccessibilityEvent()
do serviço. Esse objeto fornece detalhes sobre o
evento, incluindo o tipo de objeto em que a ação está sendo realizada, o texto descritivo e
outros detalhes.
AccessibilityEvent.getRecordCount()
egetRecord(int)
: esses métodos permitem extrair o conjunto de objetosAccessibilityRecord
que contribuem para oAccessibilityEvent
transmitido a você pelo sistema. Esse nível de detalhamento fornece mais contexto para o evento que aciona seu serviço de acessibilidade.AccessibilityRecord.getSource()
: esse método retorna um objetoAccessibilityNodeInfo
. Esse objeto permite solicitar a hierarquia de layout de visualização (pais e filhos) do componente que origina o evento de acessibilidade. Esse recurso permite que um serviço de acessibilidade investigue o contexto completo de um evento, incluindo o conteúdo e o estado de todas as visualizações filhas ou incluídas.
A Plataforma Android permite que uma AccessibilityService
consulte
a hierarquia de visualizações, coletando informações sobre o componente de interface que gera
um evento, além do pai e dos filhos dele. Para fazer isso, defina a seguinte linha
na configuração XML:
android:canRetrieveWindowContent="true"
Em seguida, receba um objeto AccessibilityNodeInfo
usando getSource()
.
Essa chamada só retorna um objeto se a janela de origem do evento ainda for a janela ativa. Caso contrário, ele retorna nulo. Portanto, comporte-se de acordo.
No exemplo abaixo, o código faz o seguinte quando um evento é recebido:
- Captura imediatamente o pai da visualização em que o evento se origina.
- Nessa visualização, procura um rótulo e uma caixa de seleção como visualizações filhas.
- Se os encontrar, cria uma string para informar ao usuário, indicando o rótulo e se ele foi verificado.
Se, em algum momento, um valor nulo for retornado ao atravessar a hierarquia de visualização, o método será desativado silenciosamente.
Kotlin
// Alternative onAccessibilityEvent that uses AccessibilityNodeInfo. override fun onAccessibilityEvent(event: AccessibilityEvent) { val source: AccessibilityNodeInfo = event.source ?: return // Grab the parent of the view that fires the event. val rowNode: AccessibilityNodeInfo = getListItemNodeInfo(source) ?: return // Using this parent, get references to both child nodes, the label, and the // checkbox. val taskLabel: CharSequence = rowNode.getChild(0)?.text ?: run { rowNode.recycle() return } val isComplete: Boolean = rowNode.getChild(1)?.isChecked ?: run { rowNode.recycle() return } // Determine what the task is and whether it's complete based on the text // inside the label, and the state of the checkbox. if (rowNode.childCount < 2 || !rowNode.getChild(1).isCheckable) { rowNode.recycle() return } val completeStr: String = if (isComplete) { getString(R.string.checked) } else { getString(R.string.not_checked) } val reportStr = "$taskLabel$completeStr" speakToUser(reportStr) }
Java
// Alternative onAccessibilityEvent that uses AccessibilityNodeInfo. @Override public void onAccessibilityEvent(AccessibilityEvent event) { AccessibilityNodeInfo source = event.getSource(); if (source == null) { return; } // Grab the parent of the view that fires the event. AccessibilityNodeInfo rowNode = getListItemNodeInfo(source); if (rowNode == null) { return; } // Using this parent, get references to both child nodes, the label, and the // checkbox. AccessibilityNodeInfo labelNode = rowNode.getChild(0); if (labelNode == null) { rowNode.recycle(); return; } AccessibilityNodeInfo completeNode = rowNode.getChild(1); if (completeNode == null) { rowNode.recycle(); return; } // Determine what the task is and whether it's complete based on the text // inside the label, and the state of the checkbox. if (rowNode.getChildCount() < 2 || !rowNode.getChild(1).isCheckable()) { rowNode.recycle(); return; } CharSequence taskLabel = labelNode.getText(); final boolean isComplete = completeNode.isChecked(); String completeStr = null; if (isComplete) { completeStr = getString(R.string.checked); } else { completeStr = getString(R.string.not_checked); } String reportStr = taskLabel + completeStr; speakToUser(reportStr); }
Agora, você tem um serviço de acessibilidade completo e funcional. Tente configurar a forma como
ele interage com o usuário adicionando o mecanismo de conversão de texto
em voz
do Android ou usando um Vibrator
para fornecer retorno tátil.
Processar texto
Os dispositivos com o Android 8.0 (API de nível 26) ou versões mais recentes incluem vários recursos de processamento de texto que facilitam a identificação e a operação dos serviços de acessibilidade em unidades de texto específicas exibidas na tela.
Dicas
O Android 9 (nível 28 da API) introduz vários recursos que dão acesso a
dicas na interface do app. Use
getTooltipText()
para ler o texto de uma dica e use
ACTION_SHOW_TOOLTIP
e
ACTION_HIDE_TOOLTIP
para instruir as instâncias de View
a mostrar ou ocultar as dicas.
Texto de dica
Desde 2017, o Android inclui vários métodos para interagir com o texto de dica de um objeto baseado em texto:
- Os métodos
isShowingHintText()
esetShowingHintText()
indicam e definem, respectivamente, se o conteúdo de texto atual do nó representa o texto de dica do nó. getHintText()
fornece acesso ao próprio texto de dica. Mesmo que um objeto não esteja exibindo texto de dica, chamargetHintText()
funciona.
Locais de caracteres de texto na tela
Em dispositivos com o Android 8.0 (nível 26 da API) e versões mais recentes, os serviços de acessibilidade
podem determinar as coordenadas da tela para cada caixa delimitadora de cada caractere visível
em um widget TextView
. Os serviços
encontram essas coordenadas chamando
refreshWithExtraData()
,
transmitindo
EXTRA_DATA_TEXT_CHARACTER_LOCATION_KEY
como o primeiro argumento e um objeto Bundle
como o segundo argumento. À medida que o método é executado, o sistema preenche o
argumento Bundle
com uma matriz parcelable de
objetos Rect
. Cada objeto Rect
representa a caixa delimitadora de um caractere específico.
Valores padronizados de intervalo unilateral
Alguns objetos AccessibilityNodeInfo
usam uma instância de
AccessibilityNodeInfo.RangeInfo
para indicar que um elemento da interface pode assumir um intervalo de valores. Ao criar um
intervalo usando
RangeInfo.obtain()
ou ao recuperar os valores extremos do intervalo usando
getMin()
e
getMax()
,
lembre-se de que dispositivos com o Android 8.0 (nível 26 da API) e versões mais recentes representam
intervalos unilaterais de forma padronizada:
- Para intervalos sem mínimo,
Float.NEGATIVE_INFINITY
representa o valor mínimo. - Para intervalos sem máximo,
Float.POSITIVE_INFINITY
representa o valor máximo.
Responder a eventos de acessibilidade
Agora que o serviço está configurado para executar e detectar eventos, escreva o código para que ele
saiba o que fazer quando um AccessibilityEvent
chegar. Comece substituindo o
método
onAccessibilityEvent(AccessibilityEvent)
. Nesse método, use
getEventType()
para determinar o tipo de evento e
getContentDescription()
para extrair qualquer texto de rótulo associado à visualização que acione o evento:
Kotlin
override fun onAccessibilityEvent(event: AccessibilityEvent) { var eventText: String = when (event.eventType) { AccessibilityEvent.TYPE_VIEW_CLICKED -> "Clicked: " AccessibilityEvent.TYPE_VIEW_FOCUSED -> "Focused: " else -> "" } eventText += event.contentDescription // Do something nifty with this text, like speak the composed string back to // the user. speakToUser(eventText) ... }
Java
@Override public void onAccessibilityEvent(AccessibilityEvent event) { final int eventType = event.getEventType(); String eventText = null; switch(eventType) { case AccessibilityEvent.TYPE_VIEW_CLICKED: eventText = "Clicked: "; break; case AccessibilityEvent.TYPE_VIEW_FOCUSED: eventText = "Focused: "; break; } eventText = eventText + event.getContentDescription(); // Do something nifty with this text, like speak the composed string back to // the user. speakToUser(eventText); ... }
Outros recursos
Para saber mais, consulte os recursos a seguir: