Kendi erişilebilirlik hizmetinizi oluşturun

Erişilebilirlik hizmeti, engelli kullanıcılara yardımcı olmak amacıyla kullanıcı arayüzünü geliştiren veya geçici olarak bir cihazla tam olarak etkileşimde bulunamayacak bir uygulamadır. Örneğin, araba kullanan, küçük bir çocukla ilgilenen veya çok gürültülü bir partiye katılan kullanıcıların arayüze ilişkin ek veya alternatif geri bildirime ihtiyacı olabilir.

Android, TalkBack de dahil olmak üzere standart erişilebilirlik hizmetleri sağlar. Geliştiriciler de kendi hizmetlerini oluşturup dağıtabilir. Bu belgede, erişilebilirlik hizmeti oluşturmanın temelleri açıklanmaktadır.

Not: Uygulamanızda platform düzeyinde erişilebilirlik hizmetleri, yalnızca engelli kullanıcıların uygulamanızla etkileşimde bulunmasına yardımcı olmak amacıyla kullanılmalıdır.

Bir erişilebilirlik hizmeti, normal bir uygulamayla birlikte paketlenebilir veya bağımsız bir Android projesi olarak oluşturulabilir. Hizmeti oluşturma adımları her iki durumda da aynıdır.

Erişilebilirlik hizmetinizi oluşturun

Projenizde AccessibilityService süresini uzatan bir sınıf oluşturun:

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() {
    }

...
}

Bu Service için yeni bir proje oluşturursanız ve bununla ilişkilendirilmiş bir uygulama olmasını planlamıyorsanız başlangıç Activity sınıfını kaynağınızdan kaldırabilirsiniz.

Manifest beyanları ve izinleri

Erişilebilirlik hizmetleri sağlayan uygulamaların, Android sistemi tarafından erişilebilirlik hizmeti olarak kabul edilmesi için uygulama manifestlerinde belirli beyanlar içermesi gerekir. Bu bölümde, erişilebilirlik hizmetleri için gerekli ve isteğe bağlı ayarlar açıklanmaktadır.

Erişilebilirlik hizmeti beyanı

Uygulamanızın erişilebilirlik hizmeti olarak değerlendirilmesi için manifest dosyanızdaki application öğesine activity yerine service öğesi ekleyin. Buna ek olarak, service öğesine bir erişilebilirlik hizmeti amacı filtresi ekleyin. Manifest ayrıca hizmete yalnızca sistemin bağlanabildiğinden emin olmak için BIND_ACCESSIBILITY_SERVICE iznini ekleyerek hizmeti korumalıdır. Aşağıda bununla ilgili bir örnek verilmiştir:

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

Erişilebilirlik hizmeti yapılandırması

Erişilebilirlik hizmetleri, hizmetin işlediği erişilebilirlik etkinliği türlerini ve hizmetle ilgili ek bilgileri belirten bir yapılandırma sağlamalıdır. Erişilebilirlik hizmetinin yapılandırması AccessibilityServiceInfo sınıfında yer alır. Hizmetiniz bu sınıfın bir örneğini ve çalışma zamanında setServiceInfo() örneğini kullanarak bir yapılandırma oluşturup ayarlayabilir. Ancak bu yöntem kullanılarak tüm yapılandırma seçenekleri kullanılamaz.

Manifest dosyanıza bir yapılandırma dosyasına referansla birlikte bir <meta-data> öğesi ekleyebilirsiniz. Bu dosya, aşağıdaki örnekte gösterildiği gibi erişilebilirlik hizmetiniz için tüm seçenekleri ayarlamanıza olanak tanır:

<service android:name=".MyAccessibilityService">
  ...
  <meta-data
    android:name="android.accessibilityservice"
    android:resource="@xml/accessibility_service_config" />
</service>

Bu <meta-data> öğesi, uygulamanızın kaynak dizininde oluşturduğunuz bir XML dosyasını ifade eder: <project_dir>/res/xml/accessibility_service_config.xml>. Aşağıdaki kod, hizmet yapılandırma dosyasının içeriğinin bir örneğini göstermektedir:

<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"
/>

Erişilebilirlik hizmeti yapılandırma dosyasında kullanılabilecek XML özellikleri hakkında daha fazla bilgi için aşağıdaki referans belgelerine bakın:

• android:description
• android:packageNames
• android:accessibilityEventTypes
• android:accessibilityFlags
• android:accessibilityFeedbackType
• android:notificationTimeout
• android:canRetrieveWindowContent
• android:settingsActivity

Çalışma zamanında hangi yapılandırma ayarlarının dinamik olarak ayarlanabileceği hakkında daha fazla bilgi edinmek için AccessibilityServiceInfo referans belgelerini inceleyin.

Erişilebilirlik hizmetinizi yapılandırın

Erişilebilirlik hizmetinizin yapılandırma değişkenlerini ayarlarken, sisteme nasıl ve ne zaman çalışacağını bildirmek için aşağıdakileri göz önünde bulundurun:

• Bu uygulamanın hangi etkinlik türlerine yanıt vermesini istiyorsunuz?
• Hizmetin tüm uygulamalar için mi yoksa yalnızca belirli paket adları için mi etkin olması gerekir?
• Hangi farklı geri bildirim türlerini kullanıyor?

Bu değişkenleri ayarlamak için iki seçeneğiniz vardır. Geriye dönük uyumlu seçenek, bunları setServiceInfo(android.accessibilityservice.AccessibilityServiceInfo) kullanarak kod içinde ayarlamaktır. Bunun için onServiceConnected() yöntemini geçersiz kılın ve aşağıdaki örnekte gösterildiği gibi hizmetinizi bu yöntemle yapılandırın:

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

}

İkinci seçenek, hizmeti XML dosyası kullanarak yapılandırmaktır. canRetrieveWindowContent gibi belirli yapılandırma seçenekleri, yalnızca hizmetinizi XML kullanarak yapılandırırsanız kullanılabilir. Önceki örnekte bulunan yapılandırma seçenekleri, XML kullanılarak tanımlandığında aşağıdaki gibi görünür:

<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"
/>

XML kullanıyorsanız XML dosyasını işaret eden hizmet beyanınıza bir <meta-data> etiketi ekleyerek manifest dosyanıza referans verin. XML dosyanızı res/xml/serviceconfig.xml içinde depolarsanız yeni etiket şu şekilde görünür:

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

Erişilebilirlik hizmeti yöntemleri

Bir erişilebilirlik hizmeti, AccessibilityService sınıfını genişletmeli ve ilgili sınıftan aşağıdaki yöntemleri geçersiz kılmalıdır. Bu yöntemler, Android sisteminin çağrıştırdığı sırayla sunulur: hizmetin başlatılmasından (onServiceConnected()), çalıştığı ana kadar (onAccessibilityEvent(), onInterrupt()) kapanmasına (onUnbind()).

• onServiceConnected(): (isteğe bağlı) Erişilebilirlik hizmetinize bağlandığında sistem bu yöntemi çağırır. Ses yöneticisi veya cihaz titreşimi gibi kullanıcı geri bildirim sistemi hizmetlerine bağlanmak da dahil olmak üzere hizmetiniz için tek seferlik kurulum adımları uygulamak için bu yöntemi kullanın. Hizmetinizin yapılandırmasını çalışma zamanında ayarlamak veya tek seferlik ayarlamalar yapmak istiyorsanız bu, setServiceInfo() öğesini çağırmak için uygun bir konumdur.

• onAccessibilityEvent(): (zorunlu) Sistem, erişilebilirlik hizmetiniz tarafından belirtilen etkinlik filtreleme parametreleriyle eşleşen bir AccessibilityEvent algıladığında (ör. kullanıcının bir düğmeye dokunması veya erişilebilirlik hizmetinizin geri bildirim sağladığı bir uygulamadaki kullanıcı arayüzü kontrolüne odaklanması) bu yöntemi geri çağırır. Sistem bu yöntemi çağırdığında, ilişkili AccessibilityEvent iletir. Hizmet daha sonra bu bilgileri yorumlayıp kullanıcıya geri bildirim sağlamak için kullanabilir. Bu yöntem, hizmetinizin yaşam döngüsü boyunca birçok kez çağrılabilir.

• onInterrupt(): (zorunlu) Sistem, hizmetinizin sağladığı geri bildirimi kesintiye uğratmak istediğinde (genellikle odağı farklı bir kontrole taşımak gibi bir kullanıcı işlemine yanıt olarak) sistem bu yöntemi çağırır. Bu yöntem, hizmetinizin yaşam döngüsü boyunca birçok kez çağrılabilir.

• onUnbind(): (isteğe bağlı) Sistem, erişilebilirlik hizmetini kapatmak üzereyken bu yöntemi çağırır. Ses yöneticisi veya cihaz titreşimi gibi kullanıcı geri bildirim sistemi hizmetlerinin bağlantısını kesmek de dahil olmak üzere tüm tek seferlik kapatma prosedürlerini uygulamak için bu yöntemi kullanın.

Bu geri çağırma yöntemleri, erişilebilirlik hizmetiniz için temel yapıyı sağlar. Android sistemi tarafından AccessibilityEvent nesneleri biçiminde sağlanan verilerin nasıl işleneceğine karar verebilir ve kullanıcıya geri bildirim sağlayabilirsiniz. Erişilebilirlik etkinliklerinden bilgi alma hakkında daha fazla bilgi edinmek için Etkinlik ayrıntılarını alma başlıklı makaleyi inceleyin.

Erişilebilirlik etkinliklerine kaydolun

Erişilebilirlik hizmeti yapılandırma parametrelerinin en önemli işlevlerinden biri, hizmetinizin işleyebileceği erişilebilirlik etkinliği türlerini belirtebilmenizi sağlamaktır. Bu bilgilerin belirtilmesi, erişilebilirlik hizmetlerinin birbirleriyle işbirliği yapmasına olanak tanır ve size belirli uygulamalardaki belirli etkinlik türlerini yönetme esnekliği sunar. Etkinlik filtrelemesi aşağıdaki ölçütleri içerebilir:

• Paket adları: Hizmetinizin erişilebilirlik etkinliklerini işlemesini istediğiniz uygulamaların paket adlarını belirtin. Bu parametre eklenmezse erişilebilirlik hizmetinizin herhangi bir uygulamanın hizmet erişilebilirlik etkinlikleri için kullanılabilir olduğu kabul edilir. Bu parametreyi, erişilebilirlik hizmeti yapılandırma dosyalarında android:packageNames özelliğiyle virgülle ayrılmış liste olarak ayarlayabilir veya AccessibilityServiceInfo.packageNames üyesini kullanabilirsiniz.

• Etkinlik türleri: Hizmetinizin işlemesini istediğiniz erişilebilirlik etkinliklerinin türlerini belirtin. Erişilebilirlik hizmeti yapılandırma dosyalarında bu parametreyi, | karakteriyle ayrılmış bir liste olarak android:accessibilityEventTypes özelliğini kullanarak ayarlayabilirsiniz (ör. accessibilityEventTypes="typeViewClicked|typeViewFocused"). Dilerseniz AccessibilityServiceInfo.eventTypes üyesini kullanarak da ayarlayabilirsiniz.

Erişilebilirlik hizmetinizi ayarlarken hizmetinizin hangi etkinlikleri işleyebileceğini dikkatlice düşünün ve yalnızca bu etkinlikler için kaydolun. Kullanıcılar aynı anda birden fazla erişilebilirlik hizmetini etkinleştirebildiğinden hizmetinizin işleyemeyeceği etkinlikleri tüketmemesi gerekir. Diğer hizmetlerin de kullanıcı deneyimini iyileştirmek için bu tür etkinliklerle ilgilenebileceğini unutmayın.

Erişilebilirlik ses düzeyi

Android 8.0 (API düzeyi 26) ve sonraki sürümleri çalıştıran cihazlar STREAM_ACCESSIBILITY ses düzeyi kategorisini içerir. Bu kategori, erişilebilirlik hizmetinizin ses çıkışının ses düzeyini cihazdaki diğer seslerden bağımsız olarak kontrol etmenize olanak tanır.

Erişilebilirlik hizmetleri, FLAG_ENABLE_ACCESSIBILITY_VOLUME seçeneğini ayarlayarak bu akış türünü kullanabilir. Daha sonra, cihazın AudioManager örneğinde adjustStreamVolume() yöntemini çağırarak cihazın erişilebilirlik ses düzeyini değiştirebilirsiniz.

Aşağıdaki kod snippet'i, erişilebilirlik hizmetlerinin STREAM_ACCESSIBILITY ses düzeyi kategorisini nasıl kullanabileceğini gösterir:

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);
        }
    }
}

Daha fazla bilgi için Google I/O 2017'de 6:35'ten itibaren yayınlanan Android erişilebilirliğindeki yenilikler oturum videosunu izleyin.

Erişilebilirlik kısayolu

Android 8.0 (API düzeyi 26) ve sonraki sürümleri çalıştıran cihazlarda kullanıcılar, her iki ses seviyesi tuşuna aynı anda basılı tutarak tercih ettikleri erişilebilirlik hizmetini herhangi bir ekrandan etkinleştirebilir ve devre dışı bırakabilir. Bu kısayol TalkBack'i varsayılan olarak etkinleştirip devre dışı bıraksa da kullanıcılar düğmeyi cihazlarında yüklü olan hizmetleri etkinleştirecek ve devre dışı bırakacak şekilde yapılandırabilir.

Kullanıcıların, erişilebilirlik kısayolundan belirli bir erişilebilirlik hizmetine erişebilmesi için hizmetin, özelliği çalışma zamanında istemesi gerekir.

Daha fazla bilgi için Google I/O 2017'de 13:25'te başlayan Android erişilebilirliğindeki yenilikler oturum videosunu izleyin.

Erişilebilirlik düğmesi

Yazılımla oluşturulan gezinme alanı kullanan ve Android 8.0 (API düzeyi 26) veya sonraki sürümleri çalıştıran cihazlarda, gezinme çubuğunun sağ tarafında bir erişilebilirlik düğmesi bulunur. Kullanıcılar bu düğmeye bastığında ekranda o anda gösterilen içeriğe bağlı olarak birkaç etkin erişilebilirlik özelliği ve hizmetinden birini çağırabilirler.

Kullanıcıların erişilebilirlik düğmesini kullanarak belirli bir erişilebilirlik hizmetini çağırmasına izin vermek için hizmetin, AccessibilityServiceInfo nesnesinin android:accessibilityFlags özelliğine FLAG_REQUEST_ACCESSIBILITY_BUTTON işaretini eklemesi gerekir. Daha sonra hizmet, registerAccessibilityButtonCallback() kullanarak geri çağırmaları kaydedebilir.

Not: Bu özellik, yalnızca yazılımla oluşturulan bir gezinme alanı sağlayan cihazlarda kullanılabilir. Hizmetler her zaman isAccessibilityButtonAvailable() kullanmalı ve erişilebilirlik düğmesinin kullanılabilirliğine göre değişikliklere onAvailabilityChanged() uygulayarak yanıt vermelidir. Bu sayede, erişilebilirlik düğmesi desteklenmese veya kullanılamaz hale gelse bile kullanıcılar hizmetin işlevlerine her zaman erişebilir.

Aşağıdaki kod snippet'i, erişilebilirlik düğmesine basan kullanıcıya yanıt vermek için bir erişilebilirlik hizmetini nasıl yapılandırabileceğinizi göstermektedir:

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);
    }
}

Daha fazla bilgi için Google I/O 2017'de 16:28'de başlayan Android erişilebilirliğindeki yenilikler oturum videosunu izleyin.

Parmak izi hareketleri

Android 8.0 (API düzeyi 26) veya sonraki sürümleri çalıştıran cihazlardaki erişilebilirlik hizmetleri, cihazın parmak izi sensörü üzerindeki yönsel kaydırmalara (yukarı, aşağı, sola ve sağa) yanıt verebilir. Bir hizmeti bu etkileşimlerle ilgili geri çağırmalar alacak şekilde yapılandırmak için aşağıdaki sırayı tamamlayın:

1. USE_BIOMETRIC iznini ve CAPABILITY_CAN_REQUEST_FINGERPRINT_GESTURES özelliğini beyan edin.
2. android:accessibilityFlags özelliği içindeki FLAG_REQUEST_FINGERPRINT_GESTURES işaretini ayarlayın.
3. registerFingerprintGestureCallback() üzerinden geri arama için kaydolun.

Not: Kullanıcıların, erişilebilirlik hizmetinin parmak izi hareketleri desteğini devre dışı bırakmasına izin verin. Birden fazla erişilebilirlik hizmeti, parmak izi hareketlerini aynı anda dinleyebilir ancak bu durum, hizmetlerin birbiriyle çakışmasına neden olur.

Tüm cihazlarda parmak izi sensörlerinin bulunmadığını unutmayın. Bir cihazın sensörü destekleyip desteklemediğini belirlemek için isHardwareDetected() yöntemini kullanın. Hizmetiniz, parmak izi sensörü içeren bir cihazda bile kimlik doğrulama amacıyla kullanılan bir sensörü kullanamaz. Sensörün ne zaman kullanılabilir olduğunu belirlemek için isGestureDetectionAvailable() yöntemini çağırın ve onGestureDetectionAvailabilityChanged() geri çağırma yöntemini uygulayın.

Aşağıdaki kod snippet'inde, sanal bir oyun tahtasında gezinmek için parmak izi hareketlerinin kullanılmasına dair bir örnek gösterilmektedir:

// 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);
        }
    }
}

Daha fazla bilgi için Google I/O 2017'de 09:03'te başlayacak olan Android erişilebilirliğindeki yenilikler oturum videosunu izleyin.

Çok dilli metin okuma

Android 8.0 (API düzeyi 26) sürümünden itibaren, Android'in metin okuma (TTS) hizmeti tek bir metin blokunda birden fazla dildeki ifadeleri tanımlayıp söyleyebilir. Bu otomatik dil geçişi özelliğini bir erişilebilirlik hizmetinde etkinleştirmek için tüm dizeleri aşağıdaki kod snippet'inde gösterildiği gibi LocaleSpan nesnelerinin içine sarmalayın:

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

Daha fazla bilgi için Google I/O 2017'de 10:59'dan itibaren yayınlanan Android erişilebilirliğindeki yenilikler oturum videosunu izleyin.

Kullanıcılar adına işlem yapma

2011'den itibaren erişilebilirlik hizmetleri, giriş odağının değiştirilmesi ve kullanıcı arayüzü öğelerinin seçilmesi (etkinleştirilmesi) dahil, kullanıcılar adına hareket edebilir. 2012'de bu işlemlerin kapsamı, kaydırma listelerini ve metin alanlarıyla etkileşimi içerecek şekilde genişletildi. Erişilebilirlik hizmetleri ayrıca ana ekrana gitmek, Geri düğmesine basmak ve bildirimler ekranı ile son uygulamalar listesini açmak gibi genel işlemler de yapabilir. Android, 2012'den beri tüm görünür öğeleri bir erişilebilirlik hizmeti tarafından seçilebilir hale getiren erişilebilirlik odağı özelliğini içermektedir.

Bu özellikler, erişilebilirlik hizmetleri geliştiricilerinin hareketle gezinme gibi alternatif gezinme modları oluşturmasına ve engelli kullanıcılara Android destekli cihazlarını daha iyi kontrol etmelerine olanak tanır.

Hareketleri dinleyin

Erişilebilirlik hizmetleri, belirli hareketleri dinleyebilir ve kullanıcı adına hareket ederek yanıt verebilir. Bu özellik, erişilebilirlik hizmeti için Dokunarak Keşfet özelliğinin etkinleştirilmesini gerektiriyor. Hizmetiniz, aşağıdaki örnekte gösterildiği gibi AccessibilityServiceInfo örneğinin flags üyesini FLAG_REQUEST_TOUCH_EXPLORATION_MODE olarak ayarlayarak bu etkinleştirme isteğinde bulunabilir.

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;
    }
    ...
}

Hizmetiniz Dokunarak Keşfet'in etkinleştirilmesini istedikten sonra, kullanıcının özelliğin açılmasına izin vermesi gerekir (etkin değilse). Bu özellik etkin olduğunda hizmetiniz, onGesture() geri çağırma yöntemi aracılığıyla erişilebilirlik hareketlerine dair bildirim alır ve kullanıcı adına hareket ederek yanıt verebilir.

Kesintisiz hareketler

Android 8.0 (API düzeyi 26) çalıştıran cihazlar, devam eden hareketleri veya birden fazla Path nesnesi içeren programatik hareketleri destekler.

Bir kulaç dizisi belirtirken, aşağıdaki kod snippet'inde gösterildiği gibi GestureDescription.StrokeDescription oluşturucudaki son willContinue bağımsız değişkenini kullanarak vuruş sırasının aynı programatik harekete ait olduğunu belirtebilirsiniz:

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);
}

Daha fazla bilgi için Google I/O 2017'de 15:47'de başlayan Android erişilebilirliğindeki yenilikler oturum videosunu izleyin.

Erişilebilirlik işlemlerini kullanma

Erişilebilirlik hizmetleri, uygulamalarla etkileşimleri basitleştirmek ve daha üretken olmak için kullanıcılar adına hareket edebilir. Erişilebilirlik hizmetlerinin işlem gerçekleştirme özelliği 2011'de eklendi ve 2012'de önemli ölçüde genişletildi.

Erişilebilirlik hizmetinizin, kullanıcıların adına işlem yapabilmesi için uygulamalardan etkinlik almak üzere kaydolması ve hizmet yapılandırma dosyasında android:canRetrieveWindowContent öğesini true olarak ayarlayarak uygulamaların içeriğini görüntüleme izni istemesi gerekir. Hizmetiniz etkinlik aldığında, getSource() kullanarak AccessibilityNodeInfo nesnesini etkinlikten alabilir. Ardından hizmetiniz, AccessibilityNodeInfo nesnesiyle görünüm hiyerarşisini inceleyerek hangi işlemin gerçekleştirileceğini belirleyebilir ve performAction() kullanarak kullanıcı adına işlem yapabilir.

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();
    }
    ...
}

performAction() yöntemi, hizmetinizin uygulama içinde işlem yapmasını sağlar. Hizmetinizin ana ekrana gitmek, Geri düğmesine dokunmak veya bildirimler ekranını ya da son uygulamalar listesini açmak gibi genel bir işlem gerçekleştirmesi gerekiyorsa performGlobalAction() yöntemini kullanın.

Odak türlerini kullanma

Android, 2012'de erişilebilirlik odağı adlı bir kullanıcı arayüzü odağını kullanıma sundu. Erişilebilirlik hizmetleri, bu odağı kullanarak görünür bir kullanıcı arayüzü öğesini seçebilir ve öğe üzerinde işlem yapabilir. Bu odak türü, kullanıcı karakter yazdığında, klavyede Enter tuşuna bastığında ya da D-pad'in orta düğmesine bastığında ekrandaki hangi kullanıcı arayüzü öğesinin giriş alacağını belirleyen giriş odağı özelliğinden farklıdır.

Kullanıcı arayüzündeki bir öğede giriş odağı bulunurken başka bir öğede erişilebilirlik odağı bulunabilir. Erişilebilirlik odağının amacı, öğenin sistem açısından girişe odaklanılabilir olup olmadığına bakılmaksızın, ekrandaki görünür öğelerle etkileşim yöntemini kullanarak erişilebilirlik hizmetleri sağlamaktır. Erişilebilirlik hizmetinizin, uygulamaların giriş öğeleriyle doğru şekilde etkileşimde bulunduğundan emin olmak için tipik bir uygulamayı kullanırken hizmetinizi test etmek üzere uygulamanın erişilebilirliğini test etme yönergelerini uygulayın.

Not: Erişilebilirlik odağını kullanan erişilebilirlik hizmetleri, bir öğe bu tür odaklama özelliğine sahip olduğunda giriş odağını senkronize etmekten sorumludur. Giriş odağını erişilebilirlik odağı riskiyle senkronize etmeyen hizmetler, belirli işlemler yapıldığında giriş odağının belirli bir konumda olmasını bekleyen uygulamalarda sorunlara neden olur.

Bir erişilebilirlik hizmeti, AccessibilityNodeInfo.findFocus() yöntemini kullanarak hangi kullanıcı arayüzü öğesinin giriş veya erişilebilirlik odağına sahip olduğunu belirleyebilir. Ayrıca, focusSearch() yöntemini kullanarak giriş odağıyla seçilebilen öğeleri arayabilirsiniz. Son olarak, erişilebilirlik hizmetiniz performAction(AccessibilityNodeInfo.ACTION_SET_ACCESSIBILITY_FOCUS) yöntemini kullanarak erişilebilirlik odağını ayarlayabilir.

Bilgi toplama

Erişilebilirlik hizmetleri; etkinlik ayrıntıları, metin ve sayılar gibi kullanıcı tarafından sağlanan bilgilerin temel birimlerini toplayıp temsil etmek için standart yöntemlere sahiptir.

Aralık değişikliği ayrıntılarını alma

Android 9 (API düzeyi 28) ve sonraki sürümler, bir uygulama aynı anda birden fazla pencereyi yeniden çizdiğinde uygulamaların pencere güncellemelerini takip etmesini sağlar. Bir TYPE_WINDOWS_CHANGED etkinliği gerçekleştiğinde pencerelerin nasıl değişeceğini belirlemek için getWindowChanges() API'yi kullanın. Çok pencereli güncelleme sırasında her pencere kendi etkinlik grubunu üretir. getSource() yöntemi, her bir etkinlikle ilişkilendirilen pencerenin kök görünümünü döndürür.

Bir uygulama, View nesneleri için erişilebilirlik bölmesi başlıklarını tanımlıyorsa hizmetiniz, uygulamanın kullanıcı arayüzünün güncellendiğinden emin olabilir. Bir TYPE_WINDOW_STATE_CHANGED etkinliği gerçekleştiğinde, pencerenin nasıl değişeceğini belirlemek için getContentChangeTypes() tarafından döndürülen türleri kullanın. Örneğin, çerçeve bir bölmenin yeni bir başlığı olduğunda bölmenin kaybolduğunu algılayabilir.

Etkinlik ayrıntılarını alma

Android, erişilebilirlik hizmetlerine AccessibilityEvent nesneleri aracılığıyla kullanıcı arayüzü etkileşimi hakkında bilgi sağlar. Önceki Android sürümlerinde, erişilebilirlik etkinliğinde yer alan bilgiler, kullanıcılar tarafından seçilen kullanıcı arayüzü kontrolü hakkında önemli ayrıntılar sağlarken bağlamla ilgili sınırlı bilgi sunuyordu. Çoğu durumda, bu eksik bağlam bilgileri, seçilen kontrolün anlamını anlamak açısından kritik olabilir.

Bağlamın çok önemli olduğu arayüze örnek olarak takvim veya gün planlayıcı verilebilir. Kullanıcı pazartesiden cumaya 16:00'a kadar bir zaman aralığı seçer ve erişilebilirlik hizmeti"16:00" değerini duyurur ancak hafta içi adını, ayın gününü veya ayın adını duyurursa sonuçta elde edilen geri bildirim karışıklığa neden olur. Bu durumda, kullanıcı arayüzü denetiminin bağlamı, toplantı planlamak isteyen kullanıcı için kritik öneme sahiptir.

Android 2011'den beri görünüm hiyerarşisine göre erişilebilirlik etkinlikleri oluşturarak erişilebilirlik hizmetinin kullanıcı arayüzü etkileşimi hakkında elde edebileceği bilgi miktarını önemli ölçüde artırmaktadır. Görünüm hiyerarşisi, bileşeni (üst öğeleri) ve bu bileşenin içerebileceği kullanıcı arayüzü öğelerini (alt öğeleri) içeren kullanıcı arayüzü bileşenleri kümesidir. Bu şekilde Android, erişilebilirlik etkinlikleri hakkında daha zengin ayrıntılar sağlayarak erişilebilirlik hizmetlerinin kullanıcılara daha faydalı geri bildirimler sunmasına olanak tanır.

Erişilebilirlik hizmeti, sistem tarafından hizmetin onAccessibilityEvent() geri çağırma yöntemine geçirilen AccessibilityEvent aracılığıyla kullanıcı arayüzü etkinliği hakkında bilgi alır. Bu nesne, üzerinde işlem yapılan nesnenin türü, açıklayıcı metin ve diğer ayrıntılar dahil olmak üzere etkinlikle ilgili ayrıntıları sağlar.

Önemli: Bir AccessibilityEvent üzerinden görünüm hiyerarşisini inceleme özelliği, gizli kullanıcı bilgilerinin erişilebilirlik hizmetinize sunulmasına yol açabilir. Bu nedenle, hizmetinizin canRetrieveWindowContent özelliğini ekleyip true olarak ayarlayarak erişilebilirlik hizmet yapılandırma XML dosyası üzerinden bu erişim düzeyini istemesi gerekir. Bu ayarı hizmet yapılandırması XML dosyanıza eklemezseniz getSource() çağrıları başarısız olur.

• AccessibilityEvent.getRecordCount() ve getRecord(int): Bu yöntemler, sistem tarafından size iletilen AccessibilityEvent'e katkıda bulunan AccessibilityRecord nesne grubunu almanıza olanak tanır. Bu ayrıntı düzeyi, erişilebilirlik hizmetinizi tetikleyen etkinlikle ilgili daha fazla bağlam sağlar.

• AccessibilityRecord.getSource(): bu yöntem bir AccessibilityNodeInfo nesnesi döndürür. Bu nesne, erişilebilirlik etkinliğini oluşturan bileşenin görünüm düzeni hiyerarşisini (üst öğeler ve alt öğeler) istemenize olanak tanır. Bu özellik, erişilebilirlik hizmetinin bir etkinliğin tam bağlamını (kapsamlı görüntülemelerin veya çocukların görüntülemelerinin içeriği ve durumu da dahil) inceleyebilmesini sağlar.

Not: getSource(), AccessibilityNodeInfo.getChild() ve getParent() yalnızca erişilebilirlik açısından önemli kabul edilen nesneleri (içerik çizen veya kullanıcı işlemlerine yanıt veren görünümler) döndürür. Hizmetiniz tüm görünümleri gerektiriyorsa hizmetin AccessibilityServiceInfo örneğinin flags üyesini FLAG_INCLUDE_NOT_IMPORTANT_VIEWS olarak ayarlayarak bunları isteyebilir.

Android platformu, AccessibilityService için görünüm hiyerarşisini sorgulayabilme özelliği sayesinde etkinlik oluşturan kullanıcı arayüzü bileşeni, bunun üst ve alt öğeleri hakkında bilgi toplar. Bunu yapmak için XML yapılandırmanızda aşağıdaki satırı ayarlayın:

android:canRetrieveWindowContent="true"

İşlem tamamlandığında getSource() kullanarak bir AccessibilityNodeInfo nesnesi alın. Bu çağrı yalnızca etkinliğin kaynağı olan pencere hâlâ etkin pencereyse bir nesne döndürür. Aksi takdirde null değerini döndürür. Bu nedenle, buna göre davranın.

Aşağıdaki örnekte, bir etkinlik alındığında kod aşağıdakileri yapar:

1. Etkinliğin gerçekleştiği görünümün üst öğesini hemen yakalar.
2. Bu görünümde, alt görüntüleme olarak bir etiket ve onay kutusu arar.
3. Bu etiketleri bulursa kullanıcıya raporlamak için, etiketi ve işaretli olup olmadığını belirten bir dize oluşturur.

Görünüm hiyerarşisinden geçerken herhangi bir noktada boş değer döndürülürse yöntem sessizce vazgeçer.

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);
}

Artık eksiksiz ve çalışan bir erişilebilirlik hizmetinize sahipsiniz. Android'in metin okuma motorunu ekleyerek veya dokunsal geribildirim sağlamak için bir Vibrator kullanarak cihazın kullanıcıyla nasıl etkileşimde bulunacağını yapılandırmayı deneyin.

Metni işle

Android 8.0 (API düzeyi 26) ve sonraki sürümleri çalıştıran cihazlar, erişilebilirlik hizmetlerinin ekranda görünen belirli metin birimlerini tanımlayıp bunlar üzerinde çalışmasını kolaylaştıran çeşitli metin işleme özellikleri içerir.

İpuçları

Android 9 (API düzeyi 28), uygulamaların kullanıcı arayüzündeki ipuçlarına erişmenizi sağlayan çeşitli özellikler sunar. İpucu metnini okumak için getTooltipText() simgesini, View örneklerine ipuçlarını gösterme veya gizleme talimatı vermek için ACTION_SHOW_TOOLTIP ve ACTION_HIDE_TOOLTIP tuşlarını kullanın.

İpucu metni

Android, 2017'den itibaren metin tabanlı bir nesnenin ipucu metniyle etkileşimde bulunmak için çeşitli yöntemler içermektedir:

• isShowingHintText() ve setShowingHintText() yöntemleri, sırasıyla düğümün mevcut metin içeriğinin, düğümün ipucu metnini temsil edip etmediğini belirtir ve ayarlar.
• getHintText(), ipucu metninin kendisine erişim sağlar. Bir nesne ipucu metni göstermese bile getHintText() çağrısı başarılı olur.

Ekrandaki metin karakterlerinin konumları

Erişilebilirlik hizmetleri, Android 8.0 (API düzeyi 26) ve sonraki sürümleri çalıştıran cihazlarda TextView widget'ı içindeki her görünür karakterin sınırlayıcı kutusunun ekran koordinatlarını belirleyebilir. Hizmetler, bu koordinatları refreshWithExtraData() çağrısı yaparak, ilk bağımsız değişken olarak EXTRA_DATA_TEXT_CHARACTER_LOCATION_KEY, ikinci bağımsız değişken olarak da Bundle nesnesi iletir. Yöntem yürütüldüğünde sistem, Bundle bağımsız değişkenini Rect nesnelerinden oluşan ayrıştırılabilir bir diziyle doldurur. Her Rect nesnesi, belirli bir karakterin sınırlayıcı kutusunu temsil eder.

Standartlaştırılmış tek taraflı aralık değerleri

Bazı AccessibilityNodeInfo nesneleri, bir kullanıcı arayüzü öğesinin bir değer aralığı alabileceğini belirtmek için AccessibilityNodeInfo.RangeInfo örneğini kullanır. RangeInfo.obtain() kullanarak bir aralık oluştururken veya getMin() ve getMax() kullanarak aralığın uç değerlerini alırken, Android 8.0 (API düzeyi 26) ve sonraki sürümleri çalıştıran cihazların tek taraflı aralıkları standartlaştırılmış bir şekilde temsil ettiğini unutmayın:

• Minimum değeri olmayan aralıklar için Float.NEGATIVE_INFINITY minimum değeri temsil eder.
• Maksimum değeri olmayan aralıklar için Float.POSITIVE_INFINITY maksimum değeri temsil eder.

Erişilebilirlik etkinliklerine yanıt verme

Hizmetiniz artık etkinlikleri çalışacak ve dinleyecek şekilde ayarlandığına göre, bir AccessibilityEvent geldiğinde ne yapacağını bilmesi için kod yazın. İlk olarak onAccessibilityEvent(AccessibilityEvent) yöntemini geçersiz kılın. Bu yöntemde etkinliğin türünü belirlemek için getEventType(), etkinliği tetikleyen görünümle ilişkili tüm etiket metinlerini ayıklamak için getContentDescription() kullanın:

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);
    ...
}

Ek kaynaklar

Daha fazla bilgi edinmek için aşağıdaki kaynaklara göz atın:

Kılavuzlar

• Erişilebilir uygulamalar geliştirme

Codelab'ler

• Android için Erişilebilirlik Hizmeti Geliştirme