最近 不知道咋回事下载不了 ，给大家提供一个地 址 速度很快 我这700k左右
2 下载 jdk6
3，下载 eclipse 3.2，3.3版本（开发 android的 ide）
然后安装android的eclipse插件
1. 启动 eclipse, 选择 help > software updates > find and install..
2. 弹出对话框后，选择 search for new features to install 点击 nex
3. 点击 new remote site.
4. 在编辑框中输入更新插件的网址:
. 点击 ok
5. 看到一个更新的列表，点击 sfinish.
6. 在返回的对话框中选择 android plugin > eclipse integration >
android development tools 并且点击 next.
7. 选择 accept terms of the license agreement, 点击 next.
8. 点击 finish.
9. 点击 install all.
10. 重新启动 eclipse.
这样就安装完毕了
4 设置android的sdk目录
5 建立新项目
输入信息：
运行这时候会提示：
也就是说需要我们建立android的虚拟设备区支持我们的sdk 1.6
选择yes，输入信息 其中选择1.6的那项
选择createavd
也可以通过命令来建立：
这时候就需要在环境变量的path里面第一步解压sdk的根目录下的tools目录，或者直接转向tools目录再运行
命令android create avd --target 2 --name avdname
然后就可以运行我们的程序了
显示结果：
屏幕上的相关信息可见于项目根目录下的res目录，例如：values/strings.xml
内容：
hello world, helloworld! my-first-android-application
相关问题：
failed to find an avd compatible with target 'android 1.6' ，no compatible avds with target
，还有无法找到avd的path问题
根据我的遭遇：由于我以前用的盗版xp新建立的avd并不在当前用户目录下也：我的文档目录是d：\我的文档 而不在 c:\documents and settings/administrator 。因此需要将.android目录拷贝到c:\documents and settings\administrator 下 重要的一步是要主意看里面的ini文件里面的路径是否对应，否则会出现路径问题：
.android/avd里面以avd名命名的.ini文件：例如我的是：
target=android-4path=c:\users\qiaobing\.android\avd\dvd6.avd（vista环境）xp要注意看是否在当前用户下
基本上就可以了.
如何让我们的程序支持多语言：
自己感觉有两种方案 ：
1，建立自己的资源文件包，然后重写onconfigurationchanged(newconfig)方法来处理我们的ui，这样可以处理非文字资源的切换。
2，在android规定的目录下建立.xml文件，由系统来处理
我们采用2来试验：
首先建立android项目，
然后右键点击res目录建立android xml file ：
选择region输入cn 选择language 输入：zh ，输入文件夹名等必要信息就ok
这样我们将选来valus问家里面得strings文件的内容的值修改成中文可以了，然后启动后根据前面介绍的修改来改变界面的语言状态的方法就可以实现语言的切换。
他的log信息是非默认的android控制台窗口，需要另外打开view，可以在show view/other/android选择logcat即可。
说明：
d：表示debug,就是代码中的log.d("tips","degug");
v：表示view,就是代码中的log.v("tips","verbose");
i：表示debug,就是代码中的log.i("tips","info");
e：表示debug,就是代码中的log.e("tips","error");
……………………
不同的方法在logcat里面显示的颜色不同，你可以根据你的需要来决定用哪个方法，然后通过上面的v，d，i，w，e来过滤掉你不需要的东西
代码下载
activitya.java
public class activitya extends activity {
/** called when the activity is first created. */
@override public void oncreate(bundle savedinstancestate) { super.oncreate(savedinstancestate); setcontentview(r.layout.a); final button tob = (button)findviewbyid(r.id.tob); tob.setonclicklistener(new onclicklistener(){ public void onclick(view v) { intent intent = new intent(); intent.setclass(activitya.this,activityb.class); startactivity(intent); finish(); 
}}); }
}public class activityb extends activity { /** called when the activity is first created. */ @override public void oncreate(bundle savedinstancestate) { super.oncreate(savedinstancestate); setcontentview(r.layout.b); final button toa = (button)findviewbyid(r.id.toa); toa.setonclicklistener(new onclicklistener(){ public void onclick(view v) { intent intent = new intent(); intent.setclass(activityb.this,activitya.class); startactivity(intent); finish(); }}); }}当然需要在xml问价备注这两个activity
package com.tishi;import java.util.calendar;import java.util.date;import java.util.locale;import android.app.activity;import android.app.alertdialog;import android.app.datepickerdialog;import android.app.datepickerdialog.ondatesetlistener;import android.content.dialoginterface;import android.os.bundle;import android.view.view;import android.view.view.onclicklistener;import android.widget.button;import android.widget.datepicker;import android.widget.textview;import android.widget.toast;public class tishi extends activity implements onclicklistener, ondatesetlistener { /** called when the activity is first created. */ @override public void oncreate(bundle savedinstancestate) { super.oncreate(savedinstancestate); setcontentview(r.layout.main); final button click1 = (button) findviewbyid(r.id.click1); final button click2 = (button) findviewbyid(r.id.click2); final button click3 = (button) findviewbyid(r.id.click3); click1.setonclicklistener(this); click2.setonclicklistener(this); click3.setonclicklistener(this); } public void onclick(view v) { switch (v.getid()) { case r.id.click1: showtoast(); break; case r.id.click2: showalertdialog(); break; case r.id.click3: showdatepickerdialog(); break; default: break; } } public void showtoast() { toast.maketext(tishi.this, "这是一个提示", toast.length_short).show(); } public void showalertdialog() { new alertdialog.builder(tishi.this).settitle("标题") .setmessage("提示内容
").setpositivebutton("确定", new dialoginterface.onclicklistener() { public void onclick(dialoginterface dialog, int whichbutton) { setresult(result_ok);// 确定按钮事件 finish(); } }) .setnegativebutton("取消", new dialoginterface.onclicklistener() { public void onclick(dialoginterface dialog, int which) { textview txt = (textview) findviewbyid(r.id.text); txt.settext("你选择了取消。"); } }).show(); } public void showdatepickerdialog() { calendar d = calendar.getinstance(locale.china); d.settime(new date()); new datepickerdialog(this, this, d.get(calendar.month), d .get(calendar.day_of_month), d.get(calendar.day_of_year)) .show(); } public void ondateset(datepicker view, int year, int monthofyear, int dayofmonth) { textview txt = (textview) findviewbyid(r.id.text); txt.settext(integer.tostring(year) "-" integer.tostring(monthofyear) "-" integer.tostring(dayofmonth)); }}
由下到上，可以看到红色的 kernel 层，绿色的系统函式库，黄色的虚拟机器，以及蓝色的 java 程序代码。以下将一一介绍。
linux kernel
必也正名乎：一般所称 linux，其实是统称，指根基在 linux kernel 以及其它许多跟 kernel 不见得有关的软件所组成的操作系统。最早，linux 一词其实是专指 kernel，它提供了系统底层与硬件间的基本平台，让其它程序可以在上头执行。其最早作者是 linus torvalds，他用自己的名字，加上采用了与 unix 系统兼容的接口，将自己的作品命名为 linux。
如前所述，在 linux kernel 上头执行的程序，跟 kernel 本身不见得有关系。可以是自由软件，也可以完全不是。把它加上一些自由软件，例如基本的函式库、工具、图形接口，应用程序等等，所组成的一套完整操作系统，才是一般所称的 linux。为了避免误解，而且也为了正确传达自身的贡献，自由软件基金会建议大家称呼这样的一套操作系统为 gnu/linux。其中的原因是，kernel 提供底层机制，但系统中重要的组件几乎都是来自于 gnu，也就是自由软件基金会。
希望大家还没被这些名词搞混。要弄清这些不同的原因是，android 是在 linux kernel 上头运作的，但他并不是 gnu/linux。因为在一般 gnu/linux 里面会有的东西，android 很多都没有。
linux kernel 的凯发k8网页登录的版权是 gnu general public license version 2 (gplv2)，这又是什么玩意呢？gplv2 是所谓的 copyleft 凯发k8网页登录的版权，简单来说，就是为了确保智慧财产能够继续公开流传，所以任何基于此创作的延伸创作，都自动采用了相同凯发k8网页登录的版权。gpl本身还有个特色，就是「共同运作」也算是延伸的一部分，意思是说你的程序没直接改gpl的程序代码，但是连结了gpl的东西跟你的程序共同运作，那你的程序也必须采用gpl凯发k8网页登录的版权。
举例来讲，假定今天某公司觉得某gpl软件不错，拿来改了改，放在自己的产品里头拿出去卖，那某公司就一定要明确的一起散布修改后的程序代码。如果没有，那就是触犯凯发k8网页登录的版权了。有个组织叫 gpl violations，专门抓这种案例，国内公司如 d-link 以及 asus 都上过榜。这下问题来了：如果你是硬件厂商，希望你的硬件能在 linux kernel 下运作，那么就必须要有驱动程序。驱动程序就是按照硬件的规格写的程序，用来告诉 kernel 怎么操作这个硬件。如果驱动程序的程序代码公开，等于硬件规格也公开的差不多了。许多厂商不愿意这么做，所以就提供编好的驱动程序，但不提供原始码。凯发k8网页登录的版权所有者，也就是 linus torvalds 以及其它许许多多的 kernel 作者们，为了支持尽可能多的硬件，对这种行为是采取睁一只眼闭一只眼的态度，也就是目前这种编译好的驱动程序，算是处在灰色地带。
既然 android 采用了 linux kernel，当然得照游戏规矩来。但我们从前文可知，android 的重点就是商业应用，他们可不愿意系统里有什么「灰色地带」，于是采用了一些手法来绕过这问题。他们把驱动程序移到“userspace”，也就是说，把驱动程序变成在 linux kernel 上头跑，而不是一起跑的东西，这样就可以避过gpl。然后，在 kernel 这边开个小门，让本来不能直接控制到硬件的“userspace”程序也可以碰得到，这样只要把「开个小门」的程序代码公布就行啦。事实上，目前因为 android 已经发行，所以依法他们已经公开了对 kernel 的修改，其原始码在 。
走笔至此，可以看出 google 的原则之一“do no evil”是很有意思的。他们自己的确承诺，而且也愿意公开 android 的程序代码，但是他们给了其它人“do evil”的选择。这样还算不算是 do no evil 呢？当作哲学问题吧。
关于 android 对 kernel 的修改，google 的简报还提供了两个重点：
binder (ipc)：提供有效率的程序间沟通管道(inter-process communication)。android 系统中有很多服务，而上层的应用程序经常要取用这些服务，一般的 linux 系统已经提供了不少 ipc 的方式，不过 android 还是搞了套自己的。虽说文件中解释原因为「一般 ipc 会造成额外资源花费，以及安全问题」，但其实这些都是可以基于原有架构在 kernel 外头解决的，为何要改在 kernel 里头，笔者对此存疑，也只能等找时间去研究程序代码才知了。
power management：与桌上型计算机或笔记型计算机不同，手持装置的电源一向相当有限，必须无所不用其极的去想办法省电，但又不损及顺畅的使用经验。android 在此采取了颇为积极的作法：「没有人说要用，就关掉」。例如某程序在放 mp3 音乐，于是此程序会需要 cpu 的计算能力，那就得开口要。如果与此同时没其它程序在执行，那么 lcd 显示器就可能被关掉，藉以省电。另一特别处，是在于 linux kernel 一般考虑的都是在计算机上的作法，所以多半只有进入暂停、休眠等等的选择，而不会如此细致的去控制到各个小装置的电源供应。
系统函式库
这里说的系统函式库是指“native libraries”，是跑在系统里头的函式库，采用的语言不是 java，提供一些基础建设。里头有几个值得一提的组件：
bionic：这是 android 版的 libc。libc 是 gnu/linux 以及其它类似 unix 系统上最基础的函式库，一般最常用的是 glibc，就是 gnu 做的 libc。不然在比较小型的装置上也可以用 uclibc。不论是 glibc or uclibc，凯发k8网页登录的版权都是lgpl (gpl 的略为弱化版)。看到这大概可以猜到了吧，又是 copyleft 问题。官方的说法是，除了凯发k8网页登录的版权问题以外，还考虑必须轻量以及快速，所以才做了自己的 libc。不过轻量、快速，本来就是小型装置用的 uclibc 一开始的目标，因此，最主要的恐怕还是凯发k8网页登录的版权问题。
webkit：鼎鼎大名的 apple safari 浏览器背后的引擎就是 webkit，android 也包含进去了。离线使用的 html 配上 html 5 的一些新发展，产生了各种有趣的可能，这部分值得另文介绍，这里就不再赘述。
surface flinger：提供把各种”surface”组合在一起的能力。在这里 surface 解释为程序想要显示在屏幕的东西，可能同一屏幕上有来自不同程序的内容，而这些内容有可能是 2d 显示或是 3d 显示等等之类。surface flinger 就是把这些东西结合起来，一起送到屏幕上。目前程序代码还没公布，不过 2d 跟 3d 的混合显示一直都是问题，根本原因是我们通常告诉 3d 显示卡的东西都是一些「我要在哪里哪里画上什么形状，贴上某某材质然后旋转多少度」之类的事情，也就是说，我们并不知道最后显示出来会长什么样子，那是显示卡上头的 gpu 去算出来的。一般这些东西是显示在一个有装饰的窗口里头，这装饰通常是 2d 效果。接下来假定我们想要旋转这整个窗口，而且里头的东西还要继续动，那等于要随时把握 3d 窗口里的东西长什么样子，然后把它跟 2d 的窗口框框结合，然后再开始转动。目前在一般 gnu/linux 上这件事情还没有处理的非常好，android 怎么做，值得在程序代码公布之后注意。
硬件抽象层 (hardware abstraction libraries)：这就是前文所述的 userspace 驱动程序，如果想要将 android 在某硬件平台上执行，基本上完成这些驱动程序就行了。其内定义了 android 对各硬件装置例如显示芯片、声音、数字相机、gps、gsm 等等的需求。
android runtime 前文已有涉及，这里不再重复。另外蓝色部分的“application framework”主要是跟如何在 android 上写程序有关系，之后将另文介绍
转载自：http://hi.baidu.com/weiyousheng/blog/item/43ef7f2e5a457e574fc226a0.html
例如，在一个联系人维护的应用中，当我们在一个联系人列表屏幕（假设对应的activity为listactivity）上，点击某个联系人后，希望能够 跳出此联系人的详细信息屏幕（假设对应的activity为detailactivity），为了实现这个目的，listactivity需要构造一个 intent，这个intent用于告诉系统，我们要做“查看”动作，此动作对应的查看对象是“某联系人”，然后调用startactivity (intent intent)，将构造的intent传入，系统会根据此intent中的描述，到manifest中找到满足此intent要求的activity，系 统会调用找到的activity，即为detailactivity，最终传入intent，detailactivity则会根据此intent中的描 述，执行相应的操作。
一、抽象描述要描述什么
在android参考文档中，对intent的定义是执行某操作的一个抽象描述（确实很抽象）。我们先来看看这里的抽象描述，到底描述了什么。
首先，是要执行的动作（action）的一个简要描述，如view_action（查看）、edit_action（修改）等，android为我们定义了一套标准动作：
- main_action
- view_action
- edit_action
- pick_action
- get_content_action
- dial_action
- call_action
- sendto_action
- answer_action
- insert_action
- delete_action
- run_action
- login_action
- clear_credentials_action
- sync_action
- pick_activity_action
- web_search_action
其次，是执行动作要操作的数据（data），android中 采用指向数据的一个uri来表示，如在联系人应用中，一个指向某联系人的uri可能为：content://contacts/1。这种uri表示，通过 contenturi这个类来描述，具体可以参考android.net.contenturi类的文档。
以联系人应用为例，以下是一些action / data对，及其它们要表达的意图：
- view_action content://contacts/1 -- 显示标识符为"1"的联系人的详细信息
- edit_action content://contacts/1 -- 编辑标识符为"1"的联系人的详细信息
- view_action content://contacts/ -- 显示所有联系人的列表
- pick_action content://contacts/ -- 显示所有联系人的列表，并且允许用户在列表中选择一个联系人，然后把这个联系人返回给父activity。例如：电子邮件客户端可以使用这个intent，要求用户在联系人列表中选择一个联系人
另外，除了action和data这两个重要属性外，还有一些附加属性：
- category（类别），被执行动作的附加信息。例如 launcher_category 表示intent 的接受者应该在launcher中作为顶级应用出现；而alternative_category表示当前的intent是一系列的可选动作中的一个，这 些动作可以在同一块数据上执行。
- type（数据类型），显式指定intent的数据类型（mime）。一般intent的数据类型能够根据数据本身进行判定，但是通过设置这个属性，可以强制采用显式指定的类型而不再进行推导。
- component（组件），指定intent的的目标组件的类名称。通常android会 根据intent 中包含的其它属性的信息，比如action、data/type、category进行查找，最终找到一个与之匹配的目标组件。但是，如果 component这个属性有指定的话，将直接使用它指定的组件，而不再执行上述查找过程。指定了这个属性以后，intent的其它所有属性都是可选的。
- extras（附加信息），是其它所有附加信息的集合。使用extras可以为组件提供扩展信息，比如，如果要执行“发送电子邮件”这个动作，可以将电子邮件的标题、正文等保存在extras里，传给电子邮件发送组件。
总之，action、 data/type、category和extras 一起形成了一种语言。这种语言使系统能够理解诸如“查看某联系人的详细信息”之类的短语。随着应用不断的加入到系统中，它们可以添加新的action、 data/type、category来扩展这种语言。应用也可以提供自己的activity来处理已经存在的这样的“短语”，从而改变这些“短语”的行 为。
二、android如何解析intent
在应用中，我们可以以两种形式来使用intent：
- 直接intent：指定了component属性的intent（调用setcomponent(componentname)或者setclass(context, class)来指定）。通过指定具体的组件类，通知应用启动对应的组件。
- 间接intent：没有指定comonent属性的intent。这些intent需要包含足够的信息，这样系统才能根据这些信息，在在所有的可用组件中，确定满足此intent的组件。
intent解析机制主要是通过查找已注册在androidmanifest.xml中的所有intentfilter及其中定义的intent，最终找 到匹配的intent。在这个解析过程中，android是通过intent的action、type、category这三个属性来进行判断的，判断方 法如下：
- 如果intent指明定了action，则目标组件的intentfilter的action列表中就必须包含有这个action，否则不能匹配；
- 如果intent没有提供type，系统将从data中得到数据类型。和action一样，目标组件的数据类型列表中必须包含intent的数据类型，否则不能匹配。
- 如果intent中的数据不是content: 类型的uri，而且intent也没有明确指定它的type，将根据intent中数据的scheme （比如 http: 或者 : ） 进行匹配。同上，intent 的scheme必须出现在目标组件的scheme列表中。
- 如果intent指定了一个或多个category，这些类别必须全部出现在组建的类别列表中。比如intent中包含了两个类别：launcher_category 和 alternative_category，解析得到的目标组件必须至少包含这两个类别。
转载自：http://hi.baidu.com/weiyousheng/blog/item/1e5da62417021d3b8744f9cd.html
一 什么是service
二 如何使用service
三 service的生命周期
一 什么是service
service，看名字就知道跟正常理解的“服务”差不多，后台运行，可交互这样的一个东西。它跟activity的级别差不多，但是他不能自己运行，需要通过某一个activity或者其他context对象来调用， context.startservice() 和 context.bindservice()。
两种启动service的方式有所不同。这里要说明一下的是如果你在service的oncreate或者onstart做一些很耗时间的事情，最好在 service里启动一个线程来完成，因为service是跑在主线程中，会影响到你的ui操作或者阻塞主线程中的其他事情。
什么时候需要service呢？比如播放多媒体的时候用户启动了其他activity这个时候程序要在后台继续播放，比如检测sd卡上文件的变化，再或者在后台记录你地理信息位置的改变等等，总之服务嘛，总是藏在后头的。
二 如何使用service
那接下来用代码来说明一下怎么使用service，这里我们要讲的是local service也就是你自己的一个service, 你也可以操作别的应用程序的service如果它允许你那么去做的话，这就设计到一个比较麻烦的东西interprocess communication (ipc)，在不同的进程中通信的机制，这个我自己也还没有用过，等用了以后再跟大伙说说，通常情况下local的就够用啦。
跟activity一样首先你要写一个类继承自android.app.service,在这里我叫他testservice
代码如下：
import android.app.notification;
import android.app.notificationmanager;
import android.app.pendingintent;
import android.app.service;
import android.content.intent;
import android.os.binder;
import android.os.ibinder;
import android.util.log;
public class testservice extends service {
private static final string tag = "testservice";
private notificationmanager _nm;
@override
public ibinder onbind(intent i) {
log.e(tag, "============> testservice.onbind");
return null;
}
public class localbinder extends binder {
testservice getservice() {
return testservice.this;
}
}
@override
public boolean onunbind(intent i) {
log.e(tag, "============> testservice.onunbind");
return false;
}
@override
public void onrebind(intent i) {
log.e(tag, "============> testservice.onrebind");
}
@override
public void oncreate() {
log.e(tag, "============> testservice.oncreate");
_nm = (notificationmanager) getsystemservice(notification_service);
shownotification();
}
@override
public void onstart(intent intent, int startid) {
log.e(tag, "============> testservice.onstart");
}
@override
public void ondestroy() {
_nm.cancel(r.string.service_started);
log.e(tag, "============> testservice.ondestroy");
}
private void shownotification() {
notification notification = new notification(r.drawable.face_1,
"service started", system.currenttimemillis());
pendingintent contentintent = pendingintent.getactivity(this, 0,
new intent(this, testserviceholder.class), 0);
// must set this for content view, or will throw a exception
notification.setlatesteventinfo(this, "test service",
"service started", contentintent);
_nm.notify(r.string.service_started, notification);
}
}
其中用到notification是为了明显地表明service存活的状态，跟demo的code学过来的，这样看上去直观一点，更多关于notification的内容以后ui部分来写吧，现在就知道怎么使用就好了。
@overridepublic void oncreate() {
log.e(tag, "============> testservice.oncreate");
_nm = (notificationmanager) getsystemservice(notification_service);
shownotification();
}
像这样，我在service的几个生命周期函数中加了打印log的语句，方便测试。
public class localbinder extends binder {
testservice getservice() {
return testservice.this;
}
}
这个方法是为了让调用者得到这个service并操作它。
service本身就这样简单了，你需要做什么就在oncreate和onstart里做好了，起个线程什么的。
再看一下它的调用者，testserviceholder
import android.app.activity;
import android.content.componentname;
import android.content.context;
import android.content.intent;
import android.content.serviceconnection;
import android.os.bundle;
import android.os.ibinder;
import android.view.view;
import android.view.view.onclicklistener;
import android.widget.button;
import android.widget.toast;
public class testserviceholder extends activity {
private boolean _isbound;
private testservice _boundservice;
public void oncreate(bundle savedinstancestate) {
super.oncreate(savedinstancestate);
setcontentview(r.layout.test_service_holder);
settitle("service test");
initbuttons();
}
private serviceconnection _connection = new serviceconnection() {
public void onserviceconnected(componentname classname, ibinder service) {
_boundservice = ((testservice.localbinder)service).getservice();
toast.maketext(testserviceholder.this, "service connected",
toast.length_short).show();
}
public void onservicedisconnected(componentname classname) {
// unexpectedly disconnected,we should never see this happen.
_boundservice = null;
toast.maketext(testserviceholder.this, "service connected",
toast.length_short).show();
}
};
private void initbuttons() {
button buttonstart = (button) findviewbyid(r.id.start_service);
buttonstart.setonclicklistener(new onclicklistener() {
public void onclick(view arg0) {
startservice();
}
});
button buttonstop = (button) findviewbyid(r.id.stop_service);
buttonstop.setonclicklistener(new onclicklistener() {
public void onclick(view arg0) {
stopservice();
}
});
button buttonbind = (button) findviewbyid(r.id.bind_service);
buttonbind.setonclicklistener(new onclicklistener() {
public void onclick(view arg0) {
bindservice();
}
});
button buttonunbind = (button) findviewbyid(r.id.unbind_service);
buttonunbind.setonclicklistener(new onclicklistener() {
public void onclick(view arg0) {
unbindservice();
}
});
}
private void startservice() {
intent i = new intent(this, testservice.class);
this.startservice(i);
}
private void stopservice() {
intent i = new intent(this, testservice.class);
this.stopservice(i);
}
private void bindservice() {
intent i = new intent(this, testservice.class);
bindservice(i, _connection, context.bind_auto_create);
_isbound = true;
}
private void unbindservice() {
if (_isbound) {
unbindservice(_connection);
_isbound = false;
}
}
}
这里可以看到两种启动方法，start和bind，当然也是通过intent调用的，在intent中指明指定要启动的service的名字，stop也一样 ：
private void startservice() {intent i = new intent(this, testservice.class);
this.startservice(i);
}
private void stopservice() {
intent i = new intent(this, testservice.class);
this.stopservice(i);
}
对于bind的话，需要一个serviceconnection对象
private serviceconnection _connection = new serviceconnection() {public void onserviceconnected(componentname classname, ibinder service) {
_boundservice = ((testservice.localbinder)service).getservice();
toast.maketext(testserviceholder.this, "service connected",
toast.length_short).show();
}
public void onservicedisconnected(componentname classname) {
// unexpectedly disconnected,we should never see this happen.
_boundservice = null;
toast.maketext(testserviceholder.this, "service connected",
toast.length_short).show();
}
};
用来把activity和特定的service连接在一起，共同存亡，具体的生命周期细节下一段来讲。
三 service的生命周期
service的生命周期方法比activity少一些，只有oncreate, onstart, ondestroy
我们有两种方式启动一个service,他们对service生命周期的影响是不一样的。
1 通过startservice
service会经历 oncreate -> onstart
stopservice的时候直接ondestroy
如果是调用者(testserviceholder)自己直接退出而没有调用stopservice的
话，service会一直在后台运行。
下次testserviceholder再起来可以stopservice。
2 通过bindservice
service只会运行oncreate， 这个时候 testserviceholder 和testservice绑定在一起
testserviceholder 退出了，srevice就会调用onunbind->ondestroyed
所谓绑定在一起就共存亡了。
那有同学问了，要是这几个方法交织在一起的话，会出现什么情况呢？
一个原则是service的oncreate的方法只会被调用一次，就是你无论多少次的startservice又 bindservice，service只被创建一次。如果先是bind了，那么start的时候就直接运行service的onstart方法，如果先 是start，那么bind的时候就直接运行onbind方法。如果你先bind上了，就stop不掉了，对啊，就是stopservice不好使了，只 能先unbindservice, 再stopservice,所以是先start还是先bind行为是有区别的。
看起来情况很多，不过我会把这次的代码包括上回activity生命周期的研究代码都贴上了，希望你喜欢！大家有兴趣可以回去点点按钮看看log，多看几遍就知道了。
转载自：http://hi.baidu.com/weiyousheng/blog/item/b82f228bb1cdaf1ac9fc7a40.html
对于一个android应用程序来说，是由四种构造块组织而成的，这四种构造块如下：
- activity
- intent receiver
- service
- content provider
但是，并不是每一个android应用程序都需要这四种构造块，这不是必须的，某些时候，我们只需要这四种中的几种组合成我们的应用。
当我们明确了我们的应用需要哪些构造块后，我们就需要在androidmanifest.xml中登记这些构造块的清单。这是一个xml配置文件，这个配置文件用于定义我们的应用程序的组件、组件的功能及必要条件等。这个配置文件是每个android应用必需的。对于androidmainfest.xml的schema，参考sdk包附带的文档。以下，我们对四种构造块做一些说明：
1、activity
activity是android构造块中最基本的一种，在应用中，一个activity通常就是一个单独的屏幕。每一个activity都被实现为一个独立的类，并且继承于activity这个基类。这个activity类将会显示由几个views控件组成的用户接口，并对事件做出响应。大部份的应用都会包含多个的屏幕。例如，一个短消息应用程序将会有一个屏幕用于显示联系人列表，第二个屏幕用于写短消息，同时还会有用于浏览旧短消息及进行系统设置的屏幕。每一个这样的屏幕，就是一个activity。从一个屏幕导航到另一个屏幕是很简单的。在一些应用中，一个屏幕甚至会返回值给前一个屏幕。
当一个新的屏幕打开后，前一个屏幕将会暂停，并保存在历史堆栈中。用户可以返回到历史堆栈中的前一个屏幕。当屏幕不再使用时，还可以从历史堆栈中删除。默认情况下，android将会保留从主屏幕到每一个应用的运行屏幕。
android使用了intent这个特殊类，实现在屏幕与屏幕之间移动。intent类用于描述一个应用将会做什么事。在intent的描述结构中，有两个最重要的部分：动作和动作对应的数据。典型的动作类型有：main（activity的门户）、view、pick、edit等。而动作对应的数据则以uri的形式进行表示。例如：要查看一个人的凯发天生赢家一触即发官网的联系方式，你需要创建一个动作类型为view的intent，以及一个表示这个人的uri。
与之有关系的一个类叫intentfilter。相对于intent是一个有效的做某事的请求，一个intent filter则用于描述一个activity（或者intent receiver）能够操作哪些intent。一个activity如果要显示一个人的凯发天生赢家一触即发官网的联系方式时，需要声明一个intentfilter，这个intentfilter要知道怎么去处理view动作和表示一个人的uri。intentfilter需要在androidmanifest.xml中定义。
通过解析各种intent，从一个屏幕导航到另一个屏幕是很简单的。当向前导航时，activity将会调用startactivity(intent myintent)方法。然后，系统会在所有安装的应用程序中定义的intentfilter中查找，找到最匹配myintent的intent对应的activity。新的activity接收到myintent的通知后，开始运行。当startactivity方法被调用将触发解析myintent的动作，这个机制提供了两个关键好处：
a、activities能够重复利用从其它组件中以intent的形式产生的一个请求；
b、activities可以在任何时候被一个具有相同intentfilter的新的activity取代。
2、intent receiver
当你希望你的应用能够对一个外部的事件（如当电话呼入时，或者数据网络可用时，或者到了晚上时）做出响应，你可以使用一个intent receiver。虽然intent receiver在感兴趣的事件发生时，会使用notificationmanager通知用户，但它并不能生成一个ui。intent receiver在androidmanifest.xml中注册，但也可以在代码中使用context.registerreceiver()进行注册。当一个intent receiver被触发时，你的应用不必对请求调用intent receiver，系统会在需要的时候启动你的应用。各种应用还可以通过使用context.broadcastintent()将它们自己的intent receiver广播给其它应用程序。
3、service
一个service是一段长生命周期的，没有用户界面的程序。比较好的一个例子就是一个正在从播放列表中播放歌曲的媒体播放器。在一个媒体播放器的应用中，应该会有多个activity，让使用者可以选择歌曲并播放歌曲。然而，音乐重放这个功能并没有对应的activity，因为使用者当然会认为在导航到其它屏幕时音乐应该还在播放的。在这个例子中，媒体播放器这个activity会使用context.startservice()来启动一个service，从而可以在后台保持音乐的播放。同时，系统也将保持这个service一直执行，直到这个service运行结束。另外，我们还可以通过使用context.bindservice()方法，连接到一个service上（如果这个service还没有运行将启动它）。当连接到一个service之后，我们还可以service提供的接口与它进行通讯。拿媒体播放器这个例子来说，我们还可以进行暂停、重播等操作。
4、content provider
应用程序能够将它们的数据保存到文件中、sql数据库中，甚至是任何有效的设备中。当你想将你的应用数据与其它的应用共享时，content provider将会很有用。一个content provider类实现了一组标准的方法，从而能够让其它的应用保存或读取此content provider处理的各种数据类型。
更详细的content provider资料，可以参考附带文档中的accessing content providers。
android一个重要并且特殊的特性就是，一个应用的进程的生命周期不是由应用自身直接控制的，而是由系统，根据运行中的应用的一些特征来决定的，包括：这些应用对用户的重要性、系统的全部可用内存。
对于应用开发者来说，理解不同的应用组件（特别是activity、service、intent receiver）对应用进程的生命周期的影响，这是非常重要的。如果没有正确地使用这些组件，将会导致当应用正在处理重要的工作时，进程却被系统消毁的后果。
对于进程生命周期，一个普遍的错误就是：当一个intent receiver在它的onreceiveintent()方法中，接收到一个intent后，就会从这个方法中返回。而一旦从这个方法返回后，系统将会认为这个intent receiver不再处于活动状态了，也就会认为它的宿主进程不需要了（除非宿主进程中还存在其它的应用组件）。从而，系统随时都会消毁这个进程，收回内存，并中止其中还在运行的子线程。问题的解决办法就是，在intentreceiver中，启动一个service，这样系统就会知道在这个进程中，还有活动的工作正在执行。
为了决定在内存不足情况下消毁哪个进程，android会根据这些进程内运行的组件及这些组件的状态，把这些进程划分出一个“重要性层次”。这个层次按顺序如下：
1、前端进程是拥有一个显示在屏幕最前端并与使用者做交互的activity（它的onresume已被调用）的进程，也可能是一个拥有正在运行的intentreceiver（它的onreceiveintent()方法正在运行）的进程。在系统中，这种进程是很少的，只有当内存低到不足于支持这些进程的继续运行，才会将这些进程消毁。通常这时候，设备已经达到了需要进行内存整理的状态，为了保障用户界面不停止响应，只能消毁这些进程；
2、可视进程是拥有一个用户在屏幕上可见的，但并没有在前端显示的activity（它的onpause已被调用）的进程。例如：一个以对话框显示的前端activity在屏幕上显示，而它后面的上一级activity仍然是可见的。这样的进程是非常重要的，一般不会被消毁，除非为了保障所有的前端进程正常运行，才会被消毁。
3、服务进程是拥有一个由startservice()方法启动的service的进程。尽管这些进程对于使用者是不可见的，但他们做的通常是使用者所关注的事情（如后台mp3播放器或后台上传下载数据的网络服务）。因此，除非为了保障前端进程和可视进程的正常运行，系统才会消毁这种进程。
4、后台进程是拥有一个用户不可见的activity（onstop()方法已经被调用）的进程。这些进程不直接影响用户的体验。如果这些进程正确地完成了自己的生命周期（详细参考activity类），系统会为了以上三种类型进程，而随时消毁这种进程以释放内存。通常会有很多这样的进程在运行着，因些这些进程会被保存在一个lru列表中，以保证在内存不足时，用户最后看到的进程将在最后才被消毁。
5、空进程是那些不拥有任何活动的应用组件的进程。保留这些进程的唯一理由是，做为一个缓存，在它所属的应用的组件下一次需要时，缩短启动的时间。同样的，为了在这些缓存的空进程和底层的核心缓存之间平衡系统资源，系统会经常消毁这些空进程。
当要对一个进程进行分类时，系统会选择在这个进程中所有活动的组件中重要等级最高的那个做为依据。可以参考activity、service、intentreceiver文档，了解这些组件如何影响进程整个生命周期的更多细节。这些类的文档都对他们如何影响他们所属的应用的整个生命周期，做了详细的描述。
转载地址：http://hi.baidu.com/weiyousheng/blog/item/c56fa81940f1bd72dbb4bd55.html
android.app.activity
对于一个android应用来说，android.app.activity类实例是一个最基本的功能单元。一个activity实例可以做很多的事情，但是它本身无法显示在屏幕上，而是借助于viewgroup和view，这两个才是android平台上最基本的两个用户界面表达单元。
android.view.viewgroup
viewgroup是一个特殊的view类，它继承于android.view.view。它的功能就是装载和管理下一层的view对象和viewgroup对象。viewgroup是布局管理器（layout）及view容器的基类。
viewgroup中，还定义了一个嵌套类viewgroup.layoutparams。这个类定义了一个显示对象的位置、大小等属性，view通过layoutparams中的这些属性值来告诉父级，它们将如何放置。
在这里，继承于viewgroup的一些主要的布局类如下：
1、framelayout：最简单的一个布局对象。它里面只显示一个显示对象。所有的显示对象都将会固定在屏幕的左上角，不能指定位置。但允许有多个显示对象，但后一个将会直接在前 一个之上进行覆盖显示，把前一个部份或全部挡住（除非后一个是透明的）。
2、linearlayout：以单一方向对其中的显示对象进行排列显示，如以垂直排列显示，则布局管理器中将只有一列；如以水平排列显示，则布局管理器中将只有一行。同时，它还可以对个别的显示对象设置显示比例。
3、tablelayout：以拥有任意行列的表格对显示对象进行布局，每个显示对象被分配到各自的单元格之中，但单元格的边框线不可见。
4、absolutelayout：允许以坐标的方式，指定显示对象的具体位置，左上角的坐标为(0, 0)，向下及向右，坐标值变大。这种布局管理器由于显示对象的位置定死了，所以在不同的设备上，有可能会出现最终的显示效果不一致。
5、relativelayout：允许通过指定显示对象相对于其它显示对象或父级对象的相对位置来布局。如一个按钮可以放于另一个按钮的右边，或者可以放在布局管理器的中央。
在android中，提供了很多的布局管理器，这里也不一一列举，开发者可以根据实际需要，选择合适的布局管理器。
android.view.view
view是所有view类的基类，一个view通常占用屏幕上的一个矩形区域，并负责绘图及事件处理。view是所有窗体部件的基类，是为窗体部件服务的，这里的窗体部件即ui控件，如一个按钮或文本框。android已经为我们提供了一系列的标准ui控件供我们直接使用，同时，我们也可以通过继承于view类或view的子类，来实现我们自定义的ui控件。
要定制我们自己的ui控件，需要重载view类中的一些方法，以下表格列出view提供出来的，供重载的方法，这些方法不必都要重载，但至少要实现ondraw(android.graphics.canvas)方法。
| 类别 | 方法 | 描述 |
|---|---|---|
| creation | constructors | |
|
当view和它的所有子对象从xml中导入之后，调用此方法 | |
| layout | |
view会调用此方法，来确认自己及所有子对象的大小 |
|
当view要为所有子对象分配大小和位置时，调用此方法 | |
|
当view大小改变时，调用此方法 | |
| drawing | |
当view要绘制它的内容时，调用此方法 |
| event processing | |
当一个新的按键事件发生时，调用此方法 |
|
当一个按键释放事件发生时，调用此方法 | |
|
当一个动作事件（如触摸）发生时，调用此方法 | |
| focus | |
当view获得或失去焦点时，调用此方法 |
| attaching | |
当view附加到一个窗体上时，调用此方法 |
|
当view离开它的窗体时，调用此方法 |
public class sendresult extends activity屏幕元素层次结构
{
protected void oncreate(bundle savedvalues)
{
...
button button = (button)findviewbyid(r.id.corky);
button.setonclicklistener(mcorkylistener);
}
private onclicklistener mcorkylistener = new onclicklistener()
{
public void onclick(view v)
{
setresult(result_ok, "corky!");
finish();
}
};
对于android应用中的一个屏幕，它的屏幕元素是按层次结构来描述的。要将一个屏幕元素层次树绑定在一个屏幕上显示，activity会调用它的setcontentview()方法并且传入这个层次树的根节点引用。当activity被激活并且获得焦点时，系统会通知activity并且 请求根节点去计算并绘制树，根节点就会请求它的子节点去绘制它们自己。
每个树上的viewgroup节点会负责绘制它的子节点。viewgroup会计算它的有效空间，布局所有的子显示对象，并最终调用所有的子显示对象的draw()方法来绘制显示对象。各个子显示对象可以向父对象请求它们在布局中的大小和位置，但最终决定各个子显示对象的大小和位置的是父对象。
首先找一个png的图片放在res/drawable文件架下，文件名和扩展名全部用小写（注意），我的文件名称：android.png
1.code方式：
imageview imageview = new imageview(this); imageview.setimageresource(r.drawable.android);//r.drawable.android后面的android是你的图片文件名 setcontentview(imageview);
2，xm方式：
修改main.xml
添加：
android:layout_height="wrap_content" //图片原来的size 如果用fill_parent 就会拉伸
android:layout_width="wrap_content"
android:src="@drawable/android" //注意文件名
/>
代码加入：setcontentview(r.layout.main);即可
运行：
