Android Activity和Intent机制学习笔记

原作者：http://www.cnblogs.com/feisky/category/225793.html

Activity

Android中，Activity是所有程序的根本，所有程序的流程都运行在Activity之中，Activity具有自己的生命周期（见http://www.cnblogs.com/feisky/archive/2010/01/01/1637427.html，由系统控制生命周期，程序无法改变，但可以用onSaveInstanceState保存其状态）。

对于Activity，关键是其生命周期的把握（如下图），其次就是状态的保存和恢复（onSaveInstanceState onRestoreInstanceState），以及Activity之间的跳转和数据传输（intent）。

 

Activity中常用的函数有SetContentView()   findViewById()    finish()   startActivity()，其生命周期涉及的函数有：

void onCreate(Bundle savedInstanceState)
void onStart()
void onRestart()
void onResume()
void onPause()
void onStop()
void onDestroy()

注意的是，Activity的使用需要在Manifest文件中添加相应的<Activity>，并设置其属性和intent-filter。

Intent

Android中提供了Intent机制来协助应用间的交互与通讯，Intent负责对应用中一次操作的动作、动作涉及数据、附加数据进行描述，Android则根据此Intent的描述，负责找到对应的组件，将 Intent传递给调用的组件，并完成组件的调用。Intent不仅可用于应用程序之间，也可用于应用程序内部的Activity/Service之间的交互。因此，Intent在这里起着一个媒体中介的作用，专门提供组件互相调用的相关信息，实现调用者与被调用者之间的解耦。在SDK中给出了Intent作用的表现形式为：

• 通过Context.startActivity() orActivity.startActivityForResult() 启动一个Activity；
• 通过 Context.startService() 启动一个服务，或者通过Context.bindService() 和后台服务交互；
• 通过广播方法(比如 Context.sendBroadcast(),Context.sendOrderedBroadcast(),  Context.sendStickyBroadcast()) 发给broadcast receivers。

Intent属性的设置，包括以下几点：（以下为XML中定义，当然也可以通过Intent类的方法来获取和设置）

（1）Action，也就是要执行的动作

SDk中定义了一些标准的动作，包括

onstantTarget componentActionACTION_CALLactivityInitiate a phone call.ACTION_EDITactivityDisplay data for the user to edit.ACTION_MAINactivityStart up as the initial activity of a task, with no data input and no returned output.ACTION_SYNCactivitySynchronize data on a server with data on the mobile device.ACTION_BATTERY_LOWbroadcast receiverA warning that the battery is low.ACTION_HEADSET_PLUGbroadcast receiverA headset has been plugged into the device, or unplugged from it.ACTION_SCREEN_ONbroadcast receiverThe screen has been turned on.ACTION_TIMEZONE_CHANGEDbroadcast receiverThe setting for the time zone has changed.

 

当然，也可以自定义动作（自定义的动作在使用时，需要加上包名作为前缀，如"com.example.project.SHOW_COLOR”），并可定义相应的Activity来处理我们的自定义动作。

（2）Data，也就是执行动作要操作的数据

Android中采用指向数据的一个URI来表示，如在联系人应用中，一个指向某联系人的URI可能为：content://contacts/1。对于不同的动作，其URI数据的类型是不同的（可以设置type属性指定特定类型数据），如ACTION_EDIT指定Data为文件URI，打电话为tel:URI，访问网络为http:URI，而由content provider提供的数据则为content: URIs。

（3）type（数据类型），显式指定Intent的数据类型（MIME）。一般Intent的数据类型能够根据数据本身进行判定，但是通过设置这个属性，可以强制采用显式指定的类型而不再进行推导。

（4）category（类别），被执行动作的附加信息。例如 LAUNCHER_CATEGORY 表示Intent 的接受者应该在Launcher中作为顶级应用出现；而ALTERNATIVE_CATEGORY表示当前的Intent是一系列的可选动作中的一个，这些动作可以在同一块数据上执行。还有其他的为

ConstantMeaningCATEGORY_BROWSABLEThe target activity can be safely invoked by the browser to display data referenced by a link — for example, an image or an e-mail message.CATEGORY_GADGETThe activity can be embedded inside of another activity that hosts gadgets.CATEGORY_HOMEThe activity displays the home screen, the first screen the user sees when the device is turned on or when the HOME key is pressed.CATEGORY_LAUNCHERThe activity can be the initial activity of a task and is listed in the top-level application launcher.CATEGORY_PREFERENCEThe target activity is a preference panel.

 

（5）component（组件），指定Intent的的目标组件的类名称。通常 Android会根据Intent 中包含的其它属性的信息，比如action、data/type、category进行查找，最终找到一个与之匹配的目标组件。但是，如果 component这个属性有指定的话，将直接使用它指定的组件，而不再执行上述查找过程。指定了这个属性以后，Intent的其它所有属性都是可选的。

（6）extras（附加信息），是其它所有附加信息的集合。使用extras可以为组件提供扩展信息，比如，如果要执行“发送电子邮件”这个动作，可以将电子邮件的标题、正文等保存在extras里，传给电子邮件发送组件。

理解Intent的关键之一是理解清楚Intent的两种基本用法：一种是显式的Intent，即在构造Intent对象时就指定接收者；另一种是隐式的Intent，即Intent的发送者在构造Intent对象时，并不知道也不关心接收者是谁，有利于降低发送者和接收者之间的耦合。

对于显式Intent，Android不需要去做解析，因为目标组件已经很明确，Android需要解析的是那些隐式Intent，通过解析，将 Intent映射给可以处理此Intent的Activity、IntentReceiver或Service。        

Intent解析机制主要是通过查找已注册在AndroidManifest.xml中的所有IntentFilter及其中定义的Intent，最终找到匹配的Intent。在这个解析过程中，Android是通过Intent的action、type、category这三个属性来进行判断的，判断方法如下：

• 如果Intent指明定了action，则目标组件的IntentFilter的action列表中就必须包含有这个action，否则不能匹配；
• 如果Intent没有提供type，系统将从data中得到数据类型。和action一样，目标组件的数据类型列表中必须包含Intent的数据类型，否则不能匹配。
• 如果Intent中的数据不是content: 类型的URI，而且Intent也没有明确指定它的type，将根据Intent中数据的scheme （比如 http: 或者mailto:） 进行匹配。同上，Intent 的scheme必须出现在目标组件的scheme列表中。
• 如果Intent指定了一个或多个category，这些类别必须全部出现在组建的类别列表中。比如Intent中包含了两个类别：LAUNCHER_CATEGORY 和 ALTERNATIVE_CATEGORY，解析得到的目标组件必须至少包含这两个类别。

Intent-Filter的定义

一些属性设置的例子：

<action android:name="com.example.project.SHOW_CURRENT" />

<category android:name="android.intent.category.DEFAULT" />

<data android:mimeType="video/mpeg" android:scheme="http" . . . /> 

<data android:mimeType="image/*" />

<data android:scheme="http" android:type="video/*" />

完整的实例

<activity android:name="NotesList" android:label="@string/title_notes_list">            <intent-filter>                <action android:name="android.intent.action.MAIN" />                <category android:name="android.intent.category.LAUNCHER" />            </intent-filter>            <intent-filter>                <action android:name="android.intent.action.VIEW" />                <action android:name="android.intent.action.EDIT" />                <action android:name="android.intent.action.PICK" />                <category android:name="android.intent.category.DEFAULT" />                <data android:mimeType="vnd.android.cursor.dir/vnd.google.note" />            </intent-filter>            <intent-filter>                <action android:name="android.intent.action.GET_CONTENT" />                <category android:name="android.intent.category.DEFAULT" />                <data android:mimeType="vnd.android.cursor.item/vnd.google.note" />            </intent-filter>        </activity>

Intent用法实例

1.无参数Activity跳转

Intent it = new Intent(Activity.Main.this, Activity2.class);startActivity(it);   

 

2.向下一个Activity传递数据（使用Bundle和Intent.putExtras）

Intent it = new Intent(Activity.Main.this, Activity2.class);Bundle bundle=new Bundle();bundle.putString("name", "This is from MainActivity!");it.putExtras(bundle);       // it.putExtra(“test”, "shuju”);startActivity(it);            // startActivityForResult(it,REQUEST_CODE);

 

对于数据的获取可以采用：

Bundle bundle=getIntent().getExtras();String name=bundle.getString("name");

 

3.向上一个Activity返回结果（使用setResult，针对startActivityForResult(it,REQUEST_CODE)启动的Activity）

        Intent intent=getIntent();        Bundle bundle2=new Bundle();        bundle2.putString("name", "This is from ShowMsg!");        intent.putExtras(bundle2);        setResult(RESULT_OK, intent);

 

4.回调上一个Activity的结果处理函数（onActivityResult）

@Override    protected void onActivityResult(int requestCode, int resultCode, Intent data) {        // TODO Auto-generated method stub        super.onActivityResult(requestCode, resultCode, data);        if (requestCode==REQUEST_CODE){            if(resultCode==RESULT_CANCELED)                  setTitle("cancle");            else if (resultCode==RESULT_OK) {                 String temp=null;                 Bundle bundle=data.getExtras();                 if(bundle!=null)   temp=bundle.getString("name");                 setTitle(temp);            }        }    }

 

下面是转载来的其他的一些Intent用法实例（转自javaeye）

显示网页
   1. Uri uri = Uri.parse("http://google.com");  
   2. Intent it = new Intent(Intent.ACTION_VIEW, uri);  
   3. startActivity(it);

显示地图
   1. Uri uri = Uri.parse("geo:38.899533,-77.036476");  
   2. Intent it = new Intent(Intent.ACTION_VIEW, uri);   
   3. startActivity(it);   
   4. //其他 geo URI 範例  
   5. //geo:latitude,longitude  
   6. //geo:latitude,longitude?z=zoom  
   7. //geo:0,0?q=my+street+address  
   8. //geo:0,0?q=business+near+city  
   9. //google.streetview:cbll=lat,lng&cbp=1,yaw,,pitch,zoom&mz=mapZoom

路径规划
   1. Uri uri = Uri.parse("http://maps.google.com/maps?f=d&saddr=startLat%20startLng&daddr=endLat%20endLng&hl=en");  
   2. Intent it = new Intent(Intent.ACTION_VIEW, uri);  
   3. startActivity(it);  
   4. //where startLat, startLng, endLat, endLng are a long with 6 decimals like: 50.123456 

打电话
   1. //叫出拨号程序 
   2. Uri uri = Uri.parse("tel:[phone]");  
   3. Intent it = new Intent(Intent.ACTION_DIAL, uri);  
   4. startActivity(it);  
   1. //直接打电话出去  
   2. Uri uri = Uri.parse("tel:[phone]");  
   3. Intent it = new Intent(Intent.ACTION_CALL, uri);  
   4. startActivity(it);  
   5. //用這個，要在 AndroidManifest.xml 中，加上  
   6. //<uses-permission id="android.permission.CALL_PHONE" /> 

传送SMS/MMS
   1. //调用短信程序 
   2. Intent it = new Intent(Intent.ACTION_VIEW, uri);  
   3. it.putExtra("sms_body", "The SMS text");   
   4. it.setType("vnd.android-dir/mms-sms");  
   5. startActivity(it); 
   1. //传送消息 
   2. Uri uri = Uri.parse("smsto://0800000123");  
   3. Intent it = new Intent(Intent.ACTION_SENDTO, uri);  
   4. it.putExtra("sms_body", "The SMS text");  
   5. startActivity(it); 
   1. //传送 MMS  
   2. Uri uri = Uri.parse("content://media/external/images/media/23");  
   3. Intent it = new Intent(Intent.ACTION_SEND);   
   4. it.putExtra("sms_body", "some text");   
   5. it.putExtra(Intent.EXTRA_STREAM, uri);  
   6. it.setType("image/png");   
   7. startActivity(it); 

传送 Email
   1. Uri uri = Uri.parse("mailto:[e-mail]");  
   2. Intent it = new Intent(Intent.ACTION_SENDTO, uri);  
   3. startActivity(it); 

   1. Intent it = new Intent(Intent.ACTION_SEND);  
   2. it.putExtra(Intent.EXTRA_EMAIL, "[e-mail]");  
   3. it.putExtra(Intent.EXTRA_TEXT, "The email body text");  
   4. it.setType("text/plain");  
   5. startActivity(Intent.createChooser(it, "Choose Email Client")); 

   1. Intent it=new Intent(Intent.ACTION_SEND);    
   2. String[] tos={"[e-mail]"};    
   3. String[] ccs={"[e-mail]"};    
   4. it.putExtra(Intent.EXTRA_EMAIL, tos);    
   5. it.putExtra(Intent.EXTRA_CC, ccs);    
   6. it.putExtra(Intent.EXTRA_TEXT, "The email body text");    
   7. it.putExtra(Intent.EXTRA_SUBJECT, "The email subject text");    
   8. it.setType("message/rfc822");    
   9. startActivity(Intent.createChooser(it, "Choose Email Client"));

   1. //传送附件
   2. Intent it = new Intent(Intent.ACTION_SEND);  
   3. it.putExtra(Intent.EXTRA_SUBJECT, "The email subject text");  
   4. it.putExtra(Intent.EXTRA_STREAM, "file:///sdcard/mysong.mp3");  
   5. sendIntent.setType("audio/mp3");  
   6. startActivity(Intent.createChooser(it, "Choose Email Client"));

播放多媒体
       Uri uri = Uri.parse("file:///sdcard/song.mp3");  
       Intent it = new Intent(Intent.ACTION_VIEW, uri);  
       it.setType("audio/mp3");  
       startActivity(it); 
       Uri uri = Uri.withAppendedPath(MediaStore.Audio.Media.INTERNAL_CONTENT_URI, "1");  
       Intent it = new Intent(Intent.ACTION_VIEW, uri);  
       startActivity(it);

Market 相关
1.        //寻找某个应用 
2.        Uri uri = Uri.parse("market://search?q=pname:pkg_name"); 
3.        Intent it = new Intent(Intent.ACTION_VIEW, uri);  
4.        startActivity(it);  
5.        //where pkg_name is the full package path for an application 
1.        //显示某个应用的相关信息 
2.        Uri uri = Uri.parse("market://details?id=app_id");  
3.        Intent it = new Intent(Intent.ACTION_VIEW, uri); 
4.        startActivity(it);  
5.        //where app_id is the application ID, find the ID   
6.        //by clicking on your application on Market home   
7.        //page, and notice the ID from the address bar

Uninstall 应用程序
1.        Uri uri = Uri.fromParts("package", strPackageName, null); 
2.        Intent it = new Intent(Intent.ACTION_DELETE, uri);   
3.        startActivity(it); 

 

 

======================

 

 

在 Android 中，多数情况下每个程序都是在各自独立的 Linux 进程中运行的。当一个程序或其某些部分被请求时，它的进程就“出生”了；当这个程序没有必要再运行下去且系统需要回收这个进程的内存用于其他程序时，这个 进程就“死亡”了。可以看出，Android 程序的生命周期是由系统控制而非程序自身直接控制。这和我们编写桌面应用程序时的思维有一些不同，一个桌面应用程序的进程也是在其他进程或用户请求时被创 建，但是往往是在程序自身收到关闭请求后执行一个特定的动作（比如从 main 函数中 return）而导致进程结束的。要想做好某种类型的程序或者某种平台下的程序的开发，最关键的就是要弄清楚这种类型的程序或整个平台下的程序的一般工作 模式并熟记在心。在 Android 中，程序的生命周期控制就是属于这个范畴——我的个人理解:)

在 Android 系统中，当某个 activity调用 startActivity(myIntent) 时，系统会在所有已经安装的程序中寻找其 intent filter 和 myIntent 最匹配的一个 activity，启动这个进程，并把这个 intent 通知给这个 activity。这就是一个程序的“生”。比如我们在 Home application 中选择 “Web browser”，系统会根据这个 intent 找到并启动 Web browser 程序，显示 Web browser 的一个 activity 供我们浏览网页（这个启动过程有点类似我们在在个人电脑上双击桌面上的一个图标，启动某个应用程序）。在 Android 中，所有的应用程序“生来就是平等的”，所以不光 Android 的核心程序甚至第三方程序也可以发出一个 intent 来启动另外一个程序中的一个 activity。Android 的这种设计非常有利于“程序部件”的重用。

  一个 Android 程序的进程是何时被系统结束的呢？通俗地说，一个即将被系统关闭的程序是系统在内存不足（low memory）时，根据“重要性层次”选出来的“牺牲品”。一个进程的重要性是根据其中运行的部件和部件的状态决定的。各种进程按照重要性从高到低排列如 下：
  1. 前台进程。这样的进程拥有一个在屏幕上显示并和用户交互的 activity 或者它的一个IntentReciver 正在运行。这样的程序重要性最高，只有在系统内存非常低，万不得已时才会被结束。
  2. 可见进程。在屏幕上显示，但是不在前台的程序。比如一个前台进程以对话框的形式显示在该进程前面。这样的进程也很重要，它们只有在系统没有足够内存运行所有前台进程时，才会被结束。
  3. 服务进程。这样的进程在后台持续运行，比如后台音乐播放、后台数据上传下载等。这样的进程对用户来说一般很有用，所以只有当系统没有足够内存来维持所有的前台和可见进程时，才会被结束。
  4. 后台进程。这样的程序拥有一个用户不可见的 activity。这样的程序在系统内存不足时，按照 LRU 的顺序被结束。
  5. 空进程。这样的进程不包含任何活动的程序部件。系统可能随时关闭这类进程。

从某种意义上讲，垃圾收集机制把程序员从“内存管理噩梦”中解放出来，而 Android 的进程生命周期管理机制把用户从“任务管理噩梦”中解放出来。我见过一些 Nokia S60 用户和 Windows Mobile 用户要么因为长期不关闭多余的应用程序而导致系统变慢，要么因为不时查看应用程序列表而影响使用体验。Android 使用 Java 作为应用程序 API，并且结合其独特的生命周期管理机制同时为开发者和使用者提供最大程度的便利。

Activity lifecycle

Activity有三种基本状态：

1. Active：处于屏幕前景（当前task的栈顶Activity处于Active状态），同一时刻只能有一个Activity处于Active状态；
2. Paused状态：处于背景画面画面状态，失去了焦点，但依然是活动状态；
3. stopped：不可见，但依然保持所有的状态和内存信息。

可以调用finish()结束处理Paused或者stopped状态的Activity。

各种状态之间通过下列的函数调用转换：

void onCreate(Bundle savedInstanceState)
void onStart()
void onRestart()
void onResume()
void onPause()
void onStop()
void onDestroy()

Activity的生命周期可以分为三组：

• The entire lifetime of an activity happens between the first call toonCreate() through to a single final call to onDestroy().

• The visible lifetime of an activity happens between a call toonStart() until a corresponding call to onStop().

• The foreground lifetime of an activity happens between a call to onResume() until a corresponding call toonPause().

 

保存Activity状态

To capture that state before the activity is killed, you can implement an onSaveInstanceState() method for the activity. Android calls this method before making the activity vulnerable to being destroyed — that is, before onPause() is called. It passes the method a Bundle object where you can record the dynamic state of the activity as name-value pairs. When the activity is again started, the Bundle is passed both to onCreate() and to a method that's called after onStart(),onRestoreInstanceState(), so that either or both of them can recreate the captured state.

Unlike onPause() and the other methods discussed earlier, onSaveInstanceState() and onRestoreInstanceState()are not lifecycle methods. They are not always called. Because onSaveInstanceState() is not always called, you should use it only to record the transient state of the activity, not to store persistent data. Use onPause() for that purpose instead.

启动另一个Activity的过程

The current activity's onPause() method is called.

Next, the starting activity's onCreate(), onStart(), and onResume() methods are called in sequence.

Then, if the starting activity is no longer visible on screen, its onStop() method is called.

service生命周期

A service can be used in two ways:

• It can be started and allowed to run until someone stops it or it stops itself. In this mode, it's started by callingContext.startService()and stopped by calling Context.stopService(). It can stop itself by callingService.stopSelf() or Service.stopSelfResult(). Only onestopService() call is needed to stop the service, no matter how many times startService() was called.

• It can be operated programmatically using an interface that it defines and exports. Clients establish a connection to the Service object and use that connection to call into the service. The connection is established by callingContext.bindService(), and is closed by calling Context.unbindService(). Multiple clients can bind to the same service. If the service has not already been launched,bindService() can optionally launch it.

相关的方法：

void onCreate()
void onStart(Intent intent)
void onDestroy()

The onCreate() and onDestroy() methods are called for all services, whether they're started byContext.startService() or Context.bindService(). However, onStart() is called only for services started bystartService().

If a service permits others to bind to it, there are additional callback methods for it to implement:

IBinder onBind(Intent intent)
boolean onUnbind(Intent intent)
void onRebind(Intent intent)

 

Broadcast receiver lifecycle

只有一个方法：void onReceive(Context curContext, Intent broadcastMsg)

A process with an active broadcast receiver is protected from being killed. But a process with only inactive components can be killed by the system at any time, when the memory it consumes is needed by other processes.

This presents a problem when the response to a broadcast message is time consuming and, therefore, something that should be done in a separate thread, away from the main thread where other components of the user interface run. IfonReceive() spawns the thread and then returns, the entire process, including the new thread, is judged to be inactive (unless other application components are active in the process), putting it in jeopardy of being killed. The solution to this problem is for onReceive() to start a service and let the service do the job, so the system knows that there is still active work being done in the process.

进程的生命周期

Android根据其重要性在内存不足的时候移去重要性最低的进程。重要性由高到低为：

1. 前台进程
2. 可见进程
3. 服务进程
4. 后台进程
5. 空进程

注意：Because a process running a service is ranked higher than one with background activities, an activity that initiates a long-running operation might do well to start a service for that operation, rather than simply spawn a thread — particularly if the operation will likely outlast the activity. 比如播放MP3的时候就要启动一个service。

<!--EndFragment--><!--EndFragment-->