DISTRHO
/
JUCE
mirror of https://github.com/DISTRHO/JUCE
1
0
Fork 0
Code Releases 1 Activity
The JUCE cross-platform C++ framework, with DISTRHO/KXStudio specific changes
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
13197 Commits
9 Branches
7.0GB
Tree: 61fd8827e1
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '61fd8827e1'
${ noResults }
JUCE/modules/juce_gui_basics/native/accessibility/juce_android_Accessibility.cpp

1036 lines
45KB
Raw Blame History 

  1. /*

  2.   ==============================================================================

  3. 

  4.    This file is part of the JUCE library.

  5.    Copyright (c) 2022 - Raw Material Software Limited

  6. 

  7.    JUCE is an open source library subject to commercial or open-source

  8.    licensing.

  9. 

  10.    By using JUCE, you agree to the terms of both the JUCE 7 End-User License

  11.    Agreement and JUCE Privacy Policy.

  12. 

  13.    End User License Agreement: www.juce.com/juce-7-licence

  14.    Privacy Policy: www.juce.com/juce-privacy-policy

  15. 

  16.    Or: You may also use this code under the terms of the GPL v3 (see

  17.    www.gnu.org/licenses).

  18. 

  19.    JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER

  20.    EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE

  21.    DISCLAIMED.

  22. 

  23.   ==============================================================================

  24. */

  25. 

  26. namespace juce

  27. {

  28. 

  29. #define JUCE_NATIVE_ACCESSIBILITY_INCLUDED 1

  30. 

  31. #define JNI_CLASS_MEMBERS(METHOD, STATICMETHOD, FIELD, STATICFIELD, CALLBACK) \

  32.  METHOD (setSource,                "setSource",                "(Landroid/view/View;I)V") \

  33.  METHOD (addChild,                 "addChild",                 "(Landroid/view/View;I)V") \

  34.  METHOD (setParent,                "setParent",                "(Landroid/view/View;)V") \

  35.  METHOD (setVirtualParent,         "setParent",                "(Landroid/view/View;I)V") \

  36.  METHOD (setBoundsInScreen,        "setBoundsInScreen",        "(Landroid/graphics/Rect;)V") \

  37.  METHOD (setBoundsInParent,        "setBoundsInParent",        "(Landroid/graphics/Rect;)V") \

  38.  METHOD (setPackageName,           "setPackageName",           "(Ljava/lang/CharSequence;)V") \

  39.  METHOD (setClassName,             "setClassName",             "(Ljava/lang/CharSequence;)V") \

  40.  METHOD (setContentDescription,    "setContentDescription",    "(Ljava/lang/CharSequence;)V") \

  41.  METHOD (setCheckable,             "setCheckable",             "(Z)V") \

  42.  METHOD (setChecked,               "setChecked",               "(Z)V") \

  43.  METHOD (setClickable,             "setClickable",             "(Z)V") \

  44.  METHOD (setEnabled,               "setEnabled",               "(Z)V") \

  45.  METHOD (setFocusable,             "setFocusable",             "(Z)V") \

  46.  METHOD (setFocused,               "setFocused",               "(Z)V") \

  47.  METHOD (setPassword,              "setPassword",              "(Z)V") \

  48.  METHOD (setSelected,              "setSelected",              "(Z)V") \

  49.  METHOD (setVisibleToUser,         "setVisibleToUser",         "(Z)V") \

  50.  METHOD (setAccessibilityFocused,  "setAccessibilityFocused",  "(Z)V") \

  51.  METHOD (setText,                  "setText",                  "(Ljava/lang/CharSequence;)V") \

  52.  METHOD (setMovementGranularities, "setMovementGranularities", "(I)V") \

  53.  METHOD (addAction,                "addAction",                "(I)V") \

  54. 

  55.  DECLARE_JNI_CLASS (AndroidAccessibilityNodeInfo, "android/view/accessibility/AccessibilityNodeInfo")

  56. #undef JNI_CLASS_MEMBERS

  57. 

  58. #define JNI_CLASS_MEMBERS(METHOD, STATICMETHOD, FIELD, STATICFIELD, CALLBACK) \

  59.  METHOD (setCollectionInfo, "setCollectionInfo", "(Landroid/view/accessibility/AccessibilityNodeInfo$CollectionInfo;)V") \

  60.  METHOD (setCollectionItemInfo, "setCollectionItemInfo", "(Landroid/view/accessibility/AccessibilityNodeInfo$CollectionItemInfo;)V")

  61. 

  62.  DECLARE_JNI_CLASS (AndroidAccessibilityNodeInfo19, "android/view/accessibility/AccessibilityNodeInfo")

  63. #undef JNI_CLASS_MEMBERS

  64. 

  65. #define JNI_CLASS_MEMBERS(METHOD, STATICMETHOD, FIELD, STATICFIELD, CALLBACK) \

  66.  STATICMETHOD (obtain, "obtain", "(IIZ)Landroid/view/accessibility/AccessibilityNodeInfo$CollectionInfo;")

  67. 

  68.  DECLARE_JNI_CLASS_WITH_MIN_SDK (AndroidAccessibilityNodeInfoCollectionInfo, "android/view/accessibility/AccessibilityNodeInfo$CollectionInfo", 19)

  69. #undef JNI_CLASS_MEMBERS

  70. 

  71. #define JNI_CLASS_MEMBERS(METHOD, STATICMETHOD, FIELD, STATICFIELD, CALLBACK) \

  72.  STATICMETHOD (obtain, "obtain", "(IIIIZ)Landroid/view/accessibility/AccessibilityNodeInfo$CollectionItemInfo;")

  73. 

  74.  DECLARE_JNI_CLASS_WITH_MIN_SDK (AndroidAccessibilityNodeInfoCollectionItemInfo, "android/view/accessibility/AccessibilityNodeInfo$CollectionItemInfo", 19)

  75. #undef JNI_CLASS_MEMBERS

  76. 

  77. #define JNI_CLASS_MEMBERS(METHOD, STATICMETHOD, FIELD, STATICFIELD, CALLBACK) \

  78.  STATICMETHOD (obtain, "obtain", "(I)Landroid/view/accessibility/AccessibilityEvent;") \

  79.  METHOD (setPackageName, "setPackageName", "(Ljava/lang/CharSequence;)V") \

  80.  METHOD (setSource, "setSource","(Landroid/view/View;I)V") \

  81.  METHOD (setAction, "setAction", "(I)V") \

  82.  METHOD (setFromIndex, "setFromIndex", "(I)V") \

  83.  METHOD (setToIndex, "setToIndex", "(I)V") \

  84. 

  85.  DECLARE_JNI_CLASS (AndroidAccessibilityEvent, "android/view/accessibility/AccessibilityEvent")

  86. #undef JNI_CLASS_MEMBERS

  87. 

  88. #define JNI_CLASS_MEMBERS(METHOD, STATICMETHOD, FIELD, STATICFIELD, CALLBACK) \

  89.  METHOD (isEnabled, "isEnabled", "()Z") \

  90. 

  91.  DECLARE_JNI_CLASS (AndroidAccessibilityManager, "android/view/accessibility/AccessibilityManager")

  92. #undef JNI_CLASS_MEMBERS

  93. 

  94. namespace

  95. {

  96.     constexpr int HOST_VIEW_ID = -1;

  97. 

  98.     constexpr int TYPE_VIEW_CLICKED                                = 0x00000001,

  99.                   TYPE_VIEW_SELECTED                               = 0x00000004,

  100.                   TYPE_VIEW_ACCESSIBILITY_FOCUSED                  = 0x00008000,

  101.                   TYPE_VIEW_ACCESSIBILITY_FOCUS_CLEARED            = 0x00010000,

  102.                   TYPE_WINDOW_CONTENT_CHANGED                      = 0x00000800,

  103.                   TYPE_VIEW_TEXT_SELECTION_CHANGED                 = 0x00002000,

  104.                   TYPE_VIEW_TEXT_CHANGED                           = 0x00000010,

  105.                   TYPE_VIEW_TEXT_TRAVERSED_AT_MOVEMENT_GRANULARITY = 0x00020000;

  106. 

  107.     constexpr int CONTENT_CHANGE_TYPE_SUBTREE             = 0x00000001,

  108.                   CONTENT_CHANGE_TYPE_CONTENT_DESCRIPTION = 0x00000004;

  109. 

  110.     constexpr int ACTION_ACCESSIBILITY_FOCUS              = 0x00000040,

  111.                   ACTION_CLEAR_ACCESSIBILITY_FOCUS        = 0x00000080,

  112.                   ACTION_CLEAR_FOCUS                      = 0x00000002,

  113.                   ACTION_CLEAR_SELECTION                  = 0x00000008,

  114.                   ACTION_CLICK                            = 0x00000010,

  115.                   ACTION_COLLAPSE                         = 0x00080000,

  116.                   ACTION_EXPAND                           = 0x00040000,

  117.                   ACTION_FOCUS                            = 0x00000001,

  118.                   ACTION_NEXT_AT_MOVEMENT_GRANULARITY     = 0x00000100,

  119.                   ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY = 0x00000200,

  120.                   ACTION_SCROLL_BACKWARD                  = 0x00002000,

  121.                   ACTION_SCROLL_FORWARD                   = 0x00001000,

  122.                   ACTION_SELECT                           = 0x00000004,

  123.                   ACTION_SET_SELECTION                    = 0x00020000,

  124.                   ACTION_SET_TEXT                         = 0x00200000;

  125. 

  126.     constexpr int MOVEMENT_GRANULARITY_CHARACTER = 0x00000001,

  127.                   MOVEMENT_GRANULARITY_LINE      = 0x00000004,

  128.                   MOVEMENT_GRANULARITY_PAGE      = 0x00000010,

  129.                   MOVEMENT_GRANULARITY_PARAGRAPH = 0x00000008,

  130.                   MOVEMENT_GRANULARITY_WORD      = 0x00000002,

  131.                   ALL_GRANULARITIES = MOVEMENT_GRANULARITY_CHARACTER

  132.                                     | MOVEMENT_GRANULARITY_LINE

  133.                                     | MOVEMENT_GRANULARITY_PAGE

  134.                                     | MOVEMENT_GRANULARITY_PARAGRAPH

  135.                                     | MOVEMENT_GRANULARITY_WORD;

  136. 

  137.     constexpr int ACCESSIBILITY_LIVE_REGION_POLITE = 0x00000001;

  138. }

  139. 

  140. static jmethodID nodeInfoSetEditable                     = nullptr;

  141. static jmethodID nodeInfoSetTextSelection                = nullptr;

  142. static jmethodID nodeInfoSetLiveRegion                   = nullptr;

  143. static jmethodID accessibilityEventSetContentChangeTypes = nullptr;

  144. 

  145. template <typename MemberFn>

  146. static AccessibilityHandler* getEnclosingHandlerWithInterface (AccessibilityHandler* handler, MemberFn fn)

  147. {

  148.     if (handler == nullptr)

  149.         return nullptr;

  150. 

  151.     if ((handler->*fn)() != nullptr)

  152.         return handler;

  153. 

  154.     return getEnclosingHandlerWithInterface (handler->getParent(), fn);

  155. }

  156. 

  157. static void loadSDKDependentMethods()

  158. {

  159.     static bool hasChecked = false;

  160. 

  161.     if (! hasChecked)

  162.     {

  163.         hasChecked = true;

  164. 

  165.         auto* env = getEnv();

  166.         const auto sdkVersion = getAndroidSDKVersion();

  167. 

  168.         if (sdkVersion >= 18)

  169.         {

  170.             nodeInfoSetEditable      = env->GetMethodID (AndroidAccessibilityNodeInfo, "setEditable",      "(Z)V");

  171.             nodeInfoSetTextSelection = env->GetMethodID (AndroidAccessibilityNodeInfo, "setTextSelection", "(II)V");

  172.         }

  173. 

  174.         if (sdkVersion >= 19)

  175.         {

  176.             nodeInfoSetLiveRegion                   = env->GetMethodID (AndroidAccessibilityNodeInfo, "setLiveRegion",         "(I)V");

  177.             accessibilityEventSetContentChangeTypes = env->GetMethodID (AndroidAccessibilityEvent,    "setContentChangeTypes", "(I)V");

  178.         }

  179.     }

  180. }

  181. 

  182. static constexpr auto getClassName (AccessibilityRole role)

  183. {

  184.     switch (role)

  185.     {

  186.         case AccessibilityRole::editableText:  return "android.widget.EditText";

  187.         case AccessibilityRole::toggleButton:  return "android.widget.CheckBox";

  188.         case AccessibilityRole::radioButton:   return "android.widget.RadioButton";

  189.         case AccessibilityRole::image:         return "android.widget.ImageView";

  190.         case AccessibilityRole::popupMenu:     return "android.widget.PopupMenu";

  191.         case AccessibilityRole::comboBox:      return "android.widget.Spinner";

  192.         case AccessibilityRole::tree:          return "android.widget.ExpandableListView";

  193.         case AccessibilityRole::progressBar:   return "android.widget.ProgressBar";

  194. 

  195.         case AccessibilityRole::scrollBar:

  196.         case AccessibilityRole::slider:        return "android.widget.SeekBar";

  197. 

  198.         case AccessibilityRole::hyperlink:

  199.         case AccessibilityRole::button:        return "android.widget.Button";

  200. 

  201.         case AccessibilityRole::label:

  202.         case AccessibilityRole::staticText:    return "android.widget.TextView";

  203. 

  204.         case AccessibilityRole::tooltip:

  205.         case AccessibilityRole::splashScreen:

  206.         case AccessibilityRole::dialogWindow:  return "android.widget.PopupWindow";

  207. 

  208.         // If we don't supply a custom class type, then TalkBack will use the node's CollectionInfo

  209.         // to make a sensible decision about how to describe the container

  210.         case AccessibilityRole::list:

  211.         case AccessibilityRole::table:

  212. 

  213.         case AccessibilityRole::column:

  214.         case AccessibilityRole::row:

  215.         case AccessibilityRole::cell:

  216.         case AccessibilityRole::menuItem:

  217.         case AccessibilityRole::menuBar:

  218.         case AccessibilityRole::listItem:

  219.         case AccessibilityRole::treeItem:

  220.         case AccessibilityRole::window:

  221.         case AccessibilityRole::tableHeader:

  222.         case AccessibilityRole::unspecified:

  223.         case AccessibilityRole::group:

  224.         case AccessibilityRole::ignored:       break;

  225.     }

  226. 

  227.     return "android.view.View";

  228. }

  229. 

  230. static jobject getSourceView (const AccessibilityHandler& handler)

  231. {

  232.     if (auto* peer = handler.getComponent().getPeer())

  233.         return (jobject) peer->getNativeHandle();

  234. 

  235.     return nullptr;

  236. }

  237. 

  238. //==============================================================================

  239. class AccessibilityNativeHandle

  240. {

  241. public:

  242.     static AccessibilityHandler* getAccessibilityHandlerForVirtualViewId (int virtualViewId)

  243.     {

  244.         auto iter = virtualViewIdMap.find (virtualViewId);

  245. 

  246.         if (iter != virtualViewIdMap.end())

  247.             return iter->second;

  248. 

  249.         return nullptr;

  250.     }

  251. 

  252.     explicit AccessibilityNativeHandle (AccessibilityHandler& h)

  253.         : accessibilityHandler (h),

  254.           virtualViewId (getVirtualViewIdForHandler (accessibilityHandler))

  255.     {

  256.         loadSDKDependentMethods();

  257. 

  258.         if (virtualViewId != HOST_VIEW_ID)

  259.             virtualViewIdMap[virtualViewId] = &accessibilityHandler;

  260.     }

  261. 

  262.     ~AccessibilityNativeHandle()

  263.     {

  264.         if (virtualViewId != HOST_VIEW_ID)

  265.             virtualViewIdMap.erase (virtualViewId);

  266.     }

  267. 

  268.     int getVirtualViewId() const noexcept  { return virtualViewId; }

  269. 

  270.     void populateNodeInfo (jobject info)

  271.     {

  272.         const ScopedValueSetter<bool> svs (inPopulateNodeInfo, true);

  273. 

  274.         const auto sourceView = getSourceView (accessibilityHandler);

  275. 

  276.         if (sourceView == nullptr)

  277.             return;

  278. 

  279.         auto* env = getEnv();

  280.         auto appContext = getAppContext();

  281. 

  282.         if (appContext.get() == nullptr)

  283.             return;

  284. 

  285.         {

  286.             for (auto* child : accessibilityHandler.getChildren())

  287.                 env->CallVoidMethod (info, AndroidAccessibilityNodeInfo.addChild,

  288.                                      sourceView, child->getNativeImplementation()->getVirtualViewId());

  289. 

  290.             if (auto* parent = accessibilityHandler.getParent())

  291.                 env->CallVoidMethod (info, AndroidAccessibilityNodeInfo.setVirtualParent,

  292.                                      sourceView, parent->getNativeImplementation()->getVirtualViewId());

  293.             else

  294.                 env->CallVoidMethod (info, AndroidAccessibilityNodeInfo.setParent, sourceView);

  295.         }

  296. 

  297.         {

  298.             const auto scale = Desktop::getInstance().getDisplays().getPrimaryDisplay()->scale;

  299. 

  300.             const auto screenBounds = accessibilityHandler.getComponent().getScreenBounds() * scale;

  301. 

  302.             LocalRef<jobject> rect (env->NewObject (AndroidRect, AndroidRect.constructor,

  303.                                                     screenBounds.getX(),     screenBounds.getY(),

  304.                                                     screenBounds.getRight(), screenBounds.getBottom()));

  305. 

  306.             env->CallVoidMethod (info, AndroidAccessibilityNodeInfo.setBoundsInScreen, rect.get());

  307. 

  308.             const auto boundsInParent = accessibilityHandler.getComponent().getBoundsInParent() * scale;

  309. 

  310.             rect = LocalRef<jobject> (env->NewObject (AndroidRect, AndroidRect.constructor,

  311.                                                       boundsInParent.getX(),     boundsInParent.getY(),

  312.                                                       boundsInParent.getRight(), boundsInParent.getBottom()));

  313. 

  314.             env->CallVoidMethod (info, AndroidAccessibilityNodeInfo.setBoundsInParent, rect.get());

  315.         }

  316. 

  317.         const auto state = accessibilityHandler.getCurrentState();

  318. 

  319.         env->CallVoidMethod (info,

  320.                              AndroidAccessibilityNodeInfo.setEnabled,

  321.                              ! state.isIgnored());

  322.         env->CallVoidMethod (info,

  323.                              AndroidAccessibilityNodeInfo.setVisibleToUser,

  324.                              true);

  325.         env->CallVoidMethod (info,

  326.                              AndroidAccessibilityNodeInfo.setPackageName,

  327.                              env->CallObjectMethod (appContext.get(),

  328.                                                     AndroidContext.getPackageName));

  329.         env->CallVoidMethod (info,

  330.                              AndroidAccessibilityNodeInfo.setSource,

  331.                              sourceView,

  332.                              virtualViewId);

  333.         env->CallVoidMethod (info,

  334.                              AndroidAccessibilityNodeInfo.setClassName,

  335.                              javaString (getClassName (accessibilityHandler.getRole())).get());

  336.         env->CallVoidMethod (info,

  337.                              AndroidAccessibilityNodeInfo.setContentDescription,

  338.                              getDescriptionString().get());

  339. 

  340.         if (state.isFocusable())

  341.         {

  342.             env->CallVoidMethod (info, AndroidAccessibilityNodeInfo.setFocusable, true);

  343. 

  344.             const auto& component = accessibilityHandler.getComponent();

  345. 

  346.             if (component.getWantsKeyboardFocus())

  347.             {

  348.                 const auto hasKeyboardFocus = component.hasKeyboardFocus (false);

  349. 

  350.                 env->CallVoidMethod (info,

  351.                                      AndroidAccessibilityNodeInfo.setFocused,

  352.                                      hasKeyboardFocus);

  353.                 env->CallVoidMethod (info,

  354.                                      AndroidAccessibilityNodeInfo.addAction,

  355.                                      hasKeyboardFocus ? ACTION_CLEAR_FOCUS : ACTION_FOCUS);

  356.             }

  357. 

  358.             const auto isAccessibleFocused = accessibilityHandler.hasFocus (false);

  359. 

  360.             env->CallVoidMethod (info,

  361.                                  AndroidAccessibilityNodeInfo.setAccessibilityFocused,

  362.                                  isAccessibleFocused);

  363. 

  364.             env->CallVoidMethod (info,

  365.                                  AndroidAccessibilityNodeInfo.addAction,

  366.                                  isAccessibleFocused ? ACTION_CLEAR_ACCESSIBILITY_FOCUS

  367.                                                      : ACTION_ACCESSIBILITY_FOCUS);

  368.         }

  369. 

  370.         if (state.isCheckable())

  371.         {

  372.             env->CallVoidMethod (info,

  373.                                  AndroidAccessibilityNodeInfo.setCheckable,

  374.                                  true);

  375.             env->CallVoidMethod (info,

  376.                                  AndroidAccessibilityNodeInfo.setChecked,

  377.                                  state.isChecked());

  378.         }

  379. 

  380.         if (state.isSelectable() || state.isMultiSelectable())

  381.         {

  382.             const auto isSelected = state.isSelected();

  383. 

  384.             env->CallVoidMethod (info,

  385.                                  AndroidAccessibilityNodeInfo.setSelected,

  386.                                  isSelected);

  387.             env->CallVoidMethod (info,

  388.                                  AndroidAccessibilityNodeInfo.addAction,

  389.                                  isSelected ? ACTION_CLEAR_SELECTION : ACTION_SELECT);

  390.         }

  391. 

  392.         if ((accessibilityHandler.getCurrentState().isCheckable() && accessibilityHandler.getActions().contains (AccessibilityActionType::toggle))

  393.             || accessibilityHandler.getActions().contains (AccessibilityActionType::press))

  394.         {

  395.             env->CallVoidMethod (info,

  396.                                  AndroidAccessibilityNodeInfo.setClickable,

  397.                                  true);

  398.             env->CallVoidMethod (info,

  399.                                  AndroidAccessibilityNodeInfo.addAction,

  400.                                  ACTION_CLICK);

  401.         }

  402. 

  403.         if (accessibilityHandler.getActions().contains (AccessibilityActionType::showMenu)

  404.             && state.isExpandable())

  405.         {

  406.             env->CallVoidMethod (info,

  407.                                  AndroidAccessibilityNodeInfo.addAction,

  408.                                  state.isExpanded() ? ACTION_COLLAPSE : ACTION_EXPAND);

  409.         }

  410. 

  411.         if (auto* textInterface = accessibilityHandler.getTextInterface())

  412.         {

  413.             env->CallVoidMethod (info,

  414.                                  AndroidAccessibilityNodeInfo.setText,

  415.                                  javaString (textInterface->getAllText()).get());

  416. 

  417.             const auto isReadOnly = textInterface->isReadOnly();

  418. 

  419.             env->CallVoidMethod (info,

  420.                                  AndroidAccessibilityNodeInfo.setPassword,

  421.                                  textInterface->isDisplayingProtectedText());

  422. 

  423.             if (nodeInfoSetEditable != nullptr)

  424.                 env->CallVoidMethod (info, nodeInfoSetEditable, ! isReadOnly);

  425. 

  426.             const auto selection = textInterface->getSelection();

  427. 

  428.             if (nodeInfoSetTextSelection != nullptr && ! selection.isEmpty())

  429.                 env->CallVoidMethod (info,

  430.                                      nodeInfoSetTextSelection,

  431.                                      selection.getStart(), selection.getEnd());

  432. 

  433.             if (nodeInfoSetLiveRegion != nullptr && accessibilityHandler.hasFocus (false))

  434.                 env->CallVoidMethod (info,

  435.                                      nodeInfoSetLiveRegion,

  436.                                      ACCESSIBILITY_LIVE_REGION_POLITE);

  437. 

  438.             env->CallVoidMethod (info,

  439.                                  AndroidAccessibilityNodeInfo.setMovementGranularities,

  440.                                  ALL_GRANULARITIES);

  441. 

  442.             env->CallVoidMethod (info,

  443.                                  AndroidAccessibilityNodeInfo.addAction,

  444.                                  ACTION_NEXT_AT_MOVEMENT_GRANULARITY);

  445.             env->CallVoidMethod (info,

  446.                                  AndroidAccessibilityNodeInfo.addAction,

  447.                                  ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY);

  448.             env->CallVoidMethod (info,

  449.                                  AndroidAccessibilityNodeInfo.addAction,

  450.                                  ACTION_SET_SELECTION);

  451. 

  452.             if (! isReadOnly)

  453.                 env->CallVoidMethod (info, AndroidAccessibilityNodeInfo.addAction, ACTION_SET_TEXT);

  454.         }

  455. 

  456.         if (auto* valueInterface = accessibilityHandler.getValueInterface())

  457.         {

  458.             if (! valueInterface->isReadOnly())

  459.             {

  460.                 const auto range = valueInterface->getRange();

  461. 

  462.                 if (range.isValid())

  463.                 {

  464.                     env->CallVoidMethod (info,

  465.                                          AndroidAccessibilityNodeInfo.addAction,

  466.                                          ACTION_SCROLL_FORWARD);

  467.                     env->CallVoidMethod (info,

  468.                                          AndroidAccessibilityNodeInfo.addAction,

  469.                                          ACTION_SCROLL_BACKWARD);

  470.                 }

  471.             }

  472.         }

  473. 

  474.         if (getAndroidSDKVersion() >= 19)

  475.         {

  476.             if (auto* tableInterface = accessibilityHandler.getTableInterface())

  477.             {

  478.                 const auto rows    = tableInterface->getNumRows();

  479.                 const auto columns = tableInterface->getNumColumns();

  480.                 const LocalRef<jobject> collectionInfo { env->CallStaticObjectMethod (AndroidAccessibilityNodeInfoCollectionInfo,

  481.                                                                                       AndroidAccessibilityNodeInfoCollectionInfo.obtain,

  482.                                                                                       (jint) rows,

  483.                                                                                       (jint) columns,

  484.                                                                                       (jboolean) false) };

  485.                 env->CallVoidMethod (info, AndroidAccessibilityNodeInfo19.setCollectionInfo, collectionInfo.get());

  486.             }

  487. 

  488.             if (auto* enclosingTableHandler = getEnclosingHandlerWithInterface (&accessibilityHandler, &AccessibilityHandler::getTableInterface))

  489.             {

  490.                 auto* interface = enclosingTableHandler->getTableInterface();

  491.                 jassert (interface != nullptr);

  492.                 const auto rowSpan    = interface->getRowSpan    (accessibilityHandler);

  493.                 const auto columnSpan = interface->getColumnSpan (accessibilityHandler);

  494. 

  495.                 enum class IsHeader { no, yes };

  496. 

  497.                 const auto addCellInfo = [env, &info] (AccessibilityTableInterface::Span rows, AccessibilityTableInterface::Span columns, IsHeader header)

  498.                 {

  499.                     const LocalRef<jobject> collectionItemInfo { env->CallStaticObjectMethod (AndroidAccessibilityNodeInfoCollectionItemInfo,

  500.                                                                                               AndroidAccessibilityNodeInfoCollectionItemInfo.obtain,

  501.                                                                                               (jint) rows.begin,

  502.                                                                                               (jint) rows.num,

  503.                                                                                               (jint) columns.begin,

  504.                                                                                               (jint) columns.num,

  505.                                                                                               (jboolean) (header == IsHeader::yes)) };

  506.                     env->CallVoidMethod (info, AndroidAccessibilityNodeInfo19.setCollectionItemInfo, collectionItemInfo.get());

  507.                 };

  508. 

  509.                 if (rowSpan.hasValue() && columnSpan.hasValue())

  510.                 {

  511.                     addCellInfo (*rowSpan, *columnSpan, IsHeader::no);

  512.                 }

  513.                 else

  514.                 {

  515.                     if (auto* tableHeader = interface->getHeaderHandler())

  516.                     {

  517.                         if (accessibilityHandler.getParent() == tableHeader)

  518.                         {

  519.                             const auto children = tableHeader->getChildren();

  520.                             const auto column = std::distance (children.cbegin(), std::find (children.cbegin(), children.cend(), &accessibilityHandler));

  521. 

  522.                             // Talkback will only treat a row as a column header if its row index is zero

  523.                             // https://github.com/google/talkback/blob/acd0bc7631a3dfbcf183789c7557596a45319e1f/utils/src/main/java/CollectionState.java#L853

  524.                             addCellInfo ({ 0, 1 }, { (int) column, 1 }, IsHeader::yes);

  525.                         }

  526.                     }

  527.                 }

  528.             }

  529.         }

  530.     }

  531. 

  532.     bool performAction (int action, jobject arguments)

  533.     {

  534.         switch (action)

  535.         {

  536.             case ACTION_ACCESSIBILITY_FOCUS:

  537.             {

  538.                 const WeakReference<Component> safeComponent (&accessibilityHandler.getComponent());

  539. 

  540.                 accessibilityHandler.getActions().invoke (AccessibilityActionType::focus);

  541. 

  542.                 if (safeComponent != nullptr)

  543.                     accessibilityHandler.grabFocus();

  544. 

  545.                 return true;

  546.             }

  547. 

  548.             case ACTION_CLEAR_ACCESSIBILITY_FOCUS:

  549.             {

  550.                 accessibilityHandler.giveAwayFocus();

  551.                 return true;

  552.             }

  553. 

  554.             case ACTION_FOCUS:

  555.             case ACTION_CLEAR_FOCUS:

  556.             {

  557.                 auto& component = accessibilityHandler.getComponent();

  558. 

  559.                 if (component.getWantsKeyboardFocus())

  560.                 {

  561.                     const auto hasFocus = component.hasKeyboardFocus (false);

  562. 

  563.                     if (hasFocus && action == ACTION_CLEAR_FOCUS)

  564.                         component.giveAwayKeyboardFocus();

  565.                     else if (! hasFocus && action == ACTION_FOCUS)

  566.                         component.grabKeyboardFocus();

  567. 

  568.                     return true;

  569.                 }

  570. 

  571.                 break;

  572.             }

  573. 

  574.             case ACTION_CLICK:

  575.             {

  576.                 // Invoking the action may delete this handler

  577.                 const WeakReference<AccessibilityNativeHandle> savedHandle { this };

  578. 

  579.                 if ((accessibilityHandler.getCurrentState().isCheckable() && accessibilityHandler.getActions().invoke (AccessibilityActionType::toggle))

  580.                     || accessibilityHandler.getActions().invoke (AccessibilityActionType::press))

  581.                 {

  582.                     if (savedHandle != nullptr)

  583.                         sendAccessibilityEventImpl (accessibilityHandler, TYPE_VIEW_CLICKED, 0);

  584. 

  585.                     return true;

  586.                 }

  587. 

  588.                 break;

  589.             }

  590. 

  591.             case ACTION_SELECT:

  592.             case ACTION_CLEAR_SELECTION:

  593.             {

  594.                 const auto state = accessibilityHandler.getCurrentState();

  595. 

  596.                 if (state.isSelectable() || state.isMultiSelectable())

  597.                 {

  598.                     const auto isSelected = state.isSelected();

  599. 

  600.                     if ((isSelected && action == ACTION_CLEAR_SELECTION)

  601.                         || (! isSelected && action == ACTION_SELECT))

  602.                     {

  603.                         return accessibilityHandler.getActions().invoke (AccessibilityActionType::toggle);

  604.                     }

  605. 

  606.                 }

  607. 

  608.                 break;

  609.             }

  610. 

  611.             case ACTION_EXPAND:

  612.             case ACTION_COLLAPSE:

  613.             {

  614.                 const auto state = accessibilityHandler.getCurrentState();

  615. 

  616.                 if (state.isExpandable())

  617.                 {

  618.                     const auto isExpanded = state.isExpanded();

  619. 

  620.                     if ((isExpanded && action == ACTION_COLLAPSE)

  621.                         || (! isExpanded && action == ACTION_EXPAND))

  622.                     {

  623.                         return accessibilityHandler.getActions().invoke (AccessibilityActionType::showMenu);

  624.                     }

  625.                 }

  626. 

  627.                 break;

  628.             }

  629. 

  630.             case ACTION_NEXT_AT_MOVEMENT_GRANULARITY:      return moveCursor (arguments, true);

  631.             case ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY:  return moveCursor (arguments, false);

  632. 

  633.             case ACTION_SET_SELECTION:

  634.             {

  635.                 if (auto* textInterface = accessibilityHandler.getTextInterface())

  636.                 {

  637.                     auto* env = getEnv();

  638. 

  639.                     const auto selection = [&]() -> Range<int>

  640.                     {

  641.                         const auto selectionStartKey = javaString ("ACTION_ARGUMENT_SELECTION_START_INT");

  642.                         const auto selectionEndKey   = javaString ("ACTION_ARGUMENT_SELECTION_END_INT");

  643. 

  644.                         const auto hasKey = [&env, &arguments] (const auto& key)

  645.                         {

  646.                             return env->CallBooleanMethod (arguments, AndroidBundle.containsKey, key.get());

  647.                         };

  648. 

  649.                         if (hasKey (selectionStartKey) && hasKey (selectionEndKey))

  650.                         {

  651.                             const auto getKey = [&env, &arguments] (const auto& key)

  652.                             {

  653.                                 return env->CallIntMethod (arguments, AndroidBundle.getInt, key.get());

  654.                             };

  655. 

  656.                             const auto start = getKey (selectionStartKey);

  657.                             const auto end   = getKey (selectionEndKey);

  658. 

  659.                             return Range<int>::between (start, end);

  660.                         }

  661. 

  662.                         return {};

  663.                     }();

  664. 

  665.                     textInterface->setSelection (selection);

  666. 

  667.                     return true;

  668.                 }

  669. 

  670.                 break;

  671.             }

  672. 

  673.             case ACTION_SET_TEXT:

  674.             {

  675.                 if (auto* textInterface = accessibilityHandler.getTextInterface())

  676.                 {

  677.                     if (! textInterface->isReadOnly())

  678.                     {

  679.                         const auto charSequenceKey = javaString ("ACTION_ARGUMENT_SET_TEXT_CHARSEQUENCE");

  680. 

  681.                         auto* env = getEnv();

  682. 

  683.                         const auto text = [&]() -> String

  684.                         {

  685.                             if (env->CallBooleanMethod (arguments, AndroidBundle.containsKey, charSequenceKey.get()))

  686.                             {

  687.                                 LocalRef<jobject> charSequence (env->CallObjectMethod (arguments,

  688.                                                                                        AndroidBundle.getCharSequence,

  689.                                                                                        charSequenceKey.get()));

  690.                                 LocalRef<jstring> textStringRef ((jstring) env->CallObjectMethod (charSequence,

  691.                                                                                                   JavaCharSequence.toString));

  692. 

  693.                                 return juceString (textStringRef.get());

  694.                             }

  695. 

  696.                             return {};

  697.                         }();

  698. 

  699.                         textInterface->setText (text);

  700.                     }

  701.                 }

  702. 

  703.                 break;

  704.             }

  705. 

  706.             case ACTION_SCROLL_BACKWARD:

  707.             case ACTION_SCROLL_FORWARD:

  708.             {

  709.                 if (auto* valueInterface = accessibilityHandler.getValueInterface())

  710.                 {

  711.                     if (! valueInterface->isReadOnly())

  712.                     {

  713.                         const auto range = valueInterface->getRange();

  714. 

  715.                         if (range.isValid())

  716.                         {

  717.                             const auto interval = action == ACTION_SCROLL_BACKWARD ? -range.getInterval()

  718.                                                                                    : range.getInterval();

  719.                             valueInterface->setValue (jlimit (range.getMinimumValue(),

  720.                                                               range.getMaximumValue(),

  721.                                                               valueInterface->getCurrentValue() + interval));

  722. 

  723.                             // required for Android to announce the new value

  724.                             sendAccessibilityEventImpl (accessibilityHandler, TYPE_VIEW_SELECTED, 0);

  725.                             return true;

  726.                         }

  727.                     }

  728.                 }

  729. 

  730.                 break;

  731.             }

  732.         }

  733. 

  734.         return false;

  735.     }

  736. 

  737.     bool isInPopulateNodeInfo() const noexcept  { return inPopulateNodeInfo; }

  738. 

  739.     static bool areAnyAccessibilityClientsActive()

  740.     {

  741.         auto* env = getEnv();

  742.         auto appContext = getAppContext();

  743. 

  744.         if (appContext.get() != nullptr)

  745.         {

  746.             LocalRef<jobject> accessibilityManager (env->CallObjectMethod (appContext.get(), AndroidContext.getSystemService,

  747.                                                                            javaString ("accessibility").get()));

  748. 

  749.             if (accessibilityManager != nullptr)

  750.                 return env->CallBooleanMethod (accessibilityManager.get(), AndroidAccessibilityManager.isEnabled);

  751.         }

  752. 

  753.         return false;

  754.     }

  755. 

  756.     template <typename ModificationCallback>

  757.     static void sendAccessibilityEventExtendedImpl (const AccessibilityHandler& handler,

  758.                                                     int eventType,

  759.                                                     ModificationCallback&& modificationCallback)

  760.     {

  761.         if (! areAnyAccessibilityClientsActive())

  762.             return;

  763. 

  764.         if (const auto sourceView = getSourceView (handler))

  765.         {

  766.             const auto* nativeImpl = handler.getNativeImplementation();

  767. 

  768.             if (nativeImpl == nullptr || nativeImpl->isInPopulateNodeInfo())

  769.                 return;

  770. 

  771.             auto* env = getEnv();

  772.             auto appContext = getAppContext();

  773. 

  774.             if (appContext.get() == nullptr)

  775.                 return;

  776. 

  777.             LocalRef<jobject> event (env->CallStaticObjectMethod (AndroidAccessibilityEvent,

  778.                                                                   AndroidAccessibilityEvent.obtain,

  779.                                                                   eventType));

  780. 

  781.             env->CallVoidMethod (event,

  782.                                  AndroidAccessibilityEvent.setPackageName,

  783.                                  env->CallObjectMethod (appContext.get(),

  784.                                                         AndroidContext.getPackageName));

  785. 

  786.             env->CallVoidMethod (event,

  787.                                  AndroidAccessibilityEvent.setSource,

  788.                                  sourceView,

  789.                                  nativeImpl->getVirtualViewId());

  790. 

  791.             modificationCallback (event);

  792. 

  793.             env->CallBooleanMethod (sourceView,

  794.                                     AndroidViewGroup.requestSendAccessibilityEvent,

  795.                                     sourceView,

  796.                                     event.get());

  797.         }

  798.     }

  799. 

  800.     static void sendAccessibilityEventImpl (const AccessibilityHandler& handler, int eventType, int contentChangeTypes)

  801.     {

  802.         sendAccessibilityEventExtendedImpl (handler, eventType, [contentChangeTypes] (auto event)

  803.         {

  804.             if (contentChangeTypes != 0 && accessibilityEventSetContentChangeTypes != nullptr)

  805.                 getEnv()->CallVoidMethod (event,

  806.                                           accessibilityEventSetContentChangeTypes,

  807.                                           contentChangeTypes);

  808.         });

  809.     }

  810. 

  811. private:

  812.     static std::unordered_map<int, AccessibilityHandler*> virtualViewIdMap;

  813. 

  814.     static int getVirtualViewIdForHandler (const AccessibilityHandler& handler)

  815.     {

  816.         static int counter = 0;

  817. 

  818.         if (handler.getComponent().isOnDesktop())

  819.             return HOST_VIEW_ID;

  820. 

  821.         return counter++;

  822.     }

  823. 

  824.     LocalRef<jstring> getDescriptionString() const

  825.     {

  826.         const auto valueString = [this]() -> String

  827.         {

  828.             if (auto* textInterface = accessibilityHandler.getTextInterface())

  829.                 return textInterface->getAllText();

  830. 

  831.             if (auto* valueInterface = accessibilityHandler.getValueInterface())

  832.                 return valueInterface->getCurrentValueAsString();

  833. 

  834.             return {};

  835.         }();

  836. 

  837.         StringArray strings (accessibilityHandler.getTitle(),

  838.                              valueString,

  839.                              accessibilityHandler.getDescription(),

  840.                              accessibilityHandler.getHelp());

  841. 

  842.         strings.removeEmptyStrings();

  843. 

  844.         return javaString (strings.joinIntoString (","));

  845.     }

  846. 

  847.     bool moveCursor (jobject arguments, bool forwards)

  848.     {

  849.         using ATH = AccessibilityTextHelpers;

  850. 

  851.         auto* textInterface = accessibilityHandler.getTextInterface();

  852. 

  853.         if (textInterface == nullptr)

  854.             return false;

  855. 

  856.         const auto granularityKey = javaString ("ACTION_ARGUMENT_MOVEMENT_GRANULARITY_INT");

  857.         const auto extendSelectionKey = javaString ("ACTION_ARGUMENT_EXTEND_SELECTION_BOOLEAN");

  858. 

  859.         auto* env = getEnv();

  860. 

  861.         const auto boundaryType = [&]

  862.         {

  863.             const auto granularity = env->CallIntMethod (arguments, AndroidBundle.getInt, granularityKey.get());

  864. 

  865.             using BoundaryType = ATH::BoundaryType;

  866. 

  867.             switch (granularity)

  868.             {

  869.                 case MOVEMENT_GRANULARITY_CHARACTER:  return BoundaryType::character;

  870.                 case MOVEMENT_GRANULARITY_WORD:       return BoundaryType::word;

  871.                 case MOVEMENT_GRANULARITY_LINE:       return BoundaryType::line;

  872.                 case MOVEMENT_GRANULARITY_PARAGRAPH:

  873.                 case MOVEMENT_GRANULARITY_PAGE:       return BoundaryType::document;

  874.             }

  875. 

  876.             jassertfalse;

  877.             return BoundaryType::character;

  878.         }();

  879. 

  880.         const auto direction = forwards

  881.                              ? ATH::Direction::forwards

  882.                              : ATH::Direction::backwards;

  883. 

  884.         const auto extend = env->CallBooleanMethod (arguments, AndroidBundle.getBoolean, extendSelectionKey.get())

  885.                           ? ATH::ExtendSelection::yes

  886.                           : ATH::ExtendSelection::no;

  887. 

  888.         const auto oldSelection = textInterface->getSelection();

  889.         const auto newSelection = ATH::findNewSelectionRangeAndroid (*textInterface, boundaryType, extend, direction);

  890.         textInterface->setSelection (newSelection);

  891. 

  892.         // Required for Android to read back the text that the cursor moved over

  893.         sendAccessibilityEventExtendedImpl (accessibilityHandler, TYPE_VIEW_TEXT_TRAVERSED_AT_MOVEMENT_GRANULARITY, [&] (auto event)

  894.         {

  895.             env->CallVoidMethod (event,

  896.                                  AndroidAccessibilityEvent.setAction,

  897.                                  forwards ? ACTION_NEXT_AT_MOVEMENT_GRANULARITY : ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY);

  898. 

  899.             env->CallVoidMethod (event,

  900.                                  AndroidAccessibilityEvent.setFromIndex,

  901.                                  oldSelection.getStart() != newSelection.getStart() ? oldSelection.getStart()

  902.                                                                                     : oldSelection.getEnd());

  903. 

  904.             env->CallVoidMethod (event,

  905.                                  AndroidAccessibilityEvent.setToIndex,

  906.                                  oldSelection.getStart() != newSelection.getStart() ? newSelection.getStart()

  907.                                                                                     : newSelection.getEnd());

  908.         });

  909. 

  910.         return true;

  911.     }

  912. 

  913.     AccessibilityHandler& accessibilityHandler;

  914.     const int virtualViewId;

  915.     bool inPopulateNodeInfo = false;

  916. 

  917.     //==============================================================================

  918.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (AccessibilityNativeHandle)

  919. 

  920.     JUCE_DECLARE_WEAK_REFERENCEABLE (AccessibilityNativeHandle)

  921. };

  922. 

  923. std::unordered_map<int, AccessibilityHandler*> AccessibilityNativeHandle::virtualViewIdMap;

  924. 

  925. class AccessibilityHandler::AccessibilityNativeImpl : public AccessibilityNativeHandle

  926. {

  927. public:

  928.     using AccessibilityNativeHandle::AccessibilityNativeHandle;

  929. };

  930. 

  931. //==============================================================================

  932. AccessibilityNativeHandle* AccessibilityHandler::getNativeImplementation() const

  933. {

  934.     return nativeImpl.get();

  935. }

  936. 

  937. void notifyAccessibilityEventInternal (const AccessibilityHandler& handler,

  938.                                        InternalAccessibilityEvent eventType)

  939. {

  940.     if (eventType == InternalAccessibilityEvent::elementCreated

  941.         || eventType == InternalAccessibilityEvent::elementDestroyed

  942.         || eventType == InternalAccessibilityEvent::elementMovedOrResized)

  943.     {

  944.         if (auto* parent = handler.getParent())

  945.             AccessibilityNativeHandle::sendAccessibilityEventImpl (*parent, TYPE_WINDOW_CONTENT_CHANGED, CONTENT_CHANGE_TYPE_SUBTREE);

  946. 

  947.         return;

  948.     }

  949. 

  950.     auto notification = [&handler, eventType]

  951.     {

  952.         switch (eventType)

  953.         {

  954.             case InternalAccessibilityEvent::focusChanged:

  955.                 return handler.hasFocus (false) ? TYPE_VIEW_ACCESSIBILITY_FOCUSED

  956.                                                 : TYPE_VIEW_ACCESSIBILITY_FOCUS_CLEARED;

  957. 

  958.             case InternalAccessibilityEvent::elementCreated:

  959.             case InternalAccessibilityEvent::elementDestroyed:

  960.             case InternalAccessibilityEvent::elementMovedOrResized:

  961.             case InternalAccessibilityEvent::windowOpened:

  962.             case InternalAccessibilityEvent::windowClosed:

  963.                 break;

  964.         }

  965. 

  966.         return 0;

  967.     }();

  968. 

  969.     if (notification != 0)

  970.         AccessibilityNativeHandle::sendAccessibilityEventImpl (handler, notification, 0);

  971. }

  972. 

  973. void AccessibilityHandler::notifyAccessibilityEvent (AccessibilityEvent eventType) const

  974. {

  975.     auto notification = [eventType]

  976.     {

  977.         switch (eventType)

  978.         {

  979.             case AccessibilityEvent::textSelectionChanged:  return TYPE_VIEW_TEXT_SELECTION_CHANGED;

  980.             case AccessibilityEvent::textChanged:           return TYPE_VIEW_TEXT_CHANGED;

  981. 

  982.             case AccessibilityEvent::titleChanged:

  983.             case AccessibilityEvent::structureChanged:      return TYPE_WINDOW_CONTENT_CHANGED;

  984. 

  985.             case AccessibilityEvent::rowSelectionChanged:

  986.             case AccessibilityEvent::valueChanged:          break;

  987.         }

  988. 

  989.         return 0;

  990.     }();

  991. 

  992.     if (notification == 0)

  993.         return;

  994. 

  995.     const auto contentChangeTypes = [eventType]

  996.     {

  997.         if (eventType == AccessibilityEvent::titleChanged)      return CONTENT_CHANGE_TYPE_CONTENT_DESCRIPTION;

  998.         if (eventType == AccessibilityEvent::structureChanged)  return CONTENT_CHANGE_TYPE_SUBTREE;

  999. 

  1000.         return 0;

  1001.     }();

  1002. 

  1003.     AccessibilityNativeHandle::sendAccessibilityEventImpl (*this, notification, contentChangeTypes);

  1004. }

  1005. 

  1006. void AccessibilityHandler::postAnnouncement (const String& announcementString,

  1007.                                              AnnouncementPriority)

  1008. {

  1009.     if (! AccessibilityNativeHandle::areAnyAccessibilityClientsActive())

  1010.         return;

  1011. 

  1012.     const auto rootView = []

  1013.     {

  1014.         LocalRef<jobject> activity (getMainActivity());

  1015. 

  1016.         if (activity != nullptr)

  1017.         {

  1018.             auto* env = getEnv();

  1019. 

  1020.             LocalRef<jobject> mainWindow (env->CallObjectMethod (activity.get(), AndroidActivity.getWindow));

  1021.             LocalRef<jobject> decorView (env->CallObjectMethod (mainWindow.get(), AndroidWindow.getDecorView));

  1022. 

  1023.             return LocalRef<jobject> (env->CallObjectMethod (decorView.get(), AndroidView.getRootView));

  1024.         }

  1025. 

  1026.         return LocalRef<jobject>();

  1027.     }();

  1028. 

  1029.     if (rootView != nullptr)

  1030.         getEnv()->CallVoidMethod (rootView.get(),

  1031.                                   AndroidView.announceForAccessibility,

  1032.                                   javaString (announcementString).get());

  1033. }

  1034. 

  1035. } // namespace juce