background会根据ImageView组件给定的长宽进行拉伸，而src就存放的是原图的大小，不会进行拉伸。src是图片内容（前景），bg是背景，可以同时使用。

此外：scaleType只对src起作用；bg可设置透明度，比如在ImageButton中就可以用android:scaleType控制图片的缩放方式

如上所述，background设置的图片会跟View组件给定的长宽比例进行拉伸。举个例子， 36x36 px的图标放在 xhdpi 文件夹中，在854x480（FWVGA，对应hdpi）环境下，按照

xhdpi : hdpi : mdpi: ldip = 2 : 1.5 : 1 : 0.75

的比例计算，在FWVGA下，图标的实际大小应该是 27x27。

但是当我把它放到一个 layout_width = 96px, layout_height = 75px 的 LinearLayout，布局代码如下：

[html] view plaincopy

1. <LinearLayout android:gravity="center" android:layout_width="96px" android:layout_height="75px"  >  
2.     <ImageButton android:layout_width="wrap_content" android:layout_height="wrap_content" android:background="@drawable/toolbar_bg"/>      
3. </LinearLayout>  

实际情况是，我们得到的ImageButton的大小是 33x27，很明显width被拉伸了，这是我们不想看到的情况。

解决方案一：

代码中动态显式设置ImageButton的layout_width和layout_width，如下 

[java] view plaincopy

1. LinearLayout.LayoutParams layoutParam = new LinearLayout.LayoutParams(27, 27);  
2. layout.addView(imageButton, layoutParam);  

解决方案二：

在你通过setBackgroundResource()或者在xml设置android:background属性时，将你的background以XML Bitmap的形式定义，如下：

[html] view plaincopy

1. <?xml version="1.0" encoding="utf-8"?>  
2. <bitmap xmlns:android="http://schemas.android.com/apk/res/android"  
3.     android:id="@id/toolbar_bg_bmp"  
4.     android:src="@drawable/toolbar_bg"  
5.     android:tileMode="disabled" android:gravity="top" >  
6. </bitmap>  

    imageButton.setBackgroundResource(R.drawable.toolbar_bg_bmp)

或者

    <ImageButton ...  android:background="@drawable/toolbar_bg_bmp" ... />

若背景图片有多种状态，还可参照toolbar_bg_selector.xml：

[html] view plaincopy

1. <?xml version="1.0" encoding="utf-8"?>  
2. <selector xmlns:android="http://schemas.android.com/apk/res/android" >  
3.     <item android:state_pressed="true" >  
4.         <bitmap android:src="@drawable/toolbar_bg_sel" android:tileMode="disabled" android:gravity="top" />  
5.     </item>  
6.     <item >  
7.         <bitmap android:src="@drawable/toolbar_bg" android:tileMode="disabled" android:gravity="top" />  
8.     </item>  
9. </selector>  

如此，不管是通过代码方式setBackgroundResource()或XML android:background方式设置背景，均不会产生被拉伸的情况。

    RTC_WAKEUP #1: Alarm{52c2ad84 type 0 com.sina.weibo}     type=0 when=+3m1s330ms repeatInterval=0 count=0     operation=PendingIntent{529fa514: PendingIntentRecord{52a7b220 com.sina.weibo broadcastIntent}} 

如果我们就可以看到其中一个微博的alarm 如果我们想看他intent的详细信息
就可以用下面这个命令
adb shell dumpsys activity intents
然后找到里面id是52a7b220 的那一段

  * PendingIntentRecord{52a7b220 com.sina.weibo broadcastIntent}     uid=10073 packageName=com.sina.weibo type=broadcastIntent flags=0x0     requestCode=1383195892 requestResolvedType=null     requestIntent=act=AlarmTaskSchedule     sent=true canceled=false

程序运行生成的*.db文件一般位于"/data/data/项目名(包括所处包名)/databases/*.db"，因此要对数据库文件进行操作需要先找到数据库文件：

1、进入shell 命令

adb shell

2、找到数据库文件

#cd data/data #ls                --列出所有项目 #cd project_name   --进入所需项目名 #cd databases     #ls                --列出现寸的数据库文件

3、进入数据库

#sqlite3 test_db   --进入所需数据库

会出现类似如下字样：

SQLite version 3.6.22 Enter ".help" for instructions Enter SQL statements terminated with a ";" sqlite>

至此，可对数据库进行操作。

4、sqlite常用命令

>.databases        --产看当前数据库 >.tables           --查看当前数据库中的表 >.help             --sqlite3帮助 >.schema            --各个表的生成语句

但有时会有这样的情况：行的左边有两个控制的同时，行的右边也有一个控制。

如图：

这怎么处理呢？

我们可以将右边的控件放在另一个LinearLayout中,同时将其对齐方式设为右对齐：android:gravity="right"，还有一点，这个LinearLayout的宽度设为充满父控件： android:layout_width="fill_parent"。这样就行了。

完整的XML代码如下：

Xml代码  

1. <?xml version="1.0" encoding="utf-8"?>  
2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
3.     android:layout_width="fill_parent"  
4.     android:layout_height="fill_parent"  
5.     android:background="@drawable/bg"  
6.     android:orientation="horizontal" >  
7.   
8.     <TextView  
9.         android:layout_width="wrap_content"  
10.         android:layout_height="wrap_content"  
11.         android:text="左边1" />  
12.   
13.     <TextView  
14.         android:layout_width="wrap_content"  
15.         android:layout_height="wrap_content"  
16.         android:text="左边2" />  
17.     <!-- 将TextView包在另一个LinearLayout中  
18.          注意android:layout_width和android:gravity这两个属性  
19.      -->  
20.     <LinearLayout  
21.         android:layout_width="fill_parent"  
22.         android:layout_height="wrap_content"  
23.         android:gravity="right" >  
24.   
25.         <TextView  
26.             android:layout_width="wrap_content"  
27.             android:layout_height="wrap_content"  
28.             android:layout_marginRight="10dp"  
29.             android:text="右边" />  
30.     </LinearLayout>  
31.   
32. </LinearLayout>  

第一步建立一个新的工程，在main布局里面建立三个EditText控件。

第二步在工程的res/values文件夹下新建一个xml文件内容如下：

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <style name="et1" parent="@android:style/Widget.EditText">
        <item name="android:background">#1A4EA4</item>
        <item name="android:textColor">#FFF111</item>
    </style>
        <style name="et2" parent="@android:style/Widget.EditText">
        <item name="android:background">#A6C60F</item>
        <item name="android:textColor">#EC02C3</item>
    </style>
</resources>
<!--
说明：
    这里建立了两种样式，从字面意思上可以看出这两中样式分别都更改了背景颜色和文字颜色
，一个控件可以更改的属性有很多，这里只改了两个，要改其它的属性，我们要知道属性的name,
才可以改。那所有的属性的名字在哪呢？找了一番终于找到了，所有的属性的名字在一个attrs.xml
文件里。这个文件存在于：android sdk目录\data\res\values 目录下，找到这个文件以后我们
改某些属性时可以做为查看的资料了。
    上面的两个样式中，都有一个parent属性。这就不难理解style是可以继承的。在这里我们继
承的是系统默认的EditText属性，只修改了背景和文字颜色而已。那系统的EditText样式是在哪
定义的呢？找了一番终于也找到了，所有系统控件的样式是在一个style.xml文件中，这个文件也
在上面说的那个目录下。里面我们可以找到Widget.EditText的样式定义。有了它我们也可以查看
某一种控件可以更改哪些样式了。
    在设置style时，我们经常用到@和？@表明引用的的资源是在一个项目或是系统框架中定义过
的。？表明引用的资源是在当前的主题定义过的。
    上面的设置背景中的值除了可以是颜色的值外，还可以是一个图片的引用哦~~。

-->

第三步我们修改main布局文件中EditText的属性。为了对比，我们将第一个属性将做改变，第二个的style属性设为我们上面建立的name为et1的样式。第三个的style属性设为我们上面建立的name为et2的样式，代码如下：

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent" android:layout_height="fill_parent"
    android:orientation="vertical">
    <EditText android:layout_width="fill_parent"
        android:layout_height="wrap_content" android:text="默认样式" android:id="@+id/et1"></EditText>
    <EditText android:layout_width="fill_parent" android:id="@+id/et2"
        android:text="自定义样式一" android:layout_height="wrap_content" style="@style/et1"></EditText>
    <EditText android:layout_width="fill_parent" android:id="@+id/et3"
        android:text="自定义样式二" android:layout_height="wrap_content" style="@style/et2"></EditText>
    <Button android:text="改变主题" android:id="@+id/btn1"
        android:layout_width="fill_parent" android:layout_height="wrap_content"></Button>
</LinearLayout>

 加了一个改变主题的按钮是无效的，下一篇会用到它来设置主题。虽然定义好了style文件，但似乎并不能在java代码里设置，我没有发现像setStyle()这样的方法。所以就不 能在java代码里能过style文件动态改变控件的样式， 不知道哪位仁兄可以解决此问题，特在此求教了。

 无图无真相，下面是截图：

         现在这里介绍一下dp和sp。dp也就是dip。这个和sp基本类似。如果设置表示长度、高度等属性时可以使用dp 或sp。但如果设置字体，需要使用sp。dp是与密度无关，sp除了与密度无关外，还与scale无关。如果屏幕密度为160，这时dp和sp和px是一样的。1dp=1sp=1px，但如果使用px作单位，如果屏幕大小不变（假设还是3.2寸），而屏幕密度变成了320。那么原来TextView的宽度设成160px，在密度为320的3.2寸屏幕里看要比在密度为160的3.2寸屏幕上看短了一半。但如果设置成160dp或160sp的话。系统会自动将width属性值设置成320px的。也就是160 * 320 / 160。其中320 / 160可称为密度比例因子。也就是说，如果使用dp和sp，系统会根据屏幕密度的变化自动进行转换。

         px：表示屏幕实际的象素。例如，320*480的屏幕在横向有320个象素，在纵向有480个象素。 

         in：表示英寸，是屏幕的物理尺寸。每英寸等于2.54厘米。例如，形容手机屏幕大小，经常说，3.2（英）寸、3.5（英）寸、4（英）寸就是指这个单位。这些尺寸是屏幕的对角线长度。如果手机的屏幕是3.2英寸，表示手机的屏幕（可视区域）对角线长度是3.2*2.54 = 8.128厘米。读者可以去量一量自己的手机屏幕，看和实际的尺寸是否一致。 

         mm：表示毫米，是屏幕的物理尺寸。 

         pt：表示一个点，是屏幕的物理尺寸。大小为1英寸的1/72。

Linux/Mac
修改 /etc/hosts

在最后添加一行:
74.125.237.1 dl-ssl.google.com

原理就是：我们输入网站时，一般都是通过DNS 域名解析。
但是顺序为：先读取 hosts 文件，是否有对应的IP，若有直接通过此IP访问。没有的话，就通过 DNS 解析到的 IP 访问，但是GOOGLE，在内地是没有服务器的，一般解析不到的。

这个问题应该是CPU可能默认没有开Vt，所以得去bios开了再说。进了bios找到virtual technology选项，选择enable即可。

android的模拟器一直以来是它的一大败笔，启动需要很长时间，运行起来也超慢，虽说可以通过创建模拟器时更改参数，但速度还是不理想。所以，以前开发时，一直用真机调试，可它的接口又是那么的脆弱，用不了多久，就接触不良了，这个问题一直困扰很多人。之前发现过一种方法，可以通过WIFI调试，但是需要有无线路由器，而且很多手机对这个支持不太好。前几天同事分享了一种方法(API guid里面有讲)，可以让模拟器在X86架构的机器上以原生的速度运行。

方法很简单：

1.通过android sdk manager下载" Intel Hardware Accelerated Execution Manager"，下载完成后，在SDK目录中找到下载文件并安装它。

2.通过android sdk manager 下载 “Intel x86 Atom System Image

3.创建Intel x86的模拟器。

下面就可以使用创建的这个x86的模拟器进行调试了，速度非常快，我用的MacBook装的WIN7，启动模拟器只需要几秒，运行APP速度跟我的三星I9001一样流畅，需要注意的是：

1.android sdk tools 至少要R17以上，android sdk API 至少要15

2.自己的电脑要给力，我的模拟器给它分了2G的内存，所以速度特别快。

不上图了，下面是文档地址：http://developer.android.com/tools/devices/emulator.html

首先打开sdk manager，确定有x86的image。如下图

4.2只有ARM的image，所以不好使，还得用4.1.2的(2013年1月31日，4.2版本已有x86的image)

然后下载一下intelHAXM

然后进到sdk\extras\intel\Hardware_Accelerated_Execution_Manager去点击exe，一路next安装一下。

为了确认是否开了，打开命令行 输入

sc query intelhaxm

CPU可能默认没有开Vt，所以得去bios开了再说。

然后建立AVD

cpu/abi的地方记得选x86的

然后下面的Hardware部分要new一下，搞出来GPU emulation 然后选择yes

更新了adt到21.0.1后，创建AVD的界面有些不同。如下图，在Emulation Options里要选上Use Host GPU.

然后就可以了，启动AVD

显示HAX is working。

2. 用USB连接手机和电脑，并确保成功。步骤： 在windows下执行c:adb devices， 查看手机是否已经连接成功；

 3. 设置应用程序为调试模式。操作： 编辑AndroidManifest.xml 增加调试参数android:debuggable="true", 如下：

<application android:icon="@drawable/icon"  android:label="@string/app_name" android:debuggable="true">

 4. 执行真机调试操作：ECLIPSE调试对话框中，Target窗口中选择Manual，点击debug按钮，选择真机设备，开始调试。

注：不管是否启用ECLIPSE环境，任何Android软件只要在真机上运行发生异常，都可以在命令行窗口下查看具体异常信息：

 执行：.adb logcat 可以查看到更多的系统异常消息。在这些消息中要注意查看Caused by:打 头的行，这些行指明了在哪行代码出的错误。

如何检查后台服务（Android的Service类）是否正在运行？我希望我的Activity能够显示Service的状态，然后我可以打开或者关闭它。

回答：

Android系统提供了一个函数ActivityManager.getRunningServices可以列出当前正在运行的后台服务线程

private boolean isServiceRunning() {
    ActivityManager manager = (ActivityManager) getSystemService(ACTIVITY_SERVICE);
    for (RunningServiceInfo service : manager.getRunningServices(Integer.MAX_VALUE)) {
        if ("com.example.MyService".equals(service.service.getClassName())) {
            return true;
        }
    }
    return false;
}

这个方法是可靠的，因为这是由Android系统提供的服务查询办法。
所以以来于OnDestroy或者OnXXX方法，甚或是Binders以及静态变量的方法都是不可靠的，因为作为一个开发者，你永远不知道Android系统什么时候会杀掉你的进程来释放内存，那些回调函数很可能根本没机会被调用。

另外，关于如果希望手工检查所有后台服务的运行状态，见如何观察和控制正在运行的Android后台服务.

刚刚开始接触android线程编程的时候，习惯好像java一样，试图用下面的代码解决问题

new Thread( new Runnable() {     
    public void run() {     
         myView.invalidate();    
     }            
}).start();

可以实现功能，刷新UI界面。但是这样是不行的，因为它违背了单线程模型：Android UI操作并不是线程安全的并且这些操作必须在UI线程中执行。

方法二：（Thread+Handler)

查阅了文档和apidemo后，发觉常用的方法是利用Handler来实现UI线程的更新的。

Handler来根据接收的消息，处理UI更新。Thread线程发出Handler消息，通知更新UI。

Handler myHandler = new Handler() {  
          public void handleMessage(Message msg) {   
               switch (msg.what) {   
                    case TestHandler.GUIUPDATEIDENTIFIER:   
                         myBounceView.invalidate();  
                         break;   
               }   
               super.handleMessage(msg);   
          }   
     };  

 class myThread implements Runnable {   
          public void run() {  
               while (!Thread.currentThread().isInterrupted()) {    
                       
                    Message message = new Message();   
                    message.what = TestHandler.GUIUPDATEIDENTIFIER;   
                      
                    TestHandler.this.myHandler.sendMessage(message);   
                    try {   
                         Thread.sleep(100);    
                    } catch (InterruptedException e) {   
                         Thread.currentThread().interrupt();   
                    }   
               }   
          }   
     }   

以上方法demo看:http://rayleung.javaeye.com/blog/411860

方法三：（java习惯，不推荐）

在Android平台中需要反复按周期执行方法可以使用Java上自带的TimerTask类，TimerTask相对于Thread来说对于资源消耗的更低，除了使用Android自带的AlarmManager使用Timer定时器是一种更好的解决方法。 我们需要引入import java.util.Timer; 和 import java.util.TimerTask;

public class JavaTimer extends Activity {  
  
    Timer timer = new Timer();  
    TimerTask task = new TimerTask(){   
        public void run() {  
            setTitle("hear me?");  
        }            
    };  

    public void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.main);  
       
         timer.schedule(task, 10000);  

    }  
}  

方法四：(TimerTask + Handler)

实际上这样做是不行的，这跟Android的线程安全有关！应该通过配合Handler来实现timer功能的！

public class TestTimer extends Activity {  
  
    Timer timer = new Timer();  
    Handler handler = new Handler(){   
        public void handleMessage(Message msg) {  
            switch (msg.what) {      
            case 1:      
                setTitle("hear me?");  
                break;      
            }      
            super.handleMessage(msg);  
        }  
          
    };  

    TimerTask task = new TimerTask(){    
        public void run() {  
            Message message = new Message();      
            message.what = 1;      
            handler.sendMessage(message);    
        }            
    };  

    public void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.main);  
      
        timer.schedule(task, 10000);  
    }  
}  

方法五：( Runnable + Handler.postDelayed(runnable,time) )

在Android里定时更新 UI，通常使用的是 java.util.Timer, java.util.TimerTask, android.os.Handler组合。实际上Handler 自身已经提供了定时的功能。 

    private Handler handler = new Handler();  
  
    private Runnable myRunnable= new Runnable() {    
        public void run() {  
             
            if (run) {  
                handler.postDelayed(this, 1000);  
                count++;  
            }  
            tvCounter.setText("Count: " + count);  

        }  
    };  

然后在其他地方调用

handler.post(myRunnable);

handler.post(myRunnable,time);

案例看：http://shaobin0604.javaeye.com/blog/515820

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

知识点总结补充：

   很多初入Android或Java开发的新手对Thread、Looper、Handler和Message仍然比较迷惑，衍生的有HandlerThread、java.util.concurrent、Task、AsyncTask由于目前市面上的书籍等资料都没有谈到这些问题，今天就这一问题做更系统性的总结。我们创建的Service、Activity以及Broadcast均是一个主线程处理，这里我们可以理解为UI线程。但是在操作一些耗时操作时，比如I/O读写的大文件读写，数据库操作以及网络下载需要很长时间，为了不阻塞用户界面，出现ANR的响应提示窗口，这个时候我们可以考虑使用Thread线程来解决。

   对于从事过J2ME开发的程序员来说Thread比较简单，直接匿名创建重写run方法，调用start方法执行即可。或者从Runnable接口继承，但对于Android平台来说UI控件都没有设计成为线程安全类型，所以需要引入一些同步的机制来使其刷新，这点Google在设计Android时倒是参考了下Win32的消息处理机制。

 1. 对于线程中的刷新一个View为基类的界面，可以使用postInvalidate()方法在线程中来处理，其中还提供了一些重写方法比如postInvalidate(int left,int top,int right,int bottom) 来刷新一个矩形区域，以及延时执行，比如postInvalidateDelayed(long delayMilliseconds)或postInvalidateDelayed(long delayMilliseconds,int left,int top,int right,int bottom) 方法，其中第一个参数为毫秒

 2. 当然推荐的方法是通过一个Handler来处理这些，可以在一个线程的run方法中调用handler对象的 postMessage或sendMessage方法来实现，Android程序内部维护着一个消息队列，会轮训处理这些，如果你是Win32程序员可以很好理解这些消息处理，不过相对于Android来说没有提供 PreTranslateMessage这些干涉内部的方法。

3. Looper又是什么呢? ，其实Android中每一个Thread都跟着一个Looper，Looper可以帮助Thread维护一个消息队列，但是Looper和Handler没有什么关系，我们从开源的代码可以看到Android还提供了一个Thread继承类HanderThread可以帮助我们处理，在HandlerThread对象中可以通过getLooper方法获取一个Looper对象控制句柄，我们可以将其这个Looper对象映射到一个Handler中去来实现一个线程同步机制，Looper对象的执行需要初始化Looper.prepare方法就是昨天我们看到的问题，同时推出时还要释放资源，使用Looper.release方法。

4.Message 在Android是什么呢? 对于Android中Handler可以传递一些内容，通过Bundle对象可以封装String、Integer以及Blob二进制对象，我们通过在线程中使用Handler对象的sendEmptyMessage或sendMessage方法来传递一个Bundle对象到Handler处理器。对于Handler类提供了重写方法handleMessage(Message msg) 来判断，通过msg.what来区分每条信息。将Bundle解包来实现Handler类更新UI线程中的内容实现控件的刷新操作。相关的Handler对象有关消息发送sendXXXX相关方法如下，同时还有postXXXX相关方法，这些和Win32中的道理基本一致，一个为发送后直接返回，一个为处理后才返回 .

5. java.util.concurrent对象分析，对于过去从事Java开发的程序员不会对Concurrent对象感到陌生吧，他是JDK 1.5以后新增的重要特性作为掌上设备，我们不提倡使用该类，考虑到Android为我们已经设计好的Task机制，这里不做过多的赘述，相关原因参考下面的介绍:

6. 在Android中还提供了一种有别于线程的处理方式，就是Task以及AsyncTask，从开源代码中可以看到是针对Concurrent的封装，开发人员可以方便的处理这些异步任务。

　　onCreateDialog(int):当你使用这个回调函数时，Android系统会有效的设置这个Activity为每个对话框的所有者，从而自动管理每个对话框的状态并挂靠到Activity上。这样，每个对话框继承这个Activity的特定属性。比如，当一个对话框打开时，菜单键显示为这个Activity定义的选项菜单，音量键修改Activity使用的音频流。

　　showDialog(int): 当你想要显示一个对话框时，调用showDialog(int id) 方法并传递一个唯一标识这个对话框的整数。当对话框第一次被请求时，Android从你的Activity中调用onCreateDialog(int id)，你应该在这里初始化这个对话框Dialog。这个回调方法被传以和showDialog(int id)相同的ID。当你创建这个对话框后，在Activity的最后返回这个对象。

　　onPrepareDialog(int, Dialog):在对话框被显示之前，Android还调用了可选的回调函数onPrepareDialog(int id, Dialog). 如果你想在每一次对话框被打开时改变它的任何属性，你可以定义这个方法。这个方法在每次打开对话框时被调用，而onCreateDialog(int) 仅在对话框第一次打开时被调用。如果你不定义onPrepareDialog()，那么这个对话框将保持和上次打开时一样。这个方法也被传递以对话框的ID，和在onCreateDialog()中创建的对话框对象。

　　dismissDialog(int):当你准备关闭对话框时，你可以通过对这个对话框调用dismiss()来消除它。如果需要，你还可以从这个Activity中调用dismissDialog(int id) 方法，这实际上将为你对这个对话框调用dismiss() 方法。 如果你想使用onCreateDialog(int id) 方法来管理你对话框的状态（就如同在前面的章节讨论的那样），然后每次你的对话框消除的时候，这个对话框对象的状态将由该Activity保留。如果你决定不再需要这个对象或者清除该状态是重要的，那么你应该调用removeDialog(int id)。这将删除任何内部对象引用而且如果这个对话框正在显示，它将被消除。

下面是几种对话框的效果

图1

图2

图3

图4

图5

图6

图7

　　图1效果：该效果是当按返回按钮时弹出一个提示，来确保无误操作，采用常见的对话框样式。

　　　　　代码：

　　创建对话框方法dialog()

protected void dialog() {
  AlertDialog.Builder builder = new Builder(Main.this);
  builder.setMessage("确认退出吗？");

  builder.setTitle("提示");

  builder.setPositiveButton("确认", new OnClickListener() {

   @Override
   public void onClick(DialogInterface dialog, int which) {
    dialog.dismiss();

    Main.this.finish();
   }
  });

  builder.setNegativeButton("取消", new OnClickListener() {

   @Override
   public void onClick(DialogInterface dialog, int which) {
    dialog.dismiss();
   }
  });

  builder.create().show();
 }

在onKeyDown(int keyCode, KeyEvent event)方法中调用此方法

public boolean onKeyDown(int keyCode, KeyEvent event) {
  if (keyCode == KeyEvent.KEYCODE_BACK && event.getRepeatCount() == 0) {
   dialog();
  }
  return false;
 }

　　图2效果：改变了对话框的图表，添加了三个按钮

Dialog dialog = new AlertDialog.Builder(this).setIcon(
     android.R.drawable.btn_star).setTitle("喜好调查").setMessage(
     "你喜欢李连杰的电影吗？").setPositiveButton("很喜欢",
     new OnClickListener() {

      @Override
      public void onClick(DialogInterface dialog, int which) {
       // TODO Auto-generated method stub
       Toast.makeText(Main.this, "我很喜欢他的电影。",
         Toast.LENGTH_LONG).show();
      }
     }).setNegativeButton("不喜欢", new OnClickListener() {

    @Override
    public void onClick(DialogInterface dialog, int which) {
     // TODO Auto-generated method stub
     Toast.makeText(Main.this, "我不喜欢他的电影。", Toast.LENGTH_LONG)
       .show();
    }
   }).setNeutralButton("一般", new OnClickListener() {

    @Override
    public void onClick(DialogInterface dialog, int which) {
     // TODO Auto-generated method stub
     Toast.makeText(Main.this, "谈不上喜欢不喜欢。", Toast.LENGTH_LONG)
       .show();
    }
   }).create();

   dialog.show();

图3效果：信息内容是一个简单的View类型

new AlertDialog.Builder(this).setTitle("请输入").setIcon(
     android.R.drawable.ic_dialog_info).setView(
     new EditText(this)).setPositiveButton("确定", null)
     .setNegativeButton("取消", null).show();

图4效果：信息内容是一组单选框

new AlertDialog.Builder(this).setTitle("复选框").setMultiChoiceItems(
     new String[] { "Item1", "Item2" }, null, null)
     .setPositiveButton("确定", null)
     .setNegativeButton("取消", null).show();

图5效果：信息内容是一组多选框

new AlertDialog.Builder(this).setTitle("单选框").setIcon(
     android.R.drawable.ic_dialog_info).setSingleChoiceItems(
     new String[] { "Item1", "Item2" }, 0,
     new DialogInterface.OnClickListener() {
      public void onClick(DialogInterface dialog, int which) {
       dialog.dismiss();
      }
     }).setNegativeButton("取消", null).show();

图6效果：信息内容是一组简单列表项

new AlertDialog.Builder(this).setTitle("列表框").setItems(
     new String[] { "Item1", "Item2" }, null).setNegativeButton(
     "确定", null).show();

图7效果：信息内容是一个自定义的布局

1.布局文件

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
 android:layout_height="wrap_content" android:layout_width="wrap_content"
 android:background="#ffffffff" android:orientation="horizontal"
 android:id="@+id/dialog">
 <TextView android:layout_height="wrap_content"
   android:layout_width="wrap_content"
  android:id="@+id/tvname" android:text="姓名：" />
 <EditText android:layout_height="wrap_content"
  android:layout_width="wrap_content" android:id="@+id/etname" android:minWidth="100dip"/>

</LinearLayout>

2.调用代码

LayoutInflater inflater = getLayoutInflater();
   View layout = inflater.inflate(R.layout.dialog,
     (ViewGroup) findViewById(R.id.dialog));

   new AlertDialog.Builder(this).setTitle("自定义布局").setView(layout)
     .setPositiveButton("确定", null)
     .setNegativeButton("取消", null).show();

 同时，在主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);
            }
        }
    }

举个例子，我们可以通过设置android:gravity="center"来让EditText中的文字在EditText组件中居中显示；同时我们设置EditText的android:layout_gravity="right"来让EditText组件在LinearLayout中居中显示。来实践以下：

正如我们所看到的，在EditText中，其中的文字已经居中显示了，而EditText组件自己也对齐到了LinearLayout的右侧。

<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent">
    <EditText
        android:layout_width="wrap_content"
        android:gravity="center"
        android:layout_height="wrap_content"
        android:text="one"
        android:layout_gravity="right"/>
</LinearLayout>

 www.puyufanyi.com;

 java.util.ArrayList;

 java.util.HashMap;

 java.util.List;

 java.util.Map;

 www.puyufanyi.com.test.Word;

 android.app.Activity;

 android.os.Bundle;

 android.view.View;

 android.widget.AdapterView;

 android.widget.AdapterView.OnItemClickListener;

 android.widget.ListView;

 android.widget.SimpleAdapter;

 android.widget.Toast;

 android.widget.TextView;

{

    private ArrayList<Word> words = new ArrayList<Word>();

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        ListView lv= (ListView)findViewById(R.id.wordlist);
         
        Word word1 = new Word("index1", "result1");
        Word word2 = new Word("index2", "result2");
        Word word3 = new Word("index3", "result3");
        Word word4 = new Word("index4", "result4");
        Word word5 = new Word("index5", "result5");
        this.words.add(word1);
        this.words.add(word2);
        this.words.add(word3);
        this.words.add(word4);
        this.words.add(word5);

        List<Map<String, Object>> listItems = new ArrayList<Map<String, Object>>();

        for (int i = 0; i < words.size(); i++) {
            Map<String, Object> listItem = new HashMap<String, Object>();
            listItem.put("Index", words.get(i).getIndex());
            listItem.put("Result", words.get(i).getResult());
            listItems.add(listItem);
        }
        SimpleAdapter simpleAdapter = new SimpleAdapter(
                this, 
                listItems, 
                R.layout.words,
                new String[]{"Index","Result"},
                new int[]{R.id.index,R.id.result}
        );
        lv.setAdapter(simpleAdapter);
        lv.setOnItemClickListener(new OnItemClickListener() {
            public void onItemClick(AdapterView<?> parent, View view,int position, long id) {
                 String  indexValue = ((TextView)view.findViewById(R.id.index)).getText().toString();
                 Toast.makeText(getApplicationContext(), indexValue, Toast.LENGTH_SHORT).show();    
            }  
        });
        
             
     }
}

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical" >

    <!-- ListView (words) -->

    <ListView
        android:id="@+id/wordlist"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" >
    </ListView>

</LinearLayout>

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="horizontal" >

    <TextView
        android:id="@+id/index"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:paddingLeft="10dp" />

    <TextView
        android:id="@+id/result"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:paddingLeft="10dp" />

</LinearLayout>

1
2
3
4
5
6

<?xml version="1.0" encoding="utf-8"?>
<selector xmlns:android="http://schemas.android.com/apk/res/android">
	<item android:state_pressed="true" android:drawable="@drawable/play_press" />
	<item android:state_focused="true" android:drawable="@drawable/play_press" />
	<item android:drawable="@drawable/play" />
</selector>

我这里获取焦点跟点击时显示的是同一张图片，必须严格照上面的顺序写，不可倒。
接下来只要在布局时写Button控件时应用到Button的Background属性即可。

1
2
3
4

<Button android:id="@+id/button1"
	android:layout_width="wrap_content" android:layout_height="wrap_content"
	android:background="@drawable/button_style"
></Button>

最终效果图：

点击时会变。
源代码下载：
Button_style (313)
再加上一种自定义样式方法，上面的是用图片，其实我们可以直接通过定义xml文件来实现不同的样式:
在上面的源代码基础上，只需要修改button_style文件,同样三种状态分开定义：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

<?xml version="1.0" encoding="utf-8"?>
<selector xmlns:android="http://schemas.android.com/apk/res/android">
	<item android:state_pressed="true">
		<shape>
			<gradient android:startColor="#0d76e1" android:endColor="#0d76e1"
				android:angle="270" />
			<stroke android:width="1dip" android:color="#f403c9" />
			<corners android:radius="2dp" />
			<padding android:left="10dp" android:top="10dp"
				android:right="10dp" android:bottom="10dp" />
		</shape>
	</item>
 
	<item android:state_focused="true">
		<shape>
			<gradient android:startColor="#ffc2b7" android:endColor="#ffc2b7"
				android:angle="270" />
			<stroke android:width="1dip" android:color="#f403c9" />
			<corners android:radius="2dp" />
			<padding android:left="10dp" android:top="10dp"
				android:right="10dp" android:bottom="10dp" />
		</shape>
	</item>
 
	<item>
		<shape>
			<gradient android:startColor="#000000" android:endColor="#ffffff"
				android:angle="180" />
			<stroke android:width="1dip" android:color="#f403c9" />
			<corners android:radius="5dip" />
			<padding android:left="10dp" android:top="10dp"
				android:right="10dp" android:bottom="10dp" />
		</shape>
	</item>
</selector>

gradient 主体渐变 startColor开始颜色，endColor结束颜色 ，angle开始渐变的角度（值只能为90的倍数，0时为左到右渐变，90时为下到上渐变，依次逆时针类推）
stroke 边框 width 边框宽度，color 边框颜色
corners 圆角 radius 半径，0为直角
padding text值的相对位置