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.
13479 Commits
9 Branches
356MB
Tree: 55a8b2ac12
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '55a8b2ac12'
${ noResults }
JUCE/modules/juce_gui_basics/native/accessibility/juce_android_Accessibility.cpp

1028 lines
44KB
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.             LocalRef<jobject> screenBounds (makeAndroidRect (accessibilityHandler.getComponent().getScreenBounds() * scale));

  301. 

  302.             env->CallVoidMethod (info, AndroidAccessibilityNodeInfo.setBoundsInScreen, screenBounds.get());

  303. 

  304.             LocalRef<jobject> boundsInParent (makeAndroidRect (accessibilityHandler.getComponent().getBoundsInParent() * scale));

  305. 

  306.             env->CallVoidMethod (info, AndroidAccessibilityNodeInfo.setBoundsInParent, boundsInParent.get());

  307.         }

  308. 

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

  310. 

  311.         env->CallVoidMethod (info,

  312.                              AndroidAccessibilityNodeInfo.setEnabled,

  313.                              ! state.isIgnored());

  314.         env->CallVoidMethod (info,

  315.                              AndroidAccessibilityNodeInfo.setVisibleToUser,

  316.                              true);

  317.         env->CallVoidMethod (info,

  318.                              AndroidAccessibilityNodeInfo.setPackageName,

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

  320.                                                     AndroidContext.getPackageName));

  321.         env->CallVoidMethod (info,

  322.                              AndroidAccessibilityNodeInfo.setSource,

  323.                              sourceView,

  324.                              virtualViewId);

  325.         env->CallVoidMethod (info,

  326.                              AndroidAccessibilityNodeInfo.setClassName,

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

  328.         env->CallVoidMethod (info,

  329.                              AndroidAccessibilityNodeInfo.setContentDescription,

  330.                              getDescriptionString().get());

  331. 

  332.         if (state.isFocusable())

  333.         {

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

  335. 

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

  337. 

  338.             if (component.getWantsKeyboardFocus())

  339.             {

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

  341. 

  342.                 env->CallVoidMethod (info,

  343.                                      AndroidAccessibilityNodeInfo.setFocused,

  344.                                      hasKeyboardFocus);

  345.                 env->CallVoidMethod (info,

  346.                                      AndroidAccessibilityNodeInfo.addAction,

  347.                                      hasKeyboardFocus ? ACTION_CLEAR_FOCUS : ACTION_FOCUS);

  348.             }

  349. 

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

  351. 

  352.             env->CallVoidMethod (info,

  353.                                  AndroidAccessibilityNodeInfo.setAccessibilityFocused,

  354.                                  isAccessibleFocused);

  355. 

  356.             env->CallVoidMethod (info,

  357.                                  AndroidAccessibilityNodeInfo.addAction,

  358.                                  isAccessibleFocused ? ACTION_CLEAR_ACCESSIBILITY_FOCUS

  359.                                                      : ACTION_ACCESSIBILITY_FOCUS);

  360.         }

  361. 

  362.         if (state.isCheckable())

  363.         {

  364.             env->CallVoidMethod (info,

  365.                                  AndroidAccessibilityNodeInfo.setCheckable,

  366.                                  true);

  367.             env->CallVoidMethod (info,

  368.                                  AndroidAccessibilityNodeInfo.setChecked,

  369.                                  state.isChecked());

  370.         }

  371. 

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

  373.         {

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

  375. 

  376.             env->CallVoidMethod (info,

  377.                                  AndroidAccessibilityNodeInfo.setSelected,

  378.                                  isSelected);

  379.             env->CallVoidMethod (info,

  380.                                  AndroidAccessibilityNodeInfo.addAction,

  381.                                  isSelected ? ACTION_CLEAR_SELECTION : ACTION_SELECT);

  382.         }

  383. 

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

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

  386.         {

  387.             env->CallVoidMethod (info,

  388.                                  AndroidAccessibilityNodeInfo.setClickable,

  389.                                  true);

  390.             env->CallVoidMethod (info,

  391.                                  AndroidAccessibilityNodeInfo.addAction,

  392.                                  ACTION_CLICK);

  393.         }

  394. 

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

  396.             && state.isExpandable())

  397.         {

  398.             env->CallVoidMethod (info,

  399.                                  AndroidAccessibilityNodeInfo.addAction,

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

  401.         }

  402. 

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

  404.         {

  405.             env->CallVoidMethod (info,

  406.                                  AndroidAccessibilityNodeInfo.setText,

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

  408. 

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

  410. 

  411.             env->CallVoidMethod (info,

  412.                                  AndroidAccessibilityNodeInfo.setPassword,

  413.                                  textInterface->isDisplayingProtectedText());

  414. 

  415.             if (nodeInfoSetEditable != nullptr)

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

  417. 

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

  419. 

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

  421.                 env->CallVoidMethod (info,

  422.                                      nodeInfoSetTextSelection,

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

  424. 

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

  426.                 env->CallVoidMethod (info,

  427.                                      nodeInfoSetLiveRegion,

  428.                                      ACCESSIBILITY_LIVE_REGION_POLITE);

  429. 

  430.             env->CallVoidMethod (info,

  431.                                  AndroidAccessibilityNodeInfo.setMovementGranularities,

  432.                                  ALL_GRANULARITIES);

  433. 

  434.             env->CallVoidMethod (info,

  435.                                  AndroidAccessibilityNodeInfo.addAction,

  436.                                  ACTION_NEXT_AT_MOVEMENT_GRANULARITY);

  437.             env->CallVoidMethod (info,

  438.                                  AndroidAccessibilityNodeInfo.addAction,

  439.                                  ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY);

  440.             env->CallVoidMethod (info,

  441.                                  AndroidAccessibilityNodeInfo.addAction,

  442.                                  ACTION_SET_SELECTION);

  443. 

  444.             if (! isReadOnly)

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

  446.         }

  447. 

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

  449.         {

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

  451.             {

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

  453. 

  454.                 if (range.isValid())

  455.                 {

  456.                     env->CallVoidMethod (info,

  457.                                          AndroidAccessibilityNodeInfo.addAction,

  458.                                          ACTION_SCROLL_FORWARD);

  459.                     env->CallVoidMethod (info,

  460.                                          AndroidAccessibilityNodeInfo.addAction,

  461.                                          ACTION_SCROLL_BACKWARD);

  462.                 }

  463.             }

  464.         }

  465. 

  466.         if (getAndroidSDKVersion() >= 19)

  467.         {

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

  469.             {

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

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

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

  473.                                                                                       AndroidAccessibilityNodeInfoCollectionInfo.obtain,

  474.                                                                                       (jint) rows,

  475.                                                                                       (jint) columns,

  476.                                                                                       (jboolean) false) };

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

  478.             }

  479. 

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

  481.             {

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

  483.                 jassert (interface != nullptr);

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

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

  486. 

  487.                 enum class IsHeader { no, yes };

  488. 

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

  490.                 {

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

  492.                                                                                               AndroidAccessibilityNodeInfoCollectionItemInfo.obtain,

  493.                                                                                               (jint) rows.begin,

  494.                                                                                               (jint) rows.num,

  495.                                                                                               (jint) columns.begin,

  496.                                                                                               (jint) columns.num,

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

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

  499.                 };

  500. 

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

  502.                 {

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

  504.                 }

  505.                 else

  506.                 {

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

  508.                     {

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

  510.                         {

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

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

  513. 

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

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

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

  517.                         }

  518.                     }

  519.                 }

  520.             }

  521.         }

  522.     }

  523. 

  524.     bool performAction (int action, jobject arguments)

  525.     {

  526.         switch (action)

  527.         {

  528.             case ACTION_ACCESSIBILITY_FOCUS:

  529.             {

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

  531. 

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

  533. 

  534.                 if (safeComponent != nullptr)

  535.                     accessibilityHandler.grabFocus();

  536. 

  537.                 return true;

  538.             }

  539. 

  540.             case ACTION_CLEAR_ACCESSIBILITY_FOCUS:

  541.             {

  542.                 accessibilityHandler.giveAwayFocus();

  543.                 return true;

  544.             }

  545. 

  546.             case ACTION_FOCUS:

  547.             case ACTION_CLEAR_FOCUS:

  548.             {

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

  550. 

  551.                 if (component.getWantsKeyboardFocus())

  552.                 {

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

  554. 

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

  556.                         component.giveAwayKeyboardFocus();

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

  558.                         component.grabKeyboardFocus();

  559. 

  560.                     return true;

  561.                 }

  562. 

  563.                 break;

  564.             }

  565. 

  566.             case ACTION_CLICK:

  567.             {

  568.                 // Invoking the action may delete this handler

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

  570. 

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

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

  573.                 {

  574.                     if (savedHandle != nullptr)

  575.                         sendAccessibilityEventImpl (accessibilityHandler, TYPE_VIEW_CLICKED, 0);

  576. 

  577.                     return true;

  578.                 }

  579. 

  580.                 break;

  581.             }

  582. 

  583.             case ACTION_SELECT:

  584.             case ACTION_CLEAR_SELECTION:

  585.             {

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

  587. 

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

  589.                 {

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

  591. 

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

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

  594.                     {

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

  596.                     }

  597. 

  598.                 }

  599. 

  600.                 break;

  601.             }

  602. 

  603.             case ACTION_EXPAND:

  604.             case ACTION_COLLAPSE:

  605.             {

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

  607. 

  608.                 if (state.isExpandable())

  609.                 {

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

  611. 

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

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

  614.                     {

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

  616.                     }

  617.                 }

  618. 

  619.                 break;

  620.             }

  621. 

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

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

  624. 

  625.             case ACTION_SET_SELECTION:

  626.             {

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

  628.                 {

  629.                     auto* env = getEnv();

  630. 

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

  632.                     {

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

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

  635. 

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

  637.                         {

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

  639.                         };

  640. 

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

  642.                         {

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

  644.                             {

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

  646.                             };

  647. 

  648.                             const auto start = getKey (selectionStartKey);

  649.                             const auto end   = getKey (selectionEndKey);

  650. 

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

  652.                         }

  653. 

  654.                         return {};

  655.                     }();

  656. 

  657.                     textInterface->setSelection (selection);

  658. 

  659.                     return true;

  660.                 }

  661. 

  662.                 break;

  663.             }

  664. 

  665.             case ACTION_SET_TEXT:

  666.             {

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

  668.                 {

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

  670.                     {

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

  672. 

  673.                         auto* env = getEnv();

  674. 

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

  676.                         {

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

  678.                             {

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

  680.                                                                                        AndroidBundle.getCharSequence,

  681.                                                                                        charSequenceKey.get()));

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

  683.                                                                                                   JavaCharSequence.toString));

  684. 

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

  686.                             }

  687. 

  688.                             return {};

  689.                         }();

  690. 

  691.                         textInterface->setText (text);

  692.                     }

  693.                 }

  694. 

  695.                 break;

  696.             }

  697. 

  698.             case ACTION_SCROLL_BACKWARD:

  699.             case ACTION_SCROLL_FORWARD:

  700.             {

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

  702.                 {

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

  704.                     {

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

  706. 

  707.                         if (range.isValid())

  708.                         {

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

  710.                                                                                    : range.getInterval();

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

  712.                                                               range.getMaximumValue(),

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

  714. 

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

  716.                             sendAccessibilityEventImpl (accessibilityHandler, TYPE_VIEW_SELECTED, 0);

  717.                             return true;

  718.                         }

  719.                     }

  720.                 }

  721. 

  722.                 break;

  723.             }

  724.         }

  725. 

  726.         return false;

  727.     }

  728. 

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

  730. 

  731.     static bool areAnyAccessibilityClientsActive()

  732.     {

  733.         auto* env = getEnv();

  734.         auto appContext = getAppContext();

  735. 

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

  737.         {

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

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

  740. 

  741.             if (accessibilityManager != nullptr)

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

  743.         }

  744. 

  745.         return false;

  746.     }

  747. 

  748.     template <typename ModificationCallback>

  749.     static void sendAccessibilityEventExtendedImpl (const AccessibilityHandler& handler,

  750.                                                     int eventType,

  751.                                                     ModificationCallback&& modificationCallback)

  752.     {

  753.         if (! areAnyAccessibilityClientsActive())

  754.             return;

  755. 

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

  757.         {

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

  759. 

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

  761.                 return;

  762. 

  763.             auto* env = getEnv();

  764.             auto appContext = getAppContext();

  765. 

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

  767.                 return;

  768. 

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

  770.                                                                   AndroidAccessibilityEvent.obtain,

  771.                                                                   eventType));

  772. 

  773.             env->CallVoidMethod (event,

  774.                                  AndroidAccessibilityEvent.setPackageName,

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

  776.                                                         AndroidContext.getPackageName));

  777. 

  778.             env->CallVoidMethod (event,

  779.                                  AndroidAccessibilityEvent.setSource,

  780.                                  sourceView,

  781.                                  nativeImpl->getVirtualViewId());

  782. 

  783.             modificationCallback (event);

  784. 

  785.             env->CallBooleanMethod (sourceView,

  786.                                     AndroidViewGroup.requestSendAccessibilityEvent,

  787.                                     sourceView,

  788.                                     event.get());

  789.         }

  790.     }

  791. 

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

  793.     {

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

  795.         {

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

  797.                 getEnv()->CallVoidMethod (event,

  798.                                           accessibilityEventSetContentChangeTypes,

  799.                                           contentChangeTypes);

  800.         });

  801.     }

  802. 

  803. private:

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

  805. 

  806.     static int getVirtualViewIdForHandler (const AccessibilityHandler& handler)

  807.     {

  808.         static int counter = 0;

  809. 

  810.         if (handler.getComponent().isOnDesktop())

  811.             return HOST_VIEW_ID;

  812. 

  813.         return counter++;

  814.     }

  815. 

  816.     LocalRef<jstring> getDescriptionString() const

  817.     {

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

  819.         {

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

  821.                 return textInterface->getAllText();

  822. 

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

  824.                 return valueInterface->getCurrentValueAsString();

  825. 

  826.             return {};

  827.         }();

  828. 

  829.         StringArray strings (accessibilityHandler.getTitle(),

  830.                              valueString,

  831.                              accessibilityHandler.getDescription(),

  832.                              accessibilityHandler.getHelp());

  833. 

  834.         strings.removeEmptyStrings();

  835. 

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

  837.     }

  838. 

  839.     bool moveCursor (jobject arguments, bool forwards)

  840.     {

  841.         using ATH = AccessibilityTextHelpers;

  842. 

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

  844. 

  845.         if (textInterface == nullptr)

  846.             return false;

  847. 

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

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

  850. 

  851.         auto* env = getEnv();

  852. 

  853.         const auto boundaryType = [&]

  854.         {

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

  856. 

  857.             using BoundaryType = ATH::BoundaryType;

  858. 

  859.             switch (granularity)

  860.             {

  861.                 case MOVEMENT_GRANULARITY_CHARACTER:  return BoundaryType::character;

  862.                 case MOVEMENT_GRANULARITY_WORD:       return BoundaryType::word;

  863.                 case MOVEMENT_GRANULARITY_LINE:       return BoundaryType::line;

  864.                 case MOVEMENT_GRANULARITY_PARAGRAPH:

  865.                 case MOVEMENT_GRANULARITY_PAGE:       return BoundaryType::document;

  866.             }

  867. 

  868.             jassertfalse;

  869.             return BoundaryType::character;

  870.         }();

  871. 

  872.         const auto direction = forwards

  873.                              ? ATH::Direction::forwards

  874.                              : ATH::Direction::backwards;

  875. 

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

  877.                           ? ATH::ExtendSelection::yes

  878.                           : ATH::ExtendSelection::no;

  879. 

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

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

  882.         textInterface->setSelection (newSelection);

  883. 

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

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

  886.         {

  887.             env->CallVoidMethod (event,

  888.                                  AndroidAccessibilityEvent.setAction,

  889.                                  forwards ? ACTION_NEXT_AT_MOVEMENT_GRANULARITY : ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY);

  890. 

  891.             env->CallVoidMethod (event,

  892.                                  AndroidAccessibilityEvent.setFromIndex,

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

  894.                                                                                     : oldSelection.getEnd());

  895. 

  896.             env->CallVoidMethod (event,

  897.                                  AndroidAccessibilityEvent.setToIndex,

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

  899.                                                                                     : newSelection.getEnd());

  900.         });

  901. 

  902.         return true;

  903.     }

  904. 

  905.     AccessibilityHandler& accessibilityHandler;

  906.     const int virtualViewId;

  907.     bool inPopulateNodeInfo = false;

  908. 

  909.     //==============================================================================

  910.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (AccessibilityNativeHandle)

  911. 

  912.     JUCE_DECLARE_WEAK_REFERENCEABLE (AccessibilityNativeHandle)

  913. };

  914. 

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

  916. 

  917. class AccessibilityHandler::AccessibilityNativeImpl : public AccessibilityNativeHandle

  918. {

  919. public:

  920.     using AccessibilityNativeHandle::AccessibilityNativeHandle;

  921. };

  922. 

  923. //==============================================================================

  924. AccessibilityNativeHandle* AccessibilityHandler::getNativeImplementation() const

  925. {

  926.     return nativeImpl.get();

  927. }

  928. 

  929. void notifyAccessibilityEventInternal (const AccessibilityHandler& handler,

  930.                                        InternalAccessibilityEvent eventType)

  931. {

  932.     if (eventType == InternalAccessibilityEvent::elementCreated

  933.         || eventType == InternalAccessibilityEvent::elementDestroyed

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

  935.     {

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

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

  938. 

  939.         return;

  940.     }

  941. 

  942.     auto notification = [&handler, eventType]

  943.     {

  944.         switch (eventType)

  945.         {

  946.             case InternalAccessibilityEvent::focusChanged:

  947.                 return handler.hasFocus (false) ? TYPE_VIEW_ACCESSIBILITY_FOCUSED

  948.                                                 : TYPE_VIEW_ACCESSIBILITY_FOCUS_CLEARED;

  949. 

  950.             case InternalAccessibilityEvent::elementCreated:

  951.             case InternalAccessibilityEvent::elementDestroyed:

  952.             case InternalAccessibilityEvent::elementMovedOrResized:

  953.             case InternalAccessibilityEvent::windowOpened:

  954.             case InternalAccessibilityEvent::windowClosed:

  955.                 break;

  956.         }

  957. 

  958.         return 0;

  959.     }();

  960. 

  961.     if (notification != 0)

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

  963. }

  964. 

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

  966. {

  967.     auto notification = [eventType]

  968.     {

  969.         switch (eventType)

  970.         {

  971.             case AccessibilityEvent::textSelectionChanged:  return TYPE_VIEW_TEXT_SELECTION_CHANGED;

  972.             case AccessibilityEvent::textChanged:           return TYPE_VIEW_TEXT_CHANGED;

  973. 

  974.             case AccessibilityEvent::titleChanged:

  975.             case AccessibilityEvent::structureChanged:      return TYPE_WINDOW_CONTENT_CHANGED;

  976. 

  977.             case AccessibilityEvent::rowSelectionChanged:

  978.             case AccessibilityEvent::valueChanged:          break;

  979.         }

  980. 

  981.         return 0;

  982.     }();

  983. 

  984.     if (notification == 0)

  985.         return;

  986. 

  987.     const auto contentChangeTypes = [eventType]

  988.     {

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

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

  991. 

  992.         return 0;

  993.     }();

  994. 

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

  996. }

  997. 

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

  999.                                              AnnouncementPriority)

  1000. {

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

  1002.         return;

  1003. 

  1004.     const auto rootView = []

  1005.     {

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

  1007. 

  1008.         if (activity != nullptr)

  1009.         {

  1010.             auto* env = getEnv();

  1011. 

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

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

  1014. 

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

  1016.         }

  1017. 

  1018.         return LocalRef<jobject>();

  1019.     }();

  1020. 

  1021.     if (rootView != nullptr)

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

  1023.                                   AndroidView.announceForAccessibility,

  1024.                                   javaString (announcementString).get());

  1025. }

  1026. 

  1027. } // namespace juce