इस पेज का अनुवाद Cloud Translation API से किया गया है.

अपनी सुलभता सेवा बनाएं

सुलभता सेवा एक ऐसा ऐप्लिकेशन है जो लोगों की मदद करने के लिए यूज़र इंटरफ़ेस को बेहतर बनाता है दिव्यांग उपयोगकर्ता या कुछ समय के लिए पूरी तरह से इंटरैक्ट न कर पाने वाले उपयोगकर्ता डिवाइस के साथ साइन इन करें. उदाहरण के लिए, ऐसे उपयोगकर्ता जो गाड़ी चला रहे हैं, किसी छोटे बच्चे की देखभाल कर रहे हैं, या बहुत शोर-शराबे वाली पार्टी में शामिल होने के लिए, अतिरिक्त या दूसरे इंटरफ़ेस की ज़रूरत पड़ सकती है सुझाव/राय दें या शिकायत करें.

Android, स्टैंडर्ड सुलभता सेवाएं उपलब्ध कराता है. इनमें ये सेवाएं शामिल हैं TalkBack से जुड़ी है. साथ ही, डेवलपर अपनी खुद की सेवाएं बना सकते हैं और उन्हें लोगों तक पहुंचा सकते हैं. यह दस्तावेज़ सुलभता सेवा बनाने की बुनियादी बातों के बारे में बताती हैं.

किसी सुलभता सेवा को सामान्य ऐप्लिकेशन के साथ बंडल किया जा सकता है या स्टैंडअलोन Android प्रोजेक्ट. सेवा बनाने का तरीका इसमें एक जैसा है दोनों में से कोई भी एक विकल्प चुनें.

सुलभता सेवा बनाएं

अपने प्रोजेक्ट में, ऐसी क्लास बनाएं जो 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() {
    }

...
}

अगर आपने इस Service के लिए कोई नया प्रोजेक्ट बनाया है और आपको कोई ऐप्लिकेशन नहीं चाहिए असोसिएट हो गया है, तो आप स्टार्टर Activity क्लास को स्रोत.

मेनिफ़ेस्ट किए गए एलान और अनुमतियां

सुलभता सेवाएं देने वाले ऐप्लिकेशन को अपने ऐप्लिकेशन मेनिफ़ेस्ट को Android ने सुलभता सेवा माना है सिस्टम. इस सेक्शन में, कन्वर्ज़न ट्रैकिंग के लिए ज़रूरी और वैकल्पिक सेटिंग के बारे में बताया गया है सुलभता सेवाएं.

सुलभता सेवा का एलान

आपके ऐप्लिकेशन को सुलभता सेवा माना जाए, इसके लिए service शामिल करें एलिमेंट—न कि activity एलिमेंट—जो application में मौजूद है एलिमेंट शामिल करें. इसके अलावा, service एलिमेंट में एक शामिल करें सुलभता सेवा इंटेंट फ़िल्टर. मेनिफ़ेस्ट को सेवा की सुरक्षा भी करनी चाहिए इसके लिए, BIND_ACCESSIBILITY_SERVICE अनुमति है, ताकि यह पक्का किया जा सके कि सिर्फ़ सिस्टम उससे जुड़ सकता है. यहां एक उदाहरण दिया गया है:

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

सुलभता सेवा का कॉन्फ़िगरेशन

सुलभता सेवाओं को ऐसा कॉन्फ़िगरेशन देना होगा जो यह बताए कि यह सेवा, सुलभता से जुड़े उन इवेंट को मैनेज करती है जिन्हें यह सेवा मैनेज करती है. साथ ही, इनके बारे में ज़्यादा जानकारी सेवा को फिर से शुरू करने के लिए ज़रूरी है. सुलभता सेवा का कॉन्फ़िगरेशन इसमें शामिल है AccessibilityServiceInfo क्लास. आपकी सेवा, इसके इंस्टेंस का इस्तेमाल करके कॉन्फ़िगरेशन बना सकती है और उसे सेट कर सकती है क्लास और setServiceInfo() इस्तेमाल करते हैं. हालांकि, इसका इस्तेमाल करके कॉन्फ़िगरेशन के सभी विकल्प उपलब्ध नहीं हैं तरीका.

अपने मेनिफ़ेस्ट में <meta-data> एलिमेंट को शामिल करके, कॉन्फ़िगरेशन फ़ाइल है, जिससे आप अपनी साइट के लिए सुलभता सेवा की जानकारी पाएं, जैसा कि नीचे दिए गए उदाहरण में दिखाया गया है:

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

यह <meta-data> एलिमेंट ऐसी एक्सएमएल फ़ाइल के बारे में बताता है जिसे आपने अपने ऐप्लिकेशन की रिसॉर्स डायरेक्ट्री: <project_dir>/res/xml/accessibility_service_config.xml>. यह कोड सर्विस कॉन्फ़िगरेशन फ़ाइल के कॉन्टेंट का एक उदाहरण दिखाता है:

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

उन एक्सएमएल एट्रिब्यूट के बारे में ज़्यादा जानकारी जिनके लिए, सुलभता सेवा की कॉन्फ़िगरेशन फ़ाइल, नीचे दिया गया रेफ़रंस देखें दस्तावेज़:

डाइनैमिक रूप से सेट की जा सकने वाली कॉन्फ़िगरेशन सेटिंग के बारे में ज़्यादा जानने के लिए, रनटाइम पर, AccessibilityServiceInfo देखें.

सुलभता सेवा कॉन्फ़िगर करें

अपने कैंपेन के लिए कॉन्फ़िगरेशन वैरिएबल सेट करते समय इन बातों का ध्यान रखें कैसे और कब चलाना है, यह बताने के लिए सुलभता सेवा:

आपको किस टाइप के इवेंट में जवाब चाहिए?
क्या सेवा को सभी ऐप्लिकेशन के लिए चालू रखना ज़रूरी है या सिर्फ़ खास पैकेज के लिए नाम?
यह किस तरह के सुझाव, शिकायत या राय का इस्तेमाल करता है?

इन वैरिएबल को सेट करने के लिए आपके पास दो विकल्प हैं. पुराने सिस्टम के साथ काम करने की सुविधा वाला विकल्प उन्हें कोड में सेट करना है, तो setServiceInfo(android.accessibilityservice.AccessibilityServiceInfo) ऐसा करने के लिए, onServiceConnected() और वहां अपनी सेवा कॉन्फ़िगर करें, जैसा कि नीचे दिए गए उदाहरण में दिखाया गया है:

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

}

दूसरा विकल्प है, एक्सएमएल फ़ाइल का इस्तेमाल करके सेवा को कॉन्फ़िगर करना. कुछ कॉन्फ़िगरेशन के विकल्प, जैसे canRetrieveWindowContent एक्सएमएल का इस्तेमाल करके सेवा को कॉन्फ़िगर करने पर ही उपलब्ध होती हैं. कॉन्फ़िगरेशन एक्सएमएल का इस्तेमाल करके तय किए जाने पर, पिछले उदाहरण में दिए गए विकल्प ऐसे दिखते हैं:

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

अगर आप एक्सएमएल का इस्तेमाल करते हैं, तो इसे अपनी मेनिफ़ेस्ट फ़ाइल में <meta-data> टैग को एक्सएमएल फ़ाइल की तरफ़ इशारा करने वाला सेवा एलान. अगर एक्सएमएल फ़ाइल को res/xml/serviceconfig.xml, नया टैग ऐसा दिखेगा:

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

सुलभता सेवा के तरीके

किसी सुलभता सेवा को, AccessibilityService क्लास का दायरा बढ़ाना होगा और उस क्लास से इन तरीकों को ओवरराइड करें. ये तरीके यहां बताए गए हैं Android सिस्टम उन्हें कॉल करने का क्रम: सेवा शुरू होने से लेकर (onServiceConnected()), जब तक यह चल रहा है (onAccessibilityEvent(), onInterrupt()), बंद होने के समय तक (onUnbind()).

onServiceConnected(): (ज़रूरी नहीं) सिस्टम इस तरीके को तब कॉल करता है, जब यह आपकी सुलभता सेवा से कनेक्ट करता है. एक बार किया जाने वाला सेटअप करने के लिए, इस तरीके का इस्तेमाल करें आपकी सेवा के चरण, जिनमें उपयोगकर्ता फ़ीडबैक सिस्टम से कनेक्ट करना शामिल है सेवाएं, जैसे कि ऑडियो मैनेजर या डिवाइस वाइब्रेटर. अगर आपको रनटाइम के दौरान आपकी सेवा का कॉन्फ़िगरेशन करना या एक बार में बदलाव करना, setServiceInfo() को कॉल करने के लिए यह एक सुविधाजनक स्थान है.
onAccessibilityEvent(): (ज़रूरी है) सिस्टम इस तरीके को तब वापस कॉल करता है, जब यह पता लगाता है कि AccessibilityEvent जो आपकी सुलभता के ज़रिए तय किए गए इवेंट फ़िल्टर करने के पैरामीटर से मेल खाता है जैसे, जब उपयोगकर्ता किसी बटन पर टैप करता है या यूज़र इंटरफ़ेस पर फ़ोकस करता है कंट्रोल करें, जिसके लिए आपकी सुलभता सेवा सुझाव दे रही है. टास्क कब शुरू होगा सिस्टम इस तरीके को कॉल करता है, तो यह संबंधित AccessibilityEvent को पास करता है, जिसे सेवा उपलब्ध कराती है और उसका इस्तेमाल उपयोगकर्ता. इस तरीके को आपके पूरे लाइफ़साइकल के दौरान कई बार कॉल किया जा सकता है सेवा.
onInterrupt(): (ज़रूरी है) सिस्टम इस तरीके को तब कॉल करता है, जब सिस्टम आपकी सेवा देने वाले फ़ीडबैक को बाधित करना चाहता है, आमतौर पर यह उपयोगकर्ता की कार्रवाई पर प्रतिक्रिया, जैसे कि फ़ोकस को किसी दूसरे कंट्रोल पर ले जाना. यह मेथड को आपकी सेवा की लाइफ़साइकल के दौरान कई बार कॉल किया जा सकता है.
onUnbind(): (ज़रूरी नहीं) सिस्टम इस तरीके को तब कॉल करता है, जब सिस्टम सुलभता सेवा बंद करने वाली है. किसी भी काम को करने के लिए, इस तरीके का इस्तेमाल करें एक बार के लिए बंद करने की प्रक्रियाएं, जिनमें उपयोगकर्ता फ़ीडबैक सिस्टम का बंटवारा करना शामिल है सेवाएं, जैसे कि ऑडियो मैनेजर या डिवाइस वाइब्रेटर.

ये कॉलबैक तरीके आपकी सुलभता के लिए बुनियादी स्ट्रक्चर देते हैं सेवा. आपके पास यह तय करने का विकल्प होता है कि Android सिस्टम से मिले डेटा को कैसे प्रोसेस किया जाए AccessibilityEvent ऑब्जेक्ट का फ़ॉर्म सबमिट कर सकते हैं और उपयोगकर्ता को सुझाव दे सकते हैं. इसके लिए किसी सुलभता इवेंट से जानकारी पाने के बारे में ज़्यादा जानकारी के लिए, इवेंट की जानकारी.

सुलभता इवेंट के लिए रजिस्टर करें

सुलभता सेवा के कॉन्फ़िगरेशन के सबसे अहम कामों में से एक पैरामीटर की मदद से, आपको यह तय करने की सुविधा मिलती है कि आपकी सेवा किस तरह के सुलभता इवेंट संभाल सकता है. इस जानकारी को तय करने से, सुलभता सेवाओं को एक-दूसरे के साथ मिलकर काम करने की सुविधा मिलती है साथ मिलकर काम करते हैं और आपको किसी खास इवेंट को मैनेज करने की सुविधा मिलती है किस तरह के ऐप्लिकेशन हैं. इवेंट फ़िल्टर में ये चीज़ें शामिल हो सकती हैं शर्तें:

पैकेज के नाम: उन ऐप्लिकेशन के पैकेज के नाम बताएं जिनकी सुलभता इवेंट जिन्हें आप अपनी सेवा से करवाना चाहते हैं. अगर यह पैरामीटर शामिल नहीं किया जाता, तो आपके सुलभता सेवा को, सेवा के लिए उपलब्ध माना जाता है किसी भी ऐप्लिकेशन के लिए इवेंट का डेटा शामिल है. इस पैरामीटर को सुलभता सेवा में सेट किया जा सकता है ऐसी कॉन्फ़िगरेशन फ़ाइलें जिनके लिए android:packageNames एट्रिब्यूट का इस्तेमाल किया गया है कॉमा लगाकर अलग की गई सूची या AccessibilityServiceInfo.packageNames सदस्य.
इवेंट के टाइप: सुलभता इवेंट के उन टाइप के बारे में बताएं जो आपको चाहिए मैनेज करने में कुछ समय लग सकता है. इस पैरामीटर को सुलभता सेवा में सेट किया जा सकता है ऐसी कॉन्फ़िगरेशन फ़ाइलें हैं जिनमें android:accessibilityEventTypes एट्रिब्यूट है | वर्ण से अलग की गई सूची—उदाहरण के लिए, accessibilityEventTypes="typeViewClicked|typeViewFocused". या आप सेट कर सकते हैं इसका इस्तेमाल करके AccessibilityServiceInfo.eventTypes सदस्य.

सुलभता सेवा सेट अप करते समय, ध्यान से देखें कि आपके कौनसे इवेंट सेवा उन इवेंट को ही हैंडल और रजिस्टर कर सकती है. चूंकि उपयोगकर्ता सक्रिय कर सकते हैं एक समय में एक से ज़्यादा पहुंच-योग्यता सेवाओं का उपयोग करते हैं, तो आपकी सेवा का उपयोग कुछ इवेंट हटाए जा सकते हैं जिन्हें यह हैंडल नहीं कर सकता. याद रखें कि दूसरी सेवाएं इन कार्रवाइयों को मैनेज कर सकती हैं इवेंट में शामिल किए गए हैं.

सुलभता सुविधाओं के लिए वॉल्यूम

Android 8.0 (एपीआई लेवल 26) और इसके बाद के वर्शन वाले डिवाइसों में, STREAM_ACCESSIBILITY वॉल्यूम कैटगरी की मदद से, सुलभता सुविधाओं के वॉल्यूम को कंट्रोल किया जा सकता है डिवाइस पर मौजूद अन्य आवाज़ों से, अलग से किसी सेवा के ऑडियो आउटपुट का इस्तेमाल करती हो.

सुलभता सेवाएं इस स्ट्रीम टाइप का इस्तेमाल कर सकती हैं. इसके लिए, FLAG_ENABLE_ACCESSIBILITY_VOLUME का विकल्प शामिल है. इसके बाद, कॉल करके डिवाइस की सुलभता सुविधाओं के ऑडियो की आवाज़ कम या ज़्यादा की जा सकती है यह adjustStreamVolume() डिवाइस के इंस्टेंस पर तरीका AudioManager.

नीचे दिया गया कोड स्निपेट से पता चलता है कि कोई सुलभता सेवा, 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);
        }
    }
}

ज़्यादा जानकारी के लिए, Google I/O 2017 का Android की सुलभता सुविधा में नया क्या है सेशन वाला वीडियो देखें. यह वीडियो यहां से शुरू हो रहा है: 6:35.

सुलभता ऐप्लिकेशन के लिए शॉर्टकट

Android 8.0 (एपीआई लेवल 26) और उसके बाद के वर्शन वाले डिवाइसों पर, उपयोगकर्ता यह सुविधा चालू कर सकते हैं किसी भी स्क्रीन से अपनी पसंदीदा सुलभता सेवा बंद करने के लिए, आवाज़ वाले दोनों बटन को एक साथ दबाकर रखें. हालांकि यह शॉर्टकट सक्षम करता है और इससे TalkBack डिफ़ॉल्ट रूप से बंद हो जाता है. उपयोगकर्ता, इसे चालू करने के लिए बटन को कॉन्फ़िगर कर सकते हैं और उनके डिवाइस पर इंस्टॉल की गई किसी भी सेवा को बंद कर देती है.

इस विकल्प की मदद से, उपयोगकर्ता सुलभता से किसी खास सुलभता सेवा को ऐक्सेस कर सकते हैं शॉर्टकट का इस्तेमाल करने के लिए, सेवा को रनटाइम के दौरान सुविधा का अनुरोध करना होगा.

ज़्यादा जानकारी के लिए, Google I/O 2017 का Android की सुलभता सुविधा में नया क्या है सेशन वाला वीडियो देखें. यह वीडियो यहां से शुरू हो रहा है: 13:25.

सुलभता बटन

सॉफ़्टवेयर के रेंडर किए गए नेविगेशन एरिया का इस्तेमाल करने वाले और Android 8.0 पर चलने वाले डिवाइसों पर (एपीआई लेवल 26) या उसके बाद के वर्शन में, नेविगेशन बार की दाईं ओर सुलभता बटन. जब उपयोगकर्ता यह बटन दबाते हैं, तो वे इनमें से किसी एक को शुरू कर सकते हैं कॉन्टेंट के हिसाब से, कई सुलभता सुविधाएं और सेवाएं चालू होती हैं जो अभी स्क्रीन पर दिख रहा है.

उपयोगकर्ताओं को सुलभता का इस्तेमाल करके किसी खास सुलभता सेवा को शुरू करने की सुविधा देने के लिए बटन दिखाई दे, तो सेवा को FLAG_REQUEST_ACCESSIBILITY_BUTTON किसी AccessibilityServiceInfo ऑब्जेक्ट के android:accessibilityFlags में फ़्लैग करें एट्रिब्यूट की वैल्यू सबमिट करें. इसके बाद, सेवा इसका इस्तेमाल करके कॉलबैक रजिस्टर कर सकती है registerAccessibilityButtonCallback().

ध्यान दें: यह सुविधा सिर्फ़ उन डिवाइसों पर उपलब्ध है जिनमें मौजूद सॉफ़्टवेयर को रेंडर किया गया हो नेविगेशन क्षेत्र. सेवाओं को हमेशा isAccessibilityButtonAvailable() साथ ही, सुलभता बटन की उपलब्धता के आधार पर, लागू करना onAvailabilityChanged(). इस तरह से, उपयोगकर्ता हमेशा सेवा के फ़ंक्शन को ऐक्सेस कर सकते हैं, भले ही सुलभता बटन काम नहीं करता है या उपलब्ध नहीं है.

नीचे दिए गए कोड स्निपेट में, सुलभता को कॉन्फ़िगर करने का तरीका बताया गया है इस सेवा के लिए, सुलभता बटन दबाएं:

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

ज़्यादा जानकारी के लिए, Google I/O 2017 का Android की सुलभता सुविधा में नया क्या है सेशन वाला वीडियो देखें. यह वीडियो यहां से शुरू हो रहा है: 16:28.

फ़िंगरप्रिंट जेस्चर

Android 8.0 (एपीआई लेवल 26) या इसके बाद के वर्शन वाले डिवाइसों पर सुलभता सेवाएं डिवाइस के दिशा-निर्देश (ऊपर, नीचे, बाएं और दाएं) की ओर स्वाइप करने पर फ़िंगरप्रिंट सेंसर. इनके बारे में कॉलबैक पाने के लिए, किसी सेवा को कॉन्फ़िगर करने के लिए इंटरैक्शन के बाद, नीचे दिए गए क्रम को पूरा करें:

USE_BIOMETRIC का एलान करें अनुमति और CAPABILITY_CAN_REQUEST_FINGERPRINT_GESTURES क्षमता.
FLAG_REQUEST_FINGERPRINT_GESTURES सेट करें फ़्लैग को android:accessibilityFlags एट्रिब्यूट में फ़्लैग करें.
registerFingerprintGestureCallback() का इस्तेमाल करके, कॉलबैक के लिए रजिस्टर करें.

ध्यान रखें कि सभी डिवाइसों में फ़िंगरप्रिंट सेंसर नहीं होते हैं. पहचान करने के लिए कि सेंसर की सुविधा किसी डिवाइस में काम करती है या नहीं, तो isHardwareDetected() तरीका. फ़िंगरप्रिंट सेंसर वाले डिवाइस पर भी, आपको यह सेवा नहीं दी जा सकती पुष्टि करने के लिए सेंसर का इस्तेमाल करें. यह पता लगाने के लिए कि ऐसा कब हो रहा है सेंसर उपलब्ध है, तो isGestureDetectionAvailable() तरीका है और onGestureDetectionAvailabilityChanged() कॉलबैक.

नीचे दिया गया कोड स्निपेट, इन कामों के लिए फ़िंगरप्रिंट जेस्चर का इस्तेमाल करने का उदाहरण दिखाता है वर्चुअल गेम बोर्ड पर जाएं:

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

ज़्यादा जानकारी के लिए, Google I/O 2017 का Android की सुलभता सुविधा में नया क्या है सेशन वाला वीडियो देखें. यह वीडियो यहां से शुरू हो रहा है: 9:03.

लिखाई को बोली में बदलने के लिए, एक से ज़्यादा भाषाओं में

Android की लिखाई को बोली में बदलने की सुविधा (टीटीएस) सेवा, Android 8.0 (एपीआई लेवल 26) से शुरू की गई है के एक ब्लॉक में एकाधिक भाषाओं में वाक्यांशों को पहचान और बोल सकते हैं टेक्स्ट. सुलभता सुविधाओं में अपने-आप भाषा बदलने की सुविधा को चालू करने के लिए सेवा, सभी स्ट्रिंग को LocaleSpan ऑब्जेक्ट, जैसा कि दिखाया गया है कोड स्निपेट में:

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

ज़्यादा जानकारी के लिए, Google I/O 2017 का Android की सुलभता सुविधा में नया क्या है सेशन वाला वीडियो देखें. यह वीडियो यहां से शुरू हो रहा है: 10:59.

उपयोगकर्ताओं की ओर से कार्रवाई करें

साल 2011 से, सुलभता सेवाएं उपयोगकर्ताओं की ओर से काम कर सकती हैं. इनमें ये शामिल हैं इनपुट फ़ोकस को बदलकर और यूज़र इंटरफ़ेस एलिमेंट को (चालू करना) चुना जा सकता है. तय सीमा में साल 2012 में, स्क्रोलिंग सूचियों और इंटरैक्शन को शामिल करने के लिए, कार्रवाइयों की रेंज बढ़ाई गई डालें. सुलभता सेवाएं वैश्विक कार्रवाइयां भी कर सकती हैं, जैसे होम स्क्रीन पर जाकर, वापस जाएँ बटन दबाएँ, और नोटिफ़िकेशन स्क्रीन और हाल ही के ऐप्लिकेशन की सूची. साल 2012 से, Android में सुलभता फ़ोकस, जिसकी मदद से दिखने वाली सभी चीज़ों को सुलभता सेवा.

इन सुविधाओं की मदद से, सुलभता सेवाओं के डेवलपर नेविगेशन मोड, जैसे कि जेस्चर नेविगेशन और दिव्यांग उपयोगकर्ता Android पर चलने वाले डिवाइसों को बेहतर तरीके से कंट्रोल कर पाते हैं.

हाथ के जेस्चर (हाव-भाव) को सुनें

सुलभता सेवाएं, हाथ के खास जेस्चर को सुन सकती हैं और उनके आधार पर कार्रवाई कर सकती हैं पर ऐक्सेस किया जा सकता है. इस सुविधा का इस्तेमाल करने के लिए, सुलभता सेवा से जुड़ा आपका अनुरोध सबमिट करना ज़रूरी है छूकर, उससे जुड़ी जानकारी सुनने की सुविधा चालू हो गई हो. आपकी सेवा, इसका अनुरोध कर सकती है को सेट करके सक्रिय करने की प्रक्रिया flags सदस्य के लिए सेवा के AccessibilityServiceInfo इंस्टेंस का FLAG_REQUEST_TOUCH_EXPLORATION_MODE, जैसा कि नीचे दिए गए उदाहरण में दिखाया गया है.

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

आपकी सेवा के ज़रिए, छूकर, उससे जुड़ी जानकारी सुनने की सुविधा को चालू करने का अनुरोध किए जाने के बाद, उपयोगकर्ता को अगर यह सुविधा पहले से चालू नहीं है, तो इसे चालू किया जाएगा. यह सुविधा कब सक्रिय है, तो आपकी सेवा को इसके द्वारा पहुंच-योग्यता जेस्चर की सूचना प्राप्त होती है आपकी सेवा का onGesture() कॉलबैक का तरीका इस्तेमाल करता है और उपयोगकर्ता की ओर से कार्रवाई करके जवाब दे सकता है.

हाथ के जेस्चर (हाव-भाव)

Android 8.0 (एपीआई लेवल 26) पर चलने वाले डिवाइस पर, हाथ के लगातार चलने वाले जेस्चर काम करते हैं या प्रोग्रैम्ड तरीके से बेचे जाने वाले हाथ के जेस्चर (हाव-भाव) में, एक से ज़्यादा जेस्चर होते हैं Path ऑब्जेक्ट.

स्ट्रोक का क्रम तय करते समय, यह बताया जा सकता है कि वे आखिरी आर्ग्युमेंट willContinue का इस्तेमाल करके एक जैसा प्रोग्रामैटिक जेस्चर किया जा सकता है GestureDescription.StrokeDescription कंस्ट्रक्टर, जैसा कि नीचे दिए गए कोड स्निपेट में दिखाया गया है:

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

ज़्यादा जानकारी के लिए, Google I/O 2017 का Android की सुलभता सुविधा में नया क्या है सेशन वाला वीडियो देखें. यह वीडियो यहां से शुरू हो रहा है: 15:47.

सुलभता से जुड़ी कार्रवाइयों का इस्तेमाल करें

सुलभता सेवाएं, उपयोगकर्ताओं की ओर से काम कर सकती हैं, ताकि उनके साथ आसानी से बातचीत की जा सके बेहतर तरीके से काम कर सकते हैं. सुलभता सेवाओं की क्षमता परफ़ॉर्म करने से जुड़ी कार्रवाइयों को 2011 में जोड़ा गया था और साल 2012 में इसका दायरा काफ़ी बढ़ गया.

उपयोगकर्ताओं की ओर से कार्रवाई करने के लिए, आपकी सुलभता सेवा को रजिस्टर करना ज़रूरी है ऐप्लिकेशन से इवेंट पाने और कॉन्टेंट देखने की अनुमति मांगने के लिए android:canRetrieveWindowContent को true पर सेट करके ऐप्लिकेशन सेवा कॉन्फ़िगरेशन फ़ाइल. जब आपके डिवाइस को इवेंट मिलते हैं सेवा नहीं है, तो यह AccessibilityNodeInfo इसका उपयोग करके इवेंट से ऑब्जेक्ट getSource(). AccessibilityNodeInfo ऑब्जेक्ट की मदद से, आपकी सेवा व्यू को एक्सप्लोर कर सकती है क्रम के हिसाब से तय होता है कि क्या कार्रवाई करनी है और फिर 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();
    }
    ...
}

performAction() तरीका, आपकी सेवा को है. अगर आपकी सेवा को वैश्विक कार्रवाई करने की ज़रूरत है, जैसे होम स्क्रीन पर जाकर, 'वापस जाएँ' बटन पर टैप करें या या हाल ही के ऐप्लिकेशन सूची दिखाई देती है, तो performGlobalAction() तरीका.

फ़ोकस टाइप इस्तेमाल करें

साल 2012 में, Android ने यूज़र इंटरफ़ेस पर फ़ोकस करने के लिए, सुलभता फ़ोकस नाम का एक नया टूल लॉन्च किया. सुलभता सेवाएं इस फ़ोकस का इस्तेमाल, दिखने वाले किसी भी यूज़र इंटरफ़ेस को चुनने के लिए कर सकती हैं और उस पर कार्रवाई करें. यह फ़ोकस टाइप, इनपुट फ़ोकस से अलग है. यह तय करता है कि किसी उपयोगकर्ता के इनपुट मिलने पर, ऑन-स्क्रीन यूज़र इंटरफ़ेस एलिमेंट को कौनसा इनपुट मिलेगा वर्णों को टाइप करता है, कीबोर्ड पर Enter दबाता है या स्क्रीन के बीच वाले हिस्से को पुश करता है डी-पैड का बटन.

यूज़र इंटरफ़ेस में किसी एक एलिमेंट के लिए, इनपुट फ़ोकस बनाए रखना मुमकिन है दूसरे एलिमेंट में सुलभता का फ़ोकस है. सुलभता पर फ़ोकस का मकसद यह है के साथ इंटरैक्ट करने के तरीके के साथ सुलभता सेवाएं उपलब्ध कराने के लिए एलिमेंट स्क्रीन पर मौजूद है. भले ही, एलिमेंट से इनपुट फ़ोकस किया जा सकता हो या नहीं में मदद की है. यह पक्का करने के लिए कि आपकी सुलभता सेवा काम करे के साथ सही ढंग से इनपुट एलिमेंट का इस्तेमाल किया जाता है, तो किसी ऐप्लिकेशन की जांच करने के लिए दिशा-निर्देशों का पालन करें आपकी सेवा की जांच करने के लिए की सुलभता सुविधा किसी सामान्य ऐप्लिकेशन का इस्तेमाल करते समय.

ध्यान दें: सुलभता सेवाओं पर फ़ोकस करने वाली सुलभता सेवाएं इन चीज़ों के लिए ज़िम्मेदार हैं जब कोई एलिमेंट इस तरह का फ़ोकस कर सकता है, तो इनपुट फ़ोकस को सिंक करना. ऐसी सेवाएं जो सुलभता फ़ोकस के जोखिम के साथ इनपुट फ़ोकस को सिंक नहीं करती हैं जिसकी वजह से उन ऐप्लिकेशन में समस्याएं आ रही हैं जो इनपुट फ़ोकस के किसी खास हिस्से में होने की उम्मीद करते हैं जगह की जानकारी.

सुलभता सेवा यह तय कर सकती है कि कौनसा यूज़र इंटरफ़ेस एलिमेंट इनपुट दिया गया है फ़ोकस या सुलभता पर फ़ोकस करने के लिए, AccessibilityNodeInfo.findFocus() तरीका. इनपुट फ़ोकस की मदद से चुने जा सकने वाले एलिमेंट भी खोजे जा सकते हैं इसका इस्तेमाल करके focusSearch() तरीका. आख़िर में, सुलभता सेवा, सुलभता सुविधाओं पर फ़ोकस करने के लिए, यह performAction(AccessibilityNodeInfo.ACTION_SET_ACCESSIBILITY_FOCUS) तरीका.

जानकारी इकट्ठा करना

सुलभता सेवाओं में, ज़रूरी जानकारी इकट्ठा करने और उसे दिखाने के स्टैंडर्ड तरीके होते हैं उपयोगकर्ता से मिली जानकारी की यूनिट, जैसे कि इवेंट की जानकारी, टेक्स्ट, और नंबर.

विंडो परिवर्तन विवरण पाएं

Android 9 (एपीआई लेवल 28) और उसके बाद के वर्शन की मदद से, ऐप्लिकेशन विंडो अपडेट को ट्रैक कर सकते हैं कोई ऐप्लिकेशन एक साथ कई विंडो को फिर से ड्रॉ करता है. जब TYPE_WINDOWS_CHANGED घटना होती है, तो इसका उपयोग करें getWindowChanges() एपीआई की मदद से तय करें कि विंडो कैसे बदलती हैं. मल्टी-विंडो (एक से ज़्यादा विंडो में) अपडेट के दौरान, हर एक विंडो, इवेंट का अपना सेट बनाती है. getSource() तरीका, रूट दिखाता है विंडो के किसी खास व्यू को दिखाता है.

अगर कोई ऐप्लिकेशन सुलभता पैनल को परिभाषित करता है टाइटल View ऑब्जेक्ट हैं. आपकी सेवा यह पता लगा सकती है कि कब ऐप्लिकेशन का यूज़र इंटरफ़ेस (यूआई) अपडेट किया जाता है. जब TYPE_WINDOW_STATE_CHANGED इवेंट होता है, तो इसके ज़रिए लौटाए गए टाइप का इस्तेमाल करें getContentChangeTypes() ताकि यह तय किया जा सके कि विंडो कैसे बदलती है. उदाहरण के लिए, फ़्रेमवर्क यह पता लगा सकता है कि जब किसी पैनल का टाइटल नया हो या किसी पैनल के गायब हो जाने पर ऐसा हो.

इवेंट की जानकारी पाना

Android, यूज़र इंटरफ़ेस के बारे में सुलभता सेवाओं को जानकारी देता है AccessibilityEvent ऑब्जेक्ट के ज़रिए इंटरैक्शन. Android के पिछले वर्शन में, किसी सुलभता इवेंट में उपलब्ध जानकारी का इस्तेमाल करते हुए, उपयोगकर्ताओं के चुने गए यूज़र इंटरफ़ेस कंट्रोल के बारे में जानकारी, सीमित ऑफ़र की गई काम की जानकारी. कई मामलों में, संदर्भ की यह जानकारी चुने गए कंट्रोल का मतलब समझने के लिए बहुत ज़रूरी है.

ऐसे इंटरफ़ेस का उदाहरण जहां कॉन्टेक्स्ट अहम है, वह कैलेंडर या दिन हो प्लानर. अगर उपयोगकर्ता सोमवार से शुक्रवार की सूची के लिए, शाम 4 बजे का टाइम स्लॉट चुनता है और सुलभता सेवा "शाम 4 बजे" की सूचना देती है, लेकिन हफ़्ते के कामकाजी दिनों के बारे में नहीं बताती नाम, महीने के दिन या महीने का नाम दोनों है, तो नतीजा यह होगा: उलझन पैदा करने वाला होता है. इस मामले में, यूज़र इंटरफ़ेस कंट्रोल का संदर्भ जो कोई उपयोगकर्ता मीटिंग शेड्यूल करना चाहता है.

साल 2011 से, Android अब तक सुलभता सेवा, उपयोगकर्ता को किसी यूज़र इंटरफ़ेस इंटरैक्शन के बारे में जानकारी दे सकती है. सुलभता इवेंट सेट अप करते हैं. व्यू हैरारकी, दो अलग-अलग तरीकों से यूज़र इंटरफ़ेस के कॉम्पोनेंट, जिनमें कॉम्पोनेंट (इसके पैरंट) और उपयोगकर्ता शामिल होते हैं इंटरफ़ेस एलिमेंट का इस्तेमाल करता है. तय सीमा में इस तरह Android सुलभता इवेंट के बारे में ज़्यादा जानकारी उपलब्ध करा सकता है, सुलभता सेवाओं से लोगों को ज़्यादा काम के सुझाव या राय मिलती हैं.

कोई सुलभता सेवा, यूज़र इंटरफ़ेस इवेंट के बारे में जानकारी इसके ज़रिए हासिल करती है इस सेवा को सिस्टम से पास किया गया एक AccessibilityEvent onAccessibilityEvent() कॉलबैक का तरीका. यह ऑब्जेक्ट इवेंट, जिसमें उस ऑब्जेक्ट का टाइप जिस पर कार्रवाई की जा रही है, उसका ब्यौरा, और अन्य विवरण.

अहम जानकारी: किसी पेज की मदद से, AccessibilityEvent संभावित रूप से आपकी निजी उपयोगकर्ता जानकारी दिखाता है सुलभता सेवा. इस वजह से, आपकी सेवा को इस लेवल का अनुरोध करना होगा सुलभता सेवा कॉन्फ़िगरेशन एक्सएमएल के ज़रिए ऐक्सेस करना फ़ाइल में canRetrieveWindowContent एट्रिब्यूट शामिल करें और true. अगर इस सेटिंग को अपने सेवा कॉन्फ़िगरेशन एक्सएमएल में शामिल नहीं किया जाता है, तो तो getSource() को कॉल नहीं किया जा सकता.

AccessibilityEvent.getRecordCount() और getRecord(int): इन तरीकों से आपको डाइग्नोस्टिक टूल के ज़रिए AccessibilityRecord वे ऑब्जेक्ट जो AccessibilityEvent में योगदान करते हैं, जिसे सिस्टम. इस तरह के ब्यौरे से, उस इवेंट के बारे में ज़्यादा जानकारी मिलती है जो ट्रिगर करती है.
AccessibilityRecord.getSource(): यह तरीका AccessibilityNodeInfo ऑब्जेक्ट दिखाता है. यह ऑब्जेक्ट आपको उस कॉम्पोनेंट के व्यू लेआउट हैरारकी (माता-पिता और चाइल्ड) का अनुरोध करें जो सुलभता इवेंट शुरू करता है. इस सुविधा की मदद से, किसी इवेंट के पूरे संदर्भ की जांच करती है. इसमें कॉन्टेंट और पास वाले व्यू या चाइल्ड व्यू की स्थिति.

ध्यान दें: getSource(), AccessibilityNodeInfo.getChild(), और getParent() सिर्फ़ वे व्यू ऑब्जेक्ट दिखाएं जो इनके लिए ज़रूरी हैं सुलभता—ऐसे व्यू जो कॉन्टेंट की ओर आकर्षित होते हैं या उपयोगकर्ता की कार्रवाइयों पर प्रतिक्रिया देते हैं. अगर आपके सेवा को सभी दृश्यों की आवश्यकता है, तो यह इसके flags सदस्य को सेट करके उनका अनुरोध कर सकती है: सेवा का AccessibilityServiceInfo इंस्टेंस FLAG_INCLUDE_NOT_IMPORTANT_VIEWS.

Android प्लैटफ़ॉर्म, AccessibilityService से क्वेरी करने की सुविधा देता है व्यू हैरारकी, यानी कि जनरेट किए गए यूज़र इंटरफ़ेस (यूआई) कॉम्पोनेंट के बारे में जानकारी इकट्ठा करना और साथ ही उसके अभिभावक और बच्चे भी. ऐसा करने के लिए, नीचे दी गई लाइन सेट करें अपने एक्सएमएल कॉन्फ़िगरेशन में:

android:canRetrieveWindowContent="true"

यह करने के बाद, getSource() का इस्तेमाल करके AccessibilityNodeInfo ऑब्जेक्ट पाएं. यह कॉल सिर्फ़ तब ऑब्जेक्ट दिखाता है, जब इवेंट शुरू होने वाली विंडो वह अब भी ऐक्टिव विंडो है. अगर ऐसा नहीं है, तो यह शून्य दिखाता है. इसलिए, इसे सही तरीके से इस्तेमाल करें.

यहां दिए गए उदाहरण में, कोई इवेंट मिलने पर कोड ये काम करता है:

उस व्यू के पैरंट को तुरंत हासिल कर लेता है जहां से इवेंट शुरू होता है.
उस व्यू में, चाइल्ड व्यू के तौर पर लेबल और चेकबॉक्स ढूंढें.
अगर उसे ये सुझाव मिलते हैं, तो वह उपयोगकर्ता को रिपोर्ट करने के लिए एक स्ट्रिंग बनाता है. इससे यह पता चलता है कि लेबल किया गया है और क्या उसे चेक किया गया है.

अगर व्यू हैरारकी (व्यू और व्यू ग्रुप के लेआउट का क्रम) को देखते हुए किसी भी पॉइंट पर शून्य वैल्यू दिखती है, यह तरीका धीरे-धीरे बंद हो जाता है.

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

अब आपके पास एक पूरी, ठीक तरीके से काम करने वाली सुलभता सेवा है. तरीका कॉन्फ़िगर करके देखें यह Android के लिखाई को बोली में बदलने की सुविधा को जोड़कर उपयोगकर्ता के साथ इंटरैक्ट करता है इंजन हैप्टिक देने के लिए Vibrator का इस्तेमाल करना सुझाव/राय दें या शिकायत करें.

टेक्स्ट प्रोसेस करें

Android 8.0 (एपीआई लेवल 26) और इसके बाद के वर्शन वाले डिवाइसों में कई डिवाइस शामिल हैं टेक्स्ट-प्रोसेसिंग सुविधाएं, जो सुलभता सेवाओं को इन कामों को आसान बनाती हैं स्क्रीन पर दिखने वाले टेक्स्ट की खास यूनिट को पहचान सकता है और उन पर काम कर सकता है.

टूलटिप

Android 9 (एपीआई लेवल 28) में ऐसी कई सुविधाएं हैं जिनसे आपको टूलटिप का इस्तेमाल करें. इस्तेमाल की जाने वाली चीज़ें getTooltipText() टूलटिप का टेक्स्ट पढ़ने के लिए, और ACTION_SHOW_TOOLTIP और ACTION_HIDE_TOOLTIP इससे View के इंस्टेंस को टूलटिप दिखाने या छिपाने का निर्देश मिलता है.

संकेत लेख

साल 2017 से, Android में टेक्स्ट पर आधारित ऑब्जेक्ट का संकेत टेक्स्ट:

कॉन्टेंट बनाने isShowingHintText() और setShowingHintText() तरीकों से यह पता चलता है और सेट किया जाता है कि नोड का मौजूदा टेक्स्ट है या नहीं कॉन्टेंट, नोड के संकेत वाला टेक्स्ट दिखाता है.
getHintText() संकेत टेक्स्ट का ऐक्सेस देता है. भले ही कोई ऑब्जेक्ट दिखाई न दे रहा हो संकेत टेक्स्ट, getHintText() को कॉल किया गया.

स्क्रीन पर दिखने वाले टेक्स्ट के किरदारों की जगह की जानकारी

Android 8.0 (एपीआई लेवल 26) और उसके बाद के वर्शन वाले डिवाइसों पर, सुलभता सेवाएं हर दिखने वाले वर्ण के बाउंडिंग बॉक्स के लिए, स्क्रीन के निर्देशांक पता कर सकता है TextView विजेट में. सेवाएं कॉल करके इन निर्देशांकों को खोजो refreshWithExtraData() पासिंग इन EXTRA_DATA_TEXT_CHARACTER_LOCATION_KEY पहले तर्क और Bundle ऑब्जेक्ट के तौर पर का इस्तेमाल दूसरे आर्ग्युमेंट के तौर पर करें. तरीका लागू होने पर, सिस्टम पार्स किए जा सकने वाले एलिमेंट के साथ Bundle आर्ग्युमेंट Rect ऑब्जेक्ट. हर Rect ऑब्जेक्ट किसी खास वर्ण के बाउंडिंग बॉक्स को दिखाता है.

मानक फ़ॉर्मैट में एक-तरफ़ा रेंज की वैल्यू

कुछ AccessibilityNodeInfo ऑब्जेक्ट, AccessibilityNodeInfo.RangeInfo यह बताने के लिए कि यूज़र इंटरफ़ेस (यूआई) एलिमेंट कई वैल्यू पर ले जा सकता है. किसी विज्ञापन को रेंज का इस्तेमाल कर रही है RangeInfo.obtain() इसका इस्तेमाल करके, रेंज के सबसे एक्सट्रीम वैल्यू फ़ेच किए जा सकते हैं. इसके लिए, getMin() और getMax(), ध्यान रखें कि Android 8.0 (एपीआई लेवल 26) और इसके बाद के वर्शन वाले डिवाइस स्टैंडर्ड तरीके से एक-तरफ़ा रेंज:

कम से कम वैल्यू वाली रेंज के लिए, Float.NEGATIVE_INFINITY सबसे कम वैल्यू दिखाता है.
बिना अधिकतम सीमा वाली रेंज के लिए, Float.POSITIVE_INFINITY सबसे बड़ी वैल्यू दिखाता है.

सुलभता इवेंट का जवाब देना

अब जबकि आपकी सेवा इवेंट चलाने और सुनने के लिए सेट अप हो गई है, तो कोड लिखें को पता है कि AccessibilityEvent के आने पर क्या करना है. ओवरराइड करके शुरू करें onAccessibilityEvent(AccessibilityEvent) तरीका. इस तरीके में, getEventType() इवेंट का टाइप तय करने के लिए और getContentDescription() इवेंट को ट्रिगर करने वाले व्यू से जुड़े लेबल टेक्स्ट को एक्सट्रैक्ट करने के लिए:

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

अन्य संसाधन

ज़्यादा जानकारी के लिए, इन संसाधनों को देखें:

गाइड

सुलभता ऐप्लिकेशन बनाने का तरीका

कोड लैब

Android के लिए सुलभता सेवा डेवलप करना