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.
13682 Commits
9 Branches
3.4GB
Tree: 221d1aa6cf
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '221d1aa6cf'
${ noResults }
JUCE/modules/juce_gui_basics/native/accessibility/juce_Accessibility_android.cpp

1034 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.             else

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

  301.         }

  302. 

  303.         {

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

  305. 

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

  307. 

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

  309. 

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

  311. 

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

  313.         }

  314. 

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

  316. 

  317.         env->CallVoidMethod (info,

  318.                              AndroidAccessibilityNodeInfo.setEnabled,

  319.                              ! state.isIgnored());

  320.         env->CallVoidMethod (info,

  321.                              AndroidAccessibilityNodeInfo.setVisibleToUser,

  322.                              true);

  323.         env->CallVoidMethod (info,

  324.                              AndroidAccessibilityNodeInfo.setPackageName,

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

  326.                                                     AndroidContext.getPackageName));

  327.         env->CallVoidMethod (info,

  328.                              AndroidAccessibilityNodeInfo.setSource,

  329.                              sourceView,

  330.                              virtualViewId);

  331.         env->CallVoidMethod (info,

  332.                              AndroidAccessibilityNodeInfo.setClassName,

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

  334.         env->CallVoidMethod (info,

  335.                              AndroidAccessibilityNodeInfo.setContentDescription,

  336.                              getDescriptionString().get());

  337. 

  338.         if (state.isFocusable())

  339.         {

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

  341. 

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

  343. 

  344.             if (component.getWantsKeyboardFocus())

  345.             {

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

  347. 

  348.                 env->CallVoidMethod (info,

  349.                                      AndroidAccessibilityNodeInfo.setFocused,

  350.                                      hasKeyboardFocus);

  351.                 env->CallVoidMethod (info,

  352.                                      AndroidAccessibilityNodeInfo.addAction,

  353.                                      hasKeyboardFocus ? ACTION_CLEAR_FOCUS : ACTION_FOCUS);

  354.             }

  355. 

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

  357. 

  358.             env->CallVoidMethod (info,

  359.                                  AndroidAccessibilityNodeInfo.setAccessibilityFocused,

  360.                                  isAccessibleFocused);

  361. 

  362.             env->CallVoidMethod (info,

  363.                                  AndroidAccessibilityNodeInfo.addAction,

  364.                                  isAccessibleFocused ? ACTION_CLEAR_ACCESSIBILITY_FOCUS

  365.                                                      : ACTION_ACCESSIBILITY_FOCUS);

  366.         }

  367. 

  368.         if (state.isCheckable())

  369.         {

  370.             env->CallVoidMethod (info,

  371.                                  AndroidAccessibilityNodeInfo.setCheckable,

  372.                                  true);

  373.             env->CallVoidMethod (info,

  374.                                  AndroidAccessibilityNodeInfo.setChecked,

  375.                                  state.isChecked());

  376.         }

  377. 

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

  379.         {

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

  381. 

  382.             env->CallVoidMethod (info,

  383.                                  AndroidAccessibilityNodeInfo.setSelected,

  384.                                  isSelected);

  385.             env->CallVoidMethod (info,

  386.                                  AndroidAccessibilityNodeInfo.addAction,

  387.                                  isSelected ? ACTION_CLEAR_SELECTION : ACTION_SELECT);

  388.         }

  389. 

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

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

  392.         {

  393.             env->CallVoidMethod (info,

  394.                                  AndroidAccessibilityNodeInfo.setClickable,

  395.                                  true);

  396.             env->CallVoidMethod (info,

  397.                                  AndroidAccessibilityNodeInfo.addAction,

  398.                                  ACTION_CLICK);

  399.         }

  400. 

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

  402.             && state.isExpandable())

  403.         {

  404.             env->CallVoidMethod (info,

  405.                                  AndroidAccessibilityNodeInfo.addAction,

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

  407.         }

  408. 

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

  410.         {

  411.             env->CallVoidMethod (info,

  412.                                  AndroidAccessibilityNodeInfo.setText,

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

  414. 

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

  416. 

  417.             env->CallVoidMethod (info,

  418.                                  AndroidAccessibilityNodeInfo.setPassword,

  419.                                  textInterface->isDisplayingProtectedText());

  420. 

  421.             if (nodeInfoSetEditable != nullptr)

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

  423. 

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

  425. 

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

  427.                 env->CallVoidMethod (info,

  428.                                      nodeInfoSetTextSelection,

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

  430. 

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

  432.                 env->CallVoidMethod (info,

  433.                                      nodeInfoSetLiveRegion,

  434.                                      ACCESSIBILITY_LIVE_REGION_POLITE);

  435. 

  436.             env->CallVoidMethod (info,

  437.                                  AndroidAccessibilityNodeInfo.setMovementGranularities,

  438.                                  ALL_GRANULARITIES);

  439. 

  440.             env->CallVoidMethod (info,

  441.                                  AndroidAccessibilityNodeInfo.addAction,

  442.                                  ACTION_NEXT_AT_MOVEMENT_GRANULARITY);

  443.             env->CallVoidMethod (info,

  444.                                  AndroidAccessibilityNodeInfo.addAction,

  445.                                  ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY);

  446.             env->CallVoidMethod (info,

  447.                                  AndroidAccessibilityNodeInfo.addAction,

  448.                                  ACTION_SET_SELECTION);

  449. 

  450.             if (! isReadOnly)

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

  452.         }

  453. 

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

  455.         {

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

  457.             {

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

  459. 

  460.                 if (range.isValid())

  461.                 {

  462.                     env->CallVoidMethod (info,

  463.                                          AndroidAccessibilityNodeInfo.addAction,

  464.                                          ACTION_SCROLL_FORWARD);

  465.                     env->CallVoidMethod (info,

  466.                                          AndroidAccessibilityNodeInfo.addAction,

  467.                                          ACTION_SCROLL_BACKWARD);

  468.                 }

  469.             }

  470.         }

  471. 

  472.         if (getAndroidSDKVersion() >= 19)

  473.         {

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

  475.             {

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

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

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

  479.                                                                                       AndroidAccessibilityNodeInfoCollectionInfo.obtain,

  480.                                                                                       (jint) rows,

  481.                                                                                       (jint) columns,

  482.                                                                                       (jboolean) false) };

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

  484.             }

  485. 

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

  487.             {

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

  489.                 jassert (interface != nullptr);

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

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

  492. 

  493.                 enum class IsHeader { no, yes };

  494. 

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

  496.                 {

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

  498.                                                                                               AndroidAccessibilityNodeInfoCollectionItemInfo.obtain,

  499.                                                                                               (jint) rows.begin,

  500.                                                                                               (jint) rows.num,

  501.                                                                                               (jint) columns.begin,

  502.                                                                                               (jint) columns.num,

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

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

  505.                 };

  506. 

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

  508.                 {

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

  510.                 }

  511.                 else

  512.                 {

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

  514.                     {

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

  516.                         {

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

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

  519. 

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

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

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

  523.                         }

  524.                     }

  525.                 }

  526.             }

  527.         }

  528.     }

  529. 

  530.     bool performAction (int action, jobject arguments)

  531.     {

  532.         switch (action)

  533.         {

  534.             case ACTION_ACCESSIBILITY_FOCUS:

  535.             {

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

  537. 

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

  539. 

  540.                 if (safeComponent != nullptr)

  541.                     accessibilityHandler.grabFocus();

  542. 

  543.                 return true;

  544.             }

  545. 

  546.             case ACTION_CLEAR_ACCESSIBILITY_FOCUS:

  547.             {

  548.                 accessibilityHandler.giveAwayFocus();

  549.                 return true;

  550.             }

  551. 

  552.             case ACTION_FOCUS:

  553.             case ACTION_CLEAR_FOCUS:

  554.             {

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

  556. 

  557.                 if (component.getWantsKeyboardFocus())

  558.                 {

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

  560. 

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

  562.                         component.giveAwayKeyboardFocus();

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

  564.                         component.grabKeyboardFocus();

  565. 

  566.                     return true;

  567.                 }

  568. 

  569.                 break;

  570.             }

  571. 

  572.             case ACTION_CLICK:

  573.             {

  574.                 // Invoking the action may delete this handler

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

  576. 

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

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

  579.                 {

  580.                     if (savedHandle != nullptr)

  581.                         sendAccessibilityEventImpl (accessibilityHandler, TYPE_VIEW_CLICKED, 0);

  582. 

  583.                     return true;

  584.                 }

  585. 

  586.                 break;

  587.             }

  588. 

  589.             case ACTION_SELECT:

  590.             case ACTION_CLEAR_SELECTION:

  591.             {

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

  593. 

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

  595.                 {

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

  597. 

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

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

  600.                     {

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

  602.                     }

  603. 

  604.                 }

  605. 

  606.                 break;

  607.             }

  608. 

  609.             case ACTION_EXPAND:

  610.             case ACTION_COLLAPSE:

  611.             {

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

  613. 

  614.                 if (state.isExpandable())

  615.                 {

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

  617. 

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

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

  620.                     {

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

  622.                     }

  623.                 }

  624. 

  625.                 break;

  626.             }

  627. 

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

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

  630. 

  631.             case ACTION_SET_SELECTION:

  632.             {

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

  634.                 {

  635.                     auto* env = getEnv();

  636. 

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

  638.                     {

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

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

  641. 

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

  643.                         {

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

  645.                         };

  646. 

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

  648.                         {

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

  650.                             {

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

  652.                             };

  653. 

  654.                             const auto start = getKey (selectionStartKey);

  655.                             const auto end   = getKey (selectionEndKey);

  656. 

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

  658.                         }

  659. 

  660.                         return {};

  661.                     }();

  662. 

  663.                     textInterface->setSelection (selection);

  664. 

  665.                     return true;

  666.                 }

  667. 

  668.                 break;

  669.             }

  670. 

  671.             case ACTION_SET_TEXT:

  672.             {

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

  674.                 {

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

  676.                     {

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

  678. 

  679.                         auto* env = getEnv();

  680. 

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

  682.                         {

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

  684.                             {

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

  686.                                                                                        AndroidBundle.getCharSequence,

  687.                                                                                        charSequenceKey.get()));

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

  689.                                                                                                   JavaCharSequence.toString));

  690. 

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

  692.                             }

  693. 

  694.                             return {};

  695.                         }();

  696. 

  697.                         textInterface->setText (text);

  698.                     }

  699.                 }

  700. 

  701.                 break;

  702.             }

  703. 

  704.             case ACTION_SCROLL_BACKWARD:

  705.             case ACTION_SCROLL_FORWARD:

  706.             {

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

  708.                 {

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

  710.                     {

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

  712. 

  713.                         if (range.isValid())

  714.                         {

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

  716.                                                                                    : range.getInterval();

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

  718.                                                               range.getMaximumValue(),

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

  720. 

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

  722.                             sendAccessibilityEventImpl (accessibilityHandler, TYPE_VIEW_SELECTED, 0);

  723.                             return true;

  724.                         }

  725.                     }

  726.                 }

  727. 

  728.                 break;

  729.             }

  730.         }

  731. 

  732.         return false;

  733.     }

  734. 

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

  736. 

  737.     static bool areAnyAccessibilityClientsActive()

  738.     {

  739.         auto* env = getEnv();

  740.         auto appContext = getAppContext();

  741. 

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

  743.         {

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

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

  746. 

  747.             if (accessibilityManager != nullptr)

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

  749.         }

  750. 

  751.         return false;

  752.     }

  753. 

  754.     template <typename ModificationCallback>

  755.     static void sendAccessibilityEventExtendedImpl (const AccessibilityHandler& handler,

  756.                                                     int eventType,

  757.                                                     ModificationCallback&& modificationCallback)

  758.     {

  759.         if (! areAnyAccessibilityClientsActive())

  760.             return;

  761. 

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

  763.         {

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

  765. 

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

  767.                 return;

  768. 

  769.             auto* env = getEnv();

  770.             auto appContext = getAppContext();

  771. 

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

  773.                 return;

  774. 

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

  776.                                                                   AndroidAccessibilityEvent.obtain,

  777.                                                                   eventType));

  778. 

  779.             env->CallVoidMethod (event,

  780.                                  AndroidAccessibilityEvent.setPackageName,

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

  782.                                                         AndroidContext.getPackageName));

  783. 

  784.             env->CallVoidMethod (event,

  785.                                  AndroidAccessibilityEvent.setSource,

  786.                                  sourceView,

  787.                                  nativeImpl->getVirtualViewId());

  788. 

  789.             modificationCallback (event);

  790. 

  791.             env->CallBooleanMethod (sourceView,

  792.                                     AndroidViewGroup.requestSendAccessibilityEvent,

  793.                                     sourceView,

  794.                                     event.get());

  795.         }

  796.     }

  797. 

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

  799.     {

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

  801.         {

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

  803.                 getEnv()->CallVoidMethod (event,

  804.                                           accessibilityEventSetContentChangeTypes,

  805.                                           contentChangeTypes);

  806.         });

  807.     }

  808. 

  809. private:

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

  811. 

  812.     static int getVirtualViewIdForHandler (const AccessibilityHandler& handler)

  813.     {

  814.         static int counter = 0;

  815. 

  816.         if (handler.getComponent().isOnDesktop())

  817.             return HOST_VIEW_ID;

  818. 

  819.         return counter++;

  820.     }

  821. 

  822.     LocalRef<jstring> getDescriptionString() const

  823.     {

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

  825.         {

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

  827.                 return textInterface->getAllText();

  828. 

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

  830.                 return valueInterface->getCurrentValueAsString();

  831. 

  832.             return {};

  833.         }();

  834. 

  835.         StringArray strings (accessibilityHandler.getTitle(),

  836.                              valueString,

  837.                              accessibilityHandler.getDescription(),

  838.                              accessibilityHandler.getHelp());

  839. 

  840.         strings.removeEmptyStrings();

  841. 

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

  843.     }

  844. 

  845.     bool moveCursor (jobject arguments, bool forwards)

  846.     {

  847.         using ATH = AccessibilityTextHelpers;

  848. 

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

  850. 

  851.         if (textInterface == nullptr)

  852.             return false;

  853. 

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

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

  856. 

  857.         auto* env = getEnv();

  858. 

  859.         const auto boundaryType = [&]

  860.         {

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

  862. 

  863.             using BoundaryType = ATH::BoundaryType;

  864. 

  865.             switch (granularity)

  866.             {

  867.                 case MOVEMENT_GRANULARITY_CHARACTER:  return BoundaryType::character;

  868.                 case MOVEMENT_GRANULARITY_WORD:       return BoundaryType::word;

  869.                 case MOVEMENT_GRANULARITY_LINE:       return BoundaryType::line;

  870.                 case MOVEMENT_GRANULARITY_PARAGRAPH:

  871.                 case MOVEMENT_GRANULARITY_PAGE:       return BoundaryType::document;

  872.             }

  873. 

  874.             jassertfalse;

  875.             return BoundaryType::character;

  876.         }();

  877. 

  878.         const auto direction = forwards

  879.                              ? ATH::Direction::forwards

  880.                              : ATH::Direction::backwards;

  881. 

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

  883.                           ? ATH::ExtendSelection::yes

  884.                           : ATH::ExtendSelection::no;

  885. 

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

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

  888.         textInterface->setSelection (newSelection);

  889. 

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

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

  892.         {

  893.             env->CallVoidMethod (event,

  894.                                  AndroidAccessibilityEvent.setAction,

  895.                                  forwards ? ACTION_NEXT_AT_MOVEMENT_GRANULARITY : ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY);

  896. 

  897.             env->CallVoidMethod (event,

  898.                                  AndroidAccessibilityEvent.setFromIndex,

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

  900.                                                                                     : oldSelection.getEnd());

  901. 

  902.             env->CallVoidMethod (event,

  903.                                  AndroidAccessibilityEvent.setToIndex,

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

  905.                                                                                     : newSelection.getEnd());

  906.         });

  907. 

  908.         return true;

  909.     }

  910. 

  911.     AccessibilityHandler& accessibilityHandler;

  912.     const int virtualViewId;

  913.     bool inPopulateNodeInfo = false;

  914. 

  915.     //==============================================================================

  916.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (AccessibilityNativeHandle)

  917. 

  918.     JUCE_DECLARE_WEAK_REFERENCEABLE (AccessibilityNativeHandle)

  919. };

  920. 

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

  922. 

  923. class AccessibilityHandler::AccessibilityNativeImpl : public AccessibilityNativeHandle

  924. {

  925. public:

  926.     using AccessibilityNativeHandle::AccessibilityNativeHandle;

  927. };

  928. 

  929. //==============================================================================

  930. AccessibilityNativeHandle* AccessibilityHandler::getNativeImplementation() const

  931. {

  932.     return nativeImpl.get();

  933. }

  934. 

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

  936.                                                              Event eventType)

  937. {

  938.     if (eventType == Event::elementCreated

  939.         || eventType == Event::elementDestroyed

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

  941.     {

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

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

  944. 

  945.         return;

  946.     }

  947. 

  948.     auto notification = [&handler, eventType]

  949.     {

  950.         switch (eventType)

  951.         {

  952.             case Event::focusChanged:

  953.                 return handler.hasFocus (false) ? TYPE_VIEW_ACCESSIBILITY_FOCUSED

  954.                                                 : TYPE_VIEW_ACCESSIBILITY_FOCUS_CLEARED;

  955. 

  956.             case Event::elementCreated:

  957.             case Event::elementDestroyed:

  958.             case Event::elementMovedOrResized:

  959.             case Event::windowOpened:

  960.             case Event::windowClosed:

  961.                 break;

  962.         }

  963. 

  964.         return 0;

  965.     }();

  966. 

  967.     if (notification != 0)

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

  969. }

  970. 

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

  972. {

  973.     auto notification = [eventType]

  974.     {

  975.         switch (eventType)

  976.         {

  977.             case AccessibilityEvent::textSelectionChanged:  return TYPE_VIEW_TEXT_SELECTION_CHANGED;

  978.             case AccessibilityEvent::textChanged:           return TYPE_VIEW_TEXT_CHANGED;

  979. 

  980.             case AccessibilityEvent::titleChanged:

  981.             case AccessibilityEvent::structureChanged:      return TYPE_WINDOW_CONTENT_CHANGED;

  982. 

  983.             case AccessibilityEvent::rowSelectionChanged:

  984.             case AccessibilityEvent::valueChanged:          break;

  985.         }

  986. 

  987.         return 0;

  988.     }();

  989. 

  990.     if (notification == 0)

  991.         return;

  992. 

  993.     const auto contentChangeTypes = [eventType]

  994.     {

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

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

  997. 

  998.         return 0;

  999.     }();

  1000. 

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

  1002. }

  1003. 

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

  1005.                                              AnnouncementPriority)

  1006. {

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

  1008.         return;

  1009. 

  1010.     const auto rootView = []

  1011.     {

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

  1013. 

  1014.         if (activity != nullptr)

  1015.         {

  1016.             auto* env = getEnv();

  1017. 

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

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

  1020. 

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

  1022.         }

  1023. 

  1024.         return LocalRef<jobject>();

  1025.     }();

  1026. 

  1027.     if (rootView != nullptr)

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

  1029.                                   AndroidView.announceForAccessibility,

  1030.                                   javaString (announcementString).get());

  1031. }

  1032. 

  1033. } // namespace juce