程序入口点
类似于win32程序里的WinMain函数，Android自然也有它的程序入口点。它通过在AndroidManifest.xml文件中配置来指明，可以看到名为NotesList的activity节点下有这样一个intent-filter,其action为android.intent.action.MAIN,
Category指定为 android.intent.category.LAUNCHER,这就指明了这个activity是作为入口activity，系统查找到它后，就会创建这个activity实例来运行，若未发现就不启动(你可以把MAIN改名字试试)。
<intent-filter>
<action android:name="android.intent.action.MAIN"
/>
<category android:name="android.intent.category.LAUNCHER"
/>
</intent-filter>
NotesList详解
就从入口点所在的activity(见图1)开始，可以看到这个activity最重要的功能就是显示日志列表。这个程序的日志都存放在Sqlite数据库中，因此需要读取出所有的日志记录并显示。
先来看两个重要的私有数据，第一个PROJECTION字段指明了“日志列表“所关注的数据库中的字段（即只需要ID和Title就可以了）。
private
static
final String[] PROJECTION =
new String[] {
Notes._ID, // 0
Notes.TITLE, // 1
};
第二个字段COLUMN_INDEX_TITLE指明title字段在数据表中的索引。
private
static
final
int COLUMN_INDEX_TITLE =
1;
然后就进入第一个调用的函数onCreate。
Intent intent = getIntent();
if (intent.getData() ==
null)
{
intent.setData(Notes.CONTENT_URI);
}
因为NotesList这个activity是系统调用的，此时的intent是不带数据和操作类型的，系统只是在其中指明了目标组件是Notelist，所以这里把”content:// com.google.provider.NotePad/notes”保存到intent里面，这个URI地址指明了数据库中的数据表名（参见以后的NotePadProvider类），也就是保存日志的数据表notes。
Cursor cursor = managedQuery(getIntent().getData(), PROJECTION, null, null, Notes.DEFAULT_SORT_ORDER);
然后调用managedQuery函数查询出所有的日志信息，这里第一个参数就是上面设置的” content:// com.google.provider.NotePad/notes”这个URI，即notes数据表。PROJECTION 字段指明了结果中所需要的字段，Notes.DEFAULT_SORT_ORDER 指明了结果的排序规则。实际上managedQuery并没有直接去查询数据库，而是通过Content Provider来完成实际的数据库操作，这样就实现了逻辑层和数据库层的分离。
SimpleCursorAdapter adapter =
new SimpleCursorAdapter(this, R.layout.noteslist_item, cursor,
new String[] { Notes.TITLE }, new
int[] { android.R.id.text1 });
setListAdapter(adapter);
查询出日志列表后，构造一个CursorAdapter，并将其作为List View的数据源，从而在界面上显示出日志列表。可以看到，第二个参数是R.layout.noteslist_item，打开对应的noteslist_item.xml文件，
<TextView xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@android:id/text1"
android:layout_width="fill_parent"
android:layout_height="?android:attr/listPreferredItemHeight"
android:textAppearance="?android:attr/textAppearanceLarge"
android:gravity="center_vertical"
android:paddingLeft="5dip"
android:singleLine="true"
/>
就是用来显示一条日志记录的TextView,最后两个字段指明了实际的字段映射关系，通过这个TextView来显示一条日志记录的title字段。
处理“选择日志”事件
既然有了“日志列表”，就自然要考虑如何处理某一条日志的单击事件，这通过重载onListItemClick方法来完成，
@Override
protected
void onListItemClick(ListView l, View v, int position, long id) {
Uri uri = ContentUris.withAppendedId(getIntent().getData(), id);
String action = getIntent().getAction();
if (Intent.ACTION_PICK.equals(action) || Intent.ACTION_GET_CONTENT.equals(action)) {
// The caller is waiting for us to return a note selected by
// the user. The have clicked on one, so return it now.
setResult(RESULT_OK, new Intent().setData(uri));
} else {
// Launch activity to view/edit the currently selected item
startActivity(new Intent(Intent.ACTION_EDIT, uri));
}
}
首先通过”content:// com.google.provider.NotePad/notes”和日志的id 号拼接得到选中日志的真正URI,然后创建一个新的Intent,其操作类型为Intent.ACTION_EDIT，数据域指出待编辑的日志URI（这里只分析else块）。
Intent深度剖析
那么，上面这句startActivity(new Intent(Intent.ACTION_EDIT, uri))执行后会发生什么事情呢？这时候Android系统就跳出来接管了，它会根据intent中的信息找到对应的activity，在这里找到的是NoteEditor这个activity，然后创建这个activity的实例并运行。
那么，Android又是如何找到NoteEditor这个对应的activity的呢？这就是intent发挥作用的时刻了。
new Intent(Intent.ACTION_EDIT, uri)
这里的Intent.ACTION_EDIT=” android.intent.action.EDIT”,另外通过设置断点，我们看下这里的uri值：
可以看到选中的日志条目的URI是：content://com.google.provider.NotePad/notes/1
然后我们再来看下Androidmanfest.xml,其中有这个provider
<provider android:name="NotePadProvider"
android:authorities="com.google.provider.NotePad"
/>
发现没有？它也有com.google.provider.NotePad，这个是content://com.google.provider.NotePad/notes/1的一部分，同时
<activity android:name="NoteEditor"
android:theme="@android:style/Theme.Light"
android:label="@string/title_note"
android:screenOrientation="sensor"
android:configChanges="keyboardHidden|orientation"
>
<!-- This filter says that we can view or edit the data of
a single note -->
<intent-filter android:label="@string/resolve_edit">
<action android:name="android.intent.action.VIEW"
/>
<action android:name="android.intent.action.EDIT"
/>
<action android:name="com.android.notepad.action.EDIT_NOTE"
/>
<category android:name="android.intent.category.DEFAULT"
/>
<data android:mimeType="vnd.android.cursor.item/vnd.google.note"
/>
</intent-filter>
<!-- This filter says that we can create a new note inside
of a directory of notes. -->
<intent-filter>
<action android:name="android.intent.action.INSERT"
/>
<category android:name="android.intent.category.DEFAULT"
/>
<data android:mimeType="vnd.android.cursor.dir/vnd.google.note"
/>
</intent-filter>
</activity>
上面第一个intent-filter中有一个action 名为android.intent.action.EDIT，而前面我们创建的Intent也正好是
Intent.ACTION_EDIT=” android.intent.action.EDIT”，想必大家已经明白是怎么回事了吧。
下面就进入activity选择机制了：
系统从intent中获取道uri，得到了content://com.google.provider.NotePad/notes/1,去掉开始的content:标识，得到com.google.provider.NotePad/notes/1,然后获取前面的com.google.provider.NotePad，然后就到Androidmanfest.xml中找到authorities为com.google.provider.NotePad的provider，这个就是后面要讲的contentprovider,然后就加载这个content
provider。
<provider android:name="NotePadProvider"
android:authorities="com.google.provider.NotePad"
/>
在这里是NotePadProvider,然后调用NotePadProvider的gettype函数，并把上述URI传给这个函数，函数返回URI所对应的类型（这里返回Notes.CONTENT_ITEM_TYPE，代表一条日志记录，而CONTENT_ITEM_TYPE = " vnd.android.cursor.item/vnd.google.note "）。
@Override
public String getType(Uri uri) {
switch (sUriMatcher.match(uri)) {
case NOTES:
return Notes.CONTENT_TYPE;
case NOTE_ID:
return Notes.CONTENT_ITEM_TYPE;
default:
throw
new IllegalArgumentException("Unknown URI "
+ uri);
}
}
上面的sUriMatcher.match是用来检测uri是否能够被处理，而sUriMatcher.match(uri)返回值其实是由
sUriMatcher =
new UriMatcher(UriMatcher.NO_MATCH);
sUriMatcher.addURI(NotePad.AUTHORITY, "notes", NOTES);
sUriMatcher.addURI(NotePad.AUTHORITY, "notes/#", NOTE_ID);
决定的。
然后系统使用获得的" vnd.android.cursor.item/vnd.google.note "和”android.intent.action.EDIT”到androidmanfest.xml中去找匹配的activity.
<intent-filter android:label="@string/resolve_edit">
<action android:name="android.intent.action.VIEW"
/>
<action android:name="android.intent.action.EDIT"
/>
<action android:name="com.android.notepad.action.EDIT_NOTE"
/>
<category android:name="android.intent.category.DEFAULT"
/>
<data android:mimeType="vnd.android.cursor.item/vnd.google.note"
/>
</intent-filter>
正好NoteEditor这个activity的intent-filter满足上述条件,这样就找到了NoteEditor。于是系统加载这个类并实例化，运行，然后就到了NoteEditor的OnCreate函数中（见后续文章）。
小技巧
1，在命令行中使用”adb shell”命令进入系统中，然后”cd app”进入应用程序所在目录，”rm XXX”就可以删除你指定的apk，从而去掉其在系统顶层界面占据的图标，若两次”cd data”则可以进入应用程序使用的数据目录，你的数据可以保存在这里，例如Notepad就是把其数据库放在它的databases目录下，名为note_pad.db.
2，第一次启动模拟器会比较慢，但以后就别关闭模拟器了，修改代码，调试都不需要再次启动的，直接修改后run或debug就是。
2.在测试时,如何实现一个提示
可以使用
1. Toast.makeText(this, "这是一个提示", Toast.LENGTH_SHORT).show();
2. //从资源文件string.xml 里面取提示信息
3. Toast.makeText(this, getString(R.string.welcome), Toast.LENGTH_SHORT).show();
这个提示会几秒钟后消失
3.可以使用AlertDialog.Builder 才产生一个提示框.
例如像messagebox那样的
1. new AlertDialog.Builder(this)
2. .setTitle("Android 提示")
3. .setMessage("这是一个提示,请确定")
4. .show();
带一个确定的对话框
1. new AlertDialog.Builder(this)
2. .setMessage("这是第二个提示")
3. .setPositiveButton("确定",
4. new DialogInterface.OnClickListener(){
5. public void onClick(DialogInterface dialoginterface, int i){
6. //按钮事件
7. }
8. })
9. .show();
AlertDialog.Builder 还有很多复杂的用法,有确定和取消的对话框
1. new AlertDialog.Builder(this)
2. .setTitle("提示")
3. .setMessage("确定退出?")
4. .setIcon(R.drawable.quit)
5. .setPositiveButton("确定", new DialogInterface.OnClickListener() {
6. public void onClick(DialogInterface dialog, int whichButton) {
7. setResult(RESULT_OK);//确定按钮事件
8. finish();
9. }
10. })
11. .setNegativeButton("取消", new DialogInterface.OnClickListener() {
12. public void onClick(DialogInterface dialog, int whichButton) {
13. //取消按钮事件
14. }
15. })
16. .show();
4. menu 的用法.
1. 简单的代码
1. public static final int ITEM_1_ID = Menu.FIRST;
2. public static final int ITEM_2_ID = Menu.FIRST + 1;
3. public static final int ITEM_3_ID = Menu.FIRST + 2;
4.
5. public boolean onCreateOptionsMenu(Menu menu) {
6. super.onCreateOptionsMenu(menu);
7. //不带图标的menu
8. menu.add(0, ITEM_1_ID, 0, "item-1");
9. //带图标的menu
10. menu.add(0, ITEM_2_ID, 1, "item-2").setIcon(R.drawable.editbills2);
11. menu.add(0, ITEM_3_ID, 2, "item-3").setIcon(R.drawable.billsum1);
12. return true;
13. }
14.
15. public boolean onOptionsItemSelected(MenuItem item){
16. switch (item.getItemId()) {
17. case 1:
18. Toast.makeText(this, "menu1",Toast.LENGTH_SHORT).show();
19. return true;
20. case 2:
21.
22. return true;
23. case 3:
24.
25. return true;
26. }
27. return false;
28. }
2. menu实现的两种方法
大部分的应用程序都包括两种人机互动方式，一种是直接通过GUI的 Views，其可以满足大部分的交互操作。另外一种是应用Menu，当按下Menu按钮后，会弹出与当前活动状态下的应用程序相匹配的菜单。
这两种方式相比较都有各自的优势，而且可以很好的相辅相成，即便用户可以由主界面完成大部分操作，但是适当的拓展Menu功能可以更加完善应用程序，至少用户可以通过排列整齐的 按钮清晰的了解当前模式下可以使用的功能。
有两种方法可以为Android APPs添加菜单功能,下边将对设置过程给出详细的介绍：
第一种方法，通过Layout来添加静态菜单元素。
一般情况下，开发者在res/Layout路径下来定义应用程序的GUI。应用Eclipse创建一个新项目后，可以看到res/layout中存在一个 预置的main.xml文件，其作为程序默认启动界面。同样，可以通过这种方式 创建一个静态的Menu，创建方法参阅下边的源代码：
?View Code XML
<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
<item
android:id="@+id/previous"
android:title="@string/previous"
android:enabled="false"
android:icon="@android:drawable/ic_media_previous"/>
<!--these may not be available in next api (level > 3), so be carefull-->
<item
android:id="@+id/play_pause"
android:title="@string/play"
android:icon="@android:drawable/ic_media_play"/>
<item
android:id="@+id/next"
android:title="@string/next"
android:icon="@android:drawable/ic_menu_next"/>
</menu>
在Activity类中调用刚刚创建的Menu，首先将当前的Activity与指定的Menu XML相关联：
@Override
public boolean onCreateOptionsMenu(Menu menu) {
super.onCreateOptionsMenu(menu);
getMenuInflater().inflate(R.layout.menu_mainactivity, menu);
return true;
}
实现onOptionsItemSelected方法: (其目的是捕捉到菜单触发事件后，对具体触发的选项作出响应，实际调用的函数包含在各自的case中)
01.@Override
02.public boolean onOptionsItemSelected(MenuItem item) {
03. switch (item.getItemId()) {
04. case R.id.previous:
05. previous(); //go to previous song in the playlist
06. return true;
07. case R.id.play_pause:
08. isPlaying() ? pause() : play(); //toggle play/pause
09. return true;
10. case R.id.next:
11. next(); //go to next song in the playlist
12. return true;
13. }
14. return false; //should never happen
15.}
最后可以通过onPrepareOptionMenu方法初始化Menu Items的属性：
01.@Override
02.public boolean onPrepareOptionsMenu(Menu menu) {
03. //set play_pause menu item look
04. if(isPlaying()) {
05. menu
06. .findItem(R.id.play_pause)
07. .setTitle(R.string.pause)
08. .setIcon(android.R.drawable.ic_media_pause);
09. } else {
10. menu
11. .findItem(R.id.play_pause)
12. .setTitle(R.string.play)
13. .setIcon(android.R.drawable.ic_media_play);
14. }
15. return true;
16.}
大部分程序都通过这种方式添加Menu菜单功能，而且通过以上的步骤来看，其实现方法非常简单。
第二种方法，在Activity类中动态创建Menu。
首先需要定义Menu Item识别序号：
1.public static final MENU_PREVIOUS = 0; //no more R.ids
2.public static final MENU_PLAY_PAUSE = 1;
3.public static final MENU_NEXT = 2;
实现onCreateOptionMenu()方法：（第一种方法中已经通过xml定义了现成的Menu结构，所以不需要应用这个方法）
01.@Override
02.public boolean onCreateOptionsMenu(Menu menu) {
03. menu
04. .add(0, MENU_PREVIOUS, 0, R.string.previous)
05. .setIcon(android.R.drawable.ic_media_previous);
06. menu
07. .add(0, MENU_PLAY_PAUSE, 0, R.string.play)
08. .setIcon (android.R.drawable.ic_media_play);
09. menu
10. .add(0, MENU_NEXT, 0, R.string.next)
11. .setIcon(android.R.drawable.ic_media_next);
12. return true;
13.}
引用与第一种方法相同的方式来捕捉菜单的行为：
01.@Override
02.public boolean onOptionsItemSelected(MenuItem item) {
03. switch (item.getItemId()) {
04. case MENU_PREVIOUS:
05. previous(); //go to previous song in the playlist
06. return true;
07. case MENU_PLAY_PAUSE:
08. isPlaying() ? pause() : play(); //toggle play/pause
09. return true;
10. case MENU_NEXT:
11. next(); //go to next song in the playlist
12. return true;
13. }
14. return false; //should never happen
15.}
————
对以上两种方法的补充：
根据需要设置不同Menu Item的属性：
1.menu.findItem(R.id.next).setEnabled(false);
设置Menu Item从属关系(添加子父级别）：
直接写在方法中：
1.menu
2. .addSubMenu(R.id.repeat)
3. .add(R.id.one)
4. .add(R.id.all)
5. .add(R.id.none);
直接定义在XML Layout中：
?View Code XML
<item android:id="@+id/repeat" android:title="@string/repeat">
<menu>
<item android:id="@+id/one" android:title="@string/repeat_one"></item>
<item android:id="@+id/all" android:title="@string/repeat_all"></item>
<item android:id="@+id/none" android:title="@string/repeat_none"></item>
</menu>
————
这两种不同的方法实现的目的是一样的，而且不存在本质上的却别，具体根据实际情况(根据项目的结构需要或者团队开发标准)选择合适的方法来创建Menu。
5.Activity 的切换（含Bundle传值）
1. 代码
1、 2个Activity 的切换,没有数据传递
1. //从A到B
2. Intent intent = new Intent();
3. intent.setClass(A.this, B.class);
4. startActivity(intent);
5. A.this.finish();
2、 2个Activity 之间传递数据(简单)
//A数据传给B
//A中代码：”passData” 是自定义的识别标志，可以随便命名~ 还可以添加多个
Intent intent = new Intent();
intent.setClass(A.this, B.class);
Bundle mBundle = new Bundle();
mBundle.putString("passData", "ray'blog");//压入数据
intent.putExtras(mBundle);
startActivity(intent);
A.this.finish();
//B中接受数据的代码：
//读出数据， 则data的值为 ray‘blog
Bundle bundle = getIntent().getExtras();
String data = bundle.getString( "passData" );
3、 2个Activity 之间传递数据（复杂方法我没看懂）
相关的几个函数
startActivityForResult
public final void setResult(int resultCode, String data)
回调函数
protected void onActivityResult(int requestCode, int resultCode, Intent data)
例如A到B, 从B得到A的数据
1. //A到B
2. static final int RG_REQUEST = 0;
3. Intent intent = new Intent();
4. intent.setClass(A.this, B.class);
5. startActivityForResult(intent,RG_REQUEST);
6.
7. //在B中处理
8. Bundle bundle = new Bundle();
bundle.putString("DataKey", edittext.getText().toString());//给bundle 写入数据
Intent mIntent = new Intent();
mIntent.putExtras(bundle);
setResult(RESULT_OK, mIntent);
finish();
9.
10. //最后在A的回调函数里面接收数据
11. if (requestCode == RG_REQUEST) {
if (resultCode == RESULT_CANCELED)
setTitle("Canceled...");
else if(resultCode == RESULT_OK) {
setTitle((String)data.getCharSequenceExtra("DataKey"));
}
}
2. 详解:
一个Android应用程序很少会只有一个Activity对象，如何在多个Activity之间进行跳转，而且能够互相传值是一个很基本的要求。
在前面创建的MyApp中，我们通过点击按钮可以更新当前界面上的文本内容。现在我们想换种方式，在点击按钮后，显示一个新的屏幕，在这个屏幕上输入一段话，然后再返回到原先的界面显示刚才输入的那句话。
首先我们新建这个新屏幕的布局文件input.xml，并添加一个文本输入框和一个按钮（注意，xml元素的命名不要和其他布局文件中的定义重名，因为所有的资源都在R中进行索引，比如id，如果重名了在使用R.id.*的时候就会有问题了）。这个布局文件对应的是一个Activity，因此我们再新建一个Input类（继承自Activity）用于显示这个布局并响应事件。
然后，还有一个重要的工作，那就是在清单文件AndroidManifest.xml中告诉程序，我定义了一个新的Activity，你可以去调用它。
我们希望在以前的那个主界面上点击按钮以后可以跳转到文本输入界面，所以我们需要对按钮的onClick事件进行定义：
在这段代码里出现了一些新东西。首先是Intent，它是Android一个很重要的类.Intent直译是“意图”，什么是意图呢？比如你想从这个Activity跳转到另外一个Activity，这就是一个意图。它不但可以连接多个Activity，还可以在它们之间传递数据。在这里，我们就是用Intent从MyApp对象跳转到了Input对象。
再看紧跟着的startActivityForResult()方法，顾名思义，它可以从一个定义好的Intent对象启动一个新的Activity，并且，这个Activity会返回执行的结果，这些内容下面马上就会提到。
好，这里我们已经可以调出新Activity了，我们看一下执行的结果：
你马上可以想到，现在需要对新的Activity（Input）进行处理了。我们在点击“确定”按钮的时候，需要获得上面EditText对象中的文本，然后返回到前一个Activity（MyApp）中去。看我们的按钮事件处理：
这里的关键是SharedPreferences对象，这是在多个Activity（同一包中）共享数据的方式，本质上它就是一个可以在包的范围内进行数据共享的文件。
我们通过一个标签“Text”获得了和文本相关的那个SharedPreferences对象（“Text”仅仅是自己定义的一个标签），然后给它赋予一个“text”对象值为当前文本框中输入的文本。设置完成以后，设置当前Activity的执行结果为RESULT_OK，再关闭当前的Activity，剩下的事情就可以回到MyApp这个主界面中去执行了。
其实剩下的事情也很简单，在MyApp这个Activity中，我们需要重写一个函数，onActivityResult()。因为我们启动Input这个Activity的时候使用的是startActivityForResult()方法，这个方法会使Input执行完以后返回给MyApp一个结果，MyApp接收到返回结果的时候会触发onActivityResult事件，对于结果的处理就在onActivityResult()中进行。同样，我们通过“Text”这个标签获得SharedPreferences对象，再把字符串从“text”对象中取出来并显示到当前屏幕上。
另外说明一下，requestCode是用来标识请求对象，我们刚才在启动Activity的时候使用的是“startActivityForResult(intent, 0)”，这里的0就是requestCode，当然，你可以设置成任何你喜欢的值。
我们看一下执行结果：
6.Android UI Layout
1. AbsoluteLayout
在 Android UI 中，最基本的构建单位（building block）是 android.view.View。一个 View 占据屏幕上的一个矩形区域，并负责该区域的绘画和事件处理。View 有一些子类，比如 ImageView、TextView 等可分别用来显示图像、文字…… View 还有一个特殊的子类 ViewGroup，ViewGroup 在 UI layout 中充当“容器”的角色，用以“包含”其他 View 以及 ViewGroup：
viewgroup.png
由于 ViewGroup 是一个 abstract class 无法直接实例化，所以在 layout 中真正充当“容器”角色的应该是 ViewGroup 的子类 ：AbsoluteLayout、 FrameLayout、 LinearLayout、 RelativeLayout 等。在实际的 UI 编程中，使用不同的 Layout 类作为容器，对该容器中的各个子 View 的排列方式有很大影响。比如，LinearLayout 中的各个子 View
按照横向或者纵向线性排列；而 AbsoluteLayout 中各个子 View 可以指定以像素为单位的“绝对”位置。AbsoluteLayout 的这种“绝对”定位的布局方式和我们非常熟悉的 Windows 编程中的 SetWindowPos() 或 Form1.Left = 10 的布局方式是一样的，比较简单：
现在我们新建一个 Android 工程中，在其主 Activity 类中添加如下三个成员：
private AbsoluteLayout al;
private TextView tv;
private View v;
改写这个类的 onCreate 方法如下：
public void onCreate(Bundle icicle) {
super.onCreate(icicle);
构造一个 AbsoluteLayout，设置其背景色
al = new AbsoluteLayout(this);
al.setBackgroundColor(Color.YELLOW);
构造一个 TextView 并设置其 text 和 背景色
tv = new TextView(this);
tv.setText("Android is a software stack for mobile devices that includes an operating system, middleware and key applications. ");
tv.setBackgroundColor(Color.BLUE);
用该 View 在父 View 中的 width，height，x，y 作为参数构造一个 AbsoluteLayout.LayoutParams
AbsoluteLayout.LayoutParams tvLP = new AbsoluteLayout.LayoutParams(70, 50, 10, 20);
把这个 TextView 加入到 AbsoluteLayout 中，并应用上一步创建的 LayoutParams。这样 TextView 就会显示在我们指定的位置上了。
al.addView(tv, tvLP);
v = new View(this);
v.setBackgroundColor(Color.RED);
AbsoluteLayout.LayoutParams vLP = new AbsoluteLayout.LayoutParams(70, 50, 90, 70);
也可以先为子 View 设置 LayoutParams，然后再调用一个参数的 ViewGroup.addView(View) 来添加。效果是一样的。
v.setLayoutParams(vLP);
al.addView(v);
设置 al 为本 Activity 的 content
这样，在该 Activity 被调用时，就会显示该 AbsoluteLayout 和其子 View
this.setContentView(al);
}
7. Tab以及 HostTab操作
Tab与TabHost
这就是Tab，而盛放Tab的容器就是TabHost
如何实现??
每一个Tab还对应了一个布局，这个就有点好玩了。一个Activity，对应了多个功能布局。
①新建一个Tab项目，注意，不要生成main Activity
这里不要选
②在包里面新建一个类MyTab，继承于TabActivity
其实，TabActivity是Activity的子类
package zyf.tab.test;
import android.app.TabActivity;
public class MyTab extends TabActivity {
}
③从父类继承OnCreate()入口方法
package zyf.tab.test;
import android.app.TabActivity;
import android.os.Bundle;
public class MyTab extends TabActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
// TODO Auto-generated method stub
super.onCreate(savedInstanceState);
}
}
④在Manifest.xml文件中注册一下MyTab类(Activity)
⑤这时候，需要设计一下标签页对应的布局，一般采用FrameLayout作为根布局，每个标签页面对应一个子节点的Layout
android:layout_width=”fill_parent” android:layout_height=”fill_parent”>
android:layout_width=”fill_parent” android:layout_height=”fill_parent”
androidrientation=”vertical” >
android:layout_height=”wrap_content” android:text=”EditText”
android:textSize=”18sp”>
android:layout_height=”wrap_content” android:text=”Button”>
android:layout_width=”fill_parent” android:layout_height=”fill_parent”
androidrientation=”vertical” >
android:layout_width=”wrap_content” android:layout_height=”wrap_content”>
android:layout_width=”fill_parent” android:layout_height=”fill_parent”
androidrientation=”vertical”>
android:layout_width=”166px” android:layout_height=”98px”
androidrientation=”vertical”>
android:layout_width=”wrap_content” android:layout_height=”wrap_content”
android:text=”RadioButton”>
android:layout_width=”wrap_content” android:layout_height=”wrap_content”
android:text=”RadioButton”>
⑥首先，应该声明TabHost，然后用LayoutInflater过滤出布局来，给TabHost加上含有Tab页面的FrameLayout
private TabHost myTabhost;
myTabhost=this.getTabHost();//从TabActivity上面获取放置Tab的TabHost
LayoutInflater.from(this).inflate(R.layout.main, myTabhost.getTabContentView(), true);
//from(this)从这个TabActivity获取LayoutInflater
//R.layout.main 存放Tab布局
//通过TabHost获得存放Tab标签页内容的FrameLayout
//是否将inflate 拴系到根布局元素上
myTabhost.setBackgroundColor(Color.argb(150, 22, 70, 150));
//设置一下TabHost的颜色
⑦接着，在TabHost创建一个标签，然后设置一下标题/图标/标签页布局
myTabhost
.addTab(myTabhost.newTabSpec(“TT”)// 制造一个新的标签TT
.setIndicator(“KK”,
getResources().getDrawable(R.drawable.ajjc))
// 设置一下显示的标题为KK，设置一下标签图标为ajjc
.setContent(R.id.widget_layout_red));
//设置一下该标签页的布局内容为R.id.widget_layout_red，这是FrameLayout中的一个子Layout
⑧标签切换事件处理，setOnTabChangedListener
myTabhost.setOnTabChangedListener(new OnTabChangeListener(){
@Override
public void onTabChanged(String tabId) {
// TODO Auto-generated method stub
}
});
⑨各个标签页的动态MENU
先把在XML中设计好的MENU放到一个int数组里
private static final int myMenuResources[] = { R.menu.phonebook_menu,
R.menu.addphone_menu, R.menu.chatting_menu, R.menu.userapp_menu };
在setOnTabChangedListener()方法中根据标签的切换情况来设置myMenuSettingTag
@Override
public void onTabChanged(String tagString) {
// TODO Auto-generated method stub
if (tagString.equals(“One”)) {
myMenuSettingTag = 1;
}
if (tagString.equals(“Two”)) {
myMenuSettingTag = 2;
}
if (tagString.equals(“Three”)) {
myMenuSettingTag = 3;
}
if (tagString.equals(“Four”)) {
myMenuSettingTag = 4;
}
if (myMenu != null) {
onCreateOptionsMenu(myMenu);
}
}
然后onCreateOptionsMenu(Menu menu) 方法中通过MenuInflater过滤器动态加入MENU
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// TODO Auto-generated method stub
// Hold on to this
myMenu = menu;
myMenu.clear();//清空MENU菜单
// Inflate the currently selected menu XML resource.
MenuInflater inflater = getMenuInflater();
//从TabActivity这里获取一个MENU过滤器
switch (myMenuSettingTag) {
case 1:
inflater.inflate(myMenuResources[0], menu);
//动态加入数组中对应的XML MENU菜单
break;
case 2:
inflater.inflate(myMenuResources[1], menu);
break;
case 3:
inflater.inflate(myMenuResources[2], menu);
break;
case 4:
inflater.inflate(myMenuResources[3], menu);
break;
default:
break;
}
return super.onCreateOptionsMenu(menu);
}
⑩运行效果
8. List (图片/按钮/标题/文本)
LIST例一
在android开发中ListView是比较常用的组件，它以列表的形式展示具体内容，并且能够根据数据的长度自适应显示。抽空把对ListView的使用做了整理，并写了个小例子，如下图。
列表的显示需要三个元素：
1．ListVeiw 用来展示列表的View。
2．适配器 用来把数据映射到ListView上的中介。
3．数据 具体的将被映射的字符串，图片，或者基本组件。
根据列表的适配器类型，列表分为三种，ArrayAdapter，SimpleAdapter和SimpleCursorAdapter
其中以ArrayAdapter最为简单，只能展示一行字。SimpleAdapter有最好的扩充性，可以自定义出各种效果。SimpleCursorAdapter可以认为是SimpleAdapter对数据库的简单结合，可以方面的把数据库的内容以列表的形式展示出来。
我们从最简单的ListView开始：
/**
* @author allin
*
*/
public class MyListView extends Activity {
private ListView listView;
//private List<String> data = new ArrayList<String>();
@Override
public void onCreate(Bundle savedInstanceState){
super.onCreate(savedInstanceState);
listView = new ListView(this);
listView.setAdapter(new ArrayAdapter<String>(this, android.R.layout.simple_expandable_list_item_1,getData()));
setContentView(listView);
}
private List<String> getData(){
List<String> data = new ArrayList<String>();
data.add("测试数据1");
data.add("测试数据2");
data.add("测试数据3");
data.add("测试数据4");
return data;
}
}
复制代码
上面代码使用了ArrayAdapter(Context context, int textViewResourceId, List<T> objects)来装配数据，要装配这些数据就需要一个连接ListView视图对象和数组数据的适配器来两者的适配工作，ArrayAdapter的构造需要三个参数，依次为this,布局文件（注意这里的布局文件描述的是列表的每一行的布局，android.R.layout.simple_list_item_1是系统定义好的布局文件只显示一行文字，数据源(一个List集合)。同时用setAdapter（）完成适配的最后工作。运行后的现实结构如下图：
SimpleCursorAdapter
sdk的解释是这样的：An easy adapter to map columns from a cursor to TextViews or ImageViews defined in an XML file. You can specify which columns you want, which views you want to display the columns, and the XML file that defines the appearance of these views。简单的说就是方便把从游标得到的数据进行列表显示，并可以把指定的列映射到对应的TextView中。
下面的程序是从电话簿中把联系人显示到类表中。先在通讯录中添加一个联系人作为数据库的数据。然后获得一个指向数据库的Cursor并且定义一个布局文件（当然也可以使用系统自带的）。
/**
* @author allin
*
*/
public class MyListView2 extends Activity {
private ListView listView;
//private List<String> data = new ArrayList<String>();
@Override
public void onCreate(Bundle savedInstanceState){
super.onCreate(savedInstanceState);
listView = new ListView(this);
Cursor cursor = getContentResolver().query(People.CONTENT_URI, null, null, null, null);
startManagingCursor(cursor);
ListAdapter listAdapter = new SimpleCursorAdapter(this, android.R.layout.simple_expandable_list_item_1,
cursor,
new String[]{People.NAME},
new int[]{android.R.id.text1});
listView.setAdapter(listAdapter);
setContentView(listView);
}
}
复制代码
Cursor cursor = getContentResolver().query(People.CONTENT_URI, null, null, null, null);先获得一个指向系统通讯录数据库的Cursor对象获得数据来源。
startManagingCursor(cursor);我们将获得的Cursor对象交由Activity管理，这样Cursor的生命周期和Activity便能够自动同步，省去自己手动管理Cursor。
SimpleCursorAdapter 构造函数前面3个参数和ArrayAdapter是一样的，最后两个参数：一个包含数据库的列的String型数组，一个包含布局文件中对应组件id的int型数组。其作用是自动的将String型数组所表示的每一列数据映射到布局文件对应id的组件上。上面的代码，将NAME列的数据一次映射到布局文件的id为text1的组件上。
注意：需要在AndroidManifest.xml中如权限：<uses-permission android:name="android.permission.READ_CONTACTS"></uses-permission>
运行后效果如下图：
SimpleAdapter
simpleAdapter的扩展性最好，可以定义各种各样的布局出来，可以放上ImageView（图片），还可以放上Button（按钮），CheckBox（复选框）等等。下面的代码都直接继承了ListActivity，ListActivity和普通的Activity没有太大的差别，不同就是对显示ListView做了许多优化，方面显示而已。
下面的程序是实现一个带有图片的类表。
首先需要定义好一个用来显示每一个列内容的xml
vlist.xml
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="horizontal" android:layout_width="fill_parent"
android:layout_height="fill_parent">
<ImageView android:id="@+id/img"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_margin="5px"/>
<LinearLayout android:orientation="vertical"
android:layout_width="wrap_content"
android:layout_height="wrap_content">
<TextView android:id="@+id/title"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:textColor="#FFFFFFFF"
android:textSize="22px" />
<TextView android:id="@+id/info"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:textColor="#FFFFFFFF"
android:textSize="13px" />
</LinearLayout>
</LinearLayout>
复制代码
下面是实现代码：
/**
* @author allin
*
*/
public class MyListView3 extends ListActivity {
// private List<String> data = new ArrayList<String>();
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
SimpleAdapter adapter = new SimpleAdapter(this,getData(),R.layout.vlist,
new String[]{"title","info","img"},
new int[]{R.id.title,R.id.info,R.id.img});
setListAdapter(adapter);
}
private List<Map<String, Object>> getData() {
List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
Map<String, Object> map = new HashMap<String, Object>();
map.put("title", "G1");
map.put("info", "google 1");
map.put("img", R.drawable.i1);
list.add(map);
map = new HashMap<String, Object>();
map.put("title", "G2");
map.put("info", "google 2");
map.put("img", R.drawable.i2);
list.add(map);
map = new HashMap<String, Object>();
map.put("title", "G3");
map.put("info", "google 3");
map.put("img", R.drawable.i3);
list.add(map);
return list;
}
}
复制代码
使用simpleAdapter的数据用一般都是HashMap构成的List，list的每一节对应ListView的每一行。HashMap的每个键值数据映射到布局文件中对应id的组件上。因为系统没有对应的布局文件可用，我们可以自己定义一个布局vlist.xml。下面做适配，new一个SimpleAdapter参数一次是：this，布局文件（vlist.xml），HashMap的 title 和 info，img。布局文件的组件id，title，info，img。布局文件的各组件分别映射到HashMap的各元素上，完成适配。
运行效果如下图：
有按钮的ListView
但是有时候，列表不光会用来做显示用，我们同样可以在在上面添加按钮。添加按钮首先要写一个有按钮的xml文件，然后自然会想到用上面的方法定义一个适配器，然后将数据映射到布局文件上。但是事实并非这样，因为按钮是无法映射的，即使你成功的用布局文件显示出了按钮也无法添加按钮的响应，这时就要研究一下ListView是如何现实的了，而且必须要重写一个类继承BaseAdapter。下面的示例将显示一个按钮和一个图片，两行字如果单击按钮将删除此按钮的所在行。并告诉你ListView究竟是如何工作的。效果如下：
vlist2.xml
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="horizontal"
android:layout_width="fill_parent"
android:layout_height="fill_parent">
<ImageView android:id="@+id/img"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_margin="5px"/>
<LinearLayout android:orientation="vertical"
android:layout_width="wrap_content"
android:layout_height="wrap_content">
<TextView android:id="@+id/title"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:textColor="#FFFFFFFF"
android:textSize="22px" />
<TextView android:id="@+id/info"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:textColor="#FFFFFFFF"
android:textSize="13px" />
</LinearLayout>
<Button android:id="@+id/view_btn"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/s_view_btn"
android:layout_gravity="bottom|right" />
</LinearLayout>
复制代码
程序代码：
/**
* @author allin
*
*/
public class MyListView4 extends ListActivity {
private List<Map<String, Object>> mData;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mData = getData();
MyAdapter adapter = new MyAdapter(this);
setListAdapter(adapter);
}
private List<Map<String, Object>> getData() {
List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
Map<String, Object> map = new HashMap<String, Object>();
map.put("title", "G1");
map.put("info", "google 1");
map.put("img", R.drawable.i1);
list.add(map);
map = new HashMap<String, Object>();
map.put("title", "G2");
map.put("info", "google 2");
map.put("img", R.drawable.i2);
list.add(map);
map = new HashMap<String, Object>();
map.put("title", "G3");
map.put("info", "google 3");
map.put("img", R.drawable.i3);
list.add(map);
return list;
}
// ListView 中某项被选中后的逻辑
@Override
protected void onListItemClick(ListView l, View v, int position, long id) {
Log.v("MyListView4-click", (String)mData.get(position).get("title"));
}
/**
* listview中点击按键弹出对话框
*/
public void showInfo(){
new AlertDialog.Builder(this)
.setTitle("我的listview")
.setMessage("介绍...")
.setPositiveButton("确定", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
}
})
.show();
}
public final class ViewHolder{
public ImageView img;
public TextView title;
public TextView info;
public Button viewBtn;
}
public class MyAdapter extends BaseAdapter{
private LayoutInflater mInflater;
public MyAdapter(Context context){
this.mInflater = LayoutInflater.from(context);
}
@Override
public int getCount() {
// TODO Auto-generated method stub
return mData.size();
}
@Override
public Object getItem(int arg0) {
// TODO Auto-generated method stub
return null;
}
@Override
public long getItemId(int arg0) {
// TODO Auto-generated method stub
return 0;
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
ViewHolder holder = null;
if (convertView == null) {
holder=new ViewHolder();
convertView = mInflater.inflate(R.layout.vlist2, null);
holder.img = (ImageView)convertView.findViewById(R.id.img);
holder.title = (TextView)convertView.findViewById(R.id.title);
holder.info = (TextView)convertView.findViewById(R.id.info);
holder.viewBtn = (Button)convertView.findViewById(R.id.view_btn);
convertView.setTag(holder);
}else {
holder = (ViewHolder)convertView.getTag();
}
holder.img.setBackgroundResource((Integer)mData.get(position).get("img"));
holder.title.setText((String)mData.get(position).get("title"));
holder.info.setText((String)mData.get(position).get("info"));
holder.viewBtn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
showInfo();
}
});
return convertView;
}
}
}
复制代码
下面将对上述代码，做详细的解释，listView在开始绘制的时候，系统首先调用getCount（）函数，根据他的返回值得到listView的长度（这也是为什么在开始的第一张图特别的标出列表长度），然后根据这个长度，调用getView（）逐一绘制每一行。如果你的getCount（）返回值是0的话，列表将不显示同样return 1，就只显示一行。
系统显示列表时，首先实例化一个适配器（这里将实例化自定义的适配器）。当手动完成适配时，必须手动映射数据，这需要重写getView（）方法。系统在绘制列表的每一行的时候将调用此方法。getView()有三个参数，position表示将显示的是第几行，covertView是从布局文件中inflate来的布局。我们用LayoutInflater的方法将定义好的vlist2.xml文件提取成View实例用来显示。然后将xml文件中的各个组件实例化（简单的findViewById()方法）。这样便可以将数据对应到各个组件上了。但是按钮为了响应点击事件，需要为它添加点击监听器，这样就能捕获点击事件。至此一个自定义的listView就完成了，现在让我们回过头从新审视这个过程。系统要绘制ListView了，他首先获得要绘制的这个列表的长度，然后开始绘制第一行，怎么绘制呢？调用getView()函数。在这个函数里面首先获得一个View（实际上是一个ViewGroup），然后再实例并设置各个组件，显示之。好了，绘制完这一行了。那
再绘制下一行，直到绘完为止。在实际的运行过程中会发现listView的每一行没有焦点了，这是因为Button抢夺了listView的焦点，只要布局文件中将Button设置为没有焦点就OK了。
运行效果如下图：
LIST例二
ListView 是android开发中最常用的组件之一，它通过一个adapter来构建显示通常有三种adapter可以使用ArrayAdapter ，SimpleAdapter，CursorAdapter。CursorAdapter主要正对数据库使用，下面通过例子介绍ArrayAdapter ，SimpleAdapter的简单使用：
1：ArrayAdapter 它接受一个数组或者List作为参数来构建。
一下通过简单例子说明：
创建Test 继承ListActivity 这里我们传入一个string数组
public class ListTest extends ListActivity {
/** *//** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
String[] sw = new String[100];
for (int i = 0; i < 100; i++) {
sw[i] = "listtest_" + i;
}
ArrayAdapter<String> adapter = new ArrayAdapter<String>(this,android.R.layout.simple_list_item_1,sw);//使用系统已经实现好的xml文件simple_list_item_1
setListAdapter(adapter);
}
}
运行如图：
从以上代码可以看不我们不需要加载我们自己的layout 而是用系统已经实现的layout很快速的实现了listview
第二种SimpleAdapter：
先看下我们例子的最终截图：
通过上图可以看出listview每行不仅仅是一个string 包括了很多项，图片，多项文字
我们通过构建list，并设置每项为一个map来实现：
代码：创建TestList类继承Activity
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
ArrayList<HashMap<String, Object>> users = new ArrayList<HashMap<String, Object>>();
for (int i = 0; i < 10; i++) {
HashMap<String, Object> user = new HashMap<String, Object>();
user.put("img", R.drawable.user);
user.put("username", "姓名(" + i+")");
user.put("age", (20 + i) + "");
users.add(user);
}
SimpleAdapter saImageItems = new SimpleAdapter(this,
users,// 数据来源
R.layout.user,//每一个user xml 相当ListView的一个组件
new String[] { "img", "username", "age" },
// 分别对应view 的id
new int[] { R.id.img, R.id.name, R.id.age });
// 获取listview
((ListView) findViewById(R.id.users)).setAdapter(saImageItems);
下面是main.xml的内容：
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical" android:layout_width="fill_parent"
android:layout_height="fill_parent">
<TextView android:text="用户列表" android:gravity="center"
android:layout_height="wrap_content"
android:layout_width="fill_parent" android:background="#DAA520"
android:textColor="#000000">
</TextView>
<LinearLayout
android:layout_width="wrap_content"
android:layout_height="wrap_content">
<TextView android:text="姓名"
android:gravity="center" android:layout_width="160px"
android:layout_height="wrap_content" android:textStyle="bold"
android:background="#7CFC00">
</TextView>
<TextView android:text="年龄"
android:layout_width="170px" android:gravity="center"
android:layout_height="wrap_content" android:textStyle="bold"
android:background="#F0E68C">
</TextView>
</LinearLayout>
<ListView android:layout_width="wrap_content"
android:layout_height="wrap_content" android:id="@+id/users">
</ListView>
</LinearLayout>
之中listView前面的可以说是标题行，listview相当于用来显示数据的容器，里面每行是一个用户信息，而用户信息是样子呢？
看看use.xml
<?xml version="1.0" encoding="utf-8"?>
<TableLayout
android:layout_width="fill_parent"
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_height="wrap_content"
>
<TableRow >
<ImageView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:id="@+id/img">
</ImageView>
<TextView
android:layout_height="wrap_content"
android:layout_width="150px"
android:id="@+id/name">
</TextView>
<TextView
android:layout_height="wrap_content"
android:layout_width="170px"
android:id="@+id/age">
</TextView>
</TableRow>
</TableLayout>
也就是说每行包含了一个img 和2个文字信息
这个文件以参数的形式通过adapter在listview中显示。
也就是：
SimpleAdapter saImageItems = new SimpleAdapter(this,
users,// 数据来源
R.layout.user,//每一个user xml 相当ListView的一个组件
new String[] { "img", "username", "age" },
// 分别对应view 的id
new int[] { R.id.img, R.id.name, R.id.age });
LIST例三
简约而不简单——Android SimpleAdapter
列表(ListView)、表格(GridView)，这在手机应用上面肯定是少不了的，怎样实现比较复杂一点的界面呢，先看一下我的效果图。
这样布局的情况是最基本的，也是最常用的，网上关于这样的布局有多种版本的实现方法，但是有很多需要自己实现Adapter，那样子是比较复杂而且没有必要的，因为我们有简约而不简单的SimpleAdapter。
1. ListView
SimpleAdapter的核心代码：
for (int i = 0; i < 10; i++) {
Map<String, Object> map = new HashMap<String, Object>();
map.put("PIC", R.drawable.pic);
map.put("TITLE", "Test Title");
map.put("CONTENT", "Test Content");
contents.add(map);
}
SimpleAdapter adapter = new SimpleAdapter(this,
(List<Map<String, Object>>) contents, R.layout.listitem,
new String[] { "PIC", "TITLE", "CONTENT" }, new int[] {
R.id.listitem_pic, R.id.listitem_title,
R.id.listitem_content });
listView.setAdapter(adapter);
listitem的Layout：
<?xml version