{'fraction_non_alphanumeric': 0.02639534232771651, 'fraction_numerical': 0.005262273974136483, 'mean_word_length': 4.84634266077565, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 0, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 3, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Developing Accessible Mobile Applications with Cross-Platform Development Frameworks

This contribution investigates how cross-platform development frameworks (CPDF) support the creation of mobile applications that are accessible to people with visual impairments through screen readers. We first systematically analyze screen-reader APIs available in native iOS and Android, and we examine whether and at what level the same functionalities are available in two popular CPDF: Xamarin and React Native. This analysis unveils that there are many functionalities shared between native iOS and Android APIs, but most of them are not available in React Native or Xamarin. In particular, not even all basic APIs are exposed by the examined CPDF. Accessing the unavailable APIs is still possible, but it requires an additional effort by the developers who need to know native APIs and to write platform specific code, hence partially negating the advantages of CPDF. To address this problem, we consider a representative set of native APIs that cannot be directly accessed from React Native and Xamarin and show sample implementations for accessing them.


Introduction
When mobile developers write native code, they interact with the operating system (OS) through application program interfaces (APIs) exposed by the OS itself or by additional platform-specific development frameworks, which we label together as system APIs. Normally, each platform has its own set of system APIs, accessed through platform-specific programming languages. Therefore, applications intended for multiple platforms generally need to be developed separately for each different platform.
To address this problem, cross-platform development frameworks (CPDF) wrap the system APIs for different platforms into their own APIs, which are consistent among different platforms and can be accessed through a single programming language. Thus, using CPDF, developers can easily implement cross platform applications, writing the code only once. This is particularly useful for mobile development since two distinct popular platforms exist, namely iOS and Android. For example, both iOS and Android APIs define their own button view 1 . CPDFs define their own button implementations that are then converted to the actual native iOS or Android buttons. Since CPDF wrap many of the commonly used system APIs, they have been shown to reduce projects' development and maintenance costs [1].
One problem with CPDF, however, is that some of the native APIs are not accessible through them. The developers can still access these APIs, but they need to write platform-specific code, which means that the same function needs to be written once for each target platform. This is not only time-consuming, but it also requires the developer to know the native APIs, hence limiting the advantages of CPDF themselves.
Previous contributions uncover that many accessibility-related APIs are unavailable in CPDF, in particular those needed to interact with the screen reader [11, 3,7]. However, to the best of our knowledge, the problem of how CPDFs support the development of accessible applications has never been systematically analyzed.
To address this problem, this paper presents three contributions: first, it reports a detailed comparison of mobile screenreaders APIs obtained through a systematical analysis of iOS and Android platforms documentation. This comparison shows that the two considered native platforms expose many functionally equivalent screen-reader related APIs. The second contribution is the analysis of how CPDF wrap these native APIs. We show that React Native and Xamarin, two of the most adopted CPDFs, only wrap about half and one third of the screen reader-related APIs shared by iOS and Android, respectively. Even worse, the two considered CPDFs do not even expose all the basic accessibility APIs (a definition of basic accessibility API is provided in the following). The third contribution consists in showing how to access the APIs that are not wrapped by CPDF. Considering a representative set of APIs, we show examples for accessing them in Xamarin and React Native, with platform-specific code. A set of example apps, each available in iOS, Android, React Native and Xamarin is introduced in this paper and is available online 2 . 1 A view is the basic building block for creating user interface components such as buttons.

Mobile Assistive Technologies and screen readers
Mobile devices are currently accessible to many people with disabilities, including people with upper limb mobility impairments, people with low vision, and blind people. To achieve this, mobile operating systems allow people with disabilities to personalize how they interact with the device, for example providing a magnifier to people with low vision. In this paper we focus on mobile assistive technologies for people who are blind or have a severe visual impairment and cannot rely solely on their residual sight to interact with the device. In such cases the assistive technology commonly used is the screen reader, which verbally describes elements on the screen [6]. Both Android and iOS mobile platforms present screen reading software. On iOS, Voice Over screen reader is part of the OS itself and third party solutions cannot be used. Android, instead, exposes APIs that enable third parties to develop screen readers. In practice, however, Talk Back screen reader, provided by Google, is most commonly used 3 . Hence in this paper we only take into account Talk Back and Voice Over.
Screen readers can render any application accessible, also those developed by a third party. In some cases an application can be (at least partially) accessible through a screen reader even though the application developer does not take explicit actions to enable screen reader accessibility. However, creating fully accessible apps often requires intervention from the developers. For example the developer has to specify the alternative text for images so that the screen reader can read them aloud. This form of intervention can be achieved though screen reader APIs that developers can use to interact with the screen-reader or to personalize its behaviour. The screen reader APIs of the two considered screen readers expose a number of shared functions, which characterize the fundamental non-visual interaction, but they also differ for a number of system-specific features, for example VoiceOver enables the use of a rotor gesture which is unavailable on TalkBack.

Cross-Platform Development Frameworks
Cross-platform development can be achieved with four approaches: web apps, hybrid apps, interpreted apps, and generated apps [10]. The first two approaches use web technologies and therefore may suffer from an overhead during interaction. Instead, in the latter two approaches, native code is automatically generated to create the user interface, which yields better performance [9], hence resulting in a better user experience. Indeed these are the ones adopted by the most recent technologies, including Xamarin and React Native.
To the best of our knowledge, no peer-reviewed publication compares the diffusion of CPDF. However, according to a 2019 survey conducted by StackOverflow 4 , React Native emerges as the most popular CPDF, followed by Xamarin. For this reason this paper focuses on these two technologies that we briefly introduce in the following.

React Native
React Native 5 is a CPDF based on the interpreted app approach [10]. The programming language is JSX, which is an extension of JavaScript that allows the developer to specify user interface with a markup code similar to XML. At compile-time this code is converted into bare JavaScript that is then interpreted at run time. The user interface is also generated at run time by first creating an abstract representation of the views and then transmitting it to the React Native library that eventually converts it into the actual user interface composed of native view elements. Therefore, APIs related to user interface are exposed through the defined JSX syntax, while other system APIs are exposed in the form of JavaScript classes.
In case a system API is not exposed by React Native, the developer can use two approaches, one based on native modules, the other on native components. With native modules the developer can define functions in platform-specific code and then call these functions from the JSX code. Native components, instead, allow the developer to specify views in platform-specific code and use them from the JSX code. In both cases the developer needs to know native APIs and to write platform-specific code in native languages, i.e., Objective-C for iOS and in Java for Android.

Xamarin
Xamarin 6 is a CPDF based on the generated app approach [10]. Applications are written in C# and then converted into native code. As depicted in Figure 1, the framework wraps all native APIs from iOS and Android into platform-specific APIs that are exposed to the C# code but are distinct for the two native platforms. To allow the developer to write the code only once, Xamarin also includes some libraries (e.g., Essentials and Forms) that remap platform-specific APIs into cross-platform APIs. For example, using Forms the developer can insert a button view only once and this will result in inserting a native button in the target native platform (iOS or Android). At run-time the right platform-specific APIs are 3 Note that Talk Back is often distributed as a pre-installed application on Android, but it is a standalone app, not part of the OS.  One problem is that these cross-platforms libraries only remap some of the platform-specific APIs. To provide access to platform-specific APIs that are not remapped into cross-platform APIs, Xamarin offers two approaches. One, called dependency service, allows the developer to define a method that can be called from cross-platform code and whose implementation is specified in platform-specific code. The second approach is based on custom renderer and allows the developer to personalize cross-platform views defined in Forms, including their aspect and behaviour.
One advantage with respect to React Native is that accessing the platform-specific APIs the developers write code in C# only and do not need to use other programming languages; however, similarly to React Native, the developers still need to know how platform-specific APIs work.
Note that in this paper we say that the platform-specific APIs that are not remapped into cross-platform APIs are not wrapped (or exposed) by Xamarin; strictly speaking this is improper, because they are actually wrapped from native code to platform-specific libraries. However, since we are interested in cross-platform APIs, in analogy with the terminology that we use for React Native we say that they are not wrapped (or exposed).

Native Screen-reader API
We conducted an analysis of screen reader APIs by considering the development documentation for iOS and Android platforms and by experimenting with the actual implementation, as described in the following of this paper. We created a taxonomy of the identified APIs based on the conceptual functionality they expose to the developer. The result of this analysis is shown in Table 1, which lists the 25 identified API functionalities and their availability in the four considered platforms (native iOS, native Android, React Native, Xamarin). Tables 3 and 4 (see "Supplementary Materials" appendix) report additional information on how each API is implemented. Table 1 also indicates which APIs implement basic screen reader functionalities. To classify basic functionalities we took into account the accessibility principles and best practices presented in introductory accessibility documentation by Apple and Google [2,5]. Then, we considered the APIs mentioned in these resources as the basic ones.
The identified APIs are organized into five categories, described in details in the following.

Accessibility focus
A basic principle in mobile screen-readers interaction is that the user can select a view, hear its description and then possibly activate it. When a view is selected, we say it receives the accessibility focus; at most one view can have the accessibility focus at the same time. Not all views should receive the accessibility focus. For example, an image should not receive the accessibility focus if it purpose is solely to improve the quality of the visual presentation. Screen reader API #1 allows the developer to specify which views should receive the accessibility focus 7 .
There are two possible forms of interaction to move the accessibility focus among views: with the sliding exploration the user slides the finger on the screen and a view gets the accessibility focus once touched. Instead, with the sequential exploration the user enters right/left swipe gestures that move the focus sequentially towards the next/previous view. This latter interaction requires the views to be ordered with a numerical index called accessibility focus order. Screen-reader Associate arbitrary accessibility-related information to a view API #2 allows the developer to personalize the accessibility-focus order. When not explicitly specified by the developer, the accessibility focus order is automatically derived from views' position on the screen. There are situations in which a developer needs to programmatically assign the accessibility focus to a view (API #3), for example when the keyboard is shown, and the developer wants to set the accessibility focus to the first key. Similarly, the developer might want to run arbitrary code when a view receives or loses the accessibility focus (API #4), for example by playing an audio cue when an icon is selected (an interaction technique commonly known as audio-icons [4]). Finally, the developer may need to determine which view has the accessibility focus (API #5). Table 1 shows that iOS and Android expose functionally equivalent APIs for all these functionalities.

Text to announce
When a view receives the accessibility focus, the screen-reader needs to read aloud the textual description associated to it. This textual description, which we call text-to-announce, can be defined by the developer. VoiceOver and TalkBack adopt two different approaches to allow the developer to personalize the text-to-announce. In iOS the developer can specify, for each view, some attributes that VoiceOver uses to compute the text-to-announce. For example, accessibilityLabel is a text that identifies the view and that forms the first part of the text-to-announce; similarly accessibilityHint specifies the effects of the interaction and is one of the last pieces of information forming the text-to-announce. Similarly to iOS, Android allows the developer to specify a field, called contentDescription, which is a textual attribute that can be read as part of the text-to-announce. However, differently from iOS, in Android the developer can also programmatically specify the text-to-announce. So there are cases in which contentDescription, although specified, is ignored. For example, a view containing editable text announces the contentDescription when the contained text is empty, and otherwise it announces the contained text ignoring the contentDescription. This difference is captured by APIs #6, which is exposed by iOS and Android, and #7, exposed by Android only.
There are other two APIs differentiating the two platforms and that are exposed by Android and not by iOS. The first API (#8) allows the developer to specify that one view describes another one, as for example in the case of a label describing an editable text field. The second difference is in API #9, to specify that a view should be announced also when the user is not interacting with it (e.g., an "incorrect password" label that is shown during a login procedure).
Finally, both native platforms allow the developer to specify the language of the text-to-announce (#10).

Explicit text-to-speech
The text-to-announce is read aloud by a text-to-speech (TTS) software. The same TTS can also be used by the developer to programmatically read a text aloud. This is useful, for example, to inform the user that a view has moved. iOS and Android provide two ways to access the TTS (APIs #11 and #14): as an accessibility function (which we call screen reader TTS) and as a functionality unrelated to accessibility (non-screen reader TTS). In the former case the text will be read aloud only when the screen reader is running, while in the latter case the text is also read aloud when the screen reader is off. In both cases, it is often necessary to synchronize the TTS output with other audio output (in many situations the developer does not want two or more audio outputs to overlap). This is possible for both types of TTS on iOS (APIs #12 and #15), and with the non-screen reader TTS only on Android (API #15).
iOS and Android also expose API #17 to personalize how the TTS reads the text aloud, for example changing the language, the speed, etc. With iOS this can be personalized also for screen reader TTS (API #13).

Accessibility tree
In iOS and Android a view can contain other views. In this case we say that the former is a container. The contained-in relationship among views defines a structure, which we call view tree: each view can be either a container or a leaf node (i.e., a non-container view) and there is a single container that acts as a root (it represents the entire screen).
There is also a similar tree, which we call accessibility tree, that represents the view tree from the point of view of a screen reader. We call accessible element the nodes in the accessibility tree and, as we detail in the following, each accessible element can correspond to a view, a group of views or a portion of a view.
By default, the views and accessibility trees coincide. However, there are two cases in which it is convenient to differentiate them. One case is when there are multiple views that should be presented as a single accessibility element. Consider for example a list in which each cell is composed of many views: by aggregating these views in a single accessible element the user can find list elements more easily using sliding exploration and can scroll it faster using sequential exploration. This behaviour can be implemented in iOS, but the developer should specify the code to aggregate multiple views in a single accessible element 8 . Instead, in Android a single API (#18) can be used to conveniently implement this.
The other case in which it is convenient to differentiate the view and accessibility trees is when a single view contains multiple pieces of information that should be provided individually to the user. Consider for example an image that can be tapped in various positions to trigger different actions. In this case the image view can be divided into multiple accessible elements, each one representing different portions of the image and triggering different actions. Both iOS and Android expose APIs to implement this (see #19).
iOS and Android also provide APIs to navigate the accessibility tree and in particular to get the parent accessibility element (API #20).

Miscellaneous
iOS and Android allow the developer to query whether the screen reader is active (API #21). This is useful, for example, when the developer wants to personalize the app behaviour for screen reader users or to remotely log screen reader usage data so that app accessibility can be evaluated and eventually improved.
In this category Android exposes three APIs that are not available in iOS. The first (#22) allows the developer to specify that a view is a header, which helps the user to navigate in the screen. The second (#24) can be used to programmatically trigger view events (e.g., activate a button); this can be used to support interaction automation within the app. The last API (#25) allows the developer to associate arbitrary information related to accessibility with any view. This information can be used, for example, to personalize the text-to-speech with code specifically designed for this purpose.
One set of APIs (#23) in this category is instead exposed by iOS and not by Android. It allows to define actions that can be triggered only when the screen reader is active. Among others, these APIs allow the developer to define actions that are specific to VoiceOver, like the rotor actions and the magic tap 9 .

CPDF Screen reader API availability
The last two columns of Table 1 report whether each functionality is available in React Native or Xamarin, respectively. We denote that the functionality is available ( symbol) in two cases: (i) when both iOS and Android expose a functionally equivalent API that is wrapped by the CPDF producing the same behaviour on both platforms, and (ii) when an API is available in either iOS or Android and the CPDF wraps the API for that native platform, producing the expected behaviour in it and not in the other native platform. We indicate that a API is not exposed by a CPDF with the symbol, while we use the symbol to denote that the API is exposed by the CPDFs, but with a possibly different behaviour in the two native platforms.
In Table 1 we can observe that in most cases (14 out of 25), the same functionality is available on both iOS and Android. In all of these cases it would be possible for CPDF to wrap native APIs into a single cross-platform API, so that the developers can easily access the native APIs for that functionality. In practice, however, this is not the case in both the examined CPDF and, in particular in Xamarin. Indeed, out of the 14 functionalities shared by iOS and Android, only 8 and 5 are wrapped into React Native and Xamarin APIs, respectively. For the APIs that are exposed by only one native platform, it could still be possible for CPDF to wrap the API for that platform. Again, this is only rarely the case. Indeed, out of 11 API exposed by iOS or Android (but not both), only 5 and 2 are wrapped by React Native and Xamarin, respectively. The situation is only slightly better considering basic functionalities only. Indeed, out of 8 basic functionalities, only 6 and 5 are available in React Native and Xamarin, respectively. In the following of this section we detail API availability for each category.

Accessibility focus
For this category, iOS and Android expose functionally equivalent APIs. React Native and Xamarin, instead, do not expose some APIs, including #2 (React Native), #3 (Xamarin), #4 and #5 (both). Interestingly, the functionality to specify the accessibility focus order (#2) which is not exposed by React Native is a basic accessibility functionality.

Text-to-announce
As explained above, iOS and Android expose a different specification of the text-to-announce (API #6). However, this difference is not well captured by the APIs exposed by React Native and Xamarin. For example, both CPDFs allow the developer to specify a field (accessibilityLabel in ReactNative and AutomationProperties.SetName in Xamarin) that wraps the field accessibilityLabel for iOS and contentDescription for Android. However these two fields produce a similar but not identical behaviour, and this can lead to unexpected results when developing with ReactNative or Xamarin.
Another problem arises in Xamarin again for API #6: text fields (e.g., Label or Entry) erroneously wrap the Automation-Properties.SetName field to the Android hint attribute, which is not designed for accessibility. The results into two possibly unpredictable behaviours. First the AutomationProperties.SetName attribute is correctly read as part of the text-to-announce only when the text field is empty. Second, when the text field is empty, the hint text is shown, which is unexpected for a field that should specify the text-to-announce.
Both React Native and Xamarin do not provide support for APIs #7 and #10. Instead, React Native supports API #9 while Xamarin expose API #8, which is a basic accessibility functionality.

Explicit TTS.
React Native exposes most APIs in this category, supporting both screen reader TTS and non-screeen reader TTS. The only APIs that are not exposed are #13 and #16.
Instead, Xamarin does not support any API related to screen reader TTS and only supports non-screen reader TTS (APIs #14 and #17). Note, in particular, that Xamarin does not expose API #11, which is a basic accessibility functionality.

Accessibility tree
While iOS and Android present functionally equivalent APIs (with the only exception of API #18 that, however, is not strictly necessary), React Native and Xamarin only expose API #18.

Miscellaneous
Xamarin does not expose any APIs in this category, including #22 and #23 that are basic accessibility functionalities. Instead, React Native exposes API #21, #22 and #23, including those to manage iOS rotor. However, no support is provided for API #24 and #25.

Implementation
In this section we describe the sample code that we distribute online and we overview the main technical challenges arising when accessing the native APIs that are not wrapped by React Native and Xamarin.

Sample apps
We selected a subset of the APIs from Table 1 (including all basic functionalities) and for each of them we designed a sample app, which we then implemented for the considered platforms (iOS, Android, React Native and Xamarin). The source code is available online 2 . Figure 2 shows some examples. In particular, Figure 2a shows the sample app for API #1 implemented in native iOS: the app shows three buttons and initially they can all receive the accessibility focus; activating the first button results in the third button to become not focusable any more. Figure 2b shows the sample app for API #2 implemented in native Android: the app shows four buttons. Initially the accessibility focus order is the same as the visual order but when the first button is activated the accessibility focus order is changed. The third example (see Figure 2c) is the sample app for API #3 implemented in React Native and deployed to Android. The app shows three buttons: when the first one is activated, the accessibility focus is assigned to Button 3. Figure 2d shows the sample app for API #4 implemented in Xamarin and deployed to iOS. The app shows two buttons: when the second one receives the accessibility focus, it changes its color and label.
As detailed in Table 2, we implemented each sample app in native code (iOS and Android) and in the two considered CPDF, each being deployable both in iOS and Android. In few cases the implementation is missing (denoted with an empty cell in Table 2) because it is not supported by the given native platform and it is not possible to implement it using a combination of other APIs (e.g., the rotor is not available in Android). We classify the sample apps depending on how the accessibility functionality is implemented: • Direct API use: the accessibility functionality is implemented directly using the API exposed by the platform ( symbol); • Semi-direct API use: the accessibility functionality is not exposed by the platform API, but a similar behaviour can still be achieved by using a combination of APIs exposed by the platform ( symbol); • Native API use (for applications developed in CPDF only): APIs are not exposed by the platform and the implementation requires to access native APIs ( symbol).
For example, functionality #1 can be implemented with direct API use in all four platforms, as they all expose API for this. Instead, iOS does not expose an API for functionality #8, but it still can be implemented with semi-direct API use, because it can be implemented using a combination of API #1 and #6 (both available in iOS). An example of native API use is functionality #4 in React Native: no API is available and it is not possible to implement the functionality using a combination other APIs available in the platform, hence it is necessary to use the native APIs available in iOS and Android. From Table 2 we can observe that implementing a functionality in CPDF is not possible if the API is not available in the target native platform. For example, consider API #22: is not available in iOS, hence cannot be implemented in React Native or Xamarin when deploying to iOS. Similarly, the implementation in CPDF is at least as difficult as in native code (native API use is more difficult than semi-direct APi use that is more difficult than direct API use). There is only one exception for API #18: this functionality can be implemented in iOS with semi-direct API use. However, React Native exposes an API that automatically implements the same behaviour of the Android call also in iOS. For this reason we report it as a direct API use.

Implementation challenges and effort
Considering the Xamarin implementation, as described in Table 2, we developed six sample apps using native API use: #3, #4, #8, #11, #22, #23. All of them have been implemented using dependency services except for sample app for API #4, for which it was necessary to use custom renderers. In both cases (dependency services and custom renderers) one challenge for the developer is to be aware of the Android and iOS native APIs, their (sometimes subtle) differences, and how they are wrapped into the C# platform-specific APIs. This typically requires the developer to deal with the documentation for native iOS, native Android, Xamarin.iOS and Xamarin.Android. An additional challenge with custom renderers is that the developer also needs to know how Xamarin Forms renderers work, and to be aware of all the classes involved in this part of the code.
To give an idea of the effort required to create accessible application in Xamarin, we report, as an example, our own experience with the sample apps, created by a novice Xamarin developer (a co-author of this paper) supported by two professional Xamarin developers, with 1 and 3 years of experience in Xamarin development, respectively, and a team of experts in mobile accessibility on native platforms. Each sample app with direct API use required about one hour of development time, requiring limited support. The development time was similar for the applications based on semi-direct API use, but in some cases some support was needed by the team of experts in mobile accessibility to define how to combine exposed API to implement the expected behaviour. Instead, sample apps with native API use required a much higher effort. In particular, those created using dependency services required about 2 hours of development each, and the intervention of the professional developers. Sample app for API #4, which required to use custom renderers required several weeks of investigation and despite the involvement of both supervising developers we were still unable to solve the problem. Eventually, we succeeded after receiving help from the official Xamarin support provided by a Microsoft developer.
Considering the implementation in React Native, sample apps for API #2 and #4 were developed with native API use. This required, for each sample app, to develop a native component, which is composed of a few classes in native Android and iOS, hence written in Java and ObjectiveC, respectively. Each native component implements the accessibility functionalities by accessing native APIs and exposing them to the remaining of the React Native code. Similarly to what happens with Xamarin, the developer needs to know the native accessibility APIs. However, in the case on React Native the developer also needs to know how to code in native programming languages (Java and ObjectivC) and how the React Native native libraries work, and this is particularly challenging due to the fact that they are poorly documented.
Also in this case we report out experience with the development of the sample apps, created by one of the co-authors of this paper who is a professional developer with more than 3 years of experience in development with React Native and no previous experience in the development of native components. On average, he required less than one hour for each of the sample apps requiring direct or semi-direct API use. Instead, he required more than 10 days to complete sample app for API #4 on Android and he also needed to be supported by another experienced iOS developer to complete the iOS native component.

Conclusions and future work
It is well known that many applications, including those for mobile devices, have accessibility issues [8]. In some cases, this is due to a lack of knowledge by the developers, who are not aware of the needs of people with disabilities, or do not know how to address these needs with the existing technology.
This paper uncovers a different problem: while native development platforms offer a broad range of APIs to develop accessible applications, many of these APIs are not wrapped by CPDF. This means, for example, that a developer who is aware of the needs of people with visual impairments and who knows the native APIs to guarantee accessibility, will still struggle to implement accessibility functionalities in React Native and Xamarin. As we show in this paper, the developer can still implement these functionalities, but this require a higher development effort; in a commercial project this implies higher costs, hence it lowers the chances that the functionality is actually implemented.
Another relevant contribution of this paper is that it lists the accessibility functionalities exposed by iOS and Android. We do not have formal guarantees that this list is complete, but it represents a starting point for a discussion in the scientific and technical community. We believe that the list of accessibility APIs represents a valid technical reference documentation. It can be used by developers interested in creating accessible applications, including in particular mobile assistive technologies. Also, developers of new CPDFs and mobile OSs can refer to this paper to quickly understand which accessibility functions they need to implement. This paper analyses an involved technical scenario and identifies a new relevant problem, hence paving the way for a number of follow-up research directions and technical interventions. On one side, this paper suggests that CPDF can contribute to the development of applications presenting accessibility issues. This hypothesis can be verified in the future, for example with large scale studies, like the one conducted by Ross et al. [8]. The same methodology presented in this paper can be adapted to analyze the accessibility of other systems, for example traditional devices (desktop computers) and pervasive ones, or to address the accessibility to mobile devices by people with other forms of disabilities, like low vision. On the technical side, this paper identifies a intervention checklist for the development community to implement new functionalities in React Native and Xamarin. Both platforms are open source and hence it is possible to contribute in the development of new functionalities, which we intend to do. In the future we also intend to consider other CPDFs, including Flutter.  Tables 3 and 4 report how APIs are implemented in native and CPDF platforms respectively. Some of the APIs are available both as dynamic methods that can be called in the code and as static properties that can be set in XML view representations.

Supplementary Materials
In Tables 3 and 4 we report the dynamic methods and indicate with the ○ symbol when a static property is also available. For React Native we instead report the XML attributes (no dynamic code is available in many cases).