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.
13702 Commits
11 Branches
3.6GB
Tree: 73459411ba
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '73459411ba'
${ noResults }
JUCE/modules/juce_gui_basics/native/accessibility/juce_Accessibility_android.cpp

1032 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_WITH_MIN_SDK (AndroidAccessibilityNodeInfo19, "android/view/accessibility/AccessibilityNodeInfo", 19)

  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. static void loadSDKDependentMethods()

  146. {

  147.     static bool hasChecked = false;

  148. 

  149.     if (! hasChecked)

  150.     {

  151.         hasChecked = true;

  152. 

  153.         auto* env = getEnv();

  154.         const auto sdkVersion = getAndroidSDKVersion();

  155. 

  156.         if (sdkVersion >= 18)

  157.         {

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

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

  160.         }

  161. 

  162.         if (sdkVersion >= 19)

  163.         {

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

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

  166.         }

  167.     }

  168. }

  169. 

  170. static constexpr auto getClassName (AccessibilityRole role)

  171. {

  172.     switch (role)

  173.     {

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

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

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

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

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

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

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

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

  182. 

  183.         case AccessibilityRole::scrollBar:

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

  185. 

  186.         case AccessibilityRole::hyperlink:

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

  188. 

  189.         case AccessibilityRole::label:

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

  191. 

  192.         case AccessibilityRole::tooltip:

  193.         case AccessibilityRole::splashScreen:

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

  195. 

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

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

  198.         case AccessibilityRole::list:

  199.         case AccessibilityRole::table:

  200. 

  201.         case AccessibilityRole::column:

  202.         case AccessibilityRole::row:

  203.         case AccessibilityRole::cell:

  204.         case AccessibilityRole::menuItem:

  205.         case AccessibilityRole::menuBar:

  206.         case AccessibilityRole::listItem:

  207.         case AccessibilityRole::treeItem:

  208.         case AccessibilityRole::window:

  209.         case AccessibilityRole::tableHeader:

  210.         case AccessibilityRole::unspecified:

  211.         case AccessibilityRole::group:

  212.         case AccessibilityRole::ignored:       break;

  213.     }

  214. 

  215.     return "android.view.View";

  216. }

  217. 

  218. static jobject getSourceView (const AccessibilityHandler& handler)

  219. {

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

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

  222. 

  223.     return nullptr;

  224. }

  225. 

  226. static jobject makeAndroidRect (Rectangle<int> r)

  227. {

  228.     return getEnv()->NewObject (AndroidRect,

  229.                                 AndroidRect.constructor,

  230.                                 r.getX(),

  231.                                 r.getY(),

  232.                                 r.getRight(),

  233.                                 r.getBottom());

  234. }

  235. 

  236. static jobject makeAndroidPoint (Point<int> p)

  237. {

  238.     return getEnv()->NewObject (AndroidPoint,

  239.                                 AndroidPoint.create,

  240.                                 p.getX(),

  241.                                 p.getY());

  242. }

  243. 

  244. //==============================================================================

  245. class AccessibilityNativeHandle

  246. {

  247. public:

  248.     static AccessibilityHandler* getAccessibilityHandlerForVirtualViewId (int virtualViewId)

  249.     {

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

  251. 

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

  253.             return iter->second;

  254. 

  255.         return nullptr;

  256.     }

  257. 

  258.     explicit AccessibilityNativeHandle (AccessibilityHandler& h)

  259.         : accessibilityHandler (h),

  260.           virtualViewId (getVirtualViewIdForHandler (accessibilityHandler))

  261.     {

  262.         loadSDKDependentMethods();

  263. 

  264.         if (virtualViewId != HOST_VIEW_ID)

  265.             virtualViewIdMap[virtualViewId] = &accessibilityHandler;

  266.     }

  267. 

  268.     ~AccessibilityNativeHandle()

  269.     {

  270.         if (virtualViewId != HOST_VIEW_ID)

  271.             virtualViewIdMap.erase (virtualViewId);

  272.     }

  273. 

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

  275. 

  276.     void populateNodeInfo (jobject info)

  277.     {

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

  279. 

  280.         const auto sourceView = getSourceView (accessibilityHandler);

  281. 

  282.         if (sourceView == nullptr)

  283.             return;

  284. 

  285.         auto* env = getEnv();

  286.         auto appContext = getAppContext();

  287. 

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

  289.             return;

  290. 

  291.         {

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

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

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

  295. 

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

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

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

  299.         }

  300. 

  301.         {

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

  303. 

  304.             LocalRef<jobject> screenBounds (makeAndroidRect (accessibilityHandler.getComponent().getScreenBounds() * scale));

  305. 

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

  307. 

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

  309. 

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

  311.         }

  312. 

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

  314. 

  315.         env->CallVoidMethod (info,

  316.                              AndroidAccessibilityNodeInfo.setEnabled,

  317.                              ! state.isIgnored());

  318.         env->CallVoidMethod (info,

  319.                              AndroidAccessibilityNodeInfo.setVisibleToUser,

  320.                              true);

  321.         env->CallVoidMethod (info,

  322.                              AndroidAccessibilityNodeInfo.setPackageName,

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

  324.                                                     AndroidContext.getPackageName));

  325.         env->CallVoidMethod (info,

  326.                              AndroidAccessibilityNodeInfo.setSource,

  327.                              sourceView,

  328.                              virtualViewId);

  329.         env->CallVoidMethod (info,

  330.                              AndroidAccessibilityNodeInfo.setClassName,

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

  332.         env->CallVoidMethod (info,

  333.                              AndroidAccessibilityNodeInfo.setContentDescription,

  334.                              getDescriptionString().get());

  335. 

  336.         if (state.isFocusable())

  337.         {

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

  339. 

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

  341. 

  342.             if (component.getWantsKeyboardFocus())

  343.             {

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

  345. 

  346.                 env->CallVoidMethod (info,

  347.                                      AndroidAccessibilityNodeInfo.setFocused,

  348.                                      hasKeyboardFocus);

  349.                 env->CallVoidMethod (info,

  350.                                      AndroidAccessibilityNodeInfo.addAction,

  351.                                      hasKeyboardFocus ? ACTION_CLEAR_FOCUS : ACTION_FOCUS);

  352.             }

  353. 

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

  355. 

  356.             env->CallVoidMethod (info,

  357.                                  AndroidAccessibilityNodeInfo.setAccessibilityFocused,

  358.                                  isAccessibleFocused);

  359. 

  360.             env->CallVoidMethod (info,

  361.                                  AndroidAccessibilityNodeInfo.addAction,

  362.                                  isAccessibleFocused ? ACTION_CLEAR_ACCESSIBILITY_FOCUS

  363.                                                      : ACTION_ACCESSIBILITY_FOCUS);

  364.         }

  365. 

  366.         if (state.isCheckable())

  367.         {

  368.             env->CallVoidMethod (info,

  369.                                  AndroidAccessibilityNodeInfo.setCheckable,

  370.                                  true);

  371.             env->CallVoidMethod (info,

  372.                                  AndroidAccessibilityNodeInfo.setChecked,

  373.                                  state.isChecked());

  374.         }

  375. 

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

  377.         {

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

  379. 

  380.             env->CallVoidMethod (info,

  381.                                  AndroidAccessibilityNodeInfo.setSelected,

  382.                                  isSelected);

  383.             env->CallVoidMethod (info,

  384.                                  AndroidAccessibilityNodeInfo.addAction,

  385.                                  isSelected ? ACTION_CLEAR_SELECTION : ACTION_SELECT);

  386.         }

  387. 

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

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

  390.         {

  391.             env->CallVoidMethod (info,

  392.                                  AndroidAccessibilityNodeInfo.setClickable,

  393.                                  true);

  394.             env->CallVoidMethod (info,

  395.                                  AndroidAccessibilityNodeInfo.addAction,

  396.                                  ACTION_CLICK);

  397.         }

  398. 

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

  400.             && state.isExpandable())

  401.         {

  402.             env->CallVoidMethod (info,

  403.                                  AndroidAccessibilityNodeInfo.addAction,

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

  405.         }

  406. 

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

  408.         {

  409.             env->CallVoidMethod (info,

  410.                                  AndroidAccessibilityNodeInfo.setText,

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

  412. 

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

  414. 

  415.             env->CallVoidMethod (info,

  416.                                  AndroidAccessibilityNodeInfo.setPassword,

  417.                                  textInterface->isDisplayingProtectedText());

  418. 

  419.             if (nodeInfoSetEditable != nullptr)

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

  421. 

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

  423. 

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

  425.                 env->CallVoidMethod (info,

  426.                                      nodeInfoSetTextSelection,

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

  428. 

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

  430.                 env->CallVoidMethod (info,

  431.                                      nodeInfoSetLiveRegion,

  432.                                      ACCESSIBILITY_LIVE_REGION_POLITE);

  433. 

  434.             env->CallVoidMethod (info,

  435.                                  AndroidAccessibilityNodeInfo.setMovementGranularities,

  436.                                  ALL_GRANULARITIES);

  437. 

  438.             env->CallVoidMethod (info,

  439.                                  AndroidAccessibilityNodeInfo.addAction,

  440.                                  ACTION_NEXT_AT_MOVEMENT_GRANULARITY);

  441.             env->CallVoidMethod (info,

  442.                                  AndroidAccessibilityNodeInfo.addAction,

  443.                                  ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY);

  444.             env->CallVoidMethod (info,

  445.                                  AndroidAccessibilityNodeInfo.addAction,

  446.                                  ACTION_SET_SELECTION);

  447. 

  448.             if (! isReadOnly)

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

  450.         }

  451. 

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

  453.         {

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

  455.             {

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

  457. 

  458.                 if (range.isValid())

  459.                 {

  460.                     env->CallVoidMethod (info,

  461.                                          AndroidAccessibilityNodeInfo.addAction,

  462.                                          ACTION_SCROLL_FORWARD);

  463.                     env->CallVoidMethod (info,

  464.                                          AndroidAccessibilityNodeInfo.addAction,

  465.                                          ACTION_SCROLL_BACKWARD);

  466.                 }

  467.             }

  468.         }

  469. 

  470.         if (getAndroidSDKVersion() >= 19)

  471.         {

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

  473.             {

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

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

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

  477.                                                                                       AndroidAccessibilityNodeInfoCollectionInfo.obtain,

  478.                                                                                       (jint) rows,

  479.                                                                                       (jint) columns,

  480.                                                                                       (jboolean) false) };

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

  482.             }

  483. 

  484.             if (auto* enclosingTableHandler = detail::AccessibilityHelpers::getEnclosingHandlerWithInterface (&accessibilityHandler, &AccessibilityHandler::getTableInterface))

  485.             {

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

  487.                 jassert (interface != nullptr);

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

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

  490. 

  491.                 enum class IsHeader { no, yes };

  492. 

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

  494.                 {

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

  496.                                                                                               AndroidAccessibilityNodeInfoCollectionItemInfo.obtain,

  497.                                                                                               (jint) rows.begin,

  498.                                                                                               (jint) rows.num,

  499.                                                                                               (jint) columns.begin,

  500.                                                                                               (jint) columns.num,

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

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

  503.                 };

  504. 

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

  506.                 {

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

  508.                 }

  509.                 else

  510.                 {

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

  512.                     {

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

  514.                         {

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

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

  517. 

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

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

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

  521.                         }

  522.                     }

  523.                 }

  524.             }

  525.         }

  526.     }

  527. 

  528.     bool performAction (int action, jobject arguments)

  529.     {

  530.         switch (action)

  531.         {

  532.             case ACTION_ACCESSIBILITY_FOCUS:

  533.             {

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

  535. 

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

  537. 

  538.                 if (safeComponent != nullptr)

  539.                     accessibilityHandler.grabFocus();

  540. 

  541.                 return true;

  542.             }

  543. 

  544.             case ACTION_CLEAR_ACCESSIBILITY_FOCUS:

  545.             {

  546.                 accessibilityHandler.giveAwayFocus();

  547.                 return true;

  548.             }

  549. 

  550.             case ACTION_FOCUS:

  551.             case ACTION_CLEAR_FOCUS:

  552.             {

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

  554. 

  555.                 if (component.getWantsKeyboardFocus())

  556.                 {

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

  558. 

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

  560.                         component.giveAwayKeyboardFocus();

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

  562.                         component.grabKeyboardFocus();

  563. 

  564.                     return true;

  565.                 }

  566. 

  567.                 break;

  568.             }

  569. 

  570.             case ACTION_CLICK:

  571.             {

  572.                 // Invoking the action may delete this handler

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

  574. 

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

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

  577.                 {

  578.                     if (savedHandle != nullptr)

  579.                         sendAccessibilityEventImpl (accessibilityHandler, TYPE_VIEW_CLICKED, 0);

  580. 

  581.                     return true;

  582.                 }

  583. 

  584.                 break;

  585.             }

  586. 

  587.             case ACTION_SELECT:

  588.             case ACTION_CLEAR_SELECTION:

  589.             {

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

  591. 

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

  593.                 {

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

  595. 

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

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

  598.                     {

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

  600.                     }

  601. 

  602.                 }

  603. 

  604.                 break;

  605.             }

  606. 

  607.             case ACTION_EXPAND:

  608.             case ACTION_COLLAPSE:

  609.             {

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

  611. 

  612.                 if (state.isExpandable())

  613.                 {

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

  615. 

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

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

  618.                     {

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

  620.                     }

  621.                 }

  622. 

  623.                 break;

  624.             }

  625. 

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

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

  628. 

  629.             case ACTION_SET_SELECTION:

  630.             {

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

  632.                 {

  633.                     auto* env = getEnv();

  634. 

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

  636.                     {

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

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

  639. 

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

  641.                         {

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

  643.                         };

  644. 

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

  646.                         {

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

  648.                             {

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

  650.                             };

  651. 

  652.                             const auto start = getKey (selectionStartKey);

  653.                             const auto end   = getKey (selectionEndKey);

  654. 

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

  656.                         }

  657. 

  658.                         return {};

  659.                     }();

  660. 

  661.                     textInterface->setSelection (selection);

  662. 

  663.                     return true;

  664.                 }

  665. 

  666.                 break;

  667.             }

  668. 

  669.             case ACTION_SET_TEXT:

  670.             {

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

  672.                 {

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

  674.                     {

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

  676. 

  677.                         auto* env = getEnv();

  678. 

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

  680.                         {

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

  682.                             {

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

  684.                                                                                        AndroidBundle.getCharSequence,

  685.                                                                                        charSequenceKey.get()));

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

  687.                                                                                                   JavaCharSequence.toString));

  688. 

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

  690.                             }

  691. 

  692.                             return {};

  693.                         }();

  694. 

  695.                         textInterface->setText (text);

  696.                     }

  697.                 }

  698. 

  699.                 break;

  700.             }

  701. 

  702.             case ACTION_SCROLL_BACKWARD:

  703.             case ACTION_SCROLL_FORWARD:

  704.             {

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

  706.                 {

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

  708.                     {

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

  710. 

  711.                         if (range.isValid())

  712.                         {

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

  714.                                                                                    : range.getInterval();

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

  716.                                                               range.getMaximumValue(),

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

  718. 

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

  720.                             sendAccessibilityEventImpl (accessibilityHandler, TYPE_VIEW_SELECTED, 0);

  721.                             return true;

  722.                         }

  723.                     }

  724.                 }

  725. 

  726.                 break;

  727.             }

  728.         }

  729. 

  730.         return false;

  731.     }

  732. 

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

  734. 

  735.     static bool areAnyAccessibilityClientsActive()

  736.     {

  737.         auto* env = getEnv();

  738.         auto appContext = getAppContext();

  739. 

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

  741.         {

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

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

  744. 

  745.             if (accessibilityManager != nullptr)

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

  747.         }

  748. 

  749.         return false;

  750.     }

  751. 

  752.     template <typename ModificationCallback>

  753.     static void sendAccessibilityEventExtendedImpl (const AccessibilityHandler& handler,

  754.                                                     int eventType,

  755.                                                     ModificationCallback&& modificationCallback)

  756.     {

  757.         if (! areAnyAccessibilityClientsActive())

  758.             return;

  759. 

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

  761.         {

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

  763. 

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

  765.                 return;

  766. 

  767.             auto* env = getEnv();

  768.             auto appContext = getAppContext();

  769. 

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

  771.                 return;

  772. 

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

  774.                                                                   AndroidAccessibilityEvent.obtain,

  775.                                                                   eventType));

  776. 

  777.             env->CallVoidMethod (event,

  778.                                  AndroidAccessibilityEvent.setPackageName,

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

  780.                                                         AndroidContext.getPackageName));

  781. 

  782.             env->CallVoidMethod (event,

  783.                                  AndroidAccessibilityEvent.setSource,

  784.                                  sourceView,

  785.                                  nativeImpl->getVirtualViewId());

  786. 

  787.             modificationCallback (event);

  788. 

  789.             env->CallBooleanMethod (sourceView,

  790.                                     AndroidViewGroup.requestSendAccessibilityEvent,

  791.                                     sourceView,

  792.                                     event.get());

  793.         }

  794.     }

  795. 

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

  797.     {

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

  799.         {

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

  801.                 getEnv()->CallVoidMethod (event,

  802.                                           accessibilityEventSetContentChangeTypes,

  803.                                           contentChangeTypes);

  804.         });

  805.     }

  806. 

  807. private:

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

  809. 

  810.     static int getVirtualViewIdForHandler (const AccessibilityHandler& handler)

  811.     {

  812.         static int counter = 0;

  813. 

  814.         if (handler.getComponent().isOnDesktop())

  815.             return HOST_VIEW_ID;

  816. 

  817.         return counter++;

  818.     }

  819. 

  820.     LocalRef<jstring> getDescriptionString() const

  821.     {

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

  823.         {

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

  825.                 return textInterface->getAllText();

  826. 

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

  828.                 return valueInterface->getCurrentValueAsString();

  829. 

  830.             return {};

  831.         }();

  832. 

  833.         StringArray strings (accessibilityHandler.getTitle(),

  834.                              valueString,

  835.                              accessibilityHandler.getDescription(),

  836.                              accessibilityHandler.getHelp());

  837. 

  838.         strings.removeEmptyStrings();

  839. 

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

  841.     }

  842. 

  843.     bool moveCursor (jobject arguments, bool forwards)

  844.     {

  845.         using ATH = AccessibilityTextHelpers;

  846. 

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

  848. 

  849.         if (textInterface == nullptr)

  850.             return false;

  851. 

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

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

  854. 

  855.         auto* env = getEnv();

  856. 

  857.         const auto boundaryType = [&]

  858.         {

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

  860. 

  861.             using BoundaryType = ATH::BoundaryType;

  862. 

  863.             switch (granularity)

  864.             {

  865.                 case MOVEMENT_GRANULARITY_CHARACTER:  return BoundaryType::character;

  866.                 case MOVEMENT_GRANULARITY_WORD:       return BoundaryType::word;

  867.                 case MOVEMENT_GRANULARITY_LINE:       return BoundaryType::line;

  868.                 case MOVEMENT_GRANULARITY_PARAGRAPH:

  869.                 case MOVEMENT_GRANULARITY_PAGE:       return BoundaryType::document;

  870.             }

  871. 

  872.             jassertfalse;

  873.             return BoundaryType::character;

  874.         }();

  875. 

  876.         const auto direction = forwards

  877.                              ? ATH::Direction::forwards

  878.                              : ATH::Direction::backwards;

  879. 

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

  881.                           ? ATH::ExtendSelection::yes

  882.                           : ATH::ExtendSelection::no;

  883. 

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

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

  886.         textInterface->setSelection (newSelection);

  887. 

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

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

  890.         {

  891.             env->CallVoidMethod (event,

  892.                                  AndroidAccessibilityEvent.setAction,

  893.                                  forwards ? ACTION_NEXT_AT_MOVEMENT_GRANULARITY : ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY);

  894. 

  895.             env->CallVoidMethod (event,

  896.                                  AndroidAccessibilityEvent.setFromIndex,

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

  898.                                                                                     : oldSelection.getEnd());

  899. 

  900.             env->CallVoidMethod (event,

  901.                                  AndroidAccessibilityEvent.setToIndex,

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

  903.                                                                                     : newSelection.getEnd());

  904.         });

  905. 

  906.         return true;

  907.     }

  908. 

  909.     AccessibilityHandler& accessibilityHandler;

  910.     const int virtualViewId;

  911.     bool inPopulateNodeInfo = false;

  912. 

  913.     //==============================================================================

  914.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (AccessibilityNativeHandle)

  915. 

  916.     JUCE_DECLARE_WEAK_REFERENCEABLE (AccessibilityNativeHandle)

  917. };

  918. 

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

  920. 

  921. class AccessibilityHandler::AccessibilityNativeImpl : public AccessibilityNativeHandle

  922. {

  923. public:

  924.     using AccessibilityNativeHandle::AccessibilityNativeHandle;

  925. };

  926. 

  927. //==============================================================================

  928. AccessibilityNativeHandle* AccessibilityHandler::getNativeImplementation() const

  929. {

  930.     return nativeImpl.get();

  931. }

  932. 

  933. void detail::AccessibilityHelpers::notifyAccessibilityEvent (const AccessibilityHandler& handler,

  934.                                                              Event eventType)

  935. {

  936.     if (eventType == Event::elementCreated

  937.         || eventType == Event::elementDestroyed

  938.         || eventType == Event::elementMovedOrResized)

  939.     {

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

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

  942. 

  943.         return;

  944.     }

  945. 

  946.     auto notification = [&handler, eventType]

  947.     {

  948.         switch (eventType)

  949.         {

  950.             case Event::focusChanged:

  951.                 return handler.hasFocus (false) ? TYPE_VIEW_ACCESSIBILITY_FOCUSED

  952.                                                 : TYPE_VIEW_ACCESSIBILITY_FOCUS_CLEARED;

  953. 

  954.             case Event::elementCreated:

  955.             case Event::elementDestroyed:

  956.             case Event::elementMovedOrResized:

  957.             case Event::windowOpened:

  958.             case Event::windowClosed:

  959.                 break;

  960.         }

  961. 

  962.         return 0;

  963.     }();

  964. 

  965.     if (notification != 0)

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

  967. }

  968. 

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

  970. {

  971.     auto notification = [eventType]

  972.     {

  973.         switch (eventType)

  974.         {

  975.             case AccessibilityEvent::textSelectionChanged:  return TYPE_VIEW_TEXT_SELECTION_CHANGED;

  976.             case AccessibilityEvent::textChanged:           return TYPE_VIEW_TEXT_CHANGED;

  977. 

  978.             case AccessibilityEvent::titleChanged:

  979.             case AccessibilityEvent::structureChanged:      return TYPE_WINDOW_CONTENT_CHANGED;

  980. 

  981.             case AccessibilityEvent::rowSelectionChanged:

  982.             case AccessibilityEvent::valueChanged:          break;

  983.         }

  984. 

  985.         return 0;

  986.     }();

  987. 

  988.     if (notification == 0)

  989.         return;

  990. 

  991.     const auto contentChangeTypes = [eventType]

  992.     {

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

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

  995. 

  996.         return 0;

  997.     }();

  998. 

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

  1000. }

  1001. 

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

  1003.                                              AnnouncementPriority)

  1004. {

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

  1006.         return;

  1007. 

  1008.     const auto rootView = []

  1009.     {

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

  1011. 

  1012.         if (activity != nullptr)

  1013.         {

  1014.             auto* env = getEnv();

  1015. 

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

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

  1018. 

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

  1020.         }

  1021. 

  1022.         return LocalRef<jobject>();

  1023.     }();

  1024. 

  1025.     if (rootView != nullptr)

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

  1027.                                   AndroidView.announceForAccessibility,

  1028.                                   javaString (announcementString).get());

  1029. }

  1030. 

  1031. } // namespace juce