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.
13885 Commits
9 Branches
457MB
Tree: 583f90bef3
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '583f90bef3'
${ noResults }
JUCE/modules/juce_gui_basics/native/accessibility/juce_Accessibility_android.cpp

1060 lines
45KB
Raw Blame History 

  1. /*

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

  3. 

  4.    This file is part of the JUCE library.

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

  6. 

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

  8.    licensing.

  9. 

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

  11.    Agreement and JUCE Privacy Policy.

  12. 

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

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

  15. 

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

  17.    www.gnu.org/licenses).

  18. 

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

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

  21.    DISCLAIMED.

  22. 

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

  24. */

  25. 

  26. namespace juce

  27. {

  28. 

  29. #define JUCE_NATIVE_ACCESSIBILITY_INCLUDED 1

  30. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  54. 

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

  56. #undef JNI_CLASS_MEMBERS

  57. 

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

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

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

  61. 

  62.  DECLARE_JNI_CLASS_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.         if (nativeChildViewId.has_value())

  274.             virtualViewIdMap.erase (*nativeChildViewId);

  275.     }

  276. 

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

  278. 

  279.     jobject getNativeView (int viewId) const

  280.     {

  281.         if (nativeChildViewId == viewId)

  282.             return static_cast<jobject> (AccessibilityHandler::getNativeChildForComponent (accessibilityHandler.getComponent()));

  283. 

  284.         return nullptr;

  285.     }

  286. 

  287.     void populateNodeInfo (jobject info, int infoVirtualViewId)

  288.     {

  289.         if (   AccessibilityHandler::getNativeChildForComponent (accessibilityHandler.getComponent()) != nullptr

  290.             && ! nativeChildViewId.has_value())

  291.         {

  292.             nativeChildViewId.emplace (getNextVirtualViewId());

  293.             virtualViewIdMap[*nativeChildViewId] = &accessibilityHandler;

  294.         }

  295. 

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

  297. 

  298.         const auto sourceView = getSourceView (accessibilityHandler);

  299. 

  300.         if (sourceView == nullptr)

  301.             return;

  302. 

  303.         auto* env = getEnv();

  304.         auto appContext = getAppContext();

  305. 

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

  307.             return;

  308. 

  309.         {

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

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

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

  313. 

  314.             if (nativeChildViewId.has_value() && nativeChildViewId != infoVirtualViewId)

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

  316.                                      sourceView, *nativeChildViewId);

  317. 

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

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

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

  321.         }

  322. 

  323.         {

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

  325. 

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

  327. 

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

  329. 

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

  331. 

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

  333.         }

  334. 

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

  336. 

  337.         env->CallVoidMethod (info,

  338.                              AndroidAccessibilityNodeInfo.setEnabled,

  339.                              ! state.isIgnored());

  340.         env->CallVoidMethod (info,

  341.                              AndroidAccessibilityNodeInfo.setVisibleToUser,

  342.                              true);

  343.         env->CallVoidMethod (info,

  344.                              AndroidAccessibilityNodeInfo.setPackageName,

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

  346.                                                     AndroidContext.getPackageName));

  347.         env->CallVoidMethod (info,

  348.                              AndroidAccessibilityNodeInfo.setSource,

  349.                              sourceView,

  350.                              virtualViewId);

  351.         env->CallVoidMethod (info,

  352.                              AndroidAccessibilityNodeInfo.setClassName,

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

  354.         env->CallVoidMethod (info,

  355.                              AndroidAccessibilityNodeInfo.setContentDescription,

  356.                              getDescriptionString().get());

  357. 

  358.         if (state.isFocusable())

  359.         {

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

  361. 

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

  363. 

  364.             if (component.getWantsKeyboardFocus())

  365.             {

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

  367. 

  368.                 env->CallVoidMethod (info,

  369.                                      AndroidAccessibilityNodeInfo.setFocused,

  370.                                      hasKeyboardFocus);

  371.                 env->CallVoidMethod (info,

  372.                                      AndroidAccessibilityNodeInfo.addAction,

  373.                                      hasKeyboardFocus ? ACTION_CLEAR_FOCUS : ACTION_FOCUS);

  374.             }

  375. 

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

  377. 

  378.             env->CallVoidMethod (info,

  379.                                  AndroidAccessibilityNodeInfo.setAccessibilityFocused,

  380.                                  isAccessibleFocused);

  381. 

  382.             env->CallVoidMethod (info,

  383.                                  AndroidAccessibilityNodeInfo.addAction,

  384.                                  isAccessibleFocused ? ACTION_CLEAR_ACCESSIBILITY_FOCUS

  385.                                                      : ACTION_ACCESSIBILITY_FOCUS);

  386.         }

  387. 

  388.         if (state.isCheckable())

  389.         {

  390.             env->CallVoidMethod (info,

  391.                                  AndroidAccessibilityNodeInfo.setCheckable,

  392.                                  true);

  393.             env->CallVoidMethod (info,

  394.                                  AndroidAccessibilityNodeInfo.setChecked,

  395.                                  state.isChecked());

  396.         }

  397. 

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

  399.         {

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

  401. 

  402.             env->CallVoidMethod (info,

  403.                                  AndroidAccessibilityNodeInfo.setSelected,

  404.                                  isSelected);

  405.             env->CallVoidMethod (info,

  406.                                  AndroidAccessibilityNodeInfo.addAction,

  407.                                  isSelected ? ACTION_CLEAR_SELECTION : ACTION_SELECT);

  408.         }

  409. 

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

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

  412.         {

  413.             env->CallVoidMethod (info,

  414.                                  AndroidAccessibilityNodeInfo.setClickable,

  415.                                  true);

  416.             env->CallVoidMethod (info,

  417.                                  AndroidAccessibilityNodeInfo.addAction,

  418.                                  ACTION_CLICK);

  419.         }

  420. 

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

  422.             && state.isExpandable())

  423.         {

  424.             env->CallVoidMethod (info,

  425.                                  AndroidAccessibilityNodeInfo.addAction,

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

  427.         }

  428. 

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

  430.         {

  431.             env->CallVoidMethod (info,

  432.                                  AndroidAccessibilityNodeInfo.setText,

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

  434. 

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

  436. 

  437.             env->CallVoidMethod (info,

  438.                                  AndroidAccessibilityNodeInfo.setPassword,

  439.                                  textInterface->isDisplayingProtectedText());

  440. 

  441.             if (nodeInfoSetEditable != nullptr)

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

  443. 

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

  445. 

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

  447.                 env->CallVoidMethod (info,

  448.                                      nodeInfoSetTextSelection,

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

  450. 

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

  452.                 env->CallVoidMethod (info,

  453.                                      nodeInfoSetLiveRegion,

  454.                                      ACCESSIBILITY_LIVE_REGION_POLITE);

  455. 

  456.             env->CallVoidMethod (info,

  457.                                  AndroidAccessibilityNodeInfo.setMovementGranularities,

  458.                                  ALL_GRANULARITIES);

  459. 

  460.             env->CallVoidMethod (info,

  461.                                  AndroidAccessibilityNodeInfo.addAction,

  462.                                  ACTION_NEXT_AT_MOVEMENT_GRANULARITY);

  463.             env->CallVoidMethod (info,

  464.                                  AndroidAccessibilityNodeInfo.addAction,

  465.                                  ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY);

  466.             env->CallVoidMethod (info,

  467.                                  AndroidAccessibilityNodeInfo.addAction,

  468.                                  ACTION_SET_SELECTION);

  469. 

  470.             if (! isReadOnly)

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

  472.         }

  473. 

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

  475.         {

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

  477.             {

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

  479. 

  480.                 if (range.isValid())

  481.                 {

  482.                     env->CallVoidMethod (info,

  483.                                          AndroidAccessibilityNodeInfo.addAction,

  484.                                          ACTION_SCROLL_FORWARD);

  485.                     env->CallVoidMethod (info,

  486.                                          AndroidAccessibilityNodeInfo.addAction,

  487.                                          ACTION_SCROLL_BACKWARD);

  488.                 }

  489.             }

  490.         }

  491. 

  492.         if (getAndroidSDKVersion() >= 19)

  493.         {

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

  495.             {

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

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

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

  499.                                                                                       AndroidAccessibilityNodeInfoCollectionInfo.obtain,

  500.                                                                                       (jint) rows,

  501.                                                                                       (jint) columns,

  502.                                                                                       (jboolean) false) };

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

  504.             }

  505. 

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

  507.             {

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

  509.                 jassert (interface != nullptr);

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

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

  512. 

  513.                 enum class IsHeader { no, yes };

  514. 

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

  516.                 {

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

  518.                                                                                               AndroidAccessibilityNodeInfoCollectionItemInfo.obtain,

  519.                                                                                               (jint) rows.begin,

  520.                                                                                               (jint) rows.num,

  521.                                                                                               (jint) columns.begin,

  522.                                                                                               (jint) columns.num,

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

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

  525.                 };

  526. 

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

  528.                 {

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

  530.                 }

  531.                 else

  532.                 {

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

  534.                     {

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

  536.                         {

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

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

  539. 

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

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

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

  543.                         }

  544.                     }

  545.                 }

  546.             }

  547.         }

  548.     }

  549. 

  550.     bool performAction (int action, jobject arguments)

  551.     {

  552.         switch (action)

  553.         {

  554.             case ACTION_ACCESSIBILITY_FOCUS:

  555.             {

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

  557. 

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

  559. 

  560.                 if (safeComponent != nullptr)

  561.                     accessibilityHandler.grabFocus();

  562. 

  563.                 return true;

  564.             }

  565. 

  566.             case ACTION_CLEAR_ACCESSIBILITY_FOCUS:

  567.             {

  568.                 accessibilityHandler.giveAwayFocus();

  569.                 return true;

  570.             }

  571. 

  572.             case ACTION_FOCUS:

  573.             case ACTION_CLEAR_FOCUS:

  574.             {

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

  576. 

  577.                 if (component.getWantsKeyboardFocus())

  578.                 {

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

  580. 

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

  582.                         component.giveAwayKeyboardFocus();

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

  584.                         component.grabKeyboardFocus();

  585. 

  586.                     return true;

  587.                 }

  588. 

  589.                 break;

  590.             }

  591. 

  592.             case ACTION_CLICK:

  593.             {

  594.                 // Invoking the action may delete this handler

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

  596. 

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

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

  599.                 {

  600.                     if (savedHandle != nullptr)

  601.                         sendAccessibilityEventImpl (accessibilityHandler, TYPE_VIEW_CLICKED, 0);

  602. 

  603.                     return true;

  604.                 }

  605. 

  606.                 break;

  607.             }

  608. 

  609.             case ACTION_SELECT:

  610.             case ACTION_CLEAR_SELECTION:

  611.             {

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

  613. 

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

  615.                 {

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

  617. 

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

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

  620.                     {

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

  622.                     }

  623. 

  624.                 }

  625. 

  626.                 break;

  627.             }

  628. 

  629.             case ACTION_EXPAND:

  630.             case ACTION_COLLAPSE:

  631.             {

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

  633. 

  634.                 if (state.isExpandable())

  635.                 {

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

  637. 

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

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

  640.                     {

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

  642.                     }

  643.                 }

  644. 

  645.                 break;

  646.             }

  647. 

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

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

  650. 

  651.             case ACTION_SET_SELECTION:

  652.             {

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

  654.                 {

  655.                     auto* env = getEnv();

  656. 

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

  658.                     {

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

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

  661. 

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

  663.                         {

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

  665.                         };

  666. 

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

  668.                         {

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

  670.                             {

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

  672.                             };

  673. 

  674.                             const auto start = getKey (selectionStartKey);

  675.                             const auto end   = getKey (selectionEndKey);

  676. 

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

  678.                         }

  679. 

  680.                         return {};

  681.                     }();

  682. 

  683.                     textInterface->setSelection (selection);

  684. 

  685.                     return true;

  686.                 }

  687. 

  688.                 break;

  689.             }

  690. 

  691.             case ACTION_SET_TEXT:

  692.             {

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

  694.                 {

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

  696.                     {

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

  698. 

  699.                         auto* env = getEnv();

  700. 

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

  702.                         {

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

  704.                             {

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

  706.                                                                                        AndroidBundle.getCharSequence,

  707.                                                                                        charSequenceKey.get()));

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

  709.                                                                                                   JavaCharSequence.toString));

  710. 

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

  712.                             }

  713. 

  714.                             return {};

  715.                         }();

  716. 

  717.                         textInterface->setText (text);

  718.                     }

  719.                 }

  720. 

  721.                 break;

  722.             }

  723. 

  724.             case ACTION_SCROLL_BACKWARD:

  725.             case ACTION_SCROLL_FORWARD:

  726.             {

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

  728.                 {

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

  730.                     {

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

  732. 

  733.                         if (range.isValid())

  734.                         {

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

  736.                                                                                    : range.getInterval();

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

  738.                                                               range.getMaximumValue(),

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

  740. 

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

  742.                             sendAccessibilityEventImpl (accessibilityHandler, TYPE_VIEW_SELECTED, 0);

  743.                             return true;

  744.                         }

  745.                     }

  746.                 }

  747. 

  748.                 break;

  749.             }

  750.         }

  751. 

  752.         return false;

  753.     }

  754. 

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

  756. 

  757.     static bool areAnyAccessibilityClientsActive()

  758.     {

  759.         auto* env = getEnv();

  760.         auto appContext = getAppContext();

  761. 

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

  763.         {

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

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

  766. 

  767.             if (accessibilityManager != nullptr)

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

  769.         }

  770. 

  771.         return false;

  772.     }

  773. 

  774.     template <typename ModificationCallback>

  775.     static void sendAccessibilityEventExtendedImpl (const AccessibilityHandler& handler,

  776.                                                     int eventType,

  777.                                                     ModificationCallback&& modificationCallback)

  778.     {

  779.         if (! areAnyAccessibilityClientsActive())

  780.             return;

  781. 

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

  783.         {

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

  785. 

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

  787.                 return;

  788. 

  789.             auto* env = getEnv();

  790.             auto appContext = getAppContext();

  791. 

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

  793.                 return;

  794. 

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

  796.                                                                   AndroidAccessibilityEvent.obtain,

  797.                                                                   eventType));

  798. 

  799.             env->CallVoidMethod (event,

  800.                                  AndroidAccessibilityEvent.setPackageName,

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

  802.                                                         AndroidContext.getPackageName));

  803. 

  804.             env->CallVoidMethod (event,

  805.                                  AndroidAccessibilityEvent.setSource,

  806.                                  sourceView,

  807.                                  nativeImpl->getVirtualViewId());

  808. 

  809.             modificationCallback (event);

  810. 

  811.             env->CallBooleanMethod (sourceView,

  812.                                     AndroidViewGroup.requestSendAccessibilityEvent,

  813.                                     sourceView,

  814.                                     event.get());

  815.         }

  816.     }

  817. 

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

  819.     {

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

  821.         {

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

  823.                 getEnv()->CallVoidMethod (event,

  824.                                           accessibilityEventSetContentChangeTypes,

  825.                                           contentChangeTypes);

  826.         });

  827.     }

  828. 

  829. private:

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

  831. 

  832.     static int getNextVirtualViewId()

  833.     {

  834.         static int counter = 0;

  835. 

  836.         return counter++;

  837.     }

  838. 

  839.     static int getVirtualViewIdForHandler (const AccessibilityHandler& handler)

  840.     {

  841.         if (handler.getComponent().isOnDesktop())

  842.             return HOST_VIEW_ID;

  843. 

  844.         return getNextVirtualViewId();

  845.     }

  846. 

  847.     LocalRef<jstring> getDescriptionString() const

  848.     {

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

  850.         {

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

  852.                 return textInterface->getAllText();

  853. 

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

  855.                 return valueInterface->getCurrentValueAsString();

  856. 

  857.             return {};

  858.         }();

  859. 

  860.         StringArray strings (accessibilityHandler.getTitle(),

  861.                              valueString,

  862.                              accessibilityHandler.getDescription(),

  863.                              accessibilityHandler.getHelp());

  864. 

  865.         strings.removeEmptyStrings();

  866. 

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

  868.     }

  869. 

  870.     bool moveCursor (jobject arguments, bool forwards)

  871.     {

  872.         using ATH = AccessibilityTextHelpers;

  873. 

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

  875. 

  876.         if (textInterface == nullptr)

  877.             return false;

  878. 

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

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

  881. 

  882.         auto* env = getEnv();

  883. 

  884.         const auto boundaryType = [&]

  885.         {

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

  887. 

  888.             using BoundaryType = ATH::BoundaryType;

  889. 

  890.             switch (granularity)

  891.             {

  892.                 case MOVEMENT_GRANULARITY_CHARACTER:  return BoundaryType::character;

  893.                 case MOVEMENT_GRANULARITY_WORD:       return BoundaryType::word;

  894.                 case MOVEMENT_GRANULARITY_LINE:       return BoundaryType::line;

  895.                 case MOVEMENT_GRANULARITY_PARAGRAPH:

  896.                 case MOVEMENT_GRANULARITY_PAGE:       return BoundaryType::document;

  897.             }

  898. 

  899.             jassertfalse;

  900.             return BoundaryType::character;

  901.         }();

  902. 

  903.         const auto direction = forwards

  904.                              ? ATH::Direction::forwards

  905.                              : ATH::Direction::backwards;

  906. 

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

  908.                           ? ATH::ExtendSelection::yes

  909.                           : ATH::ExtendSelection::no;

  910. 

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

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

  913.         textInterface->setSelection (newSelection);

  914. 

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

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

  917.         {

  918.             env->CallVoidMethod (event,

  919.                                  AndroidAccessibilityEvent.setAction,

  920.                                  forwards ? ACTION_NEXT_AT_MOVEMENT_GRANULARITY : ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY);

  921. 

  922.             env->CallVoidMethod (event,

  923.                                  AndroidAccessibilityEvent.setFromIndex,

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

  925.                                                                                     : oldSelection.getEnd());

  926. 

  927.             env->CallVoidMethod (event,

  928.                                  AndroidAccessibilityEvent.setToIndex,

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

  930.                                                                                     : newSelection.getEnd());

  931.         });

  932. 

  933.         return true;

  934.     }

  935. 

  936.     AccessibilityHandler& accessibilityHandler;

  937.     const int virtualViewId;

  938.     std::optional<int> nativeChildViewId;

  939.     bool inPopulateNodeInfo = false;

  940. 

  941.     //==============================================================================

  942.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (AccessibilityNativeHandle)

  943. 

  944.     JUCE_DECLARE_WEAK_REFERENCEABLE (AccessibilityNativeHandle)

  945. };

  946. 

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

  948. 

  949. class AccessibilityHandler::AccessibilityNativeImpl : public AccessibilityNativeHandle

  950. {

  951. public:

  952.     using AccessibilityNativeHandle::AccessibilityNativeHandle;

  953. };

  954. 

  955. //==============================================================================

  956. AccessibilityNativeHandle* AccessibilityHandler::getNativeImplementation() const

  957. {

  958.     return nativeImpl.get();

  959. }

  960. 

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

  962.                                                              Event eventType)

  963. {

  964.     if (eventType == Event::elementCreated

  965.         || eventType == Event::elementDestroyed

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

  967.     {

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

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

  970. 

  971.         return;

  972.     }

  973. 

  974.     auto notification = [&handler, eventType]

  975.     {

  976.         switch (eventType)

  977.         {

  978.             case Event::focusChanged:

  979.                 return handler.hasFocus (false) ? TYPE_VIEW_ACCESSIBILITY_FOCUSED

  980.                                                 : TYPE_VIEW_ACCESSIBILITY_FOCUS_CLEARED;

  981. 

  982.             case Event::elementCreated:

  983.             case Event::elementDestroyed:

  984.             case Event::elementMovedOrResized:

  985.             case Event::windowOpened:

  986.             case Event::windowClosed:

  987.                 break;

  988.         }

  989. 

  990.         return 0;

  991.     }();

  992. 

  993.     if (notification != 0)

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

  995. }

  996. 

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

  998. {

  999.     auto notification = [eventType]

  1000.     {

  1001.         switch (eventType)

  1002.         {

  1003.             case AccessibilityEvent::textSelectionChanged:  return TYPE_VIEW_TEXT_SELECTION_CHANGED;

  1004.             case AccessibilityEvent::textChanged:           return TYPE_VIEW_TEXT_CHANGED;

  1005. 

  1006.             case AccessibilityEvent::titleChanged:

  1007.             case AccessibilityEvent::structureChanged:      return TYPE_WINDOW_CONTENT_CHANGED;

  1008. 

  1009.             case AccessibilityEvent::rowSelectionChanged:

  1010.             case AccessibilityEvent::valueChanged:          break;

  1011.         }

  1012. 

  1013.         return 0;

  1014.     }();

  1015. 

  1016.     if (notification == 0)

  1017.         return;

  1018. 

  1019.     const auto contentChangeTypes = [eventType]

  1020.     {

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

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

  1023. 

  1024.         return 0;

  1025.     }();

  1026. 

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

  1028. }

  1029. 

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

  1031.                                              AnnouncementPriority)

  1032. {

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

  1034.         return;

  1035. 

  1036.     const auto rootView = []

  1037.     {

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

  1039. 

  1040.         if (activity != nullptr)

  1041.         {

  1042.             auto* env = getEnv();

  1043. 

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

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

  1046. 

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

  1048.         }

  1049. 

  1050.         return LocalRef<jobject>();

  1051.     }();

  1052. 

  1053.     if (rootView != nullptr)

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

  1055.                                   AndroidView.announceForAccessibility,

  1056.                                   javaString (announcementString).get());

  1057. }

  1058. 

  1059. } // namespace juce