它的主要功能有:

•运行设备的shell(命令行)
•管理模拟器或设备的端口映射
•计算机和设备之间上传/下载文件
•将本地apk软件安装至模拟器或android设备

ADB是一个 客户端-服务器端 程序, 其中客户端是你用来操作的电脑, 服务器端是android设备.

先说安装方法, 电脑上需要安装客户端. 客户端包含在sdk里. 设备上不需要安装, 只需要在手机上打开选项settings-applications-development-USB debugging.

对于Mac和Linux用户, 下载好的sdk解压后, 可以放~或者任意目录. 然后修改~/.bash_profile文件, 设置运行环境指向sdk的tools目录.
具体是打开~/.bash_profile文件(如果没有此文件也可以自行添加), 在里面加入一行:

export PATH=${PATH}:<你的sdk目录>/tools

例如：

然后就可以使用adb命令了.

嫌安装麻烦的同学其实也可以省去上面安装步骤, 直接输入完整路径来使用命令, 例如:

对于windows xp用户, 需要先安装usb驱动, 然后如果你只打算使用adb而不想下载整个sdk的话, 可以下载这个单独的adb工具包 下载后解压, 把里面 adb.exe 和 AdbWinApi.dll 两个文件放到系统盘的 windows/system32 文件夹里就可以了.

 现在说下ADB常用的几个命令
1. 查看设备

•adb devices
这个命令是查看当前连接的设备, 连接到计算机的android设备或者模拟器将会列出显示

2. 安装软件

•adb install <apk文件路径>
这个命令将指定的apk文件安装到设备上

3. 卸载软件

•adb uninstall <软件名>
•adb uninstall -k <软件名>
如果加 -k 参数,为卸载软件但是保留配置和缓存文件.

4. 登录设备shell

•adb shell
•adb shell <command命令>
这个命令将登录设备的shell.
后面加<command命令>将是直接运行设备命令, 相当于执行远程命令

5. 从电脑上发送文件到设备

•adb push <本地路径> <远程路径>
用push命令可以把本机电脑上的文件或者文件夹复制到设备(手机)

6. 从设备上下载文件到电脑

•adb pull <远程路径> <本地路径>
用pull命令可以把设备(手机)上的文件或者文件夹复制到本机电脑

7. 显示帮助信息

•adb help
这个命令将显示帮助信息

8. 更多android命令使用方法,请参考我的另一篇博文:android命令实战手册

先简单说说Widget的原理。Widget是在桌面上的一块显示信息的东西，也通过单击Widget跳转到一个程序里面。而系统自带的程序，典型的Widget是music，这个Android内置的音乐播放小程序。这个是典型的Widget+app应用。就是一个程序既可以通过Widget启动，也可以通过App启动。Widget就是一个AppWidgetProvider+一个UI界面显示（预先绑定了好多Intent），界面上的信息可以通过程序控制而改变，单击Widget，上的控件只能激发发送一个Intent，或发出一个Service的启动通知。而AppWidgetProvider可以拦截这个Intent，而进行相应的处理（比如显示新的信息）。

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="com.android"
      android:versionCode="1"
      android:versionName="1.0">
    <application android:icon="@drawable/icon" android:label="@string/app_name">
        <receiver android:name=".BatteryMonitor"
                  android:label="@string/app_name">
            <intent-filter>
                <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
            </intent-filter>
            <meta-data
                android:name="android.appwidget.provider"
                android:resource="@xml/widget_provider" />
        </receiver>

    </application>
    <uses-sdk android:minSdkVersion="3" />
</manifest> 

            <meta-data
                android:name="android.appwidget.provider"
                android:resource="@xml/widget_provider" />

<?xml version="1.0" encoding="utf-8"?>
<appwidget-provider
  xmlns:android="http://schemas.android.com/apk/res/android"
  android:minWidth="100dip"
  android:minHeight="100dip"
  android:initialLayout="@layout/main" >
</appwidget-provider>

这个是Widget的显示设置，是对Widget属性的一个配置文件这个android:minHeight是Widget的高，这个android:minWidth
是Widget的宽。这个android:updatePeriodMillis属性是设置Widget页面的
更新页面的时间的频率。而这个android:initialLayout属性是表示的是初始化页面的布局，Android里画UI的地方都是通过xml文件，也可以通过代码程序来画，不过这样画的太麻烦了。

建一个类BatteryMonitor继承于AppWidgetProvider，而AppWidgetProvider继承与android.content.BroadcastReceiver，所以TestAppWidget就是一个拦截处理Intent的BroadcastReceiver，这些Intent只能在Androidmainfest里设置来拦截处理。
在onUpdate中设置窗口界面：

    public void defaultWidget(Context context) {
        
        RemoteViews updateViews = new RemoteViews(context.getPackageName(), R.layout.main);
        
        //updateViews.setTextViewText(R.id.battery_level, BatteryLevel+" %");
        
        updateViews.setImageViewResource(R.id.battery_img, R.drawable.batteryimg);
        
        // Push update for this widget to the home screen
        ComponentName batteryWidget = new ComponentName(context, BatteryMonitor.class);
        AppWidgetManager manager = AppWidgetManager.getInstance(context);
        manager.updateAppWidget(batteryWidget, updateViews);        
    }

import android.app.Service;
import android.appwidget.AppWidgetManager;
import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.IBinder;
import android.util.Log;
import android.widget.RemoteViews;




public class BatteryMonitorReceiver extends Service
{
    private int BatteryLevel = 0;

    private BroadcastReceiver batteryReceiver = new BroadcastReceiver()
    {
        @Override
        public void onReceive(Context context, Intent intent)
        {
            String action = intent.getAction();
            if (action.equals(Intent.ACTION_BATTERY_CHANGED))
            {
                Log.d("BatteryLevel","BatteryCHANGED");
                BatteryLevel = intent.getIntExtra("level", 0);
                UpdateAppWidget(context);
            }
        }
    };
    
    public void UpdateAppWidget(Context context){
         RemoteViews updateViews = new RemoteViews(context.getPackageName(), R.layout.main);
         updateViews.setTextViewText(R.id.battery_level, BatteryLevel+" %");
        
        // Push update for this widget to the home screen
        ComponentName batteryWidget = new ComponentName(context, BatteryMonitor.class);
        AppWidgetManager manager = AppWidgetManager.getInstance(context);
        manager.updateAppWidget(batteryWidget, updateViews);
    }
    
    /**//* (non-Javadoc)
     * @see android.app.Service#onCreate()
     */
    @Override
    public void onCreate() {
        // TODO Auto-generated method stub
        super.onCreate();
        
        IntentFilter itFilter = new IntentFilter();
        itFilter.addAction(Intent.ACTION_BATTERY_CHANGED);
        registerReceiver(batteryReceiver, itFilter);
    }

    @Override
    public void onStart(Intent intent, int startId)
    {
        
    }

    
    /**//* (non-Javadoc)
     * @see android.app.Service#onDestroy()
     */
    @Override
    public void onDestroy() {
        // TODO Auto-generated method stub
        super.onDestroy();
        unregisterReceiver(batteryReceiver);
    }

    @Override
    public IBinder onBind(Intent intent)
    {
        // TODO Auto-generated method stub
        return null;
    }

}

        <service android:name=".BatteryMonitorReceiver">
          <intent-filter>
              <action android:name="com.adroid.pp" />
              <category android:name="android.intent.category.default" />
          </intent-filter>
        </service>

对于adb shell，后面可以跟的命令主要来自android-1.5\system\core\toolbox里面，如下：

    ls 
    mount 
    cat 
    ps 
    kill 
    ln 
    insmod 
    rmmod 
    lsmod 
    ifconfig 
    setconsole 
    rm 
    mkdir 
    rmdir 
    reboot 
    getevent 
    sendevent 
    date 
    wipe 
    sync 
    umount 
    start 
    stop 
    notify 
    cmp 
    dmesg 
    route 
    hd 
    dd 
    df 
    getprop 
    setprop 
    watchprops 
    log 
    sleep 
    renice 
    printenv 
    smd 
    chmod 
    chown 
    mkdosfs 
    netstat 
    ioctl 
    mv 
    schedtop 
    top 
    iftop 
    id 
    vmstat

具体的意思就不解释了，大家可以去看linux手册或者看android的源码。需要说一下的是ps命令,很多时候我们想只列举出我们需要的进程列表，例如列举出所有运行的app。从ps的源码来看，它是支持filter的，ps app应该可以列举出所有以app开头的进程，但在某些手机里面运行时这个filter又是没用的，可能是这些手机修改了ps的代码。

还有两个比较好用的命令是adb shell am和adb shell pm,这两个命令在frameworks/base/cmds下面。am命令主要用于管理Activity，例如启动，停止Activity（eclipse在运行Activity就使用了这个命令），发送intent；pm命令则主要用于管理应用package的管理，有点像控制面板的添加和删除程序。

am命令的具体用法如下：

usage: am [start|broadcast|instrument|profile]
am start -D INTENT
am broadcast INTENT
am instrument [-r] [-e <ARG_NAME> <ARG_VALUE>] [-p <PROF_FILE>]
[-w] <COMPONENT>
am profile <PROCESS> [start <PROF_FILE>|stop]
INTENT is described with:
[-a <ACTION>] [-d <DATA_URI>] [-t <MIME_TYPE>]
[-c <CATEGORY> [-c <CATEGORY>] ...]
[-e|--es <EXTRA_KEY> <EXTRA_STRING_VALUE> ...]
[--ez <EXTRA_KEY> <EXTRA_BOOLEAN_VALUE> ...]
[-e|--ei <EXTRA_KEY> <EXTRA_INT_VALUE> ...]
[-n <COMPONENT>] [-f <FLAGS>] [<URI>]
The start command starts activity. Use -D option to make 'DebugOption' true.
The broadcast command sends broadcast.
The instrument command starts instrumentation.
Use -r option to make 'rawMode' true.
Use -e option to add the pair of ARG_NAME and ARG_VALUE into Bundle.
Use -p option to specify profileFile.
Use -w option to make 'wait' true in order to new an instance of InstrumentationWatcher.
Use COMPONENT to specify the name of the instrumentation component.
The profile command turn on/off profiling in a particular process specified by PROCESS.
Use start option to turn on and stop to turn off.Use PROF_FILE to specify the file path of profile.
Use -a to set action specified by ACTION to be performed.
Use -d to create a Uri(data) which parses the given encoded URI string DATA_URI.
Use -t to specify the type specified by MIME_TYPE. Use -c to add a new category specified by
CATEGORY to the intent.
Use -e or --es to add extended data to the intent.EXTRA_KEY specifies the name of the extra data and
EXTRA_STRING_VALUE specifies the string data value.
Use --ez to add extended data to the intent. EXTRA_KEY specifies the name of the extra data and
EXTRA_BOOLEAN_VALUE specifies the serializable data value.
Use -e or --ei to add extended data to the intent. EXTRA_KEY specifies the name of the extra data and
EXTRA_INT_VALUE specifies the serializable data value.
Use -n to explicitly set the component specified by COMPONENT to handle the intent.
Use -f to set special flags controlling how this intent is handled.FLAGS specifies the desired flags.
Use URI to create an intent from a URI.

pm命令的具体用法如下：

usage: pm [list|path|install|uninstall]
       pm list packages [-f]
       pm list permission-groups
       pm list permissions [-g] [-f] [-d] [-u] [GROUP]
       pm list instrumentation [-f] [TARGET-PACKAGE]
       pm path PACKAGE
       pm install [-l] [-r] PATH
       pm uninstall [-k] PACKAGE
       pm enable PACKAGE_OR_COMPONENT
       pm disable PACKAGE_OR_COMPONENT

The list packages command prints all packages.  Use
the -f option to see their associated file.

The list permission-groups command prints all known
permission groups.

The list permissions command prints all known
permissions, optionally only those in GROUP.  Use
the -g option to organize by group.  Use
the -f option to print all information.  Use
the -s option for a short summary.  Use
the -d option to only list dangerous permissions.  Use
the -u option to list only the permissions users will see.

The list instrumentation command prints all instrumentations,
or only those that target a specified package.  Use the -f option
to see their associated file.

The path command prints the path to the .apk of a package.

The install command installs a package to the system.  Use
the -l option to install the package with FORWARD_LOCK. Use
the -r option to reinstall an exisiting app, keeping its data.

The uninstall command removes a package from the system. Use
the -k option to keep the data and cache directories around
after the package removal.

The enable and disable commands change the enabled state of
a given package or component (written as "package/class").
 

frameworks/base/cmds下面还有一个别的命令,如下

dumpstate
dumpsys
ime
input
installd
runtime
service
servicemanager
surfaceflinger
svc
system_server

下面是上述命令的一些输出：

C:\Users\xufan>adb shell dumpstate
========================================================
== dumpstate
========================================================
------ MEMORY INFO ------
MemTotal:        94348 kB
MemFree:          9912 kB
Buffers:             0 kB
Cached:          47876 kB
SwapCached:          0 kB
Active:          47016 kB
Inactive:        29980 kB
SwapTotal:           0 kB
SwapFree:            0 kB
Dirty:               0 kB
Writeback:           0 kB
AnonPages:       29156 kB
Mapped:          22948 kB
Slab:             2992 kB
SReclaimable:      796 kB
SUnreclaim:       2196 kB
PageTables:       2180 kB
NFS_Unstable:        0 kB
Bounce:              0 kB
WritebackTmp:        0 kB
CommitLimit:     47172 kB
Committed_AS:   658548 kB
VmallocTotal:   876544 kB
VmallocUsed:      8380 kB
VmallocChunk:   859132 kB

------ CPU INFO ------

User 7%, System 23%, IOW 0%, IRQ 0%
User 11 + Nice 0 + Sys 33 + Idle 98 + IOW 0 + IRQ 0 + SIRQ 0 = 142

  PID   TID CPU% S     VSS     RSS UID      Thread          Proc
  743   743  26% R    928K    384K shell    top             top
  565   581   1% S 177876K  25384K system   er.ServerThread system_server
  565   570   0% S 177876K  25384K system   Binder Thread # system_server
  565   571   0% S 177876K  25384K system   Binder Thread # system_server
  605   605   0% S 105820K  17540K radio    app_process     com.android.phone
  565   619   0% S 177876K  25384K system   er$SensorThread system_server
  565   585   0% S 177876K  25384K system   PackageManager  system_server
  565   586   0% S 177876K  25384K system   FileObserver    system_server
  565   589   0% S 177876K  25384K system   SyncHandlerThre system_server
  565   590   0% S 177876K  25384K system   UEventObserver  system_server
  565   591   0% S 177876K  25384K system   PowerManagerSer system_server
  565   592   0% S 177876K  25384K system   AlarmManager    system_server
  565   593   0% S 177876K  25384K system   WindowManager   system_server
  565   594   0% S 177876K  25384K system   InputDeviceRead system_server
  565   595   0% S 177876K  25384K system   WindowManagerPo system_server
  565   596   0% S 177876K  25384K system   InputDispatcher system_server
  565   597   0% S 177876K  25384K system   ConnectivityThr system_server
  565   598   0% S 177876K  25384K system   WifiService     system_server
  565   599   0% S 177876K  25384K system   WifiWatchdogThr system_server
  565   600   0% S 177876K  25384K system   er.ServerThread system_server
  565   601   0% S 177876K  25384K system   GpsEventThread  system_server
  565   602   0% S 177876K  25384K system   AudioService    system_server
  565   603   0% S 177876K  25384K system   android:unnamed system_server
  565   604   0% S 177876K  25384K system   android:unnamed system_server
  565   609   0% S 177876K  25384K system   watchdog        system_server
  565   640   0% S 177876K  25384K system   r.MountListener system_server
  565   651   0% S 177876K  25384K system   Binder Thread # system_server
  565   678   0% S 177876K  25384K system   Binder Thread # system_server
  605   606   0% S 105820K  17540K radio    HeapWorker      com.android.phone
  605   607   0% S 105820K  17540K radio    Signal Catcher  com.android.phone
------ PROCRANK ------
 

C:\Users\xufan>adb shell dumpsys

  Provider mms-sms
    ContentProviderRecord{436a0040 com.android.providers.telephony.MmsSmsProvide
r}
    package=com.android.providers.telephony process=com.android.phone
    app=ProcessRecord{43638990 605:com.android.phone/1001}
    launchingApp=null
    provider=android.content.ContentProviderProxy@436c8c88
    name=mms-sms
    isSyncable=false
    multiprocess=true initOrder=0 uid=1001
    clients=[]
    externals=0

  Published content providers (by class):
  Provider android.content.SyncProvider
    ContentProviderRecord{435bceb8 android.content.SyncProvider}
    package=android process=system
    app=ProcessRecord{436236b8 565:system/1000}
    launchingApp=null
    provider=android.content.ContentProvider$Transport@43634c48
    name=sync
    isSyncable=false
    multiprocess=false initOrder=0 uid=1000
    clients=[]
    externals=0
  Provider com.android.providers.telephony.MmsSmsProvider
    ContentProviderRecord{436a0040 com.android.providers.telephony.MmsSmsProvide
r}
    package=com.android.providers.telephony process=com.android.phone
    app=ProcessRecord{43638990 605:com.android.phone/1001}
    launchingApp=null
    provider=android.content.ContentProviderProxy@436c8c88
    name=mms-sms
    isSyncable=false
    multiprocess=true initOrder=0 uid=1001
    clients=[]
    externals=0
  Provider com.android.providers.settings.SettingsProvider
    ContentProviderRecord{435bda90 com.android.providers.settings.SettingsProvid
er}
    package=com.android.providers.settings process=system
    app=ProcessRecord{436236b8 565:system/1000}
    launchingApp=null
    provider=android.content.ContentProvider$Transport@435a2b58
    name=settings
    isSyncable=false
    multiprocess=false initOrder=100 uid=1000
    clients=[ProcessRecord{4371bad0 655:com.android.alarmclock/10000}, ProcessRe
cord{43638990 605:com.android.phone/1001}]
    externals=0
  Provider com.android.providers.userdictionary.UserDictionaryProvider
    ContentProviderRecord{436a2398 com.android.providers.userdictionary.UserDict
ionaryProvider}
    package=com.android.providers.userdictionary process=android.process.acore
    app=ProcessRecord{43645bc0 608:android.process.acore/10004}
    launchingApp=null
    provider=android.content.ContentProviderProxy@436ccca0
    name=user_dictionary
    isSyncable=false
    multiprocess=false initOrder=0 uid=10004
    clients=[]
    externals=0
  Provider com.android.providers.contacts.ContactsProvider
    ContentProviderRecord{436a25e8 com.android.providers.contacts.ContactsProvid
er}
    package=com.android.providers.contacts process=android.process.acore
    app=ProcessRecord{43645bc0 608:android.process.acore/10004}
    launchingApp=null
    provider=android.content.ContentProviderProxy@436cd910
    name=contacts;call_log
    isSyncable=false
    multiprocess=false initOrder=0 uid=10004
    clients=[]
    externals=0
  Provider com.android.providers.drm.DrmProvider
    ContentProviderRecord{4361c528 com.android.providers.drm.DrmProvider}
    package=com.android.providers.drm process=android.process.media
    app=ProcessRecord{436e89e8 644:android.process.media/10003}
    launchingApp=null
    provider=android.content.ContentProviderProxy@435ffed0
    name=drm
    isSyncable=false
    multiprocess=false initOrder=0 uid=10003
    clients=[]
    externals=0
  Provider com.android.launcher.LauncherProvider
    ContentProviderRecord{436a2710 com.android.launcher.LauncherProvider}
    package=com.android.launcher process=android.process.acore
    app=ProcessRecord{43645bc0 608:android.process.acore/10004}
    launchingApp=null
    provider=android.content.ContentProviderProxy@436cdff0
    name=com.android.launcher.settings
    isSyncable=false
    multiprocess=false initOrder=0 uid=10004
    clients=[]
    externals=0
  Provider com.android.providers.media.MediaProvider
    ContentProviderRecord{436e8728 com.android.providers.media.MediaProvider}
    package=com.android.providers.media process=android.process.media
    app=ProcessRecord{436e89e8 644:android.process.media/10003}
    launchingApp=ProcessRecord{436e89e8 644:android.process.media/10003}
    provider=android.content.ContentProviderProxy@435ff638
    name=media
    isSyncable=false
    multiprocess=false initOrder=0 uid=10003
    clients=[]
    externals=0
  Provider com.android.providers.downloads.DownloadProvider
    ContentProviderRecord{4369e808 com.android.providers.downloads.DownloadProvi
der}
    package=com.android.providers.downloads process=android.process.media
    app=ProcessRecord{436e89e8 644:android.process.media/10003}
    launchingApp=null
    provider=android.content.ContentProviderProxy@43600a50
    name=downloads
    isSyncable=false
    multiprocess=false initOrder=0 uid=10003
    clients=[]
    externals=0
  Provider com.android.providers.telephony.MmsProvider
    ContentProviderRecord{436a0f28 com.android.providers.telephony.MmsProvider}
    package=com.android.providers.telephony process=com.android.phone
    app=ProcessRecord{43638990 605:com.android.phone/1001}
    launchingApp=null
    provider=android.content.ContentProviderProxy@436c93a8
    name=mms
    isSyncable=false
    multiprocess=true initOrder=0 uid=1001
    clients=[]
    externals=0
  Provider com.android.googlesearch.SuggestionProvider
    ContentProviderRecord{436a24c0 com.android.googlesearch.SuggestionProvider}
    package=com.android.googlesearch process=android.process.acore
    app=ProcessRecord{43645bc0 608:android.process.acore/10004}
    launchingApp=null
    provider=android.content.ContentProviderProxy@436cd288
    name=com.android.googlesearch.SuggestionProvider
    isSyncable=false
    multiprocess=false initOrder=0 uid=10004
    clients=[]
    externals=0
  Provider com.android.providers.telephony.TelephonyProvider
    ContentProviderRecord{436a1030 com.android.providers.telephony.TelephonyProv
ider}
    package=com.android.providers.telephony process=com.android.phone
    app=ProcessRecord{43638990 605:com.android.phone/1001}
    launchingApp=null
    provider=android.content.ContentProviderProxy@436c9988
    name=telephony
    isSyncable=false
    multiprocess=true initOrder=0 uid=1001
    clients=[]
    externals=0
  Provider com.android.providers.telephony.SmsProvider
    ContentProviderRecord{436a1138 com.android.providers.telephony.SmsProvider}
    package=com.android.providers.telephony process=com.android.phone
    app=ProcessRecord{43638990 605:com.android.phone/1001}
    launchingApp=null
    provider=android.content.ContentProviderProxy@436ca038
    name=sms
    isSyncable=false
    multiprocess=true initOrder=0 uid=1001
    clients=[]
    externals=0
  Provider com.android.phone.SimProvider
    ContentProviderRecord{436a1240 com.android.phone.SimProvider}
    package=com.android.phone process=com.android.phone
    app=ProcessRecord{43638990 605:com.android.phone/1001}
    launchingApp=null
    provider=android.content.ContentProviderProxy@436ca648
    name=sim
    isSyncable=false
    multiprocess=true initOrder=0 uid=1001
    clients=[]
    externals=0
  Provider com.android.alarmclock.AlarmProvider
    ContentProviderRecord{4371d520 com.android.alarmclock.AlarmProvider}
    package=com.android.alarmclock process=com.android.alarmclock
    app=ProcessRecord{4371bad0 655:com.android.alarmclock/10000}
    launchingApp=null
    provider=android.content.ContentProviderProxy@435e2c10
    name=com.android.alarmclock
    isSyncable=false
    multiprocess=false initOrder=0 uid=10000
    clients=[]
    externals=0

Granted Uri Permissions:
-------------------------------------------------------------------------------
DUMP OF SERVICE activity.senders:
Intent Senders in Current Activity Manager State:
  IntentSender IntentSenderRecord{435bb968 android broadcastIntent}
    packageName=android type=broadcastIntent flags=0x0
    activity=null who=null
    requestCode=0 requestResolvedType=null
    requestIntent=Intent { action=android.content.syncmanager.SYNC_ALARM }
    sent=false canceled=false
  IntentSender IntentSenderRecord{4359f4e0 android broadcastIntent}
    packageName=android type=broadcastIntent flags=0x0
    activity=null who=null
    requestCode=0 requestResolvedType=null
    requestIntent=Intent { action=android.intent.action.DATE_CHANGED }
    sent=false canceled=false
  IntentSender IntentSenderRecord{43638b10 android broadcastIntent}
    packageName=android type=broadcastIntent flags=0x0
    activity=null who=null
    requestCode=0 requestResolvedType=null
    requestIntent=Intent { action=com.android.service.Watchdog.REBOOT }
    sent=false canceled=false
  IntentSender IntentSenderRecord{436714c0 android broadcastIntent}
    packageName=android type=broadcastIntent flags=0x0
    activity=null who=null
    requestCode=0 requestResolvedType=null
    requestIntent=Intent { action=com.android.server.WifiManager.action.DEVICE_I
DLE }
    sent=false canceled=false
  IntentSender IntentSenderRecord{435e56d8 android broadcastIntent}
    packageName=android type=broadcastIntent flags=0x0
    activity=null who=null
    requestCode=0 requestResolvedType=null
    requestIntent=Intent { action=android.intent.action.TIME_TICK flags=0x400000
00 }
    sent=true canceled=false
  IntentSender IntentSenderRecord{435adb08 android broadcastIntent}
    packageName=android type=broadcastIntent flags=0x0
    activity=null who=null
    requestCode=0 requestResolvedType=null
    requestIntent=Intent { action=android.content.syncmanager.SYNC_POLL_ALARM }
    sent=true canceled=false
  IntentSender IntentSenderRecord{4359edf0 android broadcastIntent}
    packageName=android type=broadcastIntent flags=0x0
    activity=null who=null
    requestCode=0 requestResolvedType=null
    requestIntent=Intent { action=com.android.service.Watchdog.CHECKUP }
    sent=false canceled=false
  IntentSender IntentSenderRecord{436e3198 android broadcastIntent}
    packageName=android type=broadcastIntent flags=0x0
    activity=null who=null
    requestCode=0 requestResolvedType=null
    requestIntent=Intent { }
    sent=false canceled=false
-------------------------------------------------------------------------------
DUMP OF SERVICE activity.services:
Services in Current Activity Manager State:
-------------------------------------------------------------------------------
DUMP OF SERVICE alarm:
Current Alarm Manager state:

  Realtime alarms that are scheduled:
  RTC #1:
    Alarm{436358a0 type 1 android}
    type=1 when=1272931200000 repeatInterval=0 count=0
    operation=PendingIntent{43617020 target IntentSenderRecord{4359f4e0 android
broadcastIntent}}
  RTC #0:
    Alarm{43695080 type 1 android}
    type=1 when=1272884280000 repeatInterval=0 count=0
    operation=PendingIntent{4358e9d8 target IntentSenderRecord{435e56d8 android
broadcastIntent}}

  Elapsed realtime wakeup alarms that are scheduled:
  ELAPSED_REALTIME_WAKEUP #0:
    Alarm{4361e8e8 type 2 android}
    type=2 when=90877805 repeatInterval=0 count=0
    operation=PendingIntent{435adc60 target IntentSenderRecord{435adb08 android
broadcastIntent}}

  Broadcast ref count: 0

  Alarm Stats:
  android
    4729ms running, 1 wakeups
    1 alarms: Intent { action=android.content.syncmanager.SYNC_POLL_ALARM flags=
0x4 (has extras) }
    28 alarms: Intent { action=android.intent.action.TIME_TICK flags=0x40000004
(has extras) }
-------------------------------------------------------------------------------
DUMP OF SERVICE appwidget:
Providers: (size=3)
  [0] provder=ComponentInfo{com.android.alarmclock/com.android.alarmclock.Analog
AppWidgetProvider} min=(146x146) updatePeriodMillis=0 initialLayout=2130903043 z
ombie=false
  [1] provder=ComponentInfo{com.android.camera/com.android.camera.PhotoAppWidget
Provider} min=(146x146) updatePeriodMillis=0 initialLayout=2130903052 zombie=fal
se
  [2] provder=ComponentInfo{com.android.music/com.android.music.MediaAppWidgetPr
ovider} min=(294x72) updatePeriodMillis=0 initialLayout=2130903040 zombie=false
AppWidgetIds: (size=1)
  [0] appWidgetId=1 host=1024/com.android.launcher provider=ComponentInfo{com.an
droid.alarmclock/com.android.alarmclock.AnalogAppWidgetProvider} host.callbacks=
com.android.internal.appwidget.IAppWidgetHost$Stub$Proxy@4363f610 views=android.
widget.RemoteViews@43731e90
Hosts: (size=1)
  [0] packageName=com.android.launcher uid=10004 hostId=1024 callbacks=com.andro
id.internal.appwidget.IAppWidgetHost$Stub$Proxy@4363f610 instances.size=1 zombie
=false
-------------------------------------------------------------------------------
DUMP OF SERVICE audio:
 

C:\Users\xufan>adb shell ime list
com.android.inputmethod.latin/.LatinIME:
  mId=com.android.inputmethod.latin/.LatinIME mSettingsActivityName=com.android.
inputmethod.latin.LatinIMESettings
  mIsDefaultResId=0x7f060001
  Service:
    Filter: null
    priority=0 preferredOrder=0 match=0x108000 specificIndex=-1 isDefault=false
    labelRes=0x0 nonLocalizedLabel=null icon=0x0
    ServiceInfo:
com.android.inputmethod.pinyin/.PinyinIME:
  mId=com.android.inputmethod.pinyin/.PinyinIME mSettingsActivityName=com.androi
d.inputmethod.pinyin.SettingsActivity
  mIsDefaultResId=0x7f060000
  Service:
    Filter: null
    priority=0 preferredOrder=0 match=0x108000 specificIndex=-1 isDefault=false
    labelRes=0x0 nonLocalizedLabel=null icon=0x0
    ServiceInfo:

C:\Users\xufan>adb shell input
usage: input [text|keyevent]
       input text <string>
       input keyevent <event_code>

    android ps 命令执行完后，会有下列各项值：“USER  PID  PPID  VSIZE  RSS  WCHAN  PC  NAME”，代表的意思分别是：

    VSIZE：进程的虚拟内存大小；
    RSS：   进程分配到得物理内存大小；
    WCHAN：address of the kernel function where the process is sleeping，Running tasks will display (0) in this column.
    其他的再说。

ContentResolver cr = getContentResolver();
        Cursor cursor = cr.query(ContactsContract.Contacts.CONTENT_URI, null, null, null, null);
        while(cursor.moveToNext()){
         //get name
         int nameFiledColumnIndex = cursor.getColumnIndex(PhoneLookup.DISPLAY_NAME);
         String contact = cursor.getString(nameFiledColumnIndex);
         
            String[] PHONES_PROJECTION = new String[] { "_id","display_name","data1","data3"};//
            String contactId = cursor.getString(cursor.getColumnIndex(PhoneLookup._ID));
            Cursor phone = cr.query(ContactsContract.CommonDataKinds.Phone.CONTENT_URI, PHONES_PROJECTION,
                                    ContactsContract.CommonDataKinds.Phone.CONTACT_ID + "=" + contactId, null, null);
            //name type ..
            while(phone.moveToNext()) {
             int i = phone.getInt(0);
             String str = phone.getString(1);
             str = phone.getString(2);
             str = phone.getString(3);
            }
            phone.close();
            //addr
            Cursor addrCur = cr.query(ContactsContract.CommonDataKinds.StructuredPostal.CONTENT_URI ,
        new String[]{"_id","data1","data2","data3"}, ContactsContract.CommonDataKinds.Phone.CONTACT_ID + "=" + contactId , null, null);
            while(addrCur.moveToNext()) {
             int i = addrCur.getInt(0);
             String str = addrCur.getString(1);
             str = addrCur.getString(2);
             str = addrCur.getString(3);
            }
            addrCur.close();
           
            //email
            Cursor emailCur = cr.query(ContactsContract.CommonDataKinds.Email.CONTENT_URI ,
        new String[]{"_id","data1","data2","data3"}, ContactsContract.CommonDataKinds.Phone.CONTACT_ID + "=" + contactId , null, null);
            while(emailCur.moveToNext()) {
             int i = emailCur.getInt(0);
             String str = emailCur.getString(1);
             str = emailCur.getString(2);
             str = emailCur.getString(3);
            }
            emailCur.close();
           
        }
        cursor.close();

android中获取通话记录
String str = "";
        int type;
        long callTime;
        Date date;
        String time= "";
        ContentResolver cr = getContentResolver();
        final Cursor cursor = cr.query(CallLog.Calls.CONTENT_URI, new String[]{CallLog.Calls.NUMBER,CallLog.Calls.CACHED_NAME,CallLog.Calls.TYPE, CallLog.Calls.DATE}, null, null,CallLog.Calls.DEFAULT_SORT_ORDER);
        for (int i = 0; i < cursor.getCount(); i++) {  
            cursor.moveToPosition(i);
            str = cursor.getString(0);
            str = cursor.getString(1);
            type = cursor.getInt(2);
            SimpleDateFormat sfd = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
            date = new Date(Long.parseLong(cursor.getString(3)));
            time = sfd.format(date);
           }

原文地址：http://apps.hi.baidu.com/share/detail/4516043
文档在：
file:///E:/Android%20study/android-sdk-windows/docs/reference/android/content/Intent.html

在移动 UI 架构开发的混战中， Android 上升到首位。如果你有一些移动体验，你会发现它是一个 Java ME 的 Canvas / Screen 对象和 BREW 构建阶层的完美组合，通过一些 XML 布局工具启动。每项活动被放置在屏幕堆栈，当它从您的应用程序启动。 Android 是已经被配置处理关闭当前的活动，并激活它的下一个活动，当你要求或当用户按下 Back 。此设置允许您认为每个作为一个屏幕基地活动。

每一项活动都可能包含不同的视图和视图组在一个层次树。你可以想像这样一个带有视图组的树，布局对象作为树干和树枝（因为视图组对象可以强制转换成对象），将视图或部件作为树叶。单一 view ，在其最基本的形式，是一个可以拖拽的矩形。一个视图组，在其最基本的形式，是一个包含一个或多个视图的对象。这个对象层次结构允许您布置复杂的用户界面，而不必经历计算视图矩形和组建重叠的错误过程。如果，另一种方法，这种事是你的袋子， Android 将退出的方式，让您呈现通过 Java ME 方法手绘游戏画布。

在本章中，你就会开始基本的基于 XML-based 屏幕布局，转移到更复杂的自定义画布上绘制。为了本书，我会分解并讨论视图作为三个主要食物群：

Ø        XML-defined widgets/views and view groups ： 良好的基本信息显示和菜单

Ø        Android native views ： TextViews, LayoutGroups, ScrollBars, and text entry

Ø        Custom views ： 游戏程序员最好的朋友

您将开始一个示例登录屏幕，并操纵和铺设移动出部件和代码的意见，最终使一个交互式动画与自定义视图。

方便、快速的 XML 布局

首先，使用 XML 的布局开始看似简单，但它会很快变得复杂。您将开始与你的布局和工作方式到的各个元素。

布置

大多 XML 屏幕将被封装在一个布局对象。布局对象来在许多不同的口味，每一个你看看实在是太快，然后检查了以下几节简单的例子了。

注意：在编译时，这些 XML 配置文件解析和 Android 包装成一个紧凑的二进制格式。这样可以节省解析可怕的启动时间上的数额。但是，它意味着 XML 文件无法通 过您的代码在运行时改变。更具体地说，您可以在执行过程中改变这些 XML 文件，但它会完全没有应用程序的布局。此外，您必须支付夸大一个视图或从 XML 视 图组一小性能价格。您的里程可能会根据 CPU 负载和用户界面的复杂性。

LinearLayout

所有元素被排列成递减的列，以在一个从上到下或从左到右的方式。每个元素可以有重力和体重的属性记，设置如何动态增长和缩小，以填补空间。元素自己排列成行或列的标示基于参数： android:orientation 。 For example (see Figure 3-1):

<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:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="Element One"

/>

<TextView

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="Element Two"

/>

<TextView

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="Element Three"

/>

</LinearLayout>

RelativeLayout

每个子元素的布局是与子元素有关的。这种关系的建立使得在上一个子元素结束的地方元素才开始。子元素可以只涉及那些所列内容的面前。因此，建立从 XML 文件开始到结束的依赖。请注意， ID 是需要的，以便部件可以互相引用。例如（见图 3-2 ）：

<RelativeLayout xmlns:android=

"http://schemas.android.com/apk/res/android"

android:layout_width="fill_parent"

android:layout_height="fill_parent"

> 

<TextView

android:id="@+id/EL01"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="Element One"

/>

<TextView

android:id="@+id/EL02"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="Element Two"

android:layout_below="@id/EL01"

/>

<TextView

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="Element Three"

android:layout_toRight="@id/EL02"

/>

</RelativeLayout>

AbsoluteLayout

每个孩子有一个一个特定的位置，必须在父母布局对象的范围内。 AbsoluteLayout 对象可能是最容易建立和可视化，但最难迁移到新的设备或屏幕尺寸上。例如（见图 3-3 ）：

<AbsoluteLayout xmlns:android=

"http://schemas.android.com/apk/res/android"

android:layout_width="fill_parent"

android:layout_height="fill_parent"

> 

<TextView

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="Element One"

/>

<TextView

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="Element Two"

android:layout_x="30px"

android:layout_y="30px"

/>

<TextView

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="Element Three"

android:layout_x="50px"

android:layout_y="50px"

/>

</AbsoluteLayout>

TableLayout

TableLayout 是一个布局对象，允许您指定表中的行。 Android 试图安排进入正确的行和列的每一个子元素。例如（见图 3-4 ）：

<TableLayout xmlns:android=

"http://schemas.android.com/apk/res/android"

android:layout_width="fill_parent"

android:layout_height="fill_parent">

<TableRow>

<TextView

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="Element One A"

/>

<TextView

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="Element One B"

/>

</TableRow>

<TableRow>

<TextView

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="Element Two A"

/>

<TextView

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="Element Two B"

/>

</TableRow>

</TableLayout>

这些是主要布局对象，你将来会遇到。每个例子有几个简单的 TextView 元素，为每种布局类型示范布局怎样起作用的，同时一幅屏幕捕获每个 XML 文件将呈现。你可以在 Android 的文件更彻底的实例 http://code.google.com/android/samples/ApiDemos/src/com/google/android/samples/view/ 。
注意：如果您是移动开发方面的新手，当决定如何布置您的应用程序时，您必须重复你的头一个座右铭： “ 移植，移植，移植。 ” 理想情况下，一个布局的设计将所有可能的工作设备。事实上，这永远不会奏效。如果你运行应用在多个电话上（如大多数运营商要求您这样做），将重点放在动态的，相对的布局结构。我保证，你的屏幕大小今后将以一种戏剧性的方式变化。减少绝对值 X/ Y 的数量，并保留那些你在方便使用找到的位置 .

接下来的任务是找到所有放置在一个布局元素，相关子元素的列表。这种资源是可以在纷繁复 杂表格 http://code.google.com/android/reference/android/R.styleable.html ＃ Menu 。

从那里，你可以尝试第一个 UI 任务：在为 “ 社交 ” 应用程序的登录屏幕。这登录屏幕将成为 getSplashy 示例应用程序的一部分。

滚动、文字输入、按钮，以及所有在生活简单的事情

现在是时候使用布局的一个类。 XML 的布局是完美的，在用户输入，信息传递，以及几乎任何屏幕的内容是相对静态地方。您将添加一个简单的登录屏幕显示前面提到的 “ 社交 ” 申请表（见代码清单 3-1 ）。第一项任务是来描述屏幕看起来的样子在一个新的视图中。您可以使用线性布局，使您可以只垂直地添加小工具。（请注意，这个 XML 需要 general_bg 图片和声明字符串被定义在 res 文件夹中。为此，从有关详细信息， Apress 网站下载该项目的一章。）

Code Listing 3-1. /res/layout/login.xml

<ScrollView xmlns:android=

"http://schemas.android.com/apk/res/android"

android:layout_width="fill_parent"

android:layout_height="wrap_content"

android:scrollbars="vertical">

<LinearLayout

android:orientation="vertical"

android:layout_width="fill_parent"

android:layout_height="fill_parent"

android:background="@drawable/general_bg"

> 

<TextView

android:text="Login Screen"

android:layout_width="fill_parent"

android:layout_height="wrap_content"

android:textAlign="center"

/>

<TextView

android:text="Username:"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

/>

<EditText

android:id="@+id/username"

android:layout_width="fill_parent"

android:layout_height="wrap_content"

/>

<TextView

android:text="Password:"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

/>

<EditText

android:id="@+id/password"

android:layout_width="fill_parent"

android:layout_height="wrap_content"

/>

<Button

android:id="@+id/loginbutton"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="Login"

/>

<TextView

android:id="@+id/status"

android:layout_width="fill_parent"

android:layout_height="wrap_content"

android:textAlign="center"

android:text="Enter Username and Password"

/>

<TextView

android:layout_width="fill_parent"

android:layout_height="wrap_content"

android:text="@string/disclaimer"

/>

</LinearLayout>

</ScrollView>

我将从原来的列举中撤出一些具体的线条并且解释他们的作用在下面部分。注意，你没有定义组成这个屏幕元素的任何位置。但是，因为您使用的是 LinearLayout 对象，每个连续的元素附加到以前的元素的底部。

Scrolling

滚动一个超过你设备屏幕大小的视图，你只是需要在 ScrollView 中封装你的布局对象。为了使用垂直滚动条，你的 ScrollView 必须设置参数 android:scrollbars="vertical" ，当你向下翻屏时，将显示一个滚动条。为了使视图足够长以说明这个对象，我已经添加 TextView 作为假声明在线性布局结束处。你会发现，如果你设置原来的 XML 为活动视图，重点将是向下移动的对象，直到到达的按钮，此时滚动条将处理键和向下移动用户文本的底部。

窥探 TextView

两个主要 “ 构件 ” 工作在原来 XML.

注意：在 Android 中的一个小部件是指任何独立视图对象的子类。

为了标题和文本输入标签，使用 TextView 对象。对于用户控制的文字输入，使用 EditText 对象。最显着的，因此，特别值得详细描述的是最后的 “status” 的文本：

<TextView

android:id="@+id/status"

android:layout_width="fill_parent"

android:layout_height="wrap_content"

android:textAlign="center"

android:text=”Enter Username and Password”

/>

首先，由于本书内容将被修改在某个时候，通过你的代码在运行的时候，所以你需要给它一个 ID 。这允许您使用 findViewById 方法后获得。

@+id/status 将添加到您的 ID 状态在 R.java ，如果文件不存在了。这一点，你的 IDE 可能会错误当您在代码中引用它第一次。不要惧怕，但因为是第一次编译，将全部解决了。

接下来，您用 TextView 设置其宽度达到其父类的宽度在这种情况下， LinearLayout 对象。你告诉它让它的高度是由文字大小范围内使用的 layout_height 参数 wrap_content 。您希望文字居住在屏幕的中心，因此您使用 textAlign ，因为你已经设置其宽度为整个屏幕。最后，您给它一些简单的文字显示在活动开始了。后来，你会改变这一案文以反映当前的状态。

看到这个手艺的结果，只需创建活动，并设置这个 XML 的布局是主要内容视图。您应该能够看到屏幕上，在文本输入字段的类型，并选择框。这些行动，但是不会有任何结果。为配合该计划将他们，让他们互动你就必须继续阅读。

XML 的布局

我们深刻体会了 XML 的布置方案既简单又强大。它提供了一个非编程接口的移动屏幕布局和设计。它给开发人员提供了工具去破解打开和修改运行时的飞行这些值，你会做探讨如何相互作用现在 Android 的内置部件。

唤醒构建

我已经说明了如何使用 Android 的 TextView ， button 和 EditText 部件。但如何有用的是一个文本输入字段，如果你不能摄取你的用户已经进入？ 这是一个反问，不要回答，我不能听你（我希望）。答案是显而易见的：没有目的和结果文本输入是没有用处的。要访问您的 EditText 部件先前定义的内容，你就必须做两件事：

1 。获取一个您在 XML 定义部件的对象句柄。

2 。监听点击或选择事件在 Login 按钮部件上。

获取的事情句柄

第一个任务就是得到一个在您的 XML 配置文件中定义的元素指针。要做到这一点，你会确保您要访问的每个 XML 部件有一个 Android ： ID 参数。正如前面简单提到，使用符号 @+id/-id_name_here- 将确保您的 R.java 文件有你需要的 ID 。以下是如何获得一个视图对象指针，当您的应用程序启动时。在新的登录活动中，这是 OnCreate 方法，被添加到 GetSplashy 示例应用程序：

Button btn = null;

public void onCreate(Bundle args)

{

super .onCreate(args);

setContentView(R.layout.login );

btn = (Button) findViewById(R.id.loginbutton );

}

在这里，您已经获得了登录按钮的指针，通过调用 findViewById 。这使您添加单击监听，会通知您当按钮被选中（在手写笔触摸屏）或选定中心软键。您将扩展 ClickListener 类的内联函数如下：

public class loginScreen extends Activity

{

private OnClickListener buttonListener =

new OnClickListener()

{

public void onClick(View v)

{

grabEnteredText();

}

};

...

}

当一个选择通知发生，以前的内联函数定义调用 grabEnteredText 方法。现在你已经定义的点击侦听器，您可以使用 btn 对象在 OnCreate 方法中：

public void onCreate(Bundle args)

{

//...

btn = (Button) findViewById(R.id.loginbutton );

btn.setOnClickListener(buttonListener);

}

如果您放断点您的按钮监听的 onClick 方法中，断点开火当您移动焦点并选择登录按钮，当您用鼠标点击它在运行模拟器中。

缫丝在文本

现在剩下要做的就是定义 grabEnteredText 来做到这点，正如它名字的含义。在登录屏幕的最终产品的版本，您要提取输入的文本，开始一个网络登录的调用，发动一个载入对话框。现在，你只显示一个对话框，包含在登录名和密码域中输入的内容。下面 grabEnteredTex 的样子在更新的登录活动：

public void grabEnteredText()

{

//Get a pointer to the status text

TextView status =

(TextView) findViewById(R.id.status );

//Grab handles to both text-entry fields

EditText username =

(EditText) findViewById(R.id.username );

EditText pwd =

(EditText) findViewById(R.id.password );

//Extract Strings from the EditText objects

// and format them in strings

String usrTxt = username.getText().toString();

String pwdTxt = pwd.getText().toString();

//HTTP transaction would spin up a

//new thread here

status.setText("Login" + usrTxt + " : " + pwdTxt);

//Show dialog box that would eventually turn into

this .showAlert("Login Data", 0, "Login"

+ usrTxt + " : " + pwdTxt, "ok!", false );

}

首先，使用 findViewById ，为了 status 、 username 、 password 部件，您检索 TextView 和 EditText 指针。接下来，您提取 Text-Entry 构建的内容通过检索 TextEntry 对象，并将其转换成 String 类。最后，你把两个字段的内容在一起，他们都加入到状态文本对象，并弹出一个对话框还包含两个字符串。
这就是它 —— 现在允许用户输入文字，你获取、操纵，甚至显示一个对话框包含了该信息。干得好！花一秒钟轻拍自己在背后，或任何胳膊可以拘着的地方。
到目前为止，您探讨如何使用 XML 来做屏幕设计，仅仅使用 “ 社交 ” 画面屏幕。此时，你已经学会了如何使用两个的混合体在您的登录屏幕。最后一站关于 Android 部件表达，就需要单独使用代码建立屏幕布局的。

Java 的部件

当你看到我写的代码产生即使是很小的选择菜单，你可能会像我，有点吓呆了。等到熟悉的 XML 的屏幕布局，试图自己用 java 动手完成这一切，会感觉像是用一对破损的保龄球演奏古典音乐。被警告，它涉及许多打字，或许不仅仅是一点挫折。

另一方面，可能有一个用户界面布局的具体元素，你要动态调整。因为正如我前面提到的，您不能在应用程序运行时编辑 XML 文件的布局，它必须有需要修改每一个用户界面的代码在运行时可能片断的工具。 Android 给你这个动力，只要你是舒适的打字以惊人速度。
引擎盖下使用

现在您可以在引擎盖下开始小小的修补，用最基本、最直觉式的方法检验 Android 的构建。你已经了解一个核心部分的基本外观，其中许多是您在 XML 形式探讨。正如在前面的例子中，为了说明起见，我将保持这种基本。我已经在这里讨论的界面布局，它应该很容易学以致应用到更复杂的问题。在后来，更多的高级例子，你会获得更多的其他 Android 部件。在下面的例子中，我将尽力确保使用很少你从前依赖没有的 XML 元素。它应该给你一个机会，获得良好的处理非 XML 布局，但要记住，实际上，你必须是疯狂的做所有的用户界面，这种方式。

主菜单

几乎所有的移动应用，至少在发行时，首先是图形主菜单。这个图形屏幕引导用户执行移动应用的各种功能。因为 “ 主菜单 ” 的概念是如此普遍的移动应用体验，它使一个很好的和实际的案例研究。在这个例子中，你的目标是将一个简单功能主菜单的放在一起。为了便于比较，你会使用其他的线性布局， 把一切融合在一起。这个例子将建立在三个主要阶段：

1 。布局：你会在屏幕上正确地安排所有的主菜单项。当然，这将只使用 Android 的大屏幕版面上的一小部分。但是，大多数应用程序菜单将使用大型图形，承担着更多的空间。

2 。焦点：您需要建立一个焦点结构，使用户可以通过元素移动。当焦点移动时，你必须调整每个菜单元素的颜色。

3 。选择活动：最后，您需要建立一个监听，以便当一个元素被选中或单击，你知情和可以在选定的项目基础上采取适当行动。

当您完成所有这些任务的三个，你应该有建立主要输入屏幕的框架，这大约占整个移动应用的百分之 80 的工作。虽然不完全现实（即，我已经完全使用 XML 的零），它是极好示范，如何做事情以自定义运行时的驱动方式。当您添加更多的功能在你的 “ 社交 ” 应用程序中，您填写此主菜单将更加完善。

布局， Java 风格

在简单主菜单上的第一步是得到所有在屏幕上的菜单元素。正如我刚才所说，你将采用线性布局完成它。您需要在申请前做这一切提请第一次，所以就必须在新的 MainMenu 活动的 OnCreate 方法中。 （请参阅第 1 章，如果你忘记了如何创建并插入一个新的活动。）代码清单 3-2 显示了它的实例化和配置的模样。

LinearLayout layout = new LinearLayout(this );

layout.setBackground(R.drawable.general_bg );

layout.setOrientation(LinearLayout.VERTICAL );

layout.setLayoutParams(

new LayoutParams(LayoutParams.FILL_PARENT ,

LayoutParams.FILL_PARENT ));

setContentView(layout);

之后，您通过什么迄今为止，这在概念上似乎应熟悉。您可以设置背景使用在 /res/drawable/ 文件夹中的图片，设置线性布局为垂直方向，并设置 LayoutParams 以填补父亲（在这种情况下，父亲是活动，控制全屏幕）。布局参数，在他们的基地，必须界定规定部件的高度和宽度。正如您后来可能会发现，在前布局参数设置之前试图放入一个部件在 ViewGroup 里，将抛出一个异常。但是，现在你有一个布局对象来填充，你可以开始建立了屏幕。

添加标题

接下来，添加一个简单的标题，在你的主菜单画面上方将为本。代码清单 3-3 显示的代码块，您需要它。

Code Listing 3-3. Adding the Title

TextView title = new TextView(this );

title.setText(R.string.man_menu_title );

title.setLayoutParams(

new LinearLayout.LayoutParams(

LinearLayout.LayoutParams.FILL_PARENT ,

LayoutParams.WRAP_CONTENT ));

title.setAlignment(Alignment.ALIGN_CENTER );

layout.addView(title);

创建文本对象，并设置文本在 /res/values/strings.xml 中 。我知道我说我不会用任何 XML ，但我恐怕我会对此有些撒谎。在开发中，您需要将所有的字符串移到这个位置，而不是在代码中定义。如果你的客户是像我这样，你就不会想拉你的源代码编辑器并重新编译每次他们想改变对 screens.Now 之一的措词，你有一个标题，是时候添 加更多有趣的和积极的菜单元素。
铺设菜单项
现在您可以添加单个菜单元素。因为这将是第一个在相当重复，我将插入和解释的第一个元素，但其余的留给你的你自己的设备。随意抓取在 Apress 网站的完整项目，看到菜单项休息。同样地，你会填补他们更为您通过 Android 要素各地的发展。
代码清单 3-4 显示的代码添加单个菜单项。

Code Listing 3-4. Adding a Menu Item

TextView ItemOne = new TextView(this );

ItemOne.setFocusable(true );

ItemOne.setText("Login Screen");

ItemOne.setTextColor(Color.WHITE );

ItemOne.setLayoutParams(

new LinearLayout.LayoutParams(

LinearLayout.LayoutParams.FILL_PARENT ,

LayoutParams.WRAP_CONTENT ));

//Give the menu item an ID for tracking reasons.

//The ID is a static int defined locally to the class

ItemOne.setId(IdOne );

//Add it to our linear layout

layout.addView(ItemOne);

天哪，你可能认为在仔细阅读代码，这看起来就像你已经添加标题。你完全正确，多么聪明的 you.The 的一个对象时表明的焦点是，当它被选中繁重还没有到，所以不要太自大还。下面是与以前的菜单项，上面列出的标题文字有差别：

Ø         你需要告诉 TextView 它可以接受的方法调用 setFocusable 焦点。

Ø         菜单上市项目将需要身份证，因此您可以区别开来，在选择处理程序菜单元素的其余部分。

正 如我刚才简单，只要增加一个小部件到 ViewGroup 的 LayoutParams 对象必须明确这一观点内组定义的对象。例如，在过去 setLayoutParams 方法调用，你必须通过在 LinearLayout.LayoutParams 对象。你必须通过正确的子类的布局参数，或机 器人将你扔在运行时异常。

正如我以前说过，为了使菜单，我将添加两个文本元素几乎完全一样，以前上市。为贪方便，我不会在这里一一列举。一定要参照整个项目，以满足你的好奇心。现在，你把所有的菜单项到位，是时候对其进行修改时，接收或失去焦点

焦点年轻的草蜢 ... 。
为了处理焦点改变事件，你必须创建一个 OnFocusChangeListener 抽象类的实现。该示例的版本，在主菜单内定义类的活动在当地，将类似于代码 3-5 。

Code Listing 3-5. Creating a Focus Listener

OnFocusChangeListener focusListener =

new OnFocusChangeListener()

{

public void onFocusChanged(View v, boolean hasFocus)

{

adjustTextColor(v, hasFocus);

}

};

private void adjustTextColor(View v, boolean hasFocus)

{

//Dangerous cast. Be sure you are

//listening only to TextView focus changes

// or this could go horribly wrong.

TextView t = (TextView)v;

if (hasFocus)

t.setTextColor(Color.RED );

else

t.setTextColor(Color.WHITE );

}

此外，您必须添加以下行对应于每个菜单中选择元素附加焦点更改侦听器对象：

ItemOne.setOnFocusChangeListener(focusListener);

随 着地方听众，您现在每次通知一个菜单要素收益或失去焦点。在更先进的主菜单，这个方法可以增加地方的形象转变，动画，三维爆炸或其他奇才邦图形效果。在这 个例子中，您将不得不满足于仅仅改变文字的颜色。现在，用户可以告诉通过颜色的变化，其中菜单项，突出显示，您需要的时候作出反应，他们按中心键选择一个 项目。

提示：它可能通过使用 setTextColor （ ColorStateList 颜色）方法，该方法是贯彻落实文本简单的方式为基础的主要 menu.There 一个 TextView 重点，没有重点，并选定颜色总是很多方法可以实现一个目标，一个很好的 IDE 中，我只是选择了更通用的（因为我 希望你的应用超越文本菜单）。有关使用 setTextColor 信息，请参阅文件 Android 在 http://code.google.com/android /reference/android/widget/TextView.html ＃ setTextColor （整型）。

单击并选择活动
你已经看到如何登记在 oginscreen onClick 事件，所以你应该能够通过这一节 withouttrouble 的微风。代码清单 3 月 6 日 显示了示例代码获取选择的事件。

Code Listing 3-6. Adding a Selection Listener

OnClickListener clickListener = new OnClickListener()

{

public void onClick(View v)

{

String text = "You selected Item: ";

switch (v.getId())

{

case IdOne :

text += "1";

startActivity(

new Intent(MainMenu.this, Login.class));

break;

case IdTwo :

text += "2";

startActivity(

new Intent(

"com.apress.example.CUSTOM_VIEW"));

break;

case IdThree :

text += "3";

break;

}

//We'll get to the following line in a bit

status.setText(text);

}

};

以前的 switch 语句是调用 setID 回来的原因当您最初创建并铺设 TextView 部件。当一个菜单项被选中或指针点击，的 onClick 函数被调 用，并通过相应的视图是作为参数。您将负责审查，以确定哪些菜单项被选为通过视图 ID 。这使您可以采取的菜单中选择适当的行动。通过这种方式，您可以切换 到先前定义的登录屏幕，你即将会与 startActivity 方法调用写入自定义视图。

还是有留下的一小步，如果你在示例代码中的 onCreatefuction 的底部，你会点它。你需要添加一个点击监听到视图。下面是应该运行在你建立的部件清单行：

ItemOne.setOnClickListener(clickListener);

回顾
回顾 Java 驱动的主菜单，你做到了几个重要 things.First ，您执行功能以前只能通过 XML 文件的布局。虽然不完全切合实际的做一方面，它会给你足够的工具来改变和定制应用程序的同时运行 XML 视图。
第二，你注册为您的所有菜单项的焦点改变事件。当焦点更改侦听叫，你改变了重点项目，以突出显示它的颜色。在实际应用中，要达到同样的事情更有效的方法，但我假设你想改变的东西代替文本颜色多，可以说，奢华。
第 三，你学会了如何倾听和作出反应的选择事件，洞悉项目选中，并采取适当的行动是 selection.Again 基础上，对所有需要将重点放在手屏幕小部件 出代码，往往是相当昂贵，但是使用你刚刚学到的工具，你可以修改，增加，以及自定义菜单或工程清单数据和用户偏好为基础，同时应用程序正在运行。但是，如 果您需要获得更多的专业如何绘制到屏幕上，你需要较少微妙和更代码重的方法。

自定义用户界面渲染的画布

这 是你出芽部分游戏开发商一直在等待 for.Android 允许你定义一个自定义视图对象只是通过扩展视图类和执行 OnDraw 方法。为了演示自定义视图在 动画循环中运行，我已经从旧金山市的探索展示一些启示我们如何看待动画和声音。您可以在 http://www.exploratorium.edu /listen/index.php 更多关于博物馆和有关的展览。你可以购买 http://www.nature.com/neuro/journal /v7/n7/full/nn1268.html 科学白皮书。
这个例子将动画两个球对对方旅游，然后或者或弹跳和移动距离通过。这个例子是为了表明反弹声音可以看到之间的传递对象，看他们相互弹球人的区别。代码方面，我将演示了一个自定义视图几个重要方面：

Ø         实施意见的 Android

Ø         绘制到屏幕上使用 Canvas 对象

Ø         创建动画循环

Ø         修改，并从活动自定义视图交互

自定义视图
您 可以自定义在两个方面视图窗口。第一，是将 View 类。这使您可以通过滚动自己创造一个 android.View 可行的子类的 “ 工具 ” 。另一种方法，您就 必须对自己的探索，是子类，如 TextView ，进度条，或 ImageView 和修改其行为受保护的方法使用现有的部件。这个例子显示了第一个选择，因为 它的范围广泛，比较容易理解。
在最基本的层面，一个自定义部件重写保护 OnDraw 方法。代码清单 3-7 显示了这样一个方法的一个示例。

Code Listing 3-7. Simple Custom View Declared in the

CanvasExample Activity

protected class CustomView extends View

{

public void onDraw(Canvas canvas)

{

Paint p = new Paint();

p.setColor(Color.WHITE );

canvas.drawText("Yo!", 0, 25, p);

}

}

祝贺！输入文字这几句，你现在是自己的自定义部件骄傲的所有者。当然，它只是打招呼，像我 17 岁朋克表妹，但我想你必须从某个地方开始。对于那些你在与 GameCanvas 的经验对象的 Java ME ，这应该很熟悉。要接收 OnDraw 中呼叫，您需要设置作为样本活动的主要内容查看。你必须仪式代码，将实例化，并使其成为当前视图。代码清单 3-8 显示了 CanvasExample 活动的外观。

Code Listing 3-8. Activating a Custom View

CustomView vw = null;

public void onCreate(Bundle args)

{

super .onCreate(args);

vw = new CustomView(this );

setTitle("Bounce or Pass, sounds changes everything");

setContentView(vw);

}

你为你的样品活动的名称，因为你没有给它一个应用程序的名称。然后，它只是一个创建新 CustomView 对象，并设置它为当前内容视图的问题。这将调用 您的自定义部件内的 OnDraw 方法，并显示您的有点不合常规的问候。您现在有一个掌握在非常基本的绘画方式到屏幕上。您现在应该可以进入更复杂的渲染和 动画的循环开始。
创建游戏循环
由于所有游戏程序员会告诉你，大多数游戏，其核心，一个不断循环 onsist 。用户输入的循环检查，并 在此输入和任何其他游戏行动，届时将制订新的框架 / 帧在您的示例应用程序 screen.The 循环将不会赢得的复杂性和独创性的任何奖项，但它会得到你开 始自己的 amerendering 循环。

注 意：如果你想实现自己以外的浏览自己的动画循环 / ViewGroup 层次，并建立与 SurfaceView 循环研究对象。你可以找到这一 http://code.google.com/android /reference/android/view/SurfaceView.html 对象文件。

加载音频和图像
在您将绘图 CustomView 得到，您需要加载初始化稍后将用于一些资源。代码清单 3-9 显示了新的构造 CustomView 包括局部类变量声明。

Code Listing 3-9. Initializing the CustomView

protected class CustomView extends View

{

Context ctx;

Paint lPaint = new Paint();

int x_1=0,y_1=0;

MediaPlayer player = null;

Bitmap ball = null ;

boolean running = true ;

CustomView(Context c)

{

super(c);

player = MediaPlayer.create (c, R.raw.bounce );

BitmapDrawable d = (BitmapDrawable)

getResources().getDrawable(R.drawable.theball );

ball = d.getBitmap();

ctx = c;

}

...

}

在构造函数中，你通过 R.java 装载常数的反弹媒体资源从 / 水库 / 原始位置的文件。因为你做了几个其他资源类型此之前，你应该是一个老手了。您还需要加 载一个，将作为 “ 球得出的形象。 ” 你这样做的资源管理器使用对象，这是从上下文对象 etrieved 。虽然你没有明确从资源加载位置之前的形象，这好像几 乎任何其他资源负载的代码。

实施环，实施循环，实施 ...
事不宜迟，代码清单 3-10 显示了 CustomView 对象的 OnDraw 方法样子。

Code Listing 3-10. The Core of the Animation Loop

public void onDraw(Canvas canvas)

{

//Draw the white background

Rect rct = new Rect();

rct.set(0, 0,

canvas.getBitmapWidth(),

canvas.getBitmapHeight());

Paint pnt = new Paint();

pnt.setStyle(Paint.Style.FILL );

pnt.setColor(Color.WHITE );

canvas.drawRect(rct, pnt);

//Increment the X and Y value for the sprites

x_1+=2;

y_1+=2;

//Reset the loop when the balls drift offscreen.

if (x_1 >= canvas.getBitmapWidth())

{

x_1 = 0;

y_1 = 0;

}

//Draw ball 1

drawSprint(x_1, y_1, canvas);

//Draw ball 2

drawSprint(canvas.getBitmapWidth() - x_1, y_1, canvas);

if (running)

invalidate();

}

从顶部开始，您的第一个白色的背景使用 paintstyle 对象和调用 canvas.drawRect 。油漆对象，结合 Rectangle 对象，将告诉画 布画一个白色盒子，覆盖整个屏幕。接下来，您将递增 x 和你的球 Sprite 的 y 值。然后，您需要重新设置他们，如果他们已经漂过去屏幕的范围，并最终绘制 用自己的 drawSprite 给他们打电话。代码清单 3-11 显示了该函数的内容。

Code Listing 3-11. Drawing a Bitmap

protected void drawSprint(int x, int y, Canvas canvas)

{

canvas.drawBitmap(ball, x, y, lPaint);

}

这个功能，现在，只是一个简单的调用 drawBitmap 方法。我已经分离出来，这种方法只是因为绘制在另一场合雪碧可能需要比这个简单的例子功能。最 后，回到 OnDraw 函数，你会打电话给你的只有无效运行标志是真实的。调用无效的看法是 Android 的强迫重绘的首选方式。在这种情况下，您自己无效，这将调 用 OnDraw 中，整个过程中，再度开始。如果你简单地设置运行的标志虚假暂停或退出和无效时再恢复它的动画应该留在同其母公司活动的重点步骤。

添加和控制声音
由于听觉错觉需要能够打开和关闭两个反弹互相对象声音，您需要设置音频比赛，他们打，然后为用户建立一个机制，把这一声音的和关闭。
要 播放的音频，在代码中添加代码清单 3 月 12 日 到以前的 OnDraw 函数，因为它也实际上，游戏控制回路。当我说 “ 游戏循环， ” 我指的是无效呼叫在 OnDraw 中结束，将设立一个重绘 Android 的 UI 事件循环。请记住， playSound 是一个布尔宣布 326-7524 自定义视图。

Code Listing 3-12. Playing and Reloading Audio

if (playSound &&

canvas.getBitmapWidth() - x_1 -16 == x_1 + 16)

player.start();

if (x_1 >= canvas.getBitmapWidth())

{

x_1 = 0;

y_1 = 0;

player.stop();

player.release();

player = MediaPlayer.create (ctx, R.raw.bounce );

}

正如您可能已经注意到，你开始音频播放时，小精灵， 16 像素远离对方。这是一个没有行贿的时间，让音频开始。我要指出，这更加证明我不能编辑音频文件而不 是针对一个缺乏效率的音频负荷和 Android 播放时间。您还必须确保以播放音频只有 playSound 布尔是真实的。这个变量是一类的活动在其中自定义视图定义 的成员。使用此布尔，你会得到了来自内部的屏幕活动自定义视图类的控制。要打开和关闭音频，您现在只需实施
在代码的方法，在活动清单 3-13 。

Code Listing 3-13. Reacting to Key Events

public boolean onKeyDown(int key, KeyEvent kc)

{

if (key == KeyEvent.KEYCODE_DPAD_CENTER )

{

playSound = !playSound;

return true;

}

return super.onKeyDown(key, kc);

}

此代码应类似于你如何驳回了在第 2 章恶作剧的应用。

把它同在一起
如果您已经按照一直密切（或欺骗，只是下载完成的项目），您应该能够运行应用程序，看的幻觉。新闻中心方向键打开和关闭音频。与音频 起飞，它应该像他们通过互相进行表决，看起来他们反弹，即走各的路。在这个例子中，我演示了如何创建自己的视图类，如何用它来画在屏幕上，如何建立一个游 戏渲染循环，以及如何控制，简单的循环利用关键事件。
使用用户界面
在本章中，您已经了解，详细，如何布局屏幕使用 Android 的 XML 架构，以及如何相互作用和修改了一些 Java 的 code.Next 运行的模式，学习了如何 UI 部件布局和视图组使用源码单。这是一个不那么实际应用 的 Android 用户界面工具，但重要的是去理解的但为了通过。最后，您探索建设 gamerendering 循环的重要工具。您加入到把一些简单的多媒体和用户控 制，创建了一个简单的听觉幻想，应该让 yourvery 讨厌鬼的朋友。

提示：使用所有你学到了在本章中，建立这种幻想，它包含了一些说明文字，以及边界使用 XML.When 活动开始了一个框架，但呈现的 XML 插入到适当的位置自定义视图。对于这项任务，我建议使用的解释，并为边境矩形相对布局， TextView 。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/lihaifeng555/archive/2009/11/02/4757323.aspx

Activity: Android 应用程序的UI(User Interface)基本组件。

Intent receiver: 可随时被启动来处理Intent，并执行其任务。

Service: 非UI功能的后台处理组件。

Content provider: 跨程序的共享资料之存储者。

Android vs. Java ME vs. BREW

一个BREW应用程序，在所有绝大多数情况下，是由一个单独的小程序组成，这个小程序是通过接收和发送活动与手机的其他部分通信的。另一方面，你可以将一个Java ME应用看做Midlet类的扩展。这个Midlet有启动、停止、暂停、键处理（key handling）的功能，并且可以完成任何手机和应用的交互。一个Java ME应用程序通常由一个单独的Midlet组成。

Android应用程序有许多活动，通过AndroidManifest.xml文件，这些活动可以被注册在手机中。 在面向Android的开发与面向其他手机开发工具包的开发之间，Android的multiactivity架构或许是的他们之间主要的区别。正是这个事实使编写模块化、分割的代码（modular, compartmentalized code）更容易。在BREW和Java ME中，开发人员可以执行在Midlet或小程序范围内的大部分功能。在Android中，你可以写一个活动、内容处理程序（content handler）、意图接收器（intent receiver）、或服务以应对几乎任何东西。一旦你编写了编辑文本文件的活动，通过发送和接收意向的行动，您可以引用这个活动在您将来所有编写的应用中。这个这并不是说，这种架构在BREW或Java ME中是不能实现的，他们只是必须在Java和C或C++编程的基础上，或在BREW中通过繁琐的扩展实现，而不是被平滑地集成到应用框架中。

Functionality

就像Midlet，活动使用了一系列的功能与外面的世界进行交换。在他的基础上，你编写的活动必须重写方法OnCreate，你还要重写其他功能，包括：onStop、onPause、onResume和onKeyDown。这几个功能可以让最大限度地将你开发的活动绑定到Android手机中。在默认情况下，在Eclipse中创建新的Android应用程序将执行一个“Hello，World”应用程序。我会告诉你如何从这个基本应用到功能齐全的画面。

如何添加图片(Image)资源

首先将图片资源(例如menu_background.jpg)直接拷贝到/res/drawable文件夹中。此时，Eclipse的Android插件(Android Plug-In)会自动将一个新的ID值添加到R.java里。所以R.java文档中会多加了一行指令如下：

public static final int menu_background=0x7f020001;

在应用程序将就用此ID值来取得这个图标文件，并显示或处理它。

如何定义XML布局 (Layout) 文件

刚才已经新增了一个图片资源文件。此时，在定义布局XML文件中，就可以引用此图片。这些布局XML文件都放在在/res/layout文件夹中，其中Eclipse的Android插件已经生成了一个main.xml文件。现在，你可利用Eclipse的 File>New>File菜单选项来生成新布局XML文件，例如：splash.xml。然后，以main.xml內容为模板，将之拷贝到新的splash.xml里，下一步移动<TextView>并且增加<ImageView>，内容如下：

<ImageView android:src="@drawable/menu_background"
android:layout_width="fill_parent"
android:layout_height="fill_parent">
</ImageView>

在Android的XML布局文件里，使用@drawable/就能轻松地引用/res文件夹中的资源，例如上面的的android:src="@drawable/menu_background"。此外，layout_width和layout_height 则说明这个ImageButton显示出來的大小(Size)。splash.xml也成為一項新的資源。所以在R.java裡也會自動產生新的一行，如下：

public static final int splash=0x7f030001;

绘制启动画面

现在，你的初始画面被定义完成，可以激活和显示。你现有的Android活动已制定了main.xml，所以你要转移到新的初始布局。为了切换，更改OnCreate方法中的代码：

setContentView（R.layout.main）；

为

setContentView（R.layout.splash）；

运行应用程序，看着你新创建的启动画面。到目前为止，如果你得到了错误信息，检查以确认你的名字是否匹配。如果图片没有显示，确保它被正确地放置在res/rawable文件夹，并splash.xml应用了正确的名称和文件。

时间可以解决任何问题

启动屏幕开始展现，但启动画面单独作无聊的应用程序，所以你需要进入主菜单。你会使用简单的内嵌定义线程来完成的定时器，有一些常数需要在定义线程前初始化。为了看上去完整，我将包括全部的OnCreate方法。代码如下。

Code Listing 2-1. Timing the Splash Screen

long m_dwSplashTime = 3000;

boolean m_bPaused = false ;

boolean m_bSplashActive = true ;

public void onCreate(Bundle icicle)

{

super .onCreate(icicle);

//Draw the splash screen

setContentView(R.layout.splash);

//Very simple timer thread

Thread splashTimer = new Thread()

{

public void run()

{

try

{

//Wait loop

long ms = 0;

while (m_bSplashActive && ms < m_dwSplashTime)

{

sleep(100);

//Advance the timer only if we're running.

if (!m_bPaused)

ms += 100;

}

//Advance to the next screen.

startActivity(new Intent(

"com.google.app.splashy.CLEARSPLASH"));

}

catch (Exception e)

{

Log.e("Splash", e.toString());

}

finally

{

finish();

}

}

};

splashTimer.start();

}

到现在 ， 你才开始看到一些 Java 代码。这个简单的线程直到运行时间计数器超过 m_dwSplashTime 才停止。虽然有实现一个计时器多种方式，选择这种方式有两个原因：

此计数器可以暂停。该计时器只有m_bPaused标志为false时才推动。正如你将看到在一分钟内，如果你调用活动的OnPause方法，可以方便暂停计时器。这并不总是对启动画面的需求，这对其他以时间为基础的业务是重要的。
 

移动到下一个屏幕很简单，只要改变的m_bSplashActive标记为false。推进到下一个屏幕，如果你执行这在时尚，不要求你作出的行动，然后取消更传统的计时器。
 

有了这个代码，只要你以毫秒为单位设置m_dwSplashTime，你应该看到启动画面。当时间到了或用户使用按键中断了启动画面，startActivity将被调用。finish可以关闭启动活动，使用户不必通过从主菜单上选择Back返回。你需要执行一项活动，接受CLEARSPLASH意图的行动。与此同时，让我们回顾一些其他重要活动的方法你需要重写。

暂停，恢复，冲洗，重复

由于呼入电话，短信或其他中断，你的活动被挂起时，暂停启动计时器，如下：

protected void onPause()

{

super.onPause();

m_bPaused = true;

}

对于这些大部分覆盖的方法 ， 在做任何事情之前 ， 你需要调用超类。如果你查看计时器线程，如果m_bPaused是true，你会看到负责跟踪时间的MS计数器保持时间没有前进。在这一点上，我相信你可以猜测onResume的样子：

protected void onResume()

{

super.onResume();

m_bPaused = false;

}

当你的应用程序恢复，计时器线程添加时间恢复到MS计数器。

基础的 Key Handling

在活动内，Key Handling是处理覆盖onKeyDown方法。我们将使用此功能允许用户取消你不完美的启动画面。正如在本节开始你看到的计时器线程，通过m_bSplashActive设置，你在计时器循环中了异常语句。为了异常处理，你只需要重写onKeyDown方法使之切换启动标记为false。下面的代码需要添加：

public boolean onKeyDown(int keyCode, KeyEvent event)

{

//if we get any key, clear the splash screen

super .onKeyDown(keyCode, event);

m_bSplashActive = false ;

return true;

}

现在 ， 当用户按下任意键 ， 屏幕将被推进到下一个路程通过计时器循环。

Clear intent

有一件事你需要在启动画面之前做 ， 我相信你想知道有关 startActivity 方法调用。这里应该简单介绍一下intent。Intent是一个对象，在两个或两个以上活动、内容处理（content handlers）、意图接收器（intent receiver）、或服务之间，可以作为一个通讯事件。你会使用com.google.app.splashy.CLEARSPLASH调用 startActivity 。当startActivity被调用时，Android搜索所有配置清单文件，寻找已注册为CLEARSPLASH Intent action节点。

你要增加一个新类MainMenu，其作为主菜单activity。它要继承Activity类，实现OnCreate方法，在R.layout.main中调用setContentView方法。你要打开的AndroidManifest.xml并增加新的 activity 元素。在 </activity> 结束符之后， 你应该插入以下内容：

<activity android:name=".MainMenu"

android:label="@string/app_name">

<intent-filter>

<action android:name=

"com.google.app.splashy.CLEARSPLASH"/>

<category android:name=

"android.intent.category.DEFAULT"/>

</intent-filter>

</activity>

确定活动的名称为 .MainMenu 。这会告诉 Android 加载和运行 Java 类。在 Intent filer 标签中 ， 注册为 com.apress.splash.CLEARSPLASH 的 Intent Action 。在现实中，名称意图可能是beef.funkporium.swizzle，只要名称在startActivity调用和前面的Android配置清单中一致，所有正确的事情应继续发生。

一项活动的生命周期

Activity的生命周期被包括在Google的文档中。但是，如果你先仔细考虑生产Activity的底层原理，你不能错过这个重要的信息。在这一点，你的启动画面，你应该准备好推出。

为了说明，我还增加了以功能在启动画面活动中：

protected void onStop()

{

super.onStop();

}

protected void onDestroy()

{

super.onDestroy();

}

如果你方断点在上面活动的所有功能，在调试模式下运行它，你会看到断点与下面顺序一致:

1. onCreate

2. onStart

3. onResume

4. 在这一点上，你的活动目前已经运行。在三秒钟内，计时器线程将达到结束，并调用startActivity结算的意图。下一步，它将调用finish，它告诉Android关闭启动画面活动。

5. onPause

6. onStop

7. onDestroy

5. onPause

6. onStop

7. onDestroy

从开始到结束 Activity ， 这是一般的生命周期来。你可以找到对生命和时代的 Android 活动更全面地披露 ， 在谷歌的文档活动中 http://code.google.com/android/reference/android/app/ Activity.html 。你甚至可以找到漂亮图形。从本质上讲，手机使用了以前的组合功能提醒你的主要事件可以发生在你的应用程序：启动，关闭，暂停和恢复。我已经讨论过，Activity将要成为任何传统应用的的核心组件；他们给你控制了屏幕，能够接收用户输入。

总结

到目前为止，我已经探讨了活动如何成在手机中，他们如何启动和停止，以及他们如何与基础层沟通。我演示了如何显示一个简单的XML视图屏幕，以及如何活性之间切换两个反应都在一个关键的事件和结束时的一个指定的时间量。在短期内，你需要了解更多有Android如何使用意向，意图接收器，过滤器和意图沟通。要做到这一点，你需要一个示例应用程序。

创建一个Intent Receiver

Intent Receiver是Android重要的组成部分，从它的名字可以看出其作用。它的作用是等待接收注册的Intent Action，Android是按照BREW的通知模式实现的。我们将使用一个简单的应用，展现一个复杂的Intent Receiver任务：输入文本消息的接收和响应。

事情的起因

我们开始设想这样一幅画面：一天下午，当你回到你的办公桌，你发现你的办公桌，从地毯到天花板与可爱的粉红色的图片，铺满最令人讨厌的图画。你知道这是谁在做，现在是你报复的时候了。你也知道你的工程部副总裁最厌恶一首特殊的歌。这首歌是 “ La Bamba “ 。让你决定通过一个休眠程序操纵你同事的Android手机。我会告诉你如何制作一个Android应用程序，收到特定的短信后，播放这种耻辱效应的音频文件。这会使你的副总对你的新敌人产生强烈的愤慨。同时，你要给他一个机会关闭声音了。这种恶作剧程序要求Intent Receiver，Activity，Service，以及所有三种方式进行通信。

这有什么实际的通途吗？这可能有吗？

这是一个很好的问题。虽然表面上看来不是很实用应用，我相信，如果有一点想像力，你可以发现其很多重要的现实用途：从推送电子邮件通知到内部电话应用通信。

你将向前迈进四个阶段。在每个阶段，你将了解更多关于Intent receives，services，所有这些应用程序之间的相互作用件：

通知收到一个短信
 

打开短信的内容和找到特殊的净荷
 

当短信到达Activity启动，并且意识到启动发生在接收器的控制下
 

开始一个新的服务，将播放音频文件
 

使用Intent Receiver

在你开始编写Intent Receiver之前，你需要了解你为什么会使用他。Intent Receriver没有或几乎没有内存占用、linkage和系统开销。在启动时，一个活动必须将所有大量的引入的类加载，Intent Receriver则没有这些约束。由于某种类型的新Intent可以达到破碎频率（例如网络状态更新），一个轻量级的对象必须在分析数据的第一阶段。如果它是一个适当的时间唤醒一个更大的用户界面程序或大幅后台服务，意图接收机应采取这种行动。

提示：意图接收器可以经常的启动和关闭（这依靠他们的监听），试图让它们变地重量轻，使用尽可能少的类库。你的用户不会高兴，如果他们电话在缓慢地爬行，因为你已经插入到太多特定的事件处理开销。

编写Intent Receiver

第一件事首先你需要创建一个这个小恶作剧应用程序建立新项目。在源目录中，创建一个新类，将成为新的Intent Receiver。在第一阶段，它看起来应该像这样：

public class PrankSMSReceiver extends IntentReceiver

{

public void onReceiveIntent

(Context context, Intent intent)

{

return;

}

}

现在你已经设定了阶级 ， 你必须告诉你想要 Android 接收 SMS 事件。你可以通过修改 AndroidManifest.xml 文件给你许可和登记 RECEIVE_SMS 的 Intent action 。

权限

运营商，用户，甚至开发人员可能不希望给Android应用自由支配，贯穿其手机和网络的特权层。因此，谷歌推出一种被移动发人员认可的权限概念。为了能够接收短信息，你需要通知手机你可以接收。

在Android中，所有元素的权限声明在特别的配置文件中，你添加的权限在<manifest>标记后（代码2-2）。该示例应用程序将被称为PrankApp。其活动主要是rankActivity。

Code Listing 2-2. Adding Permissions to Receive SMS Messages

<?xml version="1.0" encoding="utf-8"?>

<manifest xmlns:android=

"http://schemas.android.com/apk/res/android"

package="com.apress.book.PrankApp">

<uses-permission android:name=

"android.permission.RECEIVE_SMS" />

没有权限标志，Android将你的应用程序无法启动当它接收到一个短信。还有其他的权限我需要涵盖你向前看。在此期间 ， 你可以找到所有在列表的权限 Android 的文件资料 http://code.google.com/android/reference/android/ Manifest.permission.html 。

向我发送短信！

现在，你已经允许进行与手机的SMS层交互，你必须告诉手机做什么，当一个新的文本信息到达时。要做到这一点，你必须打开AndroidManifest.xml文件，添加一个新的Intent Receiver。代码清单2-3显示了要插入的代码。

Code Listing 2-3. Registering the New Intent Receiver for

Incoming SMSs

</activity>

<receiver android:name=

"PrankSMSReceiver"android:enabled="true">

<intent-filter>

<actionandroid:name="android.provider.Telephony.SMS_RECEIVED"

/>

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

</intent-filter>

</receiver>

这就是你每次必须要接受的 Intent notification ， 当手机得到一个接收到的 SMS 。

在 Action 中分析 Intent Receiver

要完成这个要比我们想象的有一点困难。一个进程必须在一个 DDMS 中运行 。但在大多数情况下，你不想让应用程序运行，除非新的事件触发它。这问题的解决方案在Eclipse IDE中只是一个小小的把戏。当你一步一步往下走时，这可能会一点一点变得复杂。

在你的onReceiveIntent方法中放置一个断点。开始调试应用程序，并让模拟器位于“Hello World，PrankActivity”屏幕上。在Eclipse中，切换视图到DDMS。你可以按这命令+ F8键几次或选择菜单 Window 􀁨 Open Perspective 􀁨 DDMS 。

沿着左边窗口，在Device选项卡上，你现在应该看有一个绿色bug图标在你的应用旁边。这是DDMS告诉你调试器附加到你的PrankApp进程中。在它的下面是Emulator Control选项卡。在这里你可以发送短信消息。首先输入任何一个电话号码，选择SMS，键入一个测试消息，并按下Send。

如果你的配置正确，你应该看到Eclipse切换到Debug透视图，并停止在你的新设置断点上。

注意：如果没有发生，首先确保你设置了权限正确。如果他们不正确，你应该看到一个失败的权限信息显示在DDMS屏幕底部的LogCat标签中。此外，请确保你的应用程序已经在运行，并在Devices选项卡有绿色调试图标在它的旁边。如果所有这些都不奏效，比较你的项目与文中的示例。

目前为止，如果你正确地完成了。你的Intent的onReceiveIntent功能被调用，当每一个SMS消息发送到手机上。接下来，你就必须弄清楚如何得到短信的内容。

什么是在一个SMS中？

可悲的是，到目前为止Android关于接收和过滤SMS信息的文档只不过是混乱的。我怀疑这不是一项需要告诉开发人员的重要功能。我不同意这些优先事项，但是使我有机会填补空缺。

下面是methodonReceiveIntent的代码，功能是监听新的SMS信息：

public void onReceiveIntent

(Context context, Intent intent)

{

SmsMessage msg[] =

Telephony.Sms.Intents.getMessagesFromIntent(intent);

for(int i = 0; i < msg.length; i++)

{

String msgTxt = msg[i].getMessageBody();

if (msgTxt.equals("0xBADCAT0_Fire_The_Missiles!"))

{

//Start the pranking here

}

}

return;

}

你还需要输入两个类库来完成这项工作：

Import android.telephony.gsm.SmsMessage;

Import android.provider.Telephony;

getMessageFromIntent 方法是在 Telephony 类中 ， 这将返回 SMS 信息的数组。现在剩下的就是得到短信的有效载荷。你要找的触发恶作剧活动的特殊代码为文本

“ 0xBADCAT0_Fire_The_Missiles ！ ”

它必须是一个适当的独特组合，以便它不会被触发事故。你不会希望自己的恶作剧失火并提醒受害人太早的。

注意：在Android里，没有记载的功能是很可能还没有完成。由于接收短信的文档几乎不存在，你应该会有些变化在如何处理手机简讯上。更可能的是整体的方法应该是相似的，但它有把握地认为其中的一些细节将改变SDK的前到达它的最终版本。这个例子是有关学习如何使用意图接收器多是有关文本的消息通信资料。

触发活动

重要的是要记住，意图接收器的生命周期短，只有只要方法调用onReceiveIntent。一旦出于这一职能，Android是免费杀死进程中运行你的应用程序。任何异步功能会死去，如果是一个十分棘手的死亡开始。如果你想要做超越了简单的处理方法内的任何事情，你需要启动服务或活动。既然你要同时播放音乐和警报你的受害者，他们去过了，你需要启动的一项活动。你完成此情况如下：

if (msgTxt.equals("0xBADCAT0_Fire_The_Missiles!"))

{

//Start the Activity

Intent startActivity = new Intent();

startActivity.setLaunchFlags(Intent.NEW_TASK_LAUNCH);

startActivity.setAction("com.apress.START_THE_MUSIC");

context.startActivity(startActivity);

}

你会看到这里是增补 NEW_TASK_LAUNCH 在 setLaunchFlags 。你需要做任何你要发送的 Intent action ， 将启动一项新的活动。此外，正如你在启动画面示例应用程序，你必须添加一个新的行动，你的Activity的Intent filter。那个过程应该看起来很熟悉：

<intent-filter>

<action android:name="android.intent.action.MAIN" />

<action android:name="com.apress.START_THE_MUSIC" />

<category android:name=

"android.intent.category.LAUNCHER" />

<category android:name=

"android.intent.category.DEFAULT" />

</intent-filter>

现在 ， 如果你在前面正确地添加了代码 ， 当你从 DDMS 透视图中 发送 SMS 消息时 ， 你应该看到你的应用跳出到前台 ， 显示 “Hello World ，PrankActivity ” 文本在屏幕上。

索具的活动

一个最后的工作你需要添加 ， 在得到卑鄙的音乐播放服务之前 ： 装配 Activity ， 以回应你的 Intent Receiver 发送的活动 。如果应用程序正常启动，你要立即关闭了。同样，如果可以通过菜单启动，这样你的恶作剧的计划就会过早的曝光。要做到这一点，你必须检索发射的Intent，并调用getAction方法来计算出在什么情况下，它已经启动。该PrankActivity的OnCreate方法现在看起来应该代码2-4。

Code Listing 2-4. Launching on a Specific Intent Action

public void onCreate(Bundle icicle)

{

super .onCreate(icicle);

Intent i = getIntent();

String action = i.getAction();

if (action != null &&

action.equals("com.apress.START_THE_MUSIC"))

{

setContentView(R.layout.pranked);

//We'll need to start the music service here

}

else

finish();

}

首先你会得到发起 Activity 的Intent 。使用目前得到的 Intent ， 你可以用 getAction 方法检索调用的行动。这个将返回一个包含启动事件的字符串，你核对你的著名音乐行动列在原来的XML。如果在启动事件为你的活动来自正常的方式（从菜单或从启动调试器），该行动字符串将是null。如果是这样的话，你要立即使用finish方法关闭活动。

注意：OnCreate方法被调用当你的应用被首次启动时。如果你已经启动你的应用程序，然后退出（使用返回键），应用程序仍然在后台运行。如果在这时，你发送短信，你的活动将回到前台，但其OnStart方法将调用而不是OnCreat。

你今天想羞辱谁呢？

虽然可能有些矫枉过正，你要使用Android的service对象来处理音乐播放。我打算这样做有因为另个原因：

n         􀂃 这是一个好的机会来展示以简单的方式service的使用，在简单的环境。

n         􀂃 潜在的，它会让你启动音乐不用看到应用程序，使你的恶作剧的应用程序更卑鄙。

神经与服务

为什么你要使用的服务？从本质上讲，它意味着是一个对象，与用户界面分离的可运行地过程。这是完美的情况，当一个开发人员希望的功能（无论是网络或多媒体相关）能够独立运行。例子包括：音频播放，网络交易的后台，和邪恶的恶作剧程序。虽然服务允许多个应用程序（打开通信信道）与他们绑定，你会使用它作为一个简单的后台进程。同样，services有很多用途不只是这个简单的例子。

创建service

添加一个新类的源码包。我已经再次调用PrankService（没有点创意）。在最基本的层面，service要重写onBind方法。要获得服务类编译，它必须看，至少有一点点，如代码2-5。

Code Listing 2-5. A Stripped-Down Service

public class PrankService extends Service

{

public IBinder onBind(Intent intent)

{

return null;

}

}

在这个例子中，你不会使用该服务onBind方法进行互动。你可以简单地启动和停止服务在你的主要活动内。要做到这一点，你必须重写两个方法在服务类：

OnStart （Int startId ，Bundle argument ）
onDestroy（）

当OnStart被调用时，你会开始播放的媒体文件。当服务被破坏，就会明确地停止。这不是必然要求，但你会明白。

启动服务

开始一个新的服务应该类似于开始活动。自从你已经接触到这是几次，我就在给你一段代码，让你整理一下。 调用前面列出的PrankActivity OnCreate方法。简单替换注释“ We’ll need to start the music service here ”用下面的代码行：

startService(new Intent

("com.apress.START_AUDIO_SERVICE"), null );

同样，这个看上去很熟悉。启动Activity和启动service之间唯一的区别是（除了不同的方法调用）是随Intent传递bundle（实际上是一个地图或哈希表）参数的能力。这bundle将被传递到OnCreate方法服务。

启动音乐

BREW和Java一样，Android的媒体播放（简单的播放/停止计算）非常简单易用。当你服务的OnStart函数被调用，你会加载和播放/res/raw 目录中的测试音频文件首先要做的是复制音频样本文件导入/res/raw（如果没有这个目录，继续并创建它）。下一步，放下羞辱，并复制写入尊重，音频文件原始文件夹。如果你使用Eclipse，你应该添加相应的元素R.raw。在你的情况下，它的R.raw.test。

现在你有一个音乐文件的引用，你可以添加程序 PrankService 的要求如下 ：

public void onStart(int startId, Bundle arguments)

{

MediaPlayer p;

super .onStart(startId, arguments);

player = MediaPlayer.create(this , R.raw.test);

player.start();

}

请记住 ， 是一个重写的 OnStart 方法 ， 因此你必须调用父类同一函数或 Android 将变得不稳定。在这一点上，你需要用MediaPlayer的静态类创建一个新的媒体播放器对象。因为service是context的子类，你将一个指针传递给你当前的context和静态变量代表你的测试媒体。在这一点上，你可以调用play，现在你可以开始忙了。播放会继续在后台运行，直到stopService这个方法是由你的主Activity调用。

当stopService被调用时，下面的方法将调用：

public void onDestroy()

{

super.onDestroy();

player.stop();

}

同情的行动

既然你是一个不错的爱开玩笑的人 ， 你要给你的受害者一个台阶下。正如你之前见过的，Activity是由Intent Receiver触发的，在活动启动服务的时间点上。正如你刚才看到的，service是负责播放噪声激怒你副总工程师。同样，因为你是仁慈的在你的执行回报的同时，你必须为受害者设计关闭音乐方法。添加在你的PrankActivity下面的方法可以实现你善意的行动：

public boolean onKeyDown(int keyCode, KeyEvent event)

{

stopService(new Intent(

"com.apress.START_AUDIO_SERVICE"));

finish();

return true;

}

配置文件

下面是表现如下所示 ：

<service android:name=".PrankService">

<intent-filter>

<action android:name=

"com.apress.START_AUDIO_SERVICE" />

<category android:name=

"android.intent.category.DEFAULT" />

</intent-filter>

</service>

禅宗和报复的艺术

通过不光明正大的小恶作剧应用程序的使用 ， 你应该明白了 Intents ，Intent Receivers ，services 和Activities 如何 共同在先进的 、 主要是后台 的 应用程序中运行的。我现在要改变一下方式，一步一步做，你做了什么以及如何实现它。

让我做的更好

你做了以下内容：

1。你使用正确的权限和系统接收器的意图级短信的意图安排的对象是PrankSMSReciever每次实例化一个手机上的SMS到达。如果你的Intent Receiver发现一个非常特定的SMS的有效载荷，它将通过发送Intent将启动你的活动。

2。这项活动名为PrankActivity，会监听被PrankSMSReceiver的特定intent action。当它收到确切intent action，你的活动将显示一个“gotcha”消息给受害者。同时，该活动将发出意图旨在启动服务。如果在任何时候受害人/用户按下一个电话上的键，应用程序将退出，音乐服务将终止。

3。服务类，称为PrankService，监听PrankActivity的intent，将启动并开始播放令人讨厌，预定义的音频文件。它将继续播放，直到它被要求停止通过PrankActivity的调用方法stopService。

注意：此示例应用程序不涉及手机的本地短信应用。因为所有的intent receiver传入的通知意图，你的应用将被争夺用户与Android的关注短信收件箱的应用。在生产中，这可能需要相当计时器也许触发文本有效载荷，这是一个微妙多一点 “0xBADCAT0_Fire_The_Missiles ！”

在Android中移动数据

最后，你需要把重点放在内容解析器。 Android不会给SDK特别的手机文件系统的访问权限，如Brew一样。它也没有提供一个RecordStore，像Java ME一样。在你的Activities、Intent  Receiver和services之间，你传递数据的主要方法是必须通过ContentResolver超类。虽然你可以存储数据通过文件，参数，和其他数据库，可以采取许多形式，Android附带的几个重要内置content resovlers。这里有一个列表，Android的主要content resovlers，你可能要经常互动基础上：

浏览器

书签
搜索历史

电话呼叫
通话记录
最近通话

联系

系统设置
硬件设置（蓝牙，网络设置）
软件设置

Android 的文档提供了非常好的示例 ：http://code.google.com/android/ devel /data/contentproviders.html ＃usingacp 。马上我要给你演示怎样添加一个书签到手机浏览器的书签列表。首先，你要搜索当前的书签列表，查看你的链接是否存在。第二，你要添加书签，如果不存在。

注意：可以创建你自己的content provider，作为一种方式，为了公共访问封装Android的SQLite的执行。你将进入如何在后面的章节中这一点。现在你只是去处理content resolver交给的“client”方面。

Android采用了自定义的SQLite实现，来存储本地信息。如果你不熟悉SQL的基础知识，现在也许是一个学习的机会。为表述方便，我要假设你了解基本的SQL查询命令。如果你需要进一步提高，Apress上有一个很好的资源http://apress.com/book/ catalog?category=145 。

无耻的自我推销

让我们说一下你的应用程序中“about”部分，你想有一个按钮，添加你的商业软件网页到用户的web书签。你要确保它不添加两次，如果你的用户有再次点击该按钮意外。为了使这个实例简单，你将触发这个事件在你示例应用程序中，当用户按下一个键。

注意：在一个有趣的注意，如果你需要证明，作为一个开发人员，Android是还没有完全成熟的，你只要看看比对下文件的android.content.ContentResolver方法getDataFilePath，其中规定： “ 请不要使用此功能！有人说这一点，他们不应该。你没有直接的访问文件内的内容提供商。不要碰这个。走开。 “ 这是好，知道即使是对Android的文档技术作家有幽默感。

获取用户的书签

这应该是显而易见的，至少在这一点，开发人员可以做一些非常邪恶的事情，访问用户的书签。目前还不清楚，在这一点，Android会做什么以防止发生这类事情。我想这得由运营商来锁定或监视此行为。在任何情况下，你将使用一个调用方法managedQuery，它将返回一个列表用户的书签：

Cursor bookmarks =

android.provider.Browser.getAllBookmarks

(getContentResolver());

int urlColumn = bookmarks.getColumnIndex(

android.provider.Browser.BookmarkColumns.URL );

Cursor results;

String[] proj = new String[]

{

android.provider.BaseColumns._ID,

android.provider.Browser.BookmarkColumns.URL,

android.provider.Browser.BookmarkColumns.TITLE

};

results =

managedQuery(android.provider.Browser.BOOKMARKS_URI,

proj, null ,

android.provider.Browser.BookmarkColumns.URL

+ " ASC");

现在我将分解每一个操作。你首先要书签网址列索引。再次，因为Android通过SQL格式提供其多数内部数据的访问，你应该习惯于用数据库的方式引你保存的信息。接下来，你将设置游标，一个类似Java ME中RecordStore枚举对象，设置字符串数值的映射。因为你只关心列包含的网址，它保存非常简单。方法调用managedQuery是调用将返回你的数据。你可以通过URI中为书签存储字符串，交给你了简单的映射数值，不需要where语句，并告诉它按降序排列的网址。

搜索结果

搜索结果很简单只要迭代游标对象，是通过简单的光标迭代对象和退出一列从URL字符串ID你检索前 ：

Cursor results =

android.provider.Browser.getAllBookmarks

(getContentResolver());

int urlColumn =

results.getColumnIndex

(android.provider.Browser.BookmarkColumns.URL);

results.first();

do

{

//url is a method param

//containing what we're looking for

if(results.getString(urlColumn).equals(url))

return false;

} while (results.next());

你可以做更多的基于 URL 的内容 ， 但现在你会只是看你的 www.apress.com 链接。很明显，如果此代码的运行是上述Apress网址，你不会找到它。因为用户希望添加贵公司的网址在虚拟的“About” ” 部分中，你也要给他们。

使用Content Resolver添加邪恶公司网址

也许他们不是邪恶，但你加入他们。由于Apress也许是公司最邪恶那里（不是我有偏见，记住），你让他们摆脱它，只此一次。下面是一个美丽的ContentReceiver方式添加书签记录：

ContentValues inputValues = new ContentValues();

inputValues.put

(android.provider.Browser.BookmarkColumns.BOOKMARK,

"1");

inputValues.put

(android.provider.Browser.BookmarkColumns.URL,

"http://www.apress.com/");

inputValues.put

(android.provider.Browser.BookmarkColumns.TITLE,

"Apress, the not so evil company");

ContentResolver cr = getContentResolver();

Uri uri =

cr.insert

(android.provider.Browser.BOOKMARKS_URI,

inputValues);

想大多数软件开发工具包，有不止一种方法来完成相同的任务。早些时候，你有更复杂的方法加书签。这个方法是有用的，因为它给你一个参考如何添加元素通过ContentResolver不具有辅助功能。现在，这里的简单的方法：android.provider.Browser.saveBookmark（this，“Apress”，url）；帮助函数会启动一个对话框，要求用户确认增加书签。这可能是最用户友好的方式来添加书签，除非你想控制对话框的模样。

平衡早餐的组成

在过去的三个例子你探讨了Android的所有主要构建模块。一开始你看到了实用的启动画面。这让你探索了基本知识关于启动、维护和移动通过Activity对象。这是你学习intents and interprocess/object communication迈出的第一步。使用和传递意图在活动，服务，内容处理，接收器和意图之间可能是一个最重要的事情，这是Android与其他移动环境的区别。

对于Activity和通信基础知识，你已经有了经验，你继续学习服务和意图接收器。要使用这两个组成部分，你烹调了 狡猾的 恶作剧应用程序，既能强迫你使用所有3个组建（活动，服务，和意图的接收器），使所有三个互相沟通。几乎是旁注，你研究什么需要得到通知时，短信在手机上到达。最后，你探讨如何检索和写入的内容是解析器本机设备：浏览器的书签数据库。事情的证明并非总是按计划进行，Android拒绝加入你在一个新的尝试通过传统的书签内容解析方法，该方法forcedthat我已经介绍的基本知识，现在是时候让手机用户在权衡多一点。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/lihaifeng555/archive/2009/09/27/4599691.aspx

import android.app.Activity;
import android.view.Window;
import android.view.WindowManager;

public class ActivityUtil {
 public static void noTitleBar(Activity activity){
  activity.requestWindowFeature(Window.FEATURE_NO_TITLE);
 }
 
 public static void noNotificationBar(Activity activity){
  final Window win = activity.getWindow();
  win.setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
 }
 public static void fullScreen(Activity activity){
  noTitleBar(activity);
  noNotificationBar(activity);
 }
}


奇怪的是2.0以上的版本，
要在.xml中设置
AndroidManifest.xml   中activity 加 android:theme="@android:style/Theme.NoTitleBar"AndroidManifest.xml   中activity 加 android:theme="@android:style/Theme.NoTitleBar"

屏幕大小 320 - 480 480-720

原文地址：http://www.chinaandroid.com/redirect.php?tid=123&goto=lastpost&styleid=13

Android 1.5 天气widget示例
http://code.google.com/p/android-sky/