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

1037 lines
45KB
Raw Blame History 

  1. /*

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

  3. 

  4.    This file is part of the JUCE library.

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

  6. 

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

  8.    licensing.

  9. 

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

  11.    Agreement and JUCE Privacy Policy.

  12. 

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

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

  15. 

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

  17.    www.gnu.org/licenses).

  18. 

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

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

  21.    DISCLAIMED.

  22. 

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

  24. */

  25. 

  26. namespace juce

  27. {

  28. 

  29. #define JUCE_NATIVE_ACCESSIBILITY_INCLUDED 1

  30. 

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

  32.  METHOD (constructor,              "<init>",                   "()V") \

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  55. 

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

  57. #undef JNI_CLASS_MEMBERS

  58. 

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

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

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

  62. 

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

  64. #undef JNI_CLASS_MEMBERS

  65. 

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

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

  68. 

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

  70. #undef JNI_CLASS_MEMBERS

  71. 

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

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

  74. 

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

  76. #undef JNI_CLASS_MEMBERS

  77. 

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

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

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

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

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

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

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

  85. 

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

  87. #undef JNI_CLASS_MEMBERS

  88. 

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

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

  91. 

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

  93. #undef JNI_CLASS_MEMBERS

  94. 

  95. namespace

  96. {

  97.     constexpr int HOST_VIEW_ID = -1;

  98. 

  99.     constexpr int TYPE_VIEW_CLICKED                                = 0x00000001,

  100.                   TYPE_VIEW_SELECTED                               = 0x00000004,

  101.                   TYPE_VIEW_ACCESSIBILITY_FOCUSED                  = 0x00008000,

  102.                   TYPE_VIEW_ACCESSIBILITY_FOCUS_CLEARED            = 0x00010000,

  103.                   TYPE_WINDOW_CONTENT_CHANGED                      = 0x00000800,

  104.                   TYPE_VIEW_TEXT_SELECTION_CHANGED                 = 0x00002000,

  105.                   TYPE_VIEW_TEXT_CHANGED                           = 0x00000010,

  106.                   TYPE_VIEW_TEXT_TRAVERSED_AT_MOVEMENT_GRANULARITY = 0x00020000;

  107. 

  108.     constexpr int CONTENT_CHANGE_TYPE_SUBTREE             = 0x00000001,

  109.                   CONTENT_CHANGE_TYPE_CONTENT_DESCRIPTION = 0x00000004;

  110. 

  111.     constexpr int ACTION_ACCESSIBILITY_FOCUS              = 0x00000040,

  112.                   ACTION_CLEAR_ACCESSIBILITY_FOCUS        = 0x00000080,

  113.                   ACTION_CLEAR_FOCUS                      = 0x00000002,

  114.                   ACTION_CLEAR_SELECTION                  = 0x00000008,

  115.                   ACTION_CLICK                            = 0x00000010,

  116.                   ACTION_COLLAPSE                         = 0x00080000,

  117.                   ACTION_EXPAND                           = 0x00040000,

  118.                   ACTION_FOCUS                            = 0x00000001,

  119.                   ACTION_NEXT_AT_MOVEMENT_GRANULARITY     = 0x00000100,

  120.                   ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY = 0x00000200,

  121.                   ACTION_SCROLL_BACKWARD                  = 0x00002000,

  122.                   ACTION_SCROLL_FORWARD                   = 0x00001000,

  123.                   ACTION_SELECT                           = 0x00000004,

  124.                   ACTION_SET_SELECTION                    = 0x00020000,

  125.                   ACTION_SET_TEXT                         = 0x00200000;

  126. 

  127.     constexpr int MOVEMENT_GRANULARITY_CHARACTER = 0x00000001,

  128.                   MOVEMENT_GRANULARITY_LINE      = 0x00000004,

  129.                   MOVEMENT_GRANULARITY_PAGE      = 0x00000010,

  130.                   MOVEMENT_GRANULARITY_PARAGRAPH = 0x00000008,

  131.                   MOVEMENT_GRANULARITY_WORD      = 0x00000002,

  132.                   ALL_GRANULARITIES = MOVEMENT_GRANULARITY_CHARACTER

  133.                                     | MOVEMENT_GRANULARITY_LINE

  134.                                     | MOVEMENT_GRANULARITY_PAGE

  135.                                     | MOVEMENT_GRANULARITY_PARAGRAPH

  136.                                     | MOVEMENT_GRANULARITY_WORD;

  137. 

  138.     constexpr int ACCESSIBILITY_LIVE_REGION_POLITE = 0x00000001;

  139. }

  140. 

  141. static jmethodID nodeInfoSetEditable                     = nullptr;

  142. static jmethodID nodeInfoSetTextSelection                = nullptr;

  143. static jmethodID nodeInfoSetLiveRegion                   = nullptr;

  144. static jmethodID accessibilityEventSetContentChangeTypes = nullptr;

  145. 

  146. template <typename MemberFn>

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

  148. {

  149.     if (handler == nullptr)

  150.         return nullptr;

  151. 

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

  153.         return handler;

  154. 

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

  156. }

  157. 

  158. static void loadSDKDependentMethods()

  159. {

  160.     static bool hasChecked = false;

  161. 

  162.     if (! hasChecked)

  163.     {

  164.         hasChecked = true;

  165. 

  166.         auto* env = getEnv();

  167.         const auto sdkVersion = getAndroidSDKVersion();

  168. 

  169.         if (sdkVersion >= 18)

  170.         {

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

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

  173.         }

  174. 

  175.         if (sdkVersion >= 19)

  176.         {

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

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

  179.         }

  180.     }

  181. }

  182. 

  183. static constexpr auto getClassName (AccessibilityRole role)

  184. {

  185.     switch (role)

  186.     {

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

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

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

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

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

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

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

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

  195. 

  196.         case AccessibilityRole::scrollBar:

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

  198. 

  199.         case AccessibilityRole::hyperlink:

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

  201. 

  202.         case AccessibilityRole::label:

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

  204. 

  205.         case AccessibilityRole::tooltip:

  206.         case AccessibilityRole::splashScreen:

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

  208. 

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

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

  211.         case AccessibilityRole::list:

  212.         case AccessibilityRole::table:

  213. 

  214.         case AccessibilityRole::column:

  215.         case AccessibilityRole::row:

  216.         case AccessibilityRole::cell:

  217.         case AccessibilityRole::menuItem:

  218.         case AccessibilityRole::menuBar:

  219.         case AccessibilityRole::listItem:

  220.         case AccessibilityRole::treeItem:

  221.         case AccessibilityRole::window:

  222.         case AccessibilityRole::tableHeader:

  223.         case AccessibilityRole::unspecified:

  224.         case AccessibilityRole::group:

  225.         case AccessibilityRole::ignored:       break;

  226.     }

  227. 

  228.     return "android.view.View";

  229. }

  230. 

  231. static jobject getSourceView (const AccessibilityHandler& handler)

  232. {

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

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

  235. 

  236.     return nullptr;

  237. }

  238. 

  239. //==============================================================================

  240. class AccessibilityNativeHandle

  241. {

  242. public:

  243.     static AccessibilityHandler* getAccessibilityHandlerForVirtualViewId (int virtualViewId)

  244.     {

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

  246. 

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

  248.             return iter->second;

  249. 

  250.         return nullptr;

  251.     }

  252. 

  253.     explicit AccessibilityNativeHandle (AccessibilityHandler& h)

  254.         : accessibilityHandler (h),

  255.           virtualViewId (getVirtualViewIdForHandler (accessibilityHandler))

  256.     {

  257.         loadSDKDependentMethods();

  258. 

  259.         if (virtualViewId != HOST_VIEW_ID)

  260.             virtualViewIdMap[virtualViewId] = &accessibilityHandler;

  261.     }

  262. 

  263.     ~AccessibilityNativeHandle()

  264.     {

  265.         if (virtualViewId != HOST_VIEW_ID)

  266.             virtualViewIdMap.erase (virtualViewId);

  267.     }

  268. 

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

  270. 

  271.     void populateNodeInfo (jobject info)

  272.     {

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

  274. 

  275.         const auto sourceView = getSourceView (accessibilityHandler);

  276. 

  277.         if (sourceView == nullptr)

  278.             return;

  279. 

  280.         auto* env = getEnv();

  281.         auto appContext = getAppContext();

  282. 

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

  284.             return;

  285. 

  286.         {

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

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

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

  290. 

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

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

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

  294.             else

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

  296.         }

  297. 

  298.         {

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

  300. 

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

  302. 

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

  304.                                                     screenBounds.getX(),     screenBounds.getY(),

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

  306. 

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

  308. 

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

  310. 

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

  312.                                                       boundsInParent.getX(),     boundsInParent.getY(),

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

  314. 

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

  316.         }

  317. 

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

  319. 

  320.         env->CallVoidMethod (info,

  321.                              AndroidAccessibilityNodeInfo.setEnabled,

  322.                              ! state.isIgnored());

  323.         env->CallVoidMethod (info,

  324.                              AndroidAccessibilityNodeInfo.setVisibleToUser,

  325.                              true);

  326.         env->CallVoidMethod (info,

  327.                              AndroidAccessibilityNodeInfo.setPackageName,

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

  329.                                                     AndroidContext.getPackageName));

  330.         env->CallVoidMethod (info,

  331.                              AndroidAccessibilityNodeInfo.setSource,

  332.                              sourceView,

  333.                              virtualViewId);

  334.         env->CallVoidMethod (info,

  335.                              AndroidAccessibilityNodeInfo.setClassName,

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

  337.         env->CallVoidMethod (info,

  338.                              AndroidAccessibilityNodeInfo.setContentDescription,

  339.                              getDescriptionString().get());

  340. 

  341.         if (state.isFocusable())

  342.         {

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

  344. 

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

  346. 

  347.             if (component.getWantsKeyboardFocus())

  348.             {

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

  350. 

  351.                 env->CallVoidMethod (info,

  352.                                      AndroidAccessibilityNodeInfo.setFocused,

  353.                                      hasKeyboardFocus);

  354.                 env->CallVoidMethod (info,

  355.                                      AndroidAccessibilityNodeInfo.addAction,

  356.                                      hasKeyboardFocus ? ACTION_CLEAR_FOCUS : ACTION_FOCUS);

  357.             }

  358. 

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

  360. 

  361.             env->CallVoidMethod (info,

  362.                                  AndroidAccessibilityNodeInfo.setAccessibilityFocused,

  363.                                  isAccessibleFocused);

  364. 

  365.             env->CallVoidMethod (info,

  366.                                  AndroidAccessibilityNodeInfo.addAction,

  367.                                  isAccessibleFocused ? ACTION_CLEAR_ACCESSIBILITY_FOCUS

  368.                                                      : ACTION_ACCESSIBILITY_FOCUS);

  369.         }

  370. 

  371.         if (state.isCheckable())

  372.         {

  373.             env->CallVoidMethod (info,

  374.                                  AndroidAccessibilityNodeInfo.setCheckable,

  375.                                  true);

  376.             env->CallVoidMethod (info,

  377.                                  AndroidAccessibilityNodeInfo.setChecked,

  378.                                  state.isChecked());

  379.         }

  380. 

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

  382.         {

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

  384. 

  385.             env->CallVoidMethod (info,

  386.                                  AndroidAccessibilityNodeInfo.setSelected,

  387.                                  isSelected);

  388.             env->CallVoidMethod (info,

  389.                                  AndroidAccessibilityNodeInfo.addAction,

  390.                                  isSelected ? ACTION_CLEAR_SELECTION : ACTION_SELECT);

  391.         }

  392. 

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

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

  395.         {

  396.             env->CallVoidMethod (info,

  397.                                  AndroidAccessibilityNodeInfo.setClickable,

  398.                                  true);

  399.             env->CallVoidMethod (info,

  400.                                  AndroidAccessibilityNodeInfo.addAction,

  401.                                  ACTION_CLICK);

  402.         }

  403. 

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

  405.             && state.isExpandable())

  406.         {

  407.             env->CallVoidMethod (info,

  408.                                  AndroidAccessibilityNodeInfo.addAction,

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

  410.         }

  411. 

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

  413.         {

  414.             env->CallVoidMethod (info,

  415.                                  AndroidAccessibilityNodeInfo.setText,

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

  417. 

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

  419. 

  420.             env->CallVoidMethod (info,

  421.                                  AndroidAccessibilityNodeInfo.setPassword,

  422.                                  textInterface->isDisplayingProtectedText());

  423. 

  424.             if (nodeInfoSetEditable != nullptr)

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

  426. 

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

  428. 

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

  430.                 env->CallVoidMethod (info,

  431.                                      nodeInfoSetTextSelection,

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

  433. 

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

  435.                 env->CallVoidMethod (info,

  436.                                      nodeInfoSetLiveRegion,

  437.                                      ACCESSIBILITY_LIVE_REGION_POLITE);

  438. 

  439.             env->CallVoidMethod (info,

  440.                                  AndroidAccessibilityNodeInfo.setMovementGranularities,

  441.                                  ALL_GRANULARITIES);

  442. 

  443.             env->CallVoidMethod (info,

  444.                                  AndroidAccessibilityNodeInfo.addAction,

  445.                                  ACTION_NEXT_AT_MOVEMENT_GRANULARITY);

  446.             env->CallVoidMethod (info,

  447.                                  AndroidAccessibilityNodeInfo.addAction,

  448.                                  ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY);

  449.             env->CallVoidMethod (info,

  450.                                  AndroidAccessibilityNodeInfo.addAction,

  451.                                  ACTION_SET_SELECTION);

  452. 

  453.             if (! isReadOnly)

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

  455.         }

  456. 

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

  458.         {

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

  460.             {

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

  462. 

  463.                 if (range.isValid())

  464.                 {

  465.                     env->CallVoidMethod (info,

  466.                                          AndroidAccessibilityNodeInfo.addAction,

  467.                                          ACTION_SCROLL_FORWARD);

  468.                     env->CallVoidMethod (info,

  469.                                          AndroidAccessibilityNodeInfo.addAction,

  470.                                          ACTION_SCROLL_BACKWARD);

  471.                 }

  472.             }

  473.         }

  474. 

  475.         if (getAndroidSDKVersion() >= 19)

  476.         {

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

  478.             {

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

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

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

  482.                                                                                       AndroidAccessibilityNodeInfoCollectionInfo.obtain,

  483.                                                                                       (jint) rows,

  484.                                                                                       (jint) columns,

  485.                                                                                       (jboolean) false) };

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

  487.             }

  488. 

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

  490.             {

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

  492.                 jassert (interface != nullptr);

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

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

  495. 

  496.                 enum class IsHeader { no, yes };

  497. 

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

  499.                 {

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

  501.                                                                                               AndroidAccessibilityNodeInfoCollectionItemInfo.obtain,

  502.                                                                                               (jint) rows.begin,

  503.                                                                                               (jint) rows.num,

  504.                                                                                               (jint) columns.begin,

  505.                                                                                               (jint) columns.num,

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

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

  508.                 };

  509. 

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

  511.                 {

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

  513.                 }

  514.                 else

  515.                 {

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

  517.                     {

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

  519.                         {

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

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

  522. 

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

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

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

  526.                         }

  527.                     }

  528.                 }

  529.             }

  530.         }

  531.     }

  532. 

  533.     bool performAction (int action, jobject arguments)

  534.     {

  535.         switch (action)

  536.         {

  537.             case ACTION_ACCESSIBILITY_FOCUS:

  538.             {

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

  540. 

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

  542. 

  543.                 if (safeComponent != nullptr)

  544.                     accessibilityHandler.grabFocus();

  545. 

  546.                 return true;

  547.             }

  548. 

  549.             case ACTION_CLEAR_ACCESSIBILITY_FOCUS:

  550.             {

  551.                 accessibilityHandler.giveAwayFocus();

  552.                 return true;

  553.             }

  554. 

  555.             case ACTION_FOCUS:

  556.             case ACTION_CLEAR_FOCUS:

  557.             {

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

  559. 

  560.                 if (component.getWantsKeyboardFocus())

  561.                 {

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

  563. 

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

  565.                         component.giveAwayKeyboardFocus();

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

  567.                         component.grabKeyboardFocus();

  568. 

  569.                     return true;

  570.                 }

  571. 

  572.                 break;

  573.             }

  574. 

  575.             case ACTION_CLICK:

  576.             {

  577.                 // Invoking the action may delete this handler

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

  579. 

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

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

  582.                 {

  583.                     if (savedHandle != nullptr)

  584.                         sendAccessibilityEventImpl (accessibilityHandler, TYPE_VIEW_CLICKED, 0);

  585. 

  586.                     return true;

  587.                 }

  588. 

  589.                 break;

  590.             }

  591. 

  592.             case ACTION_SELECT:

  593.             case ACTION_CLEAR_SELECTION:

  594.             {

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

  596. 

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

  598.                 {

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

  600. 

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

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

  603.                     {

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

  605.                     }

  606. 

  607.                 }

  608. 

  609.                 break;

  610.             }

  611. 

  612.             case ACTION_EXPAND:

  613.             case ACTION_COLLAPSE:

  614.             {

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

  616. 

  617.                 if (state.isExpandable())

  618.                 {

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

  620. 

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

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

  623.                     {

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

  625.                     }

  626.                 }

  627. 

  628.                 break;

  629.             }

  630. 

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

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

  633. 

  634.             case ACTION_SET_SELECTION:

  635.             {

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

  637.                 {

  638.                     auto* env = getEnv();

  639. 

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

  641.                     {

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

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

  644. 

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

  646.                         {

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

  648.                         };

  649. 

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

  651.                         {

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

  653.                             {

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

  655.                             };

  656. 

  657.                             const auto start = getKey (selectionStartKey);

  658.                             const auto end   = getKey (selectionEndKey);

  659. 

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

  661.                         }

  662. 

  663.                         return {};

  664.                     }();

  665. 

  666.                     textInterface->setSelection (selection);

  667. 

  668.                     return true;

  669.                 }

  670. 

  671.                 break;

  672.             }

  673. 

  674.             case ACTION_SET_TEXT:

  675.             {

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

  677.                 {

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

  679.                     {

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

  681. 

  682.                         auto* env = getEnv();

  683. 

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

  685.                         {

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

  687.                             {

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

  689.                                                                                        AndroidBundle.getCharSequence,

  690.                                                                                        charSequenceKey.get()));

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

  692.                                                                                                   JavaCharSequence.toString));

  693. 

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

  695.                             }

  696. 

  697.                             return {};

  698.                         }();

  699. 

  700.                         textInterface->setText (text);

  701.                     }

  702.                 }

  703. 

  704.                 break;

  705.             }

  706. 

  707.             case ACTION_SCROLL_BACKWARD:

  708.             case ACTION_SCROLL_FORWARD:

  709.             {

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

  711.                 {

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

  713.                     {

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

  715. 

  716.                         if (range.isValid())

  717.                         {

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

  719.                                                                                    : range.getInterval();

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

  721.                                                               range.getMaximumValue(),

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

  723. 

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

  725.                             sendAccessibilityEventImpl (accessibilityHandler, TYPE_VIEW_SELECTED, 0);

  726.                             return true;

  727.                         }

  728.                     }

  729.                 }

  730. 

  731.                 break;

  732.             }

  733.         }

  734. 

  735.         return false;

  736.     }

  737. 

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

  739. 

  740.     static bool areAnyAccessibilityClientsActive()

  741.     {

  742.         auto* env = getEnv();

  743.         auto appContext = getAppContext();

  744. 

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

  746.         {

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

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

  749. 

  750.             if (accessibilityManager != nullptr)

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

  752.         }

  753. 

  754.         return false;

  755.     }

  756. 

  757.     template <typename ModificationCallback>

  758.     static void sendAccessibilityEventExtendedImpl (const AccessibilityHandler& handler,

  759.                                                     int eventType,

  760.                                                     ModificationCallback&& modificationCallback)

  761.     {

  762.         if (! areAnyAccessibilityClientsActive())

  763.             return;

  764. 

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

  766.         {

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

  768. 

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

  770.                 return;

  771. 

  772.             auto* env = getEnv();

  773.             auto appContext = getAppContext();

  774. 

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

  776.                 return;

  777. 

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

  779.                                                                   AndroidAccessibilityEvent.obtain,

  780.                                                                   eventType));

  781. 

  782.             env->CallVoidMethod (event,

  783.                                  AndroidAccessibilityEvent.setPackageName,

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

  785.                                                         AndroidContext.getPackageName));

  786. 

  787.             env->CallVoidMethod (event,

  788.                                  AndroidAccessibilityEvent.setSource,

  789.                                  sourceView,

  790.                                  nativeImpl->getVirtualViewId());

  791. 

  792.             modificationCallback (event);

  793. 

  794.             env->CallBooleanMethod (sourceView,

  795.                                     AndroidViewGroup.requestSendAccessibilityEvent,

  796.                                     sourceView,

  797.                                     event.get());

  798.         }

  799.     }

  800. 

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

  802.     {

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

  804.         {

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

  806.                 getEnv()->CallVoidMethod (event,

  807.                                           accessibilityEventSetContentChangeTypes,

  808.                                           contentChangeTypes);

  809.         });

  810.     }

  811. 

  812. private:

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

  814. 

  815.     static int getVirtualViewIdForHandler (const AccessibilityHandler& handler)

  816.     {

  817.         static int counter = 0;

  818. 

  819.         if (handler.getComponent().isOnDesktop())

  820.             return HOST_VIEW_ID;

  821. 

  822.         return counter++;

  823.     }

  824. 

  825.     LocalRef<jstring> getDescriptionString() const

  826.     {

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

  828.         {

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

  830.                 return textInterface->getAllText();

  831. 

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

  833.                 return valueInterface->getCurrentValueAsString();

  834. 

  835.             return {};

  836.         }();

  837. 

  838.         StringArray strings (accessibilityHandler.getTitle(),

  839.                              valueString,

  840.                              accessibilityHandler.getDescription(),

  841.                              accessibilityHandler.getHelp());

  842. 

  843.         strings.removeEmptyStrings();

  844. 

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

  846.     }

  847. 

  848.     bool moveCursor (jobject arguments, bool forwards)

  849.     {

  850.         using ATH = AccessibilityTextHelpers;

  851. 

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

  853. 

  854.         if (textInterface == nullptr)

  855.             return false;

  856. 

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

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

  859. 

  860.         auto* env = getEnv();

  861. 

  862.         const auto boundaryType = [&]

  863.         {

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

  865. 

  866.             using BoundaryType = ATH::BoundaryType;

  867. 

  868.             switch (granularity)

  869.             {

  870.                 case MOVEMENT_GRANULARITY_CHARACTER:  return BoundaryType::character;

  871.                 case MOVEMENT_GRANULARITY_WORD:       return BoundaryType::word;

  872.                 case MOVEMENT_GRANULARITY_LINE:       return BoundaryType::line;

  873.                 case MOVEMENT_GRANULARITY_PARAGRAPH:

  874.                 case MOVEMENT_GRANULARITY_PAGE:       return BoundaryType::document;

  875.             }

  876. 

  877.             jassertfalse;

  878.             return BoundaryType::character;

  879.         }();

  880. 

  881.         const auto direction = forwards

  882.                              ? ATH::Direction::forwards

  883.                              : ATH::Direction::backwards;

  884. 

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

  886.                           ? ATH::ExtendSelection::yes

  887.                           : ATH::ExtendSelection::no;

  888. 

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

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

  891.         textInterface->setSelection (newSelection);

  892. 

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

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

  895.         {

  896.             env->CallVoidMethod (event,

  897.                                  AndroidAccessibilityEvent.setAction,

  898.                                  forwards ? ACTION_NEXT_AT_MOVEMENT_GRANULARITY : ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY);

  899. 

  900.             env->CallVoidMethod (event,

  901.                                  AndroidAccessibilityEvent.setFromIndex,

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

  903.                                                                                     : oldSelection.getEnd());

  904. 

  905.             env->CallVoidMethod (event,

  906.                                  AndroidAccessibilityEvent.setToIndex,

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

  908.                                                                                     : newSelection.getEnd());

  909.         });

  910. 

  911.         return true;

  912.     }

  913. 

  914.     AccessibilityHandler& accessibilityHandler;

  915.     const int virtualViewId;

  916.     bool inPopulateNodeInfo = false;

  917. 

  918.     //==============================================================================

  919.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (AccessibilityNativeHandle)

  920. 

  921.     JUCE_DECLARE_WEAK_REFERENCEABLE (AccessibilityNativeHandle)

  922. };

  923. 

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

  925. 

  926. class AccessibilityHandler::AccessibilityNativeImpl : public AccessibilityNativeHandle

  927. {

  928. public:

  929.     using AccessibilityNativeHandle::AccessibilityNativeHandle;

  930. };

  931. 

  932. //==============================================================================

  933. AccessibilityNativeHandle* AccessibilityHandler::getNativeImplementation() const

  934. {

  935.     return nativeImpl.get();

  936. }

  937. 

  938. void notifyAccessibilityEventInternal (const AccessibilityHandler& handler,

  939.                                        InternalAccessibilityEvent eventType)

  940. {

  941.     if (eventType == InternalAccessibilityEvent::elementCreated

  942.         || eventType == InternalAccessibilityEvent::elementDestroyed

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

  944.     {

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

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

  947. 

  948.         return;

  949.     }

  950. 

  951.     auto notification = [&handler, eventType]

  952.     {

  953.         switch (eventType)

  954.         {

  955.             case InternalAccessibilityEvent::focusChanged:

  956.                 return handler.hasFocus (false) ? TYPE_VIEW_ACCESSIBILITY_FOCUSED

  957.                                                 : TYPE_VIEW_ACCESSIBILITY_FOCUS_CLEARED;

  958. 

  959.             case InternalAccessibilityEvent::elementCreated:

  960.             case InternalAccessibilityEvent::elementDestroyed:

  961.             case InternalAccessibilityEvent::elementMovedOrResized:

  962.             case InternalAccessibilityEvent::windowOpened:

  963.             case InternalAccessibilityEvent::windowClosed:

  964.                 break;

  965.         }

  966. 

  967.         return 0;

  968.     }();

  969. 

  970.     if (notification != 0)

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

  972. }

  973. 

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

  975. {

  976.     auto notification = [eventType]

  977.     {

  978.         switch (eventType)

  979.         {

  980.             case AccessibilityEvent::textSelectionChanged:  return TYPE_VIEW_TEXT_SELECTION_CHANGED;

  981.             case AccessibilityEvent::textChanged:           return TYPE_VIEW_TEXT_CHANGED;

  982. 

  983.             case AccessibilityEvent::titleChanged:

  984.             case AccessibilityEvent::structureChanged:      return TYPE_WINDOW_CONTENT_CHANGED;

  985. 

  986.             case AccessibilityEvent::rowSelectionChanged:

  987.             case AccessibilityEvent::valueChanged:          break;

  988.         }

  989. 

  990.         return 0;

  991.     }();

  992. 

  993.     if (notification == 0)

  994.         return;

  995. 

  996.     const auto contentChangeTypes = [eventType]

  997.     {

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

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

  1000. 

  1001.         return 0;

  1002.     }();

  1003. 

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

  1005. }

  1006. 

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

  1008.                                              AnnouncementPriority)

  1009. {

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

  1011.         return;

  1012. 

  1013.     const auto rootView = []

  1014.     {

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

  1016. 

  1017.         if (activity != nullptr)

  1018.         {

  1019.             auto* env = getEnv();

  1020. 

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

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

  1023. 

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

  1025.         }

  1026. 

  1027.         return LocalRef<jobject>();

  1028.     }();

  1029. 

  1030.     if (rootView != nullptr)

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

  1032.                                   AndroidView.announceForAccessibility,

  1033.                                   javaString (announcementString).get());

  1034. }

  1035. 

  1036. } // namespace juce