pdfbox c# port : Creating bookmarks in pdf documents application Library tool html asp.net .net online android-cdd1-part524

MUST provide the user with per-app App Links controls in Settings as follows:
The user MUST be able to override holistically the default app links behavior for
an app to be: always open, always ask, or never open, which must apply to all
candidate URI intent filters equally.
The user MUST be able to see a list of the candidate URI intent filters.
The device implementation MAY provide the user with the ability to override
specific candidate URI intent filters that were successfully verified, on a per-
intent filter basis.
The device implementation MUST provide users with the ability to view and
override specific candidate URI intent filters if the device implementation lets
some candidate URI intent filters succeed verification while some others can
fail.
3.2.3.3. Intent Namespaces
Device implementations MUST NOT include any Android component that honors any new intent or
broadcast intent patterns using an ACTION, CATEGORY, or other key string in the android.* or
com.android.* namespace. Device implementers MUST NOT include any Android components that
honor any new intent or broadcast intent patterns using an ACTION, CATEGORY, or other key string
in a package space belonging to another organization. Device implementers MUST NOT alter or
extend any of the intent patterns used by the core apps listed in section 3.2.3.1
. Device
implementations MAY include intent patterns using namespaces clearly and obviously associated with
their own organization. This prohibition is analogous to that specified for Java language classes in
section 3.6
.
3.2.3.4. Broadcast Intents
Third-party applications rely on the platform to broadcast certain intents to notify them of changes in
the hardware or software environment. Android-compatible devices MUST broadcast the public
broadcast intents in response to appropriate system events. Broadcast intents are described in the
SDK documentation.
3.2.3.5. Default App Settings
Android includes settings that provide users an easy way to select their default applications, for
example for Home screen or SMS. Where it makes sense, device implementations MUST provide a
similar settings menu and be compatible with the intent filter pattern and API methods described in the
SDK documentation as below.
Device implementations:
MUST honor the android.settings.HOME_SETTINGS intent to show a default app settings
menu for Home Screen, if the device implementation reports
android.software.home_screen [Resources, 10
]
MUST provide a settings menu that will call the
android.provider.Telephony.ACTION_CHANGE_DEFAULT intent to show a dialog to
change the default SMS application, if the device implementation reports
android.hardware.telephony [Resources, 11
]
MUST honor the android.settings.NFC_PAYMENT_SETTINGS intent to show a default
app settings menu for Tap and Pay, if the device implementation reports
android.hardware.nfc.hce [Resources, 10
]
3.3. Native API Compatibility
Page 11 of 74
Creating bookmarks in pdf documents - add, remove, update PDF bookmarks in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Empower Your C# Project with Rapid PDF Internal Navigation Via Bookmark and Outline
bookmark pdf in preview; creating bookmarks pdf
Creating bookmarks in pdf documents - VB.NET PDF bookmark library: add, remove, update PDF bookmarks in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Empower Your VB.NET Project with Rapid PDF Internal Navigation Via Bookmark and Outline
bookmarks pdf reader; creating bookmarks in pdf files
3.3.1. Application Binary Interfaces
Managed Dalvik bytecode can call into native code provided in the application .apk file as an ELF .so
file compiled for the appropriate device hardware architecture. As native code is highly dependent on
the underlying processor technology, Android defines a number of Application Binary Interfaces (ABIs)
in the Android NDK. Device implementations MUST be compatible with one or more defined ABIs, and
MUST implement compatibility with the Android NDK, as below.
If a device implementation includes support for an Android ABI, it:
MUST include support for code running in the managed environment to call into native
code, using the standard Java Native Interface (JNI) semantics
MUST be source-compatible (i.e. header compatible) and binary-compatible (for the ABI)
with each required library in the list below
MUST support the equivalent 32-bit ABI if any 64-bit ABI is supported
MUST accurately report the native Application Binary Interface (ABI) supported by the
device, via the android.os.Build.SUPPORTED_ABIS,
android.os.Build.SUPPORTED_32_BIT_ABIS, and
android.os.Build.SUPPORTED_64_BIT_ABIS parameters, each a comma separated list of
ABIs ordered from the most to the least preferred one
MUST report, via the above parameters, only those ABIs documented and described in the
latest version of the Android NDK ABI Management documentation [Resources, 12
], and
MUST include support for the Advanced SIMD (a.k.a. NEON) [Resources, 13
] extension
SHOULD be built using the source code and header files available in the upstream Android
Open Source Project
The following native code APIs MUST be available to apps that include native code:
libc (C library)
libm (math library)
Minimal support for C++
JNI interface
liblog (Android logging)
libz (Zlib compression)
libdl (dynamic linker)
libGLESv1_CM.so (OpenGL ES 1.x)
libGLESv2.so (OpenGL ES 2.0)
libGLESv3.so (OpenGL ES 3.x)
libEGL.so (native OpenGL surface management)
libjnigraphics.so
libOpenSLES.so (OpenSL ES 1.0.1 audio support)
libOpenMAXAL.so (OpenMAX AL 1.0.1 support)
libandroid.so (native Android activity support)
libmediandk.so (native media APIs support)
Support for OpenGL, as described below
Note that future releases of the Android NDK may introduce support for additional ABIs. If a device
implementation is not compatible with an existing predefined ABI, it MUST NOT report support for any
ABIs at all.
Note that device implementations MUST include libGLESv3.so and it MUST symlink (symbolic link) to
libGLESv2.so. in turn, MUST export all the OpenGL ES 3.1 and Android Extension Pack [Resources,
14
] function symbols as defined in the NDK release android-21. Although all the symbols must be
Page 12 of 74
C# Create PDF Library SDK to convert PDF from other file formats
Gratis control for creating PDF from multiple image formats PDF with a blank page, bookmarks, links, signatures Load PDF from existing documents and image in
edit pdf bookmarks; auto bookmark pdf
VB.NET Create PDF Library SDK to convert PDF from other file
Gratis control for creating PDF from multiple image formats PDF with a blank page, bookmarks, links, signatures Load PDF from existing documents and image in
bookmarks in pdf reader; how to create bookmarks in pdf file
present, only the corresponding functions for OpenGL ES versions and extensions actually supported
by the device must be fully implemented.
Device implementations MUST NOT include a native library with the name libvulkan.so.
Native code compatibility is challenging. For this reason, device implementers are STRONGLY
RECOMMENDED to use the implementations of the libraries listed above from the upstream Android
Open Source Project.
3.3.2. 32-bit ARM Native Code Compatibility
The ARMv8 architecture deprecates several CPU operations, including some operations used in
existing native code. On 64-bit ARM devices, the following deprecated operations MUST remain
available to 32-bit native ARM code, either through native CPU support or through software emulation:
SWP and SWPB instructions
SETEND instruction
CP15ISB, CP15DSB, and CP15DMB barrier operations
Legacy versions of the Android NDK used /proc/cpuinfo to discover CPU features from 32-bit ARM
native code. For compatibility with applications built using this NDK, devices MUST include the
following lines in /proc/cpuinfo when it is read by 32-bit ARM applications:
"Features: ", followed by a list of any optional ARMv7 CPU features supported by the
device
"CPU architecture: ", followed by an integer describing the device's highest supported ARM
architecture (e.g., "8" for ARMv8 devices)
These requirements only apply when /proc/cpuinfo is read by 32-bit ARM applications. Devices
SHOULD not alter /proc/cpuinfo when read by 64-bit ARM or non-ARM applications.
3.4. Web Compatibility
3.4.1. WebView Compatibility
Android Watch devices MAY, but all other device implementations MUST provide a complete
implementation of the android.webkit.Webview API.
The platform feature android.software.webview MUST be reported on any device that provides a
complete implementation of the android.webkit.WebView API, and MUST NOT be reported on devices
without a complete implementation of the API. The Android Open Source implementation uses code
from the Chromium Project to implement the android.webkit.WebView [Resources, 15
]. Because it is
not feasible to develop a comprehensive test suite for a web rendering system, device implementers
MUST use the specific upstream build of Chromium in the WebView implementation. Specifically:
Device android.webkit.WebView implementations MUST be based on the Chromium build
from the upstream Android Open Source Project for Android 6.0. This build includes a
specific set of functionality and security fixes for the WebView [Resources, 16
].
The user agent string reported by the WebView MUST be in this format:
Mozilla/5.0 (Linux; Android $(VERSION); $(MODEL) Build/$(BUILD); wv)
AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 $(CHROMIUM_VER) Mobile
Safari/537.36
The value of the $(VERSION) string MUST be the same as the value for
android.os.Build.VERSION.RELEASE.
The value of the $(MODEL) string MUST be the same as the value for
Page 13 of 74
XDoc.Word for .NET, Advanced .NET Word Processing Features
Viewing, editing, converting, processing, creating, annotating and zooming & rotation; Outlines, bookmarks, & thumbnail Create Word from PDF; Create Word from
export bookmarks from pdf to excel; create pdf with bookmarks from word
PDF Image Viewer| What is PDF
such as text extraction, hyperlinks, bookmarks and metadata as version among a suite of PDF-based standards to develop specifications for creating, viewing, and
add bookmark to pdf reader; bookmark pdf documents
android.os.Build.MODEL.
The value of the $(BUILD) string MUST be the same as the value for
android.os.Build.ID.
The value of the $(CHROMIUM_VER) string MUST be the version of
Chromium in the upstream Android Open Source Project.
Device implementations MAY omit Mobile in the user agent string.
The WebView component SHOULD include support for as many HTML5 features as possible and if it
supports the feature SHOULD conform to the HTML5 specification [Resources, 17
].
3.4.2. Browser Compatibility
Android Television, Watch, and Android Automotive implementations MAY omit a browser
application, but MUST support the public intent patterns as described in section 3.2.3.1
. All
other types of device implementations MUST include a standalone Browser application for
general user web browsing.
The standalone Browser MAY be based on a browser technology other than WebKit. However, even if
an alternate Browser application is used, the android.webkit.WebView component provided to third-
party applications MUST be based on WebKit, as described in section 3.4.1
.
Implementations MAY ship a custom user agent string in the standalone Browser application.
The standalone Browser application (whether based on the upstream WebKit Browser application or a
third-party replacement) SHOULD include support for as much of HTML5 [Resources, 17
] as possible.
Minimally, device implementations MUST support each of these APIs associated with HTML5:
application cache/offline operation [Resources, 18
]
the <video> tag [Resources, 19
]
geolocation [Resources, 20
]
Additionally, device implementations MUST support the HTML5/W3C webstorage API [Resources,
21
], and SHOULD support the HTML5/W3C IndexedDB API [Resources, 22
]. Note that as the web
development standards bodies are transitioning to favor IndexedDB over webstorage, IndexedDB is
expected to become a required component in a future version of Android.
3.5. API Behavioral Compatibility
The behaviors of each of the API types (managed, soft, native, and web) must be consistent with the
preferred implementation of the upstream Android Open Source Project [Resources, 2
]. Some specific
areas of compatibility are:
Devices MUST NOT change the behavior or semantics of a standard intent.
Devices MUST NOT alter the lifecycle or lifecycle semantics of a particular type of system
component (such as Service, Activity, ContentProvider, etc.).
Devices MUST NOT change the semantics of a standard permission.
The above list is not comprehensive. The Compatibility Test Suite (CTS) tests significant portions of
the platform for behavioral compatibility, but not all. It is the responsibility of the implementer to ensure
behavioral compatibility with the Android Open Source Project. For this reason, device implementers
SHOULD use the source code available via the Android Open Source Project where possible, rather
than re-implement significant parts of the system.
3.6. API Namespaces
Page 14 of 74
How to C#: Basic SDK Concept of XDoc.PDF for .NET
annotation features can be integrated into your C# project, such as annotation creating, deleting, modifying This class describes bookmarks in a PDF document
export pdf bookmarks to text file; creating bookmarks in pdf documents
VB.NET PDF: Basic SDK Concept of XDoc.PDF
features can be integrated into your VB.NET project, such as annotation creating, deleting, modifying This class describes bookmarks in a PDF document.
export pdf bookmarks to excel; adding bookmarks in pdf
Android follows the package and class namespace conventions defined by the Java programming
language. To ensure compatibility with third-party applications, device implementers MUST NOT make
any prohibited modifications (see below) to these package namespaces:
java.*
javax.*
sun.*
android.*
com.android.*
Prohibited modifications include:
Device implementations MUST NOT modify the publicly exposed APIs on the Android
platform by changing any method or class signatures, or by removing classes or class
fields.
Device implementers MAY modify the underlying implementation of the APIs, but such
modifications MUST NOT impact the stated behavior and Java-language signature of any
publicly exposed APIs.
Device implementers MUST NOT add any publicly exposed elements (such as classes or
interfaces, or fields or methods to existing classes or interfaces) to the APIs above.
A “publicly exposed element” is any construct which is not decorated with the“@hide” marker as used
in the upstream Android source code. In other words, device implementers MUST NOT expose new
APIs or alter existing APIs in the namespaces noted above. Device implementers MAY make internal-
only modifications, but those modifications MUST NOT be advertised or otherwise exposed to
developers.
Device implementers MAY add custom APIs, but any such APIs MUST NOT be in a namespace
owned by or referring to another organization. For instance, device implementers MUST NOT add
APIs to the com.google.* or similar namespace: only Google may do so. Similarly, Google MUST NOT
add APIs to other companies' namespaces. Additionally, if a device implementation includes custom
APIs outside the standard Android namespace, those APIs MUST be packaged in an Android shared
library so that only apps that explicitly use them (via the lt;uses-librarygt; mechanism) are affected by
the increased memory usage of such APIs.
If a device implementer proposes to improve one of the package namespaces above (such as by
adding useful new functionality to an existing API, or adding a new API), the implementer SHOULD
visit source.android.com
and begin the process for contributing changes and code, according to the
information on that site.
Note that the restrictions above correspond to standard conventions for naming APIs in the Java
programming language; this section simply aims to reinforce those conventions and make them
binding through inclusion in this Compatibility Definition.
3.7. Runtime Compatibility
Device implementations MUST support the full Dalvik Executable (DEX) format and Dalvik bytecode
specification and semantics [Resources, 23
]. Device implementers SHOULD use ART, the reference
upstream implementation of the Dalvik Executable Format, and the reference implementation’s
package management system.
Device implementations MUST configure Dalvik runtimes to allocate memory in accordance with the
upstream Android platform, and as specified by the following table. (See section 7.1.1
for screen size
and screen density definitions.)
Note that memory values specified below are considered minimum values and device
implementations MAY allocate more memory per application.
Page 15 of 74
How to C#: Basic SDK Concept of XDoc.PowerPoint
Conversely, conversion from PDF to PowerPoint (.PPTX C# project, such as annotation creating, deleting, modifying This class describes bookmarks in a PowerPoint
add bookmarks to pdf file; export pdf bookmarks to text
How to C#: Basic SDK Concept of XDoc.Word
Conversely, conversion from PDF to Word (.docx) is C# project, such as annotation creating, deleting, modifying This class describes bookmarks in a Word document
how to bookmark a pdf file in acrobat; bookmarks in pdf
Screen Layout
Screen Density
Minimum Application Memory
Android Watch
120 dpi (ldpi)
32MB
160 dpi (mdpi)
213 dpi (tvdpi)
240 dpi (hdpi)
36MB
280 dpi (280dpi)
320 dpi (xhdpi)
48MB
360 dpi (360dpi)
400 dpi (400dpi)
56MB
420 dpi (420dpi)
64MB
480 dpi (xxhdpi)
88MB
560 dpi (560dpi)
112MB
640 dpi (xxxhdpi)
154MB
small/normal
120 dpi (ldpi)
32MB
160 dpi (mdpi)
213 dpi (tvdpi)
48MB
240 dpi (hdpi)
280 dpi (280dpi)
320 dpi (xhdpi)
80MB
360 dpi (360dpi)
400 dpi (400dpi)
96MB
420 dpi (420dpi)
112MB
480 dpi (xxhdpi)
128MB
560 dpi (560dpi)
192MB
640 dpi (xxxhdpi)
256MB
large
120 dpi (ldpi)
32MB
160 dpi (mdpi)
48MB
213 dpi (tvdpi)
80MB
240 dpi (hdpi)
280 dpi (280dpi)
96MB
320 dpi (xhdpi)
128MB
360 dpi (360dpi)
160MB
400 dpi (400dpi)
192MB
420 dpi (420dpi)
228MB
480 dpi (xxhdpi)
256MB
560 dpi (560dpi)
384MB
640 dpi (xxxhdpi)
512MB
Page 16 of 74
How to C#: Basic SDK Concept of XDoc.Excel
Conversely, conversion from PDF to Excel (.XLSX) is also C# project, such as annotation creating, deleting, modifying This class describes bookmarks in a Excel
pdf bookmarks; adding bookmarks to pdf
xlarge
120 dpi (ldpi)
48MB
160 dpi (mdpi)
80MB
213 dpi (tvdpi)
96MB
240 dpi (hdpi)
280 dpi (280dpi)
144MB
320 dpi (xhdpi)
192MB
360 dpi (360dpi)
240MB
400 dpi (400dpi)
288MB
420 dpi (420dpi)
336MB
480 dpi (xxhdpi)
384MB
560 dpi (560dpi)
576MB
640 dpi (xxxhdpi)
768MB
3.8. User Interface Compatibility
3.8.1. Launcher (Home Screen)
Android includes a launcher application (home screen) and support for third-party applications to
replace the device launcher (home screen). Device implementations that allow third-party applications
to replace the device home screen MUST declare the platform feature android.software.home_screen.
3.8.2. Widgets
Widgets are optional for all Android device implementations, but SHOULD be supported on
Android Handheld devices.
Android defines a component type and corresponding API and lifecycle that allows applications to
expose an “AppWidget” to the end user [Resources, 24
] a feature that is STRONGLY
RECOMMENDED to be supported on Handheld Device implementations. Device implementations that
support embedding widgets on the home screen MUST meet the following requirements and declare
support for platform feature android.software.app_widgets.
Device launchers MUST include built-in support for AppWidgets, and expose user interface
affordances to add, configure, view, and remove AppWidgets directly within the Launcher.
Device implementations MUST be capable of rendering widgets that are 4 x 4 in the
standard grid size. See the App Widget Design Guidelines in the Android SDK
documentation [Resources, 24
] for details.
Device implementations that include support for lock screen MAY support application
widgets on the lock screen.
3.8.3. Notifications
Android includes APIs that allow developers to notify users of notable events [Resources, 25
], using
hardware and software features of the device.
Some APIs allow applications to perform notifications or attract attention using hardware—specifically
sound, vibration, and light. Device implementations MUST support notifications that use hardware
features, as described in the SDK documentation, and to the extent possible with the device
implementation hardware. For instance, if a device implementation includes a vibrator, it MUST
Page 17 of 74
correctly implement the vibration APIs. If a device implementation lacks hardware, the corresponding
APIs MUST be implemented as no-ops. This behavior is further detailed in section 7
.
Additionally, the implementation MUST correctly render all resources (icons, animation files etc.)
provided for in the APIs [Resources, 26
], or in the Status/System Bar icon style guide [Resources, 27
],
which in the case of an Android Television device includes the possibility to not display the
notifications. Device implementers MAY provide an alternative user experience for notifications than
that provided by the reference Android Open Source implementation; however, such alternative
notification systems MUST support existing notification resources, as above.
Android includes support for various notifications, such as:
Rich notifications. Interactive Views for ongoing notifications.
Heads-up notifications. Interactive Views users can act on or dismiss without leaving the
current app.
Lockscreen notifications. Notifications shown over a lock screen with granular control on
visibility.
Android device implementations, when such notifications are made visible, MUST properly execute
Rich and Heads-up notifications and include the title/name, icon, text as documented in the Android
APIs [Resources, 28
].
Android includes Notification Listener Service APIs that allow apps (once explicitly enabled by the
user) to receive a copy of all notifications as they are posted or updated. Device implementations
MUST correctly and promptly send notifications in their entirety to all such installed and user-enabled
listener services, including any and all metadata attached to the Notification object.
3.8.4. Search
Android includes APIs [Resources, 29
] that allow developers to incorporate search into their
applications, and expose their application’s data into the global system search. Generally speaking,
this functionality consists of a single, system-wide user interface that allows users to enter queries,
displays suggestions as users type, and displays results. The Android APIs allow developers to reuse
this interface to provide search within their own apps, and allow developers to supply results to the
common global search user interface.
Android device implementations SHOULD include global search, a single, shared, system-wide
search user interface capable of real-time suggestions in response to user input. Device
implementations SHOULD implement the APIs that allow developers to reuse this user interface to
provide search within their own applications. Device implementations that implement the global search
interface MUST implement the APIs that allow third-party applications to add suggestions to the
search box when it is run in global search mode. If no third-party applications are installed that make
use of this functionality, the default behavior SHOULD be to display web search engine results and
suggestions.
Android device implementations SHOULD implement an assistant on the device to handle the Assist
action [Resources, 30
].
Android also includes the Assist APIs to allow applications to elect how much information of the
current context is shared with the assistant on the device [Resources, 31
]. Device implementations
supporting the Assist action MUST indicate clearly to the end user when the the context is shared by
displaying a white light around the edges of the screen. To ensure clear visibility to the end user, the
indication MUST meet or exceed the duration and brightness of the Android Open Source Project
implementation.
3.8.5. Toasts
Applications can use the “Toast” API to display short non-modal strings to the end user, that disappear
after a brief period of time [Resources, 32
]. Device implementations MUST display Toasts from
Page 18 of 74
applications to end users in some high-visibility manner.
3.8.6. Themes
Android provides “themes” as a mechanism for applications to apply styles across an entire Activity or
application.
Android includes a “Holo” theme family as a set of defined styles for application developers to use if
they want to match the Holo theme look and feel as defined by the Android SDK [Resources, 33
].
Device implementations MUST NOT alter any of the Holo theme attributes exposed to applications
[Resources, 34
].
Android includes a “Material” theme family as a set of defined styles for application developers to use
if they want to match the design theme’s look and feel across the wide variety of different Android
device types. Device implementations MUST support the “Material” theme family and MUST NOT alter
any of the Material theme attributes or their assets exposed to applications [Resources, 35
].
Android also includes a “Device Default” theme family as a set of defined styles for application
developers to use if they want to match the look and feel of the device theme as defined by the device
implementer. Device implementations MAY modify the Device Default theme attributes exposed to
applications [Resources, 34
].
Android supports a variant theme with translucent system bars, which allows application developers to
fill the area behind the status and navigation bar with their app content. To enable a consistent
developer experience in this configuration, it is important the status bar icon style is maintained across
different device implementations. Therefore, Android device implementations MUST use white for
system status icons (such as signal strength and battery level) and notifications issued by the system,
unless the icon is indicating a problematic status or an app requests a light status bar using the
SYSTEM_UI_FLAG_LIGHT_STATUS_BAR flag. When an app requests a light status bar, Android
device implementations MUST change the color of the system status icons to black [Resources, 34
].
3.8.7. Live Wallpapers
Android defines a component type and corresponding API and lifecycle that allows applications to
expose one or more “Live Wallpapers” to the end user [Resources, 36
]. Live wallpapers are
animations, patterns, or similar images with limited input capabilities that display as a wallpaper,
behind other applications.
Hardware is considered capable of reliably running live wallpapers if it can run all live wallpapers, with
no limitations on functionality, at a reasonable frame rate with no adverse effects on other
applications. If limitations in the hardware cause wallpapers and/or applications to crash, malfunction,
consume excessive CPU or battery power, or run at unacceptably low frame rates, the hardware is
considered incapable of running live wallpaper. As an example, some live wallpapers may use an
OpenGL 2.0 or 3.x context to render their content. Live wallpaper will not run reliably on hardware that
does not support multiple OpenGL contexts because the live wallpaper use of an OpenGL context
may conflict with other applications that also use an OpenGL context.
Device implementations capable of running live wallpapers reliably as described above SHOULD
implement live wallpapers, and when implemented MUST report the platform feature flag
android.software.live_wallpaper.
3.8.8. Activity Switching
As the Recent function navigation key is OPTIONAL, the requirements to implement the
overview screen is OPTIONAL for Android Television devices and Android Watch devices.
The upstream Android source code includes the overview screen [Resources, 37
], a system-level user
interface for task switching and displaying recently accessed activities and tasks using a thumbnail
image of the application’s graphical state at the moment the user last left the application. Device
Page 19 of 74
implementations including the recents function navigation key as detailed in section 7.2.3
, MAY alter
the interface but MUST meet the following requirements:
MUST display affiliated recents as a group that moves together.
MUST support at least up to 20 displayed activities.
MUST at least display the title of 4 activities at a time.
SHOULD display highlight color, icon, screen title in recents.
MUST implement the screen pinning behavior [Resources, 38
] and provide the user with a
settings menu to toggle the feature.
SHOULD display a closing affordance ("x") but MAY delay this until user interacts with
screens.
Device implementations are STRONGLY RECOMMENDED to use the upstream Android user
interface (or a similar thumbnail-based interface) for the overview screen.
3.8.9. Input Management
Android includes support for Input Management and support for third-party input method editors
[Resources, 39
]. Device implementations that allow users to use third-party input methods on the
device MUST declare the platform feature android.software.input_methods and support IME APIs as
defined in the Android SDK documentation.
Device implementations that declare the android.software.input_methods feature MUST provide a
user-accessible mechanism to add and configure third-party input methods. Device implementations
MUST display the settings interface in response to the android.settings.INPUT_METHOD_SETTINGS
intent.
3.8.10. Lock Screen Media Control
The Remote Control Client API is deprecated from Android 5.0 in favor of the Media Notification
Template that allows media applications to integrate with playback controls that are displayed on the
lock screen [Resources, 40
]. Device implementations that support a lock screen, unless an Android
Automotive or Watch implementation, MUST display the Lockscreen Notifications including the Media
Notification Template.
3.8.11. Dreams
Android includes support for interactive screensavers called Dreams [Resources, 41
]. Dreams allows
users to interact with applications when a device connected to a power source is idle or docked in a
desk dock. Android Watch devices MAY implement Dreams, but other types of device
implementations SHOULD include support for Dreams and provide a settings option for users to
configure Dreams in response to the android.settings.DREAM_SETTINGS intent.
3.8.12. Location
When a device has a hardware sensor (e.g. GPS) that is capable of providing the location
coordinates, location modes MUST be displayed in the Location menu within Settings [Resources, 42
].
3.8.13. Unicode and Font
Android includes support for color emoji characters. When Android device implementations include an
IME, devices SHOULD provide an input method to the user for the Emoji characters defined in
Unicode 6.1 [Resources, 43
]. All devices MUST be capable of rendering these emoji characters in
color glyph.
Page 20 of 74
Documents you may be interested
Documents you may be interested