For Android 1.5, the Linux kernel received an upgrade from version
2.6.25 to 2.6.27. Although this type of change might not have an obvious
effect for the typical Android developer, it is important to note that
the kernel can and will be upgraded frequently. These seemingly minor
incremental updates often include major security, performance, and
functional features.
Kernel changes often have an impact on the security of the
underlying device operating system and provide features and improvements
for OEM-level Android device manufacturers. When stable, these features
can be exposed to developers as part of an Android SDK upgrade, in the
form of new APIs and performance enhancements to existing features. The
Android 1.5 version provides substantial feature enhancements, many of
which tie back to features of the upgraded Linux kernel. Although the
kernel memory footprint is larger, overall system performance has
improved and a number of bugs have been fixed.
Some of the core functions the kernel handles include
1. Enforcement of application permissions and security
2. Low-level memory management
3. Process management and threading
4. The network stack
5. Display, keypad input, camera,WiFi, Flash memory, audio, and binder (IPC) driver access
Android Application Runtime Environment
Each Android application runs in a separate process, with its own instance of the Dalvik virtual machine (VM). Based on the Java VM, the Dalvik design has been optimized for mobile devices.The Dalvik VM has a small memory footprint and multiple instances of the Dalvik VM can run concurrently on the handset.
Security and Permissions
The integrity of the Android platform is maintained through a variety of security measures. Applications as Operating System Users. When an application is installed, the operating system creates a new user profile associated with the application. Each application runs as a different user, with its own private files on the file system, a user ID, and a secure operating environment.
The application executes in its own process with its own instance of the Dalvik VM and under its own user ID on the operating system. Explicitly Defined Application Permissions To access shared resources on the system,Android applications register for the specific privileges they require. Some of these privileges enable the application to use phone functionality to make calls, access the network, and control the camera and other hardware sensors. Applications also require permission to access shared data containing private and personal information such as user preferences, user’s location, and contact information.
Applications might also enforce their own permissions by declaring them for other applications to use.The application can declare any number of different permission types, such as read-only or read-write permissions, for finer control over the application.
Applications that act as content providers might want to provide some on-the-fly permissions to other applications for specific information they want to share openly.This is done using ad-hoc granting and revoking of access to specific resources using Uniform Resource Identifiers (URIs).
URIs index specific data assets on the system, such as images and text. Here is an example of a URI that provides the phone numbers of all contacts:
content://contacts/phones To understand how this permission process works, let’s look at an example.
Let’s say we’ve got an application that keeps track of the user’s public and private birthday wish lists. If this application wanted to share its data with other applications, it could grant URI permissions for the public wish list, allowing another application permission to access this list without explicitly having to ask for it.
All Android applications packages are signed with a certificate, so users know that the application is authentic.The private key for the certificate is held by the developer. This helps establish a trust relationship between the developer and the user. It also allows the developer to control which applications can grant access to one another on the system. No certificate authority is necessary; self-signed certificates are acceptable.
The Android SDK provides an extensive set of application programming interfaces (APIs) that is both modern and robust.Android handset core system services are exposed and accessible to all applications.When granted the appropriate permissions,Android applications can share data among one another and access shared resources on the system securely.
Android applications are written in Java. For now, the Java language is the developer’s only choice on the Android platform.There has been some speculation that other programming languages, such as C++, might be added in future versions of Android.
0 comments:
Post a Comment