Survey
* Your assessment is very important for improving the workof artificial intelligence, which forms the content of this project
* Your assessment is very important for improving the workof artificial intelligence, which forms the content of this project
By: Eliav Menachi http://developer.android.com/guide/topics/f undamentals.html Android relies on Linux version 2.6 The kernel acts as an abstraction layer between the hardware and the rest of the software stack Provides services such as security, memory management, process management, network stack, driver model.. Set of C/C++ libraries Surface Manager - manages access to the display subsystem and seamlessly composites 2D and 3D graphic layers from multiple applications System C library - a BSD-derived implementation of the standard C system library (libc) Media Libraries - based on PacketVideo's OpenCORE; support playback and recording of many popular audio and video formats, as well as static image files, including MPEG4, H.264, MP3, AAC, AMR, JPG, and PNG LibWebCore - web browser engine SGL - 2D graphics engine 3D libraries - based on OpenGL ES 1.0 APIs FreeType - bitmap and vector font rendering SQLite - relational database engine Core libraries of the Java programming language (most of it) Every Android application runs in its own process Every process has its own instance of the Dalvik VM Dalvik can run multiple VMs efficiently .java files are compiled into .dex files Optimized for minimal memory footprint The Dalvik VM relies on the Linux kernel for underlying functionality such as threading and lowlevel memory management Views: including lists, grids, text boxes, buttons, and even an embeddable web browser Content Providers: enable applications to access data from other applications, or to share their own data Resource Manager: providing access to non-code resources such as localized strings, graphics, and layout files Notification Manager: enables display of custom alerts in the status bar Activity Manager: manages the lifecycle of applications Java programming language The compiled Java code — along with any data and resource files required by the application — is bundled by the aapt tool into an Android package Android package - an archive file marked by an .apk suffix All the code in a single .apk file is considered to be one application Every application runs in its own Linux process Android starts the process when any of the application's code needs to be executed Android shuts down the process when it's no longer needed and system resources are required by other applications Each process has its own Java virtual machine (VM) Each application is assigned a unique Linux user ID Permissions are set so that the application's files are visible only that user (there are ways to export them to other applications as well) One application can make use of elements of other applications Android applications don't have a single entry point for everything in the application (no main() function, for example) Rather, they have essential components that the system can instantiate and run as needed. There are four types of components Activities Services Broadcast receivers Content providers Presents a visual user interface Each activity is independent of the others Each activity is implemented as a subclass of the Activity base class One of the activities is marked as the first one that should be presented to the user when the application is launched Moving from one activity to another is accomplished by having the current activity start the next one Runs in the background Each service extends the Service base class It's possible to connect (bind) to an ongoing service (and start the service if it's not already running) While connected, you can communicate with the service through an interface that the service exposes Like activities services run in the main thread of the application process Services often spawn another thread for time-consuming tasks Component that receive and react to broadcast announcements Broadcasts originate from the system: i.e. battery is low, picture has been taken, user changed a language preference Broadcasts originate from Applications :i.e. to let other applications know that some data has been downloaded to the device and is available for them to use… Broadcast receivers do not display a user interface Broadcast receivers may start an activity in response to the information they receive Broadcast receivers may use the Notification Manager to alert the user Notifications can be: flashing the backlight, vibrating the device, playing a sound, and so on A content provider makes a specific set of the application's data available to other applications The data can be stored in the file system, in an SQLite database, or in any other manner ... The content provider extends the ContentProvider base class to implement a standard set of methods However, applications do not call these methods directly .Rather they use a ContentResolver object and call its methods instead A ContentResolver can talk to any content provider Content providers are activated when they're targeted by a request from a ContentResolver. The other three components — activities, services, and broadcast receivers — are activated by asynchronous messages called intents . An object that holds a message content For activities and services: names the action being requested URI of the data to act on For broadcast receivers names the action being announced Applications declare their components in a manifest file Bundled into the Android package Used for: declaring the application's components naming any libraries the application needs identifying any permissions the application expects to be granted <?xml version="1.0" encoding="utf-8"?> <manifest xmlns:android=“…." package=“…“ android:versionCode="1“ android:versionName="1.0"> <application android:icon=“…“ aandroid:label=“…"> <activity android:name=".Name 1“ android:label=“…"> <intent-filter> <action android:name="android.intent.action.MAIN" /> <category android:name="android.intent.category.LAUNCHER" /> </intent-filter> </activity> <activity android:name=".Name 2“ android:label=“…"> </activity> </application> <uses-sdk android:minSdkVersion="3" /> </manifest> An activity is launched by passing an Intent object to: Context.startActivity Activity.startActivityForResult (expects a result back from the activity) The responding activity can look at the initial intent that caused it to be launched: getIntent While executing Android pass additional intents onNewIntent lunched activity returns data to the initiator activity by: onActivityResult Intent intent = new Intent(this,Activity.class); startActivity(intent); A service is started (or new instructions are given to an ongoing service )by passing an Intent object to Context.startService Android calls the service's onStart )(method and passes it the Intent object. Similarly, an intent can be passed to Context.bindService )( to establish an ongoing connection between the calling component and a target service . The service receives the Intent object in an onBind )(call. (If the service is not already running ,bindService )(can optionally start it ). An application can initiate a broadcast by passing an Intent object to methods like: Context.sendBroadcast )( Context.sendOrderedBroadcast )( Context.sendStickyBroadcast )( Android delivers the intent to all interested broadcast receivers by calling their onReceive )(methods Content provider is active only while it's responding to a request from a ContentResolver. Broadcast receiver is active only while it's responding to a broadcast message. So there's no need to explicitly shut down these components. Android has methods to shut down activities and services in an orderly way: Activity can be shut down by calling its finish() method. One activity can shut down another activity (one it started with startActivityForResult()) by calling finishActivity(). Service can be stopped by calling: stopSelf Context.stopService Android shut down components: when they are no longer being used when Android must reclaim memory for more active components Task - group of related activities, arranged stack in a The root activity in the stack is the one that began the task The activity at the top of the stack is one that's currently running When the user presses the BACK key, the current activity is popped from the stack, and the previous one resumes as the running activity Values for the task as a whole are set in the root activity The stack contains objects If a task has more than one instance of the same Activity subclass open, the stack has a separate entry for each instance Activities in the stack are never rearranged, only pushed and popped Suppose, for instance, that the current task has four activities in its stack — three under the current activity. The user presses the HOME key, goes to the application launcher, and selects a new application (actually, a new task). The current task goes into the background and the root activity for the new task is displayed .Then, after a short period, the user goes back to the home screen and again selects the previous application (the previous task .)That task, with all four activities in the stack, comes forward .When the user presses the BACK key, the screen does not display the activity the user just left (the root activity of the previous task .)Rather, the activity on the top of the stack is removed and the previous activity in the same task is displayed . If the user leaves a task for a long time, the system clears the task of all activities except the root activity When the user returns to the task again, it's as the user left it, except that only the initial activity is present . The idea is that, after a time, users will likely have abandoned what they were doing before and are returning to the task to begin something new There are some activity attributes that can be used to control this behavior and modify it: alwaysRetainTaskState - The task retains all activities in its stack even after a long period. clearTaskOnLaunch - the stack is cleared down to the root activity whenever the user leaves the task and returns to it. finishOnTaskLaunch - This attribute is like clearTaskOnLaunch, but it operates on a single activity, not an entire task. And it can cause any activity to go away, including the root activity. If the user leaves and then returns to the task, it no longer is present. An activity is set up as the entry point for a task by giving it an intent filter with: "android.intent.action.MAIN "as the specified action "android.intent.category.LAUNCHER "as the specified category A filter of this kind causes an icon and label for the activity to be displayed in the application launcher, giving users a way both to launch the task and to return to it at any time after it has been launched The first application's components starts a Linux process for it with a single thread Additional components can run in other processes Additional threads can spawn for any process Component process is controlled by the manifest file The component elements have a process attribute These attributes set: each component runs in its own process some components share a process components of different applications run in the same process The application element can set a default value that applies to all components All components are instantiated in the main thread of the specified process All methods runs in the main thread of the process No component should perform long or blocking operations (such as networking operations or computation loops) Blocking operations will block any other components in the process Long operations can be spawned to separate threads Android may decide to shut down a process at any point Application components running in the process are consequently destroyed The decision whether to terminate a process depends on the state of the process components A process is restarted for those components when there's again work for them to do Thread do background work The thread that hosts an activity should not also host timeconsuming operations Anything that may not be completed quickly should be assigned to a different thread Threads are created in code using standard Java Thread objects Android provides a number of convenience classes for managing threads: Looper for running a message loop within a thread Handler for processing messages HandlerThread for setting up a thread with a message loop An activity has essentially three states: Active: when it is in the foreground of the screen Paused: lost focus but still visible to the user Stopped: completely obscured by another activity If an activity is paused or stopped, the system can drop it from memory either by asking it to finish (finish))(, or simply killing its process When it is displayed again to the user, it must be completely restarted and restored to its previous state . As an activity transitions from state to state, it is notified of the change by calls to the following protected methods : void onCreate(Bundle savedInstanceState( void onStart )( void onRestart )( void onResume )( void onPause )( void onStop )( void onDestroy)( Lifecycle Activity Methods Method Description Killa ble? Next onCreate )( Called when the activity is first created . No onStart)( onRestart)( Called when the activity is becoming visible to the user . No onResume)( or onStop() onResume)( Called when the activity will start No interacting with the user . onPause)( onPause)( Called when the system is about to start resuming a previous activity . Yes onResume)( or onStop() onStop)( Called when the activity is no longer visible to the user Yes onRestart)( or onDestroy() Yes nothing onDestroy)( The final call you receive before your activity is destroyed . There are generally two kinds of persistent state: shared document- like data (SQLite) internal state – like user preferences getPreferences(int): used for retrieving and modifying a set of name/value pairs associated with the activity getSharedPreferences(int): used for retrieving and modifying a set of name/value pairs shared across multiple application components Retrieving info: SharedPreferences ref = getSharedPreferences(TAG, MODE_PRIVATE); String lastActivity = ref.getString(LAST_ACTIVITY, "Ex2"); Writing info: SharedPreferences.Editor ed = ref.edit(); ed.putString(LAST_ACTIVITY, "Activity3"); ed.commit();