Android: How do you check if a particular AccessibilityService is enabled

I’ve written an android app that requires the use of the AccessibilityService.
I know how to check to see if Accessibility is enabled or disabled on the phone, but I cannot work out a way to determine if my app has been specifically enabled within the accessibility menu.

I’m wanting to prompt the user if the AccessibilityService is not running, but can’t find a good way of doing this.
Is there any API methods that I might be missing that would let me know which accessibility services are enabled on the device?

  • Error Message in console on running the app on emulator: WindowSurfaceColorBuffer
  • Android Studio 2.0 No USB devices detected
  • Soft Keyboard Overlapping with EditText Field
  • What is the maximum amount of RAM an app can use?
  • Manually installing an updated APK fails with “signatures do not match the previously installed version”
  • Detect listener on month scrolling in android times square
  • Related posts:

    How to get profile like gender from google signin in Android?
    Android Key Hash
    pdf viewer in phonegap android
    How do I remove the divider from a listview on android?
    Android NDK, two Static Libraries and Linking
    Environment variable in settings.gradle not working with Android Studio
  • How to send a JSON object over Request with Android?
  • ADB not recognising Nexus 4 under Windows 7
  • How to change size of title's text on Action Bar?
  • Recursive entry to executePendingTransactions
  • No such table android_metadata, what's the problem?
  • Howto avoid the “EACCES permission denied” ON SDCARD with KITKAT 4.4.2 Version. New policy from google
  • 7 Solutions collect form web for “Android: How do you check if a particular AccessibilityService is enabled”

    I worked this one out myself in the end:

        public boolean isAccessibilityEnabled(){
        int accessibilityEnabled = 0;
        final String LIGHTFLOW_ACCESSIBILITY_SERVICE = "com.example.test/com.example.text.ccessibilityService";
        boolean accessibilityFound = false;
        try {
            accessibilityEnabled = Settings.Secure.getInt(this.getContentResolver(),android.provider.Settings.Secure.ACCESSIBILITY_ENABLED);
            Log.d(LOGTAG, "ACCESSIBILITY: " + accessibilityEnabled);
        } catch (SettingNotFoundException e) {
            Log.d(LOGTAG, "Error finding setting, default accessibility to not found: " + e.getMessage());
        }
    
        TextUtils.SimpleStringSplitter mStringColonSplitter = new TextUtils.SimpleStringSplitter(':');
    
        if (accessibilityEnabled==1){
            Log.d(LOGTAG, "***ACCESSIBILIY IS ENABLED***: ");
    
    
             String settingValue = Settings.Secure.getString(getContentResolver(), Settings.Secure.ENABLED_ACCESSIBILITY_SERVICES);
             Log.d(LOGTAG, "Setting: " + settingValue);
             if (settingValue != null) {
                 TextUtils.SimpleStringSplitter splitter = mStringColonSplitter;
                 splitter.setString(settingValue);
                 while (splitter.hasNext()) {
                     String accessabilityService = splitter.next();
                     Log.d(LOGTAG, "Setting: " + accessabilityService);
                     if (accessabilityService.equalsIgnoreCase(ACCESSIBILITY_SERVICE_NAME)){
                         Log.d(LOGTAG, "We've found the correct setting - accessibility is switched on!");
                         return true;
                     }
                 }
             }
    
            Log.d(LOGTAG, "***END***");
        }
        else{
            Log.d(LOGTAG, "***ACCESSIBILIY IS DISABLED***");
        }
        return accessibilityFound;
    }
    

    Since API Level 14, it is also possible to obtain the running accessibility services through the AccessibilityManager:

    public static boolean isAccessibilityEnabled(Context context, String id) {
    
        AccessibilityManager am = (AccessibilityManager) context
                .getSystemService(Context.ACCESSIBILITY_SERVICE);
    
        List<AccessibilityServiceInfo> runningServices = am
                .getEnabledAccessibilityServiceList(AccessibilityEvent.TYPES_ALL_MASK);
        for (AccessibilityServiceInfo service : runningServices) {
            if (id.equals(service.getId())) {
                return true;
            }
        }
    
        return false;
    }
    

    To find out the ID of your and all the installed accessibility services, you can run the following code snippet:

    public static void logInstalledAccessiblityServices(Context context) {
    
        AccessibilityManager am = (AccessibilityManager) context
                .getSystemService(Context.ACCESSIBILITY_SERVICE);
    
        List<AccessibilityServiceInfo> runningServices = am
                .getInstalledAccessibilityServiceList();
        for (AccessibilityServiceInfo service : runningServices) {
            Log.i(TAG, service.getId());
        }
    }
    

    In my example, the ID looked like org.your.package/.YourAccessibilityService.

    So far, the method worked reliable.

    Can you just keep track of whether the service is running like this? If the accessibility service is enabled shouldn’t it also be running??

    public class MyAccessibilityService extends AccessibilityService{
    public static boolean isEnabled = false; 
    
     @Override
        public void onServiceConnected() {
          isEnabled = true; 
        }
     @Override 
        public void onDestroy(){ 
          isEnabled = false; 
        }
    

    Checking if the service is enabled

    /**
     * Based on {@link com.android.settingslib.accessibility.AccessibilityUtils#getEnabledServicesFromSettings(Context,int)}
     * @see <a href="https://github.com/android/platform_frameworks_base/blob/d48e0d44f6676de6fd54fd8a017332edd6a9f096/packages/SettingsLib/src/com/android/settingslib/accessibility/AccessibilityUtils.java#L55">AccessibilityUtils</a>
     */
    public static boolean isAccessibilityServiceEnabled(Context context, Class<?> accessibilityService) {
        ComponentName expectedComponentName = new ComponentName(context, accessibilityService);
    
        String enabledServicesSetting = Settings.Secure.getString(context.getContentResolver(),  Settings.Secure.ENABLED_ACCESSIBILITY_SERVICES);
        if (enabledServicesSetting == null)
            return false;
    
        TextUtils.SimpleStringSplitter colonSplitter = new TextUtils.SimpleStringSplitter(':');
        colonSplitter.setString(enabledServicesSetting);
    
        while (colonSplitter.hasNext()) {
            String componentNameString = colonSplitter.next();
            ComponentName enabledService = ComponentName.unflattenFromString(componentNameString);
    
            if (enabledService != null && enabledService.equals(expectedComponentName))
                return true;
        }
    
        return false;
    }
    

    Usage:

    boolean enabled = isAccessibilityServiceEnabled(context, MyAccessibilityService.class);
    

    Detecting when the service is enabled or disabled

    Make a callback:

    ContentObserver observer = new ContentObserver() {
        @Override
        public void onChange(boolean selfChange) {
            super.onChange(selfChange);
            boolean accessibilityServiceEnabled = isAccessibilityServiceEnabled(context, MyAccessibilityService.class);
            //Do something here
        }
    };
    

    Subscribe:

    context.getContentResolver().registerContentObserver(uri, false, observer);
    

    Unsubscribe when you’re done:

    context.getContentResolver().unregisterContentObserver(observer);
    

    Note that this doesn’t work with the getEnabledAccessibilityServiceList() approach since its values were out-of-sync with the Settings.Secure.ENABLED_ACCESSIBILITY_SERVICES values. That’s why I think using Settings.Secure.ENABLED_ACCESSIBILITY_SERVICES is a better one-size-fits-all approach.

    Get the ID when your activity service just started.
    In your Activity service OnSeriviceCeonnected after all the initialize calls. Use this…

    AccessibilityServiceInfo serviceInfo = this.getServiceInfo();
        String accessibilityId = serviceInfo.getId();
    

    Requires Jelly Bean API

    Then you can use Martin’s code (isAccessibilityEnabled) to check running services.

    this need more times

    AccessibilityManager am = (AccessibilityManager) context
            .getSystemService(Context.ACCESSIBILITY_SERVICE);
    
     AccessibilityManager accessibilityManager = (AccessibilityManager)context.getSystemService(Context.ACCESSIBILITY_SERVICE);
            List<AccessibilityServiceInfo> runningservice = accessibilityManager.getEnabledAccessibilityServiceList(AccessibilityServiceInfo.FEEDBACK_ALL_MASK);
    
            accessibilityManager.addAccessibilityStateChangeListener(new AccessibilityManager.AccessibilityStateChangeListener() {
                @Override
                public void onAccessibilityStateChanged(boolean b) {
                    Toast.makeText(MainActivity.this, "permission "+b, Toast.LENGTH_SHORT).show();
                }
            });
    

    Listner will be called whenever state is changed
    you can keep track of the boolean to check the permission
    this is by far the simplest and lightest solution to check permission

    Android Babe is a Google Android Fan, All about Android Phones, Android Wear, Android Dev and Android Games Apps and so on.