pdfbox c# port : Bookmarks pdf file Library control class asp.net web page wpf ajax android-cdd3-part526

implementations that declare the feature android.hardware.audio.output:
EFFECT_TYPE_LOUDNESS_ENHANCER implementations controllable through the
AudioEffect subclasses Equalizer, LoudnessEnhancer.
MUST support the visualizer API implementation, controllable through the Visualizer class.
implementations controllable through the AudioEffect sub-classes BassBoost,
EnvironmentalReverb, PresetReverb, and Virtualizer.
5.5.3. Audio Output Volume
Android Television device implementations MUST include support for system Master Volume and
digital audio output volume attenuation on supported outputs, except for compressed audio
passthrough output (where no audio decoding is done on the device).
5.6. Audio Latency
Audio latency is the time delay as an audio signal passes through a system. Many classes of
applications rely on short latencies, to achieve real-time sound effects.
For the purposes of this section, use the following definitions:
output latency. The interval between when an application writes a frame of PCM-coded
data and when the corresponding sound can be heard by an external listener or observed
by a transducer.
cold output latency. The output latency for the first frame, when the audio output system
has been idle and powered down prior to the request.
continuous output latency. The output latency for subsequent frames, after the device is
playing audio.
input latency. The interval between when an external sound is presented to the device
and when an application reads the corresponding frame of PCM-coded data.
cold input latency. The sum of lost input time and the input latency for the first frame,
when the audio input system has been idle and powered down prior to the request.
continuous input latency. The input latency for subsequent frames, while the device is
capturing audio.
cold output jitter. The variance among separate measurements of cold output latency
cold input jitter. The variance among separate measurements of cold input latency
continuous round-trip latency. The sum of continuous input latency plus continuous
output latency plus one buffer period. The buffer period term allows processing time for the
app and for the app to mitigate phase difference between input and output streams.
OpenSL ES PCM buffer queue API. The set of PCM-related OpenSL ES APIs within
Android NDK; see NDK_root/docs/opensles/index.html.
Device implementations that declare android.hardware.audio.output are STRONGLY
RECOMMENDED to meet or exceed these audio output requirements:
cold output latency of 100 milliseconds or less
continuous output latency of 45 milliseconds or less
minimize the cold output jitter
Page 31 of 74
Bookmarks pdf file - 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; add bookmarks to pdf preview
Bookmarks pdf file - 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
create bookmark pdf file; copy pdf bookmarks to another pdf
If a device implementation meets the requirements of this section after any initial calibration when
using the OpenSL ES PCM buffer queue API, for continuous output latency and cold output latency
over at least one supported audio output device, it is STRONGLY RECOMMENDED to report support
for low-latency audio, by reporting the feature android.hardware.audio.low_latency via the
android.content.pm.PackageManager class [Resources, 70
]. Conversely, if the device implementation
does not meet these requirements it MUST NOT report support for low-latency audio.
Device implementations that include android.hardware.microphone are STRONGLY
RECOMMENDED to meet these input audio requirements:
cold input latency of 100 milliseconds or less
continuous input latency of 30 milliseconds or less
continuous round-trip latency of 50 milliseconds or less
minimize the cold input jitter
5.7. Network Protocols
Devices MUST support the media network protocols for audio and video playback as specified in the
Android SDK documentation [Resources, 64
]. Specifically, devices MUST support the following media
network protocols:
HTTP(S) progressive streaming
HTTP(S) Live Streaming draft protocol, Version 3 [Resources, 71
5.8. Secure Media
Device implementations that support secure video output and are capable of supporting secure
surfaces MUST declare support for Display.FLAG_SECURE. Device implementations that declare
support for Display.FLAG_SECURE, if they support a wireless display protocol, MUST secure the link
with a cryptographically strong mechanism such as HDCP 2.x or higher for Miracast wireless displays.
Similarly if they support a wired external display, the device implementations MUST support HDCP 1.2
or higher. Android Television device implementations MUST support HDCP 2.2 for devices supporting
4K resolution and HDCP 1.4 or above for lower resolutions. The upstream Android open source
implementation includes support for wireless (Miracast) and wired (HDMI) displays that satisfies this
5.9. Musical Instrument Digital Interface (MIDI)
If a device implementation supports the inter-app MIDI software transport (virtual MIDI devices), and it
supports MIDI over all of the following MIDI-capable hardware transports for which it provides generic
non-MIDI connectivity, it is STRONGLY RECOMMENDED to report support for feature
android.software.midi via the android.content.pm.PackageManager class [Resources, 70
The MIDI-capable hardware transports are:
USB host mode (section 7.7 USB)
USB peripheral mode (section 7.7 USB)
Conversely, if the device implementation provides generic non-MIDI connectivity over a particular
MIDI-capable hardware transport listed above, but does not support MIDI over that hardware
transport, it MUST NOT report support for feature android.software.midi.
MIDI over Bluetooth LE acting in central role (section 7.4.3 Bluetooth) is in trial use status. A device
implementation that reports feature android.software.midi, and which provides generic non-MIDI
Page 32 of 74
VB.NET PDF File Compress Library: Compress reduce PDF size in vb.
Compress & decompress PDF document file while maintaining original content of target PDF document file. Remove bookmarks, annotations, watermark, page labels
how to add bookmarks to pdf document; copy bookmarks from one pdf to another
C# PDF File Split Library: Split, seperate PDF into multiple files
Split PDF file by top level bookmarks. The following C# codes explain how to split a PDF file into multiple ones by PDF bookmarks or outlines.
create bookmarks in pdf from excel; split pdf by bookmark
connectivity over Bluetooth LE, SHOULD support MIDI over Bluetooth LE.
5.10. Professional Audio
If a device implementation meets all of the following requirements, it is STRONGLY RECOMMENDED
to report support for feature android.hardware.audio.pro via the android.content.pm.PackageManager
class [Resources, 70
The device implementation MUST report support for feature
The continuous round-trip audio latency, as defined in section 5.6 Audio Latency, MUST be
20 milliseconds or less and SHOULD be 10 milliseconds or less over at least one
supported path.
If the device includes a 4 conductor 3.5mm audio jack, the continuous round-trip audio
latency MUST be 20 milliseconds or less over the audio jack path, and SHOULD be 10
milliseconds or less over at the audio jack path.
The device implementation MUST include a USB port(s) supporting USB host mode and
USB peripheral mode.
The USB host mode MUST implement the USB audio class.
If the device includes an HDMI port, the device implementation MUST support output in
stereo and eight channels at 20-bit or 24-bit depth and 192 kHz without bit-depth loss or
The device implementation MUST report support for feature android.software.midi.
If the device includes a 4 conductor 3.5mm audio jack, the device implementation is
STRONGLY RECOMMENDED to comply with section Mobile device (jack) specifications
of the Wired Audio Headset Specification (v1.1)
6. Developer Tools and Options Compatibility
6.1. Developer Tools
Device implementations MUST support the Android Developer Tools provided in the Android SDK.
Android compatible devices MUST be compatible with:
Android Debug Bridge (adb) [Resources, 72
Device implementations MUST support all adb functions as documented in the Android SDK including
dumpsys [Resources, 73
]. The device-side adb daemon MUST be inactive by default and there MUST
be a user-accessible mechanism to turn on the Android Debug Bridge. If a device implementation
omits USB peripheral mode, it MUST implement the Android Debug Bridge via local-area network
(such as Ethernet or 802.11).
Android includes support for secure adb. Secure adb enables adb on known authenticated hosts.
Device implementations MUST support secure adb.
Dalvik Debug Monitor Service (ddms) [Resources, 74
Device implementations MUST support all ddms features as documented in the Android SDK. As
ddms uses adb, support for ddms SHOULD be inactive by default, but MUST be supported whenever
the user has activated the Android Debug Bridge, as above.
Monkey [Resources, 75
Device implementations MUST include the Monkey framework, and make it available for applications
Page 33 of 74
VB.NET PDF File Split Library: Split, seperate PDF into multiple
Split PDF File by Top Level Bookmarks Demo Code in VB.NET. The following VB.NET codes explain how to split a PDF file into multiple
how to bookmark a pdf file; how to bookmark a pdf page
C# PDF File Compress Library: Compress reduce PDF size in C#.net
Easy to compress & decompress PDF document file in .NET framework. Remove bookmarks, annotations, watermark, page labels and article threads from PDF while
how to bookmark a page in pdf document; adding bookmarks to pdf reader
to use.
SysTrace [Resources, 76
Device implementations MUST support systrace tool as documented in the Android SDK. Systrace
must be inactive by default, and there MUST be a user-accessible mechanism to turn on Systrace.
Most Linux-based systems and Apple Macintosh systems recognize Android devices using the
standard Android SDK tools, without additional support; however Microsoft Windows systems typically
require a driver for new Android devices. (For instance, new vendor IDs and sometimes new device
IDs require custom USB drivers for Windows systems.) If a device implementation is unrecognized by
the adb tool as provided in the standard Android SDK, device implementers MUST provide Windows
drivers allowing developers to connect to the device using the adb protocol. These drivers MUST be
provided for Windows XP, Windows Vista, Windows 7, Windows 8 and Windows 10 in both 32-bit and
64-bit versions.
6.2. Developer Options
Android includes support for developers to configure application development-related settings. Device
implementations MUST honor the android.settings.APPLICATION_DEVELOPMENT_SETTINGS
intent to show application development-related settings [Resources, 77
]. The upstream Android
implementation hides the Developer Options menu by default and enables users to launch Developer
Options after pressing seven (7) times on the Settings > About Device > Build Number menu item.
Device implementations MUST provide a consistent experience for Developer Options. Specifically,
device implementations MUST hide Developer Options by default and MUST provide a mechanism to
enable Developer Options that is consistent with the upstream Android implementation.
7. Hardware Compatibility
If a device includes a particular hardware component that has a corresponding API for third-party
developers, the device implementation MUST implement that API as described in the Android SDK
documentation. If an API in the SDK interacts with a hardware component that is stated to be optional
and the device implementation does not possess that component:
Complete class definitions (as documented by the SDK) for the component APIs MUST
still be presented.
The API’s behaviors MUST be implemented as no-ops in some reasonable fashion.
API methods MUST return null values where permitted by the SDK documentation.
API methods MUST return no-op implementations of classes where null values are not
permitted by the SDK documentation.
API methods MUST NOT throw exceptions not documented by the SDK documentation.
A typical example of a scenario where these requirements apply is the telephony API: even on non-
phone devices, these APIs must be implemented as reasonable no-ops.
Device implementations MUST consistently report accurate hardware configuration information via the
getSystemAvailableFeatures() and hasSystemFeature(String) methods on the
android.content.pm.PackageManager class for the same build fingerprint. [Resources, 70
7.1. Display and Graphics
Android includes facilities that automatically adjust application assets and UI layouts appropriately for
the device, to ensure that third-party applications run well on a variety of hardware configurations
[Resources, 78
]. Devices MUST properly implement these APIs and behaviors, as detailed in this
Page 34 of 74
.NET PDF SDK - Description of All PDF Processing Control Feastures
Full page navigation, zooming & rotation; Outlines, bookmarks, & thumbnail display; Convert PDF to Jpeg images; More about PDF Conversion Page File & Page Process
pdf reader with bookmarks; add bookmarks to pdf online
XDoc.Word for .NET, Advanced .NET Word Processing Features
Full page navigation, zooming & rotation; Outlines, bookmarks, & thumbnail display; Convert Word to PDF; Convert Word to HTML5; Convert Word to File & Page Process
add bookmarks to pdf; adding bookmarks to pdf document
The units referenced by the requirements in this section are defined as follows:
physical diagonal size. The distance in inches between two opposing corners of the
illuminated portion of the display.
dots per inch (dpi). The number of pixels encompassed by a linear horizontal or vertical
span of 1”. Where dpi values are listed, both horizontal and vertical dpi must fall within the
aspect ratio. The ratio of the pixels of the longer dimension to the shorter dimension of the
screen. For example, a display of 480x854 pixels would be 854/480 = 1.779, or roughly
density-independent pixel (dp) The virtual pixel unit normalized to a 160 dpi screen,
calculated as: pixels = dps * (density/160).
7.1.1. Screen Configuration Screen Size
Android Watch devices (detailed in section 2
) MAY have smaller screen sizes as described in
this section.
The Android UI framework supports a variety of different screen sizes, and allows applications to
query the device screen size (aka “screen layout") via android.content.res.Configuration.screenLayout
with the SCREENLAYOUT_SIZE_MASK. Device implementations MUST report the correct screen
size as defined in the Android SDK documentation [Resources, 78
] and determined by the upstream
Android platform. Specifically, device implementations MUST report the correct screen size according
to the following logical density-independent pixel (dp) screen dimensions.
Devices MUST have screen sizes of at least 426 dp x 320 dp (‘small’), unless it is an
Android Watch device.
Devices that report screen size ‘normal’ MUST have screen sizes of at least 480 dp x 320
Devices that report screen size ‘large’ MUST have screen sizes of at least 640 dp x 480
Devices that report screen size ‘xlarge’ MUST have screen sizes of at least 960 dp x 720
In addition,
Android Watch devices MUST have a screen with the physical diagonal size in the range
from 1.1 to 2.5 inches.
Other types of Android device implementations, with a physically integrated screen, MUST
have a screen at least 2.5 inches in physical diagonal size.
Devices MUST NOT change their reported screen size at any time.
Applications optionally indicate which screen sizes they support via the <supports-screens> attribute
in the AndroidManifest.xml file. Device implementations MUST correctly honor applications' stated
support for small, normal, large, and xlarge screens, as described in the Android SDK documentation. Screen Aspect Ratio
Android Watch devices MAY have an aspect ratio of 1.0 (1:1).
The screen aspect ratio MUST be a value from 1.3333 (4:3) to 1.86 (roughly 16:9), but Android Watch
devices MAY have an aspect ratio of 1.0 (1:1) because such a device implementation will use a
Page 35 of 74
C# Create PDF Library SDK to convert PDF from other file formats
Create multipage PDF from OpenOffice and CSV file. Create and save editable PDF with a blank page, bookmarks, links, signatures, etc.
creating bookmarks pdf; create bookmarks pdf files
XDoc.PowerPoint for .NET, All Mature Features Introductions
zooming & rotation; Outlines, bookmarks, & thumbnail Convert PowerPoint to PDF; Convert PowerPoint to HTML5; PowerPoint from existing PowerPoint file or stream
bookmark a pdf file; bookmark pdf acrobat
UI_MODE_TYPE_WATCH as the android.content.res.Configuration.uiMode. Screen Density
The Android UI framework defines a set of standard logical densities to help application developers
target application resources. Device implementations MUST report only one of the following logical
Android framework densities through the android.util.DisplayMetrics APIs, and MUST execute
applications at this standard density and MUST NOT change the value at at any time for the default
120 dpi (ldpi)
160 dpi (mdpi)
213 dpi (tvdpi)
240 dpi (hdpi)
280 dpi (280dpi)
320 dpi (xhdpi)
360 dpi (360dpi)
400 dpi (400dpi)
420 dpi (420dpi)
480 dpi (xxhdpi)
560 dpi (560dpi)
640 dpi (xxxhdpi)
Device implementations SHOULD define the standard Android framework density that is numerically
closest to the physical density of the screen, unless that logical density pushes the reported screen
size below the minimum supported. If the standard Android framework density that is numerically
closest to the physical density results in a screen size that is smaller than the smallest supported
compatible screen size (320 dp width), device implementations SHOULD report the next lowest
standard Android framework density.
7.1.2. Display Metrics
Device implementations MUST report correct values for all display metrics defined in
android.util.DisplayMetrics [Resources, 79
] and MUST report the same values regardless of whether
the embedded or external screen is used as the default display.
7.1.3. Screen Orientation
Devices MUST report which screen orientations they support (android.hardware.screen.portrait and/or
android.hardware.screen.landscape) and MUST report at least one supported orientation. For
example, a device with a fixed orientation landscape screen, such as a television or laptop, SHOULD
only report android.hardware.screen.landscape.
Devices that report both screen orientations MUST support dynamic orientation by applications to
either portrait or landscape screen orientation. That is, the device must respect the application’s
request for a specific screen orientation. Device implementations MAY select either portrait or
landscape orientation as the default.
Devices MUST report the correct value for the device’s current orientation, whenever queried via the
android.content.res.Configuration.orientation, android.view.Display.getOrientation(), or other APIs.
Devices MUST NOT change the reported screen size or density when changing orientation.
7.1.4. 2D and 3D Graphics Acceleration
Page 36 of 74
Device implementations MUST support both OpenGL ES 1.0 and 2.0, as embodied and detailed in the
Android SDK documentations. Device implementations SHOULD support OpenGL ES 3.0 or 3.1 on
devices capable of supporting it. Device implementations MUST also support Android RenderScript,
as detailed in the Android SDK documentation [Resources, 80
Device implementations MUST also correctly identify themselves as supporting OpenGL ES 1.0,
OpenGL ES 2.0, OpenGL ES 3.0 or OpenGL 3.1. That is:
The managed APIs (such as via the GLES10.getString() method) MUST report support for
OpenGL ES 1.0 and OpenGL ES 2.0.
The native C/C++ OpenGL APIs (APIs available to apps via libGLES_v1CM.so,
libGLES_v2.so, or libEGL.so) MUST report support for OpenGL ES 1.0 and OpenGL ES
Device implementations that declare support for OpenGL ES 3.0 or 3.1 MUST support the
corresponding managed APIs and include support for native C/C++ APIs. On device
implementations that declare support for OpenGL ES 3.0 or 3.1, libGLESv2.so MUST
export the corresponding function symbols in addition to the OpenGL ES 2.0 function
In addition to OpenGL ES 3.1, Android provides an extension pack with Java interfaces [Resources,
] and native support for advanced graphics functionality such as tessellation and the ASTC texture
compression format. Android device implementations MAY support this extension pack, and—only if
fully implemented—MUST identify the support through the android.hardware.opengles.aep feature
Also, device implementations MAY implement any desired OpenGL ES extensions. However, device
implementations MUST report via the OpenGL ES managed and native APIs all extension strings that
they do support, and conversely MUST NOT report extension strings that they do not support.
Note that Android includes support for applications to optionally specify that they require specific
OpenGL texture compression formats. These formats are typically vendor-specific. Device
implementations are not required by Android to implement any specific texture compression format.
However, they SHOULD accurately report any texture compression formats that they do support, via
the getString() method in the OpenGL API.
Android includes a mechanism for applications to declare that they want to enable hardware
acceleration for 2D graphics at the Application, Activity, Window, or View level through the use of a
manifest tag android:hardwareAccelerated or direct API calls [Resources, 82
Device implementations MUST enable hardware acceleration by default, and MUST disable hardware
acceleration if the developer so requests by setting android:hardwareAccelerated="false” or disabling
hardware acceleration directly through the Android View APIs.
In addition, device implementations MUST exhibit behavior consistent with the Android SDK
documentation on hardware acceleration [Resources, 82
Android includes a TextureView object that lets developers directly integrate hardware-accelerated
OpenGL ES textures as rendering targets in a UI hierarchy. Device implementations MUST support
the TextureView API, and MUST exhibit consistent behavior with the upstream Android
Android includes support for EGL_ANDROID_RECORDABLE, an EGLConfig attribute that indicates
whether the EGLConfig supports rendering to an ANativeWindow that records images to a video.
Device implementations MUST support EGL_ANDROID_RECORDABLE extension [Resources, 83
7.1.5. Legacy Application Compatibility Mode
Android specifies a “compatibility mode” in which the framework operates in a 'normal' screen size
equivalent (320dp width) mode for the benefit of legacy applications not developed for old versions of
Android that pre-date screen-size independence.
Page 37 of 74
Android Automotive does not support legacy compatibility mode.
All other device implementations MUST include support for legacy application compatibility
mode as implemented by the upstream Android open source code. That is, device
implementations MUST NOT alter the triggers or thresholds at which compatibility mode is
activated, and MUST NOT alter the behavior of the compatibility mode itself.
7.1.6. Screen Technology
The Android platform includes APIs that allow applications to render rich graphics to the display.
Devices MUST support all of these APIs as defined by the Android SDK unless specifically allowed in
this document.
Devices MUST support displays capable of rendering 16-bit color graphics and SHOULD
support displays capable of 24-bit color graphics.
Devices MUST support displays capable of rendering animations.
The display technology used MUST have a pixel aspect ratio (PAR) between 0.9 and 1.15.
That is, the pixel aspect ratio MUST be near square (1.0) with a 10 ~ 15% tolerance.
7.1.7. Secondary Displays
Android includes support for secondary display to enable media sharing capabilities and developer
APIs for accessing external displays. If a device supports an external display either via a wired,
wireless, or an embedded additional display connection then the device implementation MUST
implement the display manager API as described in the Android SDK documentation [Resources, 84
7.2. Input Devices
Devices MUST support a touchscreen or meet the requirements listed in 7.2.2 for non-touch
7.2.1. Keyboard
Android Watch and Android Automotive implementations MAY implement a soft keyboard. All
other device implementations MUST implement a soft keyboard and:
Device implementations:
MUST include support for the Input Management Framework (which allows third-party
developers to create Input Method Editors—i.e. soft keyboard) as detailed at
MUST provide at least one soft keyboard implementation (regardless of whether a hard
keyboard is present) except for Android Watch devices where the screen size makes it
less reasonable to have a soft keyboard.
MAY include additional soft keyboard implementations.
MAY include a hardware keyboard.
MUST NOT include a hardware keyboard that does not match one of the formats specified
in android.content.res.Configuration.keyboard [Resources, 85
] (QWERTY or 12-key).
7.2.2. Non-touch Navigation
Android Television devices MUST support D-pad.
Device implementations:
Page 38 of 74
MAY omit a non-touch navigation option (trackball, d-pad, or wheel) if the device
implementation is not an Android Television device.
MUST report the correct value for android.content.res.Configuration.navigation
[Resources, 85
MUST provide a reasonable alternative user interface mechanism for the selection and
editing of text, compatible with Input Management Engines. The upstream Android open
source implementation includes a selection mechanism suitable for use with devices that
lack non-touch navigation inputs.
7.2.3. Navigation Keys
The availability and visibility requirement of the Home, Recents, and Back functions differ
between device types as described in this section.
The Home, Recents, and Back functions (mapped to the key events KEYCODE_HOME,
KEYCODE_APP_SWITCH, KEYCODE_BACK, respectively) are essential to the Android navigation
paradigm and therefore:
Android Handheld device implementations MUST provide the Home, Recents, and Back
Android Television device implementations MUST provide the Home and Back functions.
Android Watch device implementations MUST have the Home function available to the
user, and the Back function except for when it is in UI_MODE_TYPE_WATCH.
Android Automotive implementations MUST provide the Home function and MAY provide
Back and Recent functions.
All other types of device implementations MUST provide the Home and Back functions.
These functions MAY be implemented via dedicated physical buttons (such as mechanical or
capacitive touch buttons), or MAY be implemented using dedicated software keys on a distinct portion
of the screen, gestures, touch panel, etc. Android supports both implementations. All of these
functions MUST be accessible with a single action (e.g. tap, double-click or gesture) when visible.
Recents function, if provided, MUST have a visible button or icon unless hidden together with other
navigation functions in full-screen mode. This does not apply to devices upgrading from earlier
Android versions that have physical buttons for navigation and no recents key.
The Home and Back functions, if provided, MUST each have a visible button or icon unless hidden
together with other navigation functions in full-screen mode or when the uiMode
The Menu function is deprecated in favor of action bar since Android 4.0. Therefore the new device
implementations shipping with Android 6.0 and later MUST NOT implement a dedicated physical
button for the Menu function. Older device implementations SHOULD NOT implement a dedicated
physical button for the Menu function, but if the physical Menu button is implemented and the device is
running applications with targetSdkVersion > 10, the device implementation:
MUST display the action overflow button on the action bar when it is visible and the
resulting action overflow menu popup is not empty. For a device implementation launched
before Android 4.4 but upgrading to Android 6.0, this is RECOMMENDED.
MUST NOT modify the position of the action overflow popup displayed by selecting the
overflow button in the action bar.
MAY render the action overflow popup at a modified position on the screen when it is
displayed by selecting the physical menu button.
For backwards compatibility, device implementations MUST make the Menu function available to
applications when targetSdkVersion is less than 10, either by a physical button, a software key, or
Page 39 of 74
gestures. This Menu function should be presented unless hidden together with other navigation
Android device implementations with the support of the Assist action [Resources, 30
] MUST make this
accessisble with a single action (e.g. tap, double-click, or gesture) when other navigation keys are
visible, and are STRONGLY RECOMMENDED to use the long-press on the Home button or software
key as the single action.
Device implementations MAY use a distinct portion of the screen to display the navigation keys, but if
so, MUST meet these requirements:
Device implementation navigation keys MUST use a distinct portion of the screen, not
available to applications, and MUST NOT obscure or otherwise interfere with the portion of
the screen available to applications.
Device implementations MUST make available a portion of the display to applications that
meets the requirements defined in section 7.1.1
Device implementations MUST display the navigation keys when applications do not
specify a system UI mode, or specify SYSTEM_UI_FLAG_VISIBLE.
Device implementations MUST present the navigation keys in an unobtrusive “low profile”
(eg. dimmed) mode when applications specify SYSTEM_UI_FLAG_LOW_PROFILE.
Device implementations MUST hide the navigation keys when applications specify
7.2.4. Touchscreen Input
Android Handhelds and Watch Devices MUST support touchscreen input.
Device implementations SHOULD have a pointer input system of some kind (either mouse-like or
touch). However, if a device implementation does not support a pointer input system, it MUST NOT
report the android.hardware.touchscreen or android.hardware.faketouch feature constant. Device
implementations that do include a pointer input system:
SHOULD support fully independently tracked pointers, if the device input system supports
multiple pointers.
MUST report the value of android.content.res.Configuration.touchscreen [Resources, 85
corresponding to the type of the specific touchscreen on the device.
Android includes support for a variety of touchscreens, touch pads, and fake touch input devices.
Touchscreen based device implementations are associated with a display [Resources, 86
] such that
the user has the impression of directly manipulating items on screen. Since the user is directly
touching the screen, the system does not require any additional affordances to indicate the objects
being manipulated. In contrast, a fake touch interface provides a user input system that approximates
a subset of touchscreen capabilities. For example, a mouse or remote control that drives an on-screen
cursor approximates touch, but requires the user to first point or focus then click. Numerous input
devices like the mouse, trackpad, gyro-based air mouse, gyro-pointer, joystick, and multi-touch
trackpad can support fake touch interactions. Android includes the feature constant
android.hardware.faketouch, which corresponds to a high-fidelity non-touch (pointer-based) input
device such as a mouse or trackpad that can adequately emulate touch-based input (including basic
gesture support), and indicates that the device supports an emulated subset of touchscreen
functionality. Device implementations that declare the fake touch feature MUST meet the fake touch
requirements in section 7.2.5
Device implementations MUST report the correct feature corresponding to the type of input used.
Device implementations that include a touchscreen (single-touch or better) MUST report the platform
feature constant android.hardware.touchscreen. Device implementations that report the platform
feature constant android.hardware.touchscreen MUST also report the platform feature constant
android.hardware.faketouch. Device implementations that do not include a touchscreen (and rely on a
Page 40 of 74
Documents you may be interested
Documents you may be interested