android学习笔记1

adb 常用命令

adb device 

adb kill-server

adb start-server

adb install

adb uninstall

adb pull 

adb push 

adb shell

测试相关概念

根据测试是否知道源代码

黑盒测试：只关心程序的过程和结果。

白盒测试：根据源代码写测试方法 或者 测试用例。

根据测试的粒度：

方法测试：dunction test

单元测试：unit test

集成测试： intergration test

根据测试的次数：

冒烟测试：smoke test

压力测试：pressure test

Logcat简介

日志信息是分等级的：

Verbase -->提醒；

Debug-->调试；

保存文件到手机内存  数据存储和访问

上下文 就是一个类 提供一些些方便的api 可以得到应用程序的环境

环境包括 安装路径  文件的路径  资源的路径 资产的路径

getFileDir        /data/data/包名/files/

getCacheDir   /data/data/包名/cache/

027_分析setting源代码获取SD卡大小

028_sharedPreference入门

很多时候我们开发的软件需要向用户提供软件参数设置功能，例如我们常用的QQ，用户可以设置是否允许陌生人添加自己为好友。对于软件配置参数的保存，如果是window软件通常我们会采用ini文件进行保存，如果是j2se应用，我们会采用properties属性文件或者xml进行保存。如果是Android应用，我们最适合采用什么方式保存软件配置参数呢？Android平台给我们提供了一个SharedPreferences类，它是一个轻量级的存储类，特别适合用于保存软件配置参数。使用SharedPreferences保存数据，其背后是用xml文件存放数据，文件存放在/data/data/<package name>/shared_prefs目录下：

SharedPreferences sharedPreferences = getSharedPreferences("itcast", Context.MODE_PRIVATE);

Editor editor = sharedPreferences.edit();     //获取编辑器

editor.putString("name", "HQ");

editor.putInt("age", 4);

editor.commit();      //提交修改

生成的itcast.xml文件内容如下：

<?xml version='1.0' encoding='utf-8' standalone='yes' ?>

<map>

<string name="name">HQ</string>

<int name="age" value="4" />

</map>

因为SharedPreferences背后是使用xml文件保存数据，getSharedPreferences(name,mode)方法的第一个参数用于指定该文件的名称，名称不用带后缀，后缀会由Android自动加上。方法的第二个参数指定文件的操作模式，共有四种操作模式，这四种模式前面介绍使用文件方式保存数据时已经讲解过。如果希望SharedPreferences背后使用的xml文件能被其他应用读和写，可以指定Context.MODE_WORLD_READABLE和Context.MODE_WORLD_WRITEABLE权限。

另外Activity还提供了另一个getPreferences(mode)方法操作SharedPreferences，这个方法默认使用当前类不带包名的类名作为文件的名称。

访问SharedPreferences中的数据代码如下：

SharedPreferences sharedPreferences = getSharedPreferences("itcast", Context.MODE_PRIVATE);

//getString()第二个参数为缺省值，如果preference中不存在该key，将返回缺省值

String name = sharedPreferences.getString("name", "");

int age = sharedPreferences.getInt("age", 1);

如果访问其他应用中的Preference，前提条件是：该preference创建时指定了Context.MODE_WORLD_READABLE或者Context.MODE_WORLD_WRITEABLE权限。如：有个<package name>为cn.itcast.action的应用使用下面语句创建了preference。

getSharedPreferences("itcast", Context.MODE_WORLD_READABLE);

其他应用要访问上面应用的preference，首先需要创建上面应用的Context，然后通过Context 访问preference，访问preference时会在应用所在包下的shared_prefs目录找到preference ：

Context otherAppsContext = createPackageContext("cn.itcast.action", Context.CONTEXT_IGNORE_SECURITY);

SharedPreferences sharedPreferences = otherAppsContext.getSharedPreferences("itcast", Context.MODE_WORLD_READABLE);

String name = sharedPreferences.getString("name", "");

int age = sharedPreferences.getInt("age", 0);

如果不通过创建Context访问其他应用的preference，也可以以读取xml文件方式直接访问其他应用preference对应的xml文件，如：

File xmlFile = new File(“/data/data/<package name>/shared_prefs/itcast.xml”);      //<package name>应替换成应用的包名

使用嵌入式关系型SQLite数据库存储数据

在Android平台上，集成了一个嵌入式关系型数据库—SQLite，SQLite3支持 NULL、INTEGER、REAL（浮点数字）、TEXT(字符串文本)和BLOB(二进制对象)数据类型，虽然它支持的类型只有五种，但实际上sqlite3也接受varchar(n)、char(n)、decimal(p,s) 等数据类型，只不过在运算或保存时会转成对应的五种数据类型。 SQLite最大的特点是你可以把各种类型的数据保存到任何字段中，而不用关心字段声明的数据类型是什么。例如：可以在Integer类型的字段中存放字符串，或者在布尔型字段中存放浮点数，或者在字符型字段中存放日期型值。 但有一种情况例外：定义为INTEGER PRIMARY KEY的字段只能存储64位整数， 当向这种字段保存除整数以外的数据时，将会产生错误。 另外， SQLite 在解析CREATE TABLE 语句时，会忽略 CREATE TABLE 语句中跟在字段名后面的数据类型信息，如下面语句会忽略 name字段的类型信息：

CREATE TABLE person (personid integer primary key autoincrement, name varchar(20))

SQLite可以解析大部分标准SQL语句，如：

查询语句：select * from 表名where 条件子句group by 分组字句having ... order by 排序子句

如：select * from person

        select * from person order by id desc

        select name from person group by name having count(*)>1

分页SQL与mysql类似，下面SQL语句获取5条记录，跳过前面3条记录

select * from Account limit 5 offset 3 或者 select * from Account limit 3,5

插入语句：insert into 表名(字段列表) values(值列表)。如：insert into person(name, age) values(‘HQ’,3)

更新语句：update 表名set 字段名=值where 条件子句。如：update person set name=‘HQ‘ where id=10

删除语句：delete from 表名where 条件子句。如：delete from person  where id=10

使用SQLiteOpenHelper对数据库进行版本管理

我们在编写数据库应用软件时，需要考虑这样的问题：因为我们开发的软件可能会安装在很多用户的手机上，如果应用使用到了SQLite数据库，我们必须在用户初次使用软件时创建出应用使用到的数据库表结构及添加一些初始化记录，另外在软件升级的时候，也需要对数据表结构进行更新。那么，我们如何才能实现在用户初次使用或升级软件时自动在用户的手机上创建出应用需要的数据库表呢？总不能让我们在每个需要安装此软件的手机上通过手工方式创建数据库表吧？因为这种需求是每个数据库应用都要面临的，所以在Android系统，为我们提供了一个名为SQLiteOpenHelper的抽象类，必须继承它才能使用，它是通过对数据库版本进行管理来实现前面提出的需求。

为了实现对数据库版本进行管理，SQLiteOpenHelper类提供了两个重要的方法，分别是onCreate(SQLiteDatabase db)和onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion)，前者用于初次使用软件时生成数据库表，后者用于升级软件时更新数据库表结构。当调用SQLiteOpenHelper的getWritableDatabase()或者getReadableDatabase()方法获取用于操作数据库的SQLiteDatabase实例的时候，如果数据库不存在，Android系统会自动生成一个数据库，接着调用onCreate()方法，onCreate()方法在初次生成数据库时才会被调用，在onCreate()方法里可以生成数据库表结构及添加一些应用使用到的初始化数据。onUpgrade()方法在数据库的版本发生变化时会被调用，一般在软件升级时才需改变版本号，而数据库的版本是由程序员控制的，假设数据库现在的版本是1，由于业务的变更，修改了数据库表结构，这时候就需要升级软件，升级软件时希望更新用户手机里的数据库表结构，为了实现这一目的，可以把原来的数据库版本设置为2(有同学问设置为3行不行？当然可以，如果你愿意，设置为100也行)，并且在onUpgrade()方法里面实现表结构的更新。当软件的版本升级次数比较多，这时在onUpgrade()方法里面可以根据原版号和目标版本号进行判断，然后作出相应的表结构及数据更新。

getWritableDatabase()和getReadableDatabase()方法都可以获取一个用于操作数据库的SQLiteDatabase实例。但getWritableDatabase() 方法以读写方式打开数据库，一旦数据库的磁盘空间满了，数据库就只能读而不能写，倘若使用getWritableDatabase()打开数据库就会出错。getReadableDatabase()方法先以读写方式打开数据库，如果数据库的磁盘空间满了，就会打开失败，当打开失败后会继续尝试以只读方式打开数据库。

public class DatabaseHelper extends SQLiteOpenHelper {

    //类没有实例化,是不能用作父类构造器的参数,必须声明为静态

         private static final String name = "itcast";//数据库名称

         private static final int version = 1; //数据库版本

         public DatabaseHelper(Context context) {

//第三个参数CursorFactory指定在执行查询时获得一个游标实例的工厂类,设置为null,代表使用系统默认的工厂类

                super(context, name, null, version);

         }

        @Override public void onCreate(SQLiteDatabase db) {

              db.execSQL("CREATE TABLE IF NOT EXISTS person (personid integer primary key autoincrement, name varchar(20), age INTEGER)");  

         }

        @Override public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {

               db.execSQL(" ALTER TABLE person ADD phone VARCHAR(12) NULL ");//往表中增加一列

// DROP TABLE IF EXISTS person 删除表

       }

}

在实际项目开发中，当数据库表结构发生更新时，应该避免用户存放于数据库中的数据丢失。

使用SQLiteDatabase操作SQLite数据库

Android提供了一个名为SQLiteDatabase的类，该类封装了一些操作数据库的API，使用该类可以完成对数据进行添加(Create)、查询(Retrieve)、更新(Update)和删除(Delete)操作（这些操作简称为CRUD）。对SQLiteDatabase的学习，我们应该重点掌握execSQL()和rawQuery()方法。 execSQL()方法可以执行insert、delete、update和CREATE TABLE之类有更改行为的SQL语句； rawQuery()方法用于执行select语句。

execSQL()方法的使用例子：

SQLiteDatabase db = ....;

db.execSQL("insert into person(name, age) values('HQ', 4)");

db.close();

执行上面SQL语句会往person表中添加进一条记录，在实际应用中， 语句中的“HQ”这些参数值会由用户输入界面提供，如果把用户输入的内容原样组拼到上面的insert语句， 当用户输入的内容含有单引号时，组拼出来的SQL语句就会存在语法错误。要解决这个问题需要对单引号进行转义，也就是把单引号转换成两个单引号。有些时候用户往往还会输入像“ & ”这些特殊SQL符号，为保证组拼好的SQL语句语法正确，必须对SQL语句中的这些特殊SQL符号都进行转义，显然，对每条SQL语句都做这样的处理工作是比较烦琐的。 SQLiteDatabase类提供了一个重载后的execSQL(String sql, Object[] bindArgs)方法，使用这个方法可以解决前面提到的问题，因为这个方法支持使用占位符参数(?)。使用例子如下：

SQLiteDatabase db = ....;

db.execSQL("insert into person(name, age) values(?,?)", new Object[]{"HQ", 4});

db.close();

execSQL(String sql, Object[] bindArgs)方法的第一个参数为SQL语句，第二个参数为SQL语句中占位符参数的值，参数值在数组中的顺序要和占位符的位置对应。

SQLiteDatabase的rawQuery() 用于执行select语句，使用例子如下：
 SQLiteDatabase db = ....;

Cursor cursor = db.rawQuery(“select * from person”, null);

while (cursor.moveToNext()) {

int personid = cursor.getInt(0); //获取第一列的值,第一列的索引从0开始

String name = cursor.getString(1);//获取第二列的值

int age = cursor.getInt(2);//获取第三列的值

}

cursor.close();

db.close();

rawrawQuery()方法的第一个参数为select语句；第二个参数为select语句中占位符参数的值，如果select语句没有使用占位符，该参数可以设置为null。带占位符参数的select语句使用例子如下：

Cursor cursor = db.rawQuery("select * from person where name like ? and age=?", new String[]{"%LP%", "4"});

Cursor是结果集游标，用于对结果集进行随机访问，如果大家熟悉jdbc， 其实Cursor与JDBC中的ResultSet作用很相似。使用moveToNext()方法可以将游标从当前行移动到下一行，如果已经移过了结果集的最后一行，返回结果为false，否则为true。另外Cursor 还有常用的moveToPrevious()方法（用于将游标从当前行移动到上一行，如果已经移过了结果集的第一行，返回值为false，否则为true ）、moveToFirst()方法（用于将游标移动到结果集的第一行，如果结果集为空，返回值为false，否则为true ）和moveToLast()方法（用于将游标移动到结果集的最后一行，如果结果集为空，返回值为false，否则为true ） 。

除了前面给大家介绍的execSQL()和rawQuery()方法， SQLiteDatabase还专门提供了对应于添加、删除、更新、查询的操作方法： insert()、delete()、update()和query() 。这些方法实际上是给那些不太了解SQL语法的菜鸟使用的，对于熟悉SQL语法的程序员而言，直接使用execSQL()和rawQuery()方法执行SQL语句就能完成数据的添加、删除、更新、查询操作。

Insert()方法用于添加数据，各个字段的数据使用ContentValues进行存放。 ContentValues类似于MAP，相对于MAP，它提供了存取数据对应的put(String key, Xxx value)和getAsXxx(String key)方法，  key为字段名称，value为字段值，Xxx指的是各种常用的数据类型，如：String、Integer等。

SQLiteDatabase db = databaseHelper.getWritableDatabase();

ContentValues values = new ContentValues();

values.put("name", "HQ");

values.put("age", 4);

long rowid = db.insert(“person”, null, values);//返回新添记录的行号，与主键id无关

不管第三个参数是否包含数据，执行Insert()方法必然会添加一条记录，如果第三个参数为空，会添加一条除主键之外其他字段值为Null的记录。Insert()方法内部实际上通过构造insert SQL语句完成数据的添加，Insert()方法的第二个参数用于指定空值字段的名称，相信大家对该参数会感到疑惑，该参数的作用是什么？是这样的：如果第三个参数values 为Null或者元素个数为0， 由于Insert()方法要求必须添加一条除了主键之外其它字段为Null值的记录，为了满足SQL语法的需要， insert语句必须给定一个字段名，如：insert into person(name) values(NULL)，倘若不给定字段名 ， insert语句就成了这样： insert into person() values()，显然这不满足标准SQL的语法。对于字段名，建议使用主键之外的字段，如果使用了INTEGER类型的主键字段，执行类似insert into person(personid) values(NULL)的insert语句后，该主键字段值也不会为NULL。如果第三个参数values 不为Null并且元素的个数大于0 ，可以把第二个参数设置为null。

delete()方法的使用：

SQLiteDatabase db = databaseHelper.getWritableDatabase();

db.delete("person", "personid<?", new String[]{"2"});

db.close();

上面代码用于从person表中删除personid小于2的记录。

update()方法的使用：

SQLiteDatabase db = databaseHelper.getWritableDatabase();

ContentValues values = new ContentValues();

values.put(“name”, “HQ”);//key为字段名，value为值

db.update("person", values, "personid=?", new String[]{"1"});

db.close();

上面代码用于把person表中personid等于1的记录的name字段的值改为“HQ”。

query()方法实际上是把select语句拆分成了若干个组成部分，然后作为方法的输入参数：

SQLiteDatabase db = databaseHelper.getWritableDatabase();

Cursor cursor = db.query("person", new String[]{"personid,name,age"}, "name like ?", new String[]{"%LP%"}, null, null, "personid desc", "1,2");

while (cursor.moveToNext()) {

         int personid = cursor.getInt(0); //获取第一列的值,第一列的索引从0开始

        String name = cursor.getString(1);//获取第二列的值

        int age = cursor.getInt(2);//获取第三列的值

}

cursor.close();

db.close();

上面代码用于从person表中查找name字段含有“LP”的记录，匹配的记录按personid降序排序，对排序后的结果略过第一条记录，只获取2条记录。

query(table, columns, selection, selectionArgs, groupBy, having, orderBy, limit)方法各参数的含义：

table：表名。相当于select语句from关键字后面的部分。如果是多表联合查询，可以用逗号将两个表名分开。

columns：要查询出来的列名。相当于select语句select关键字后面的部分。

selection：查询条件子句，相当于select语句where关键字后面的部分，在条件子句允许使用占位符“?”

selectionArgs：对应于selection语句中占位符的值，值在数组中的位置与占位符在语句中的位置必须一致，否则就会有异常。

groupBy：相当于select语句group by关键字后面的部分

having：相当于select语句having关键字后面的部分

orderBy：相当于select语句order by关键字后面的部分，如：personid desc, age asc;

limit：指定偏移量和获取的记录数，相当于select语句limit关键字后面的部分。

使用SQLiteOpenHelper获取用于操作数据库的SQLiteDatabase实例

public class DatabaseHelper extends SQLiteOpenHelper {

         private static final String name = "itcast";//数据库名称

         private static final int version = 1; //数据库版本

         ......略

}

public class HelloActivity extends Activity {

    @Override public void onCreate(Bundle savedInstanceState) {

        ......

        Button button =(Button) this.findViewById(R.id.button);

        button.setOnClickListener(new View.OnClickListener(){

public void onClick(View v) {

DatabaseHelper databaseHelper = new DatabaseHelper(HelloActivity.this);

SQLiteDatabase db = databaseHelper.getWritableDatabase();

db.execSQL("insert into person(name, age) values(?,?)", new Object[]{"HQ", 4});

db.close(); 

}});       

    }

}

第一次调用getWritableDatabase()或getReadableDatabase()方法后，SQLiteOpenHelper会缓存当前的SQLiteDatabase实例，SQLiteDatabase实例正常情况下会维持数据库的打开状态，所以在你不再需要SQLiteDatabase实例时，请及时调用close()方法释放资源。一旦SQLiteDatabase实例被缓存，多次调用getWritableDatabase()或getReadableDatabase()方法得到的都是同一实例。

使用事务操作SQLite数据库

使用SQLiteDatabase的beginTransaction()方法可以开启一个事务，程序执行到endTransaction() 方法时会检查事务的标志是否为成功，如果程序执行到endTransaction()之前调用了setTransactionSuccessful() 方法设置事务的标志为成功则提交事务，如果没有调用setTransactionSuccessful() 方法则回滚事务。使用例子如下：
 SQLiteDatabase db = ....;

db.beginTransaction();//开始事务

try {

    db.execSQL("insert into person(name, age) values(?,?)", new Object[]{"HQ", 4});

    db.execSQL("update person set name=? where personid=?", new Object[]{"LP", 1});

    db.setTransactionSuccessful();//调用此方法会在执行到endTransaction() 时提交当前事务，如果不调用此方法会回滚事务

} finally {

    db.endTransaction();//由事务的标志决定是提交事务，还是回滚事务

}

db.close();

上面两条SQL语句在同一个事务中执行。

Android sqlite3工具的使用

1 cmd à adb shell 首先挂载到linux

2 cd data/data/com.android.contacts.provider

3 cd database

4 sqlite3 contacts 打开数据库eg: sqlite3 contacts.db

5 .tables 查看所有的表  eg: .table

6 .schema 查看所有的创建表、视图的语句eg: .schema

7 .help 查看帮助  eg: .help

8 .header(s) NO |OFF是否显示列头信息eg: headers ON

9 .mode MODE  ?table? 指定数据显示风格eg: .mode column

10 .nullValue NULL空值数据显示问题eg: .nullValue NULL

使用ContentProvider（内容提供者）共享数据

ContentProvider 在android中的作用是对外共享数据，也就是说你可以通过ContentProvider把应用中的数据共享给其他应用访问，其他应用可以通过ContentProvider对你应用中的数据进行添删改查。关于数据共享，以前我们学习过文件操作模式，知道通过指定文件的操作模式为Context.MODE_WORLD_READABLE 或Context.MODE_WORLD_WRITEABLE同样也可以对外共享数据。那么，这里为何要使用ContentProvider对外共享数据呢？是这样的，如果采用文件操作模式对外共享数据，数据的访问方式会因数据存储的方式而不同，导致数据的访问方式无法统一，如：采用xml文件对外共享数据，需要进行xml解析才能读取数据；采用sharedpreferences共享数据，需要使用sharedpreferences API读取数据。

使用ContentProvider对外共享数据的好处是统一了数据的访问方式。

当应用需要通过ContentProvider对外共享数据时，第一步需要继承ContentProvider并重写下面方法：

public class PersonContentProvider extends ContentProvider{

   public boolean onCreate()

   public Uri insert(Uri uri, ContentValues values)

   public int delete(Uri uri, String selection, String[] selectionArgs)

   public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs)

   public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder)

   public String getType(Uri uri)}

第二步需要在AndroidManifest.xml使用<provider>对该ContentProvider进行配置，为了能让其他应用找到该ContentProvider ，ContentProvider 采用了authorities（主机名/域名）对它进行唯一标识，你可以把ContentProvider看作是一个网站（想想，网站也是提供数据者），authorities 就是他的域名：

<manifest .... >

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

        <provider android:name=".PersonContentProvider" android:authorities="cn.itcast.providers.personprovider"/>

    </application>

</manifest>

Uri介绍

Uri代表了要操作的数据，Uri主要包含了两部分信息：1》需要操作的ContentProvider ，2》对ContentProvider中的什么数据进行操作，一个Uri由以下几部分组成：

ContentProvider（内容提供者）的scheme已经由Android所规定，scheme为：content://

主机名（或叫Authority）用于唯一标识这个ContentProvider，外部调用者可以根据这个标识来找到它。

路径（path）可以用来表示我们要操作的数据，路径的构建应根据业务而定，如下:

要操作person表中id为10的记录，可以构建这样的路径:/person/10

要操作person表中id为10的记录的name字段，person/10/name

要操作person表中的所有记录，可以构建这样的路径:/person

要操作xxx表中的记录，可以构建这样的路径:/xxx

当然要操作的数据不一定来自数据库，也可以是文件、xml或网络等其他存储方式，如下:

要操作xml文件中person节点下的name节点，可以构建这样的路径：/person/name

如果要把一个字符串转换成Uri，可以使用Uri类中的parse()方法，如下：

Uri uri = Uri.parse("content://cn.itcast.provider.personprovider/person")

UriMatcher类使用介绍

因为Uri代表了要操作的数据，所以我们经常需要解析Uri，并从Uri中获取数据。Android系统提供了两个用于操作Uri的工具类，分别为UriMatcher 和ContentUris 。掌握它们的使用，会便于我们的开发工作。

UriMatcher类用于匹配Uri，它的用法如下：

首先第一步把你需要匹配Uri路径全部给注册上，如下：

//常量UriMatcher.NO_MATCH表示不匹配任何路径的返回码

UriMatcher  sMatcher = new UriMatcher(UriMatcher.NO_MATCH);

//如果match()方法匹配content://cn.itcast.provider.personprovider/person路径，返回匹配码为1

sMatcher.addURI(“cn.itcast.provider.personprovider”, “person”, 1);//添加需要匹配uri，如果匹配就会返回匹配码

//如果match()方法匹配content://cn.itcast.provider.personprovider/person/230路径，返回匹配码为2

sMatcher.addURI(“cn.itcast.provider.personprovider”, “person/#”, 2);//#号为通配符

switch (sMatcher.match(Uri.parse("content://cn.itcast.provider.personprovider/person/10"))) {

   case 1

    break;

   case 2

    break;

   default://不匹配

    break;

}

注册完需要匹配的Uri后，就可以使用sMatcher.match(uri)方法对输入的Uri进行匹配，如果匹配就返回匹配码，匹配码是调用addURI()方法传入的第三个参数，假设匹配content://cn.itcast.provider.personprovider/person路径，返回的匹配码为1

ContentUris类使用介绍

ContentUris类用于获取Uri路径后面的ID部分，它有两个比较实用的方法：

withAppendedId(uri, id)用于为路径加上ID部分：

Uri uri = Uri.parse("content://cn.itcast.provider.personprovider/person")

Uri resultUri = ContentUris.withAppendedId(uri, 10);

//生成后的Uri为：content://cn.itcast.provider.personprovider/person/10

parseId(uri)方法用于从路径中获取ID部分：

Uri uri = Uri.parse("content://cn.itcast.provider.personprovider/person/10")

long personid = ContentUris.parseId(uri);       //获取的结果为:10

使用ContentProvider共享数据

ContentProvider类主要方法的作用：

public boolean onCreate()

该方法在ContentProvider创建后就会被调用， Android开机后， ContentProvider在其它应用第一次访问它时才会被创建。

public Uri insert(Uri uri, ContentValues values)

该方法用于供外部应用往ContentProvider添加数据。

public int delete(Uri uri, String selection, String[] selectionArgs)

该方法用于供外部应用从ContentProvider删除数据。

public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs)

该方法用于供外部应用更新ContentProvider中的数据。

public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder)

该方法用于供外部应用从ContentProvider中获取数据。

public String getType(Uri uri)

该方法用于返回当前Url所代表数据的MIME类型。如果操作的数据属于集合类型，那么MIME类型字符串应该以vnd.android.cursor.dir/开头，例如：要得到所有person记录的Uri为content://cn.itcast.provider.personprovider/person，那么返回的MIME类型字符串应该为：“vnd.android.cursor.dir/person”。如果要操作的数据属于非集合类型数据，那么MIME类型字符串应该以vnd.android.cursor.item/开头，例如：得到id为10的person记录，Uri为content://cn.itcast.provider.personprovider/person/10，那么返回的MIME类型字符串应该为：“vnd.android.cursor.item/person”。

使用ContentResolver操作ContentProvider中的数据

当外部应用需要对ContentProvider中的数据进行添加、删除、修改和查询操作时，可以使用ContentResolver 类来完成，要获取ContentResolver 对象，可以使用Activity提供的getContentResolver()方法。 ContentResolver 类提供了与ContentProvider类相同签名的四个方法：

public Uri insert(Uri uri, ContentValues values)

该方法用于往ContentProvider添加数据。

public int delete(Uri uri, String selection, String[] selectionArgs)

该方法用于从ContentProvider删除数据。

public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs)

该方法用于更新ContentProvider中的数据。

public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder)

该方法用于从ContentProvider中获取数据。

这些方法的第一个参数为Uri，代表要操作的ContentProvider和对其中的什么数据进行操作，假设给定的是：Uri.parse(“content://cn.itcast.providers.personprovider/person/10”)，那么将会对主机名为cn.itcast.providers.personprovider的ContentProvider进行操作，操作的数据为person表中id为10的记录。

使用ContentResolver对ContentProvider中的数据进行添加、删除、修改和查询操作：

ContentResolver resolver =  getContentResolver();

Uri uri = Uri.parse("content://cn.itcast.provider.personprovider/person");

//添加一条记录

ContentValues values = new ContentValues();

values.put("name", "itcast");

values.put("age", 25);

resolver.insert(uri, values);

//获取person表中所有记录

Cursor cursor = resolver.query(uri, null, null, null, "personid desc");

while(cursor.moveToNext()){

Log.i("ContentTest", "personid="+ cursor.getInt(0)+ ",name="+ cursor.getString(1));

}

//把id为1的记录的name字段值更改新为liming

ContentValues updateValues = new ContentValues();

updateValues.put("name", "liming");

Uri updateIdUri = ContentUris.withAppendedId(uri, 2);

resolver.update(updateIdUri, updateValues, null, null);

//删除id为2的记录

Uri deleteIdUri = ContentUris.withAppendedId(uri, 2);

resolver.delete(deleteIdUri, null, null);

监听ContentProvider中数据的变化

如果ContentProvider的访问者需要知道ContentProvider中的数据发生了变化，可以在ContentProvider 发生数据变化时调用getContentResolver().notifyChange(uri, null)来通知注册在此URI上的访问者，例子如下：

public class PersonContentProvider extends ContentProvider {

public Uri insert(Uri uri, ContentValues values) {

db.insert("person", "personid", values);

getContext().getContentResolver().notifyChange(uri, null);

}

}

如果ContentProvider的访问者需要得到数据变化通知，必须使用ContentObserver对数据（数据采用uri描述）进行监听，当监听到数据变化通知时，系统就会调用ContentObserver的onChange()方法：

getContentResolver().registerContentObserver(Uri.parse("content://cn.itcast.providers.personprovider/person"),

        true, new PersonObserver(new Handler()));

public class PersonObserver extends ContentObserver{

public PersonObserver(Handler handler) {

super(handler);

 }

public void onChange(boolean selfChange) {

    //此处可以进行相应的业务处理

}

}

窃听用户发出的短信

用户使用系统自带的短信程序发送短信，程序会通过ContentProvider把短信保存进数据库，并且发出一个数据变化通知，使用ContentObserver对数据变化进行监听，在用户发送短信时，就会被ContentObserver窃听到短信：

注册监听：

getContentResolver().registerContentObserver(Uri.parse("content://sms"),  true, new SmsObserver(new Handler()));

监听类：

private final class SmsObserver extends ContentObserver{

public SmsObserver(Handler handler) {

super(handler);

}

public void onChange(boolean selfChange) {//查询发送箱中的短信(处于正在发送状态的短信放在发送箱)

Cursor cursor = getContentResolver().query(Uri.parse("content://sms/outbox"),null, null, null, null);

while(cursor.moveToNext()){

StringBuilder sb = new StringBuilder();

sb.append("_id=").append(cursor.getInt(cursor.getColumnIndex("_id")));

sb.append(",address=").append(cursor.getString(cursor.getColumnIndex("address")));

sb.append(";body=").append(cursor.getString(cursor.getColumnIndex("body")));

sb.append(";time=").append(cursor.getLong(cursor.getColumnIndex("date")));

Log.i("ReceiveSendSMS", sb.toString());

             } }   

}

通信录操作

使用ContentResolver对通信录中的数据进行添加、删除、修改和查询操作：

加入读写联系人信息的权限

<uses-permission android:name="android.permission.READ_CONTACTS" />

<uses-permission android:name="android.permission.WRITE_CONTACTS" />

加入读取联系人信息的权限

<uses-permission android:name="android.permission.READ_CONTACTS"/>

content://com.android.contacts/contacts 操作的数据是联系人信息Uri

content://com.android.contacts/data/phones 联系人电话Uri

content://com.android.contacts/data/emails 联系人Email Uri

读取联系人信息

Cursor cursor = getContentResolver().query(ContactsContract.Contacts.CONTENT_URI, 

    null, null, null, null); 

  while (cursor.moveToNext()) { 

   String contactId = cursor.getString(cursor.getColumnIndex(ContactsContract.Contacts._ID)); 

   String name = cursor.getString(cursor.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME)); 

  

   Cursor phones = getContentResolver().query(ContactsContract.CommonDataKinds.Phone.CONTENT_URI, 

        null, 

        ContactsContract.CommonDataKinds.Phone.CONTACT_ID +" = "+ contactId, 

        null, null); 

    while (phones.moveToNext()) { 

     String phoneNumber = phones.getString(phones.getColumnIndex( 

         ContactsContract.CommonDataKinds.Phone.NUMBER)); 

     Log.i("RongActivity", "phoneNumber="+phoneNumber);

    } 

    phones.close(); 

  

    Cursor emails = getContentResolver().query(ContactsContract.CommonDataKinds.Email.CONTENT_URI, 

       null, 

       ContactsContract.CommonDataKinds.Email.CONTACT_ID + " = " + contactId, 

       null, null); 

       while (emails.moveToNext()) { 

        // This would allow you get several email addresses 

        String emailAddress = emails.getString(emails.getColumnIndex(ContactsContract.CommonDataKinds.Email.DATA));

        Log.i("RongActivity", "emailAddress="+ emailAddress);

       } 

       emails.close(); 

  } 

  cursor.close();

==================== 添加联系人===========================

方法一：

/**

 * 首先向RawContacts.CONTENT_URI执行一个空值插入，目的是获取系统返回的rawContactId

 * 这时后面插入data表的依据，只有执行空值插入，才能使插入的联系人在通讯录里面可见

 */

public void testInsert() {

ContentValues values = new ContentValues();

//首先向RawContacts.CONTENT_URI执行一个空值插入，目的是获取系统返回的rawContactId

Uri rawContactUri = this.getContext().getContentResolver().insert(RawContacts.CONTENT_URI, values);

long rawContactId = ContentUris.parseId(rawContactUri);

//往data表入姓名数据

values.clear();

values.put(Data.RAW_CONTACT_ID, rawContactId);

values.put(Data.MIMETYPE, StructuredName.CONTENT_ITEM_TYPE);//内容类型

values.put(StructuredName.GIVEN_NAME, "李天山");

this.getContext().getContentResolver().insert(android.provider.ContactsContract.Data.CONTENT_URI, values);

//往data表入电话数据

values.clear();

values.put(Data.RAW_CONTACT_ID, rawContactId);

values.put(Data.MIMETYPE, Phone.CONTENT_ITEM_TYPE);

values.put(Phone.NUMBER, "13921009789");

values.put(Phone.TYPE, Phone.TYPE_MOBILE);

this.getContext().getContentResolver().insert(android.provider.ContactsContract.Data.CONTENT_URI, values);

//往data表入Email数据

values.clear();

values.put(Data.RAW_CONTACT_ID, rawContactId);

values.put(Data.MIMETYPE, Email.CONTENT_ITEM_TYPE);

values.put(Email.DATA, "[e-mail]");

values.put(Email.TYPE, Email.TYPE_WORK);

this.getContext().getContentResolver().insert(android.provider.ContactsContract.Data.CONTENT_URI, values);

}

方法二：批量添加,处于同一个事务中

public void testSave() throws Throwable{

//文档位置：reference\android\provider\ContactsContract.RawContacts.html

ArrayList<ContentProviderOperation> ops = new ArrayList<ContentProviderOperation>();

int rawContactInsertIndex = 0;

ops.add(ContentProviderOperation.newInsert(RawContacts.CONTENT_URI)

.withValue(RawContacts.ACCOUNT_TYPE, null)

.withValue(RawContacts.ACCOUNT_NAME, null)

.build());

//文档位置：reference\android\provider\ContactsContract.Data.html

ops.add(ContentProviderOperation.newInsert(android.provider.ContactsContract.Data.CONTENT_URI)

.withValueBackReference(Data.RAW_CONTACT_ID, rawContactInsertIndex)

.withValue(Data.MIMETYPE, StructuredName.CONTENT_ITEM_TYPE)

.withValue(StructuredName.GIVEN_NAME, "赵薇")

.build());

ops.add(ContentProviderOperation.newInsert(android.provider.ContactsContract.Data.CONTENT_URI)

 .withValueBackReference(Data.RAW_CONTACT_ID, rawContactInsertIndex)

         .withValue(Data.MIMETYPE, Phone.CONTENT_ITEM_TYPE)

         .withValue(Phone.NUMBER, "13671323809")

         .withValue(Phone.TYPE, Phone.TYPE_MOBILE)

         .withValue(Phone.LABEL, "手机号")

         .build());

ops.add(ContentProviderOperation.newInsert(android.provider.ContactsContract.Data.CONTENT_URI)

 .withValueBackReference(Data.RAW_CONTACT_ID, rawContactInsertIndex)

         .withValue(Data.MIMETYPE, Email.CONTENT_ITEM_TYPE)

         .withValue(Email.DATA, "[e-mail]")

         .withValue(Email.TYPE, Email.TYPE_WORK)

         .build());

ContentProviderResult[] results = this.getContext().getContentResolver()

.applyBatch(ContactsContract.AUTHORITY, ops);

for(ContentProviderResult result : results){

Log.i(TAG, result.uri.toString());

}

}

从Internet获取数据

利用HttpURLConnection对象,我们可以从网络中获取网页数据.

URL url = new URL("http://www.sohu.com");

HttpURLConnection conn = (HttpURLConnection) url.openConnection();

conn.setConnectTimeout(5* 1000);     //设置连接超时

conn.setRequestMethod(“GET”);     //以get方式发起请求

if (conn.getResponseCode() != 200) throw new RuntimeException("请求url失败");

InputStream is = conn.getInputStream();      //得到网络返回的输入流

String result = readData(is, "GBK");

conn.disconnect();

//第一个参数为输入流,第二个参数为字符集编码

public static String readData(InputStream inSream, String charsetName) throws Exception{

ByteArrayOutputStream outStream = new ByteArrayOutputStream();

byte[] buffer = new byte[1024];

int len = -1;

while( (len = inSream.read(buffer)) != -1 ){

outStream.write(buffer, 0, len);

}

byte[] data = outStream.toByteArray();

outStream.close();

inSream.close();

return new String(data, charsetName);

}

利用HttpURLConnection对象,我们可以从网络中获取文件数据.

URL url = new URL("http://photocdn.sohu.com/20100125/Img269812337.jpg");

HttpURLConnection conn = (HttpURLConnection) url.openConnection();

conn.setConnectTimeout(5* 1000);

conn.setRequestMethod("GET");

if (conn.getResponseCode() != 200) throw new RuntimeException("请求url失败");

InputStream is = conn.getInputStream();

readAsFile(is, "Img269812337.jpg");

public static void readAsFile(InputStream inSream, File file) throws Exception{

FileOutputStream outStream = new FileOutputStream(file);

byte[] buffer = new byte[1024];

int len = -1;

while( (len = inSream.read(buffer)) != -1 ){

outStream.write(buffer, 0, len);

}

 outStream.close();

inSream.close();

}

向Internet发送请求参数

利用HttpURLConnection对象,我们可以向网络发送请求参数.

String requestUrl = "http://localhost:8080/itcast/contanctmanage.do";

Map<String, String> requestParams = new HashMap<String, String>();

requestParams.put("age", "12");

requestParams.put("name", "中国");

 StringBuilder params = new StringBuilder();

for(Map.Entry<String, String> entry : requestParams.entrySet()){

params.append(entry.getKey());

params.append("=");

params.append(URLEncoder.encode(entry.getValue(), "UTF-8"));

params.append("&");

}

if (params.length() > 0) params.deleteCharAt(params.length() - 1);

byte[] data = params.toString().getBytes();

URL realUrl = new URL(requestUrl);

HttpURLConnection conn = (HttpURLConnection) realUrl.openConnection();

conn.setDoOutput(true);    //发送POST请求必须设置允许输出

conn.setUseCaches(false);   //不使用Cache

conn.setRequestMethod("POST");       

conn.setRequestProperty("Connection", "Keep-Alive");    //维持长连接

conn.setRequestProperty("Charset", "UTF-8");

conn.setRequestProperty("Content-Length", String.valueOf(data.length));

conn.setRequestProperty("Content-Type","application/x-www-form-urlencoded");

DataOutputStream outStream = new DataOutputStream(conn.getOutputStream());

outStream.write(data);

outStream.flush();

if( conn.getResponseCode() == 200 ){

        String result = readAsString(conn.getInputStream(), "UTF-8");

        outStream.close();

        System.out.println(result);

}

向Internet发送xml数据

利用HttpURLConnection对象,我们可以向网络发送xml数据.

StringBuilder xml =  new StringBuilder();

xml.append("<?xml version=\"1.0\" encoding=\"utf-8\" ?>");

xml.append("<M1 V=10000>");

xml.append("<U I=1 D=\"N73\">中国</U>");

xml.append("</M1>");

byte[] xmlbyte = xml.toString().getBytes("UTF-8");

URL url = new URL("http://localhost:8080/itcast/contanctmanage.do?method=readxml");

HttpURLConnection conn = (HttpURLConnection) url.openConnection();

conn.setConnectTimeout(5* 1000);

conn.setDoOutput(true);   //允许输出

conn.setUseCaches(false);  //不使用Cache

conn.setRequestMethod("POST");       

conn.setRequestProperty("Connection", "Keep-Alive");   //维持长连接

conn.setRequestProperty("Charset", "UTF-8");

conn.setRequestProperty("Content-Length", String.valueOf(xmlbyte.length));

conn.setRequestProperty("Content-Type", "text/xml; charset=UTF-8");

DataOutputStream outStream = new DataOutputStream(conn.getOutputStream());

outStream.write(xmlbyte);   //发送xml数据

outStream.flush();

if (conn.getResponseCode() != 200) throw new RuntimeException("请求url失败");

InputStream is = conn.getInputStream();   //获取返回数据

String result = readAsString(is, "UTF-8");

outStream.close();

多线程断点续传下载

使用多线程下载文件可以更快完成文件的下载，多线程下载文件之所以快，是因为其抢占的服务器资源多。如：假设服务器同时最多服务100个用户，在服务器中一条线程对应一个用户，100条线程在计算机中并非并发执行，而是由CPU划分时间片轮流执行，如果A应用使用了99条线程下载文件，那么相当于占用了99个用户的资源，假设一秒内CPU分配给每条线程的平均执行时间是10ms，A应用在服务器中一秒内就得到了990ms的执行时间，而其他应用在一秒内只有10ms的执行时间。就如同一个水龙头，每秒出水量相等的情况下，放990毫秒的水

肯定比放10毫秒的水要多。

多线程下载的实现过程：

1>首先得到下载文件的长度，然后设置本地文件

的长度。

HttpURLConnection.getContentLength();

RandomAccessFile file = new RandomAccessFile("QQWubiSetup.exe","rwd");

file.setLength(filesize);//设置本地文件的长度

2>根据文件长度和线程数计算每条线程下载的数据长度和下载位置。如：文件的长度为6M，线程数为3，那么，每条线程下载的数据长度为2M，每条线程开始下载的位置如上图所示。

3>使用Http的Range头字段指定每条线程从文件的什么位置开始下载，下载到什么位置为止，如：指定从文件的2M位置开始下载，下载到位置(4M-1byte)为止，代码如下：

HttpURLConnection.setRequestProperty("Range", "bytes=2097152-4194303");

4>保存文件，使用RandomAccessFile类指定每条线程从本地文件的什么位置开始写入数据。

RandomAccessFile threadfile = new RandomAccessFile("QQWubiSetup.exe ","rwd");

threadfile.seek(2097152);//从文件的什么位置开始写入数据

public class FileDownLoader {

@Test

public void download() throws Exception {

String path = "http://browse.babasport.com/QQWubiSetup.exe";

URL url = new URL(path);

HttpURLConnection conn = (HttpURLConnection) url.openConnection();

conn.setConnectTimeout(5*1000);

conn.setRequestMethod("GET");

conn.setRequestProperty("Accept", "image/gif, image/jpeg, image/pjpeg, image/pjpeg, application/x-shockwave-flash, application/xaml+xml, application/vnd.ms-xpsdocument, application/x-ms-xbap, application/x-ms-application, application/vnd.ms-excel, application/vnd.ms-powerpoint, application/msword, */*");

conn.setRequestProperty("Accept-Language", "zh-CN");

conn.setRequestProperty("Charset", "UTF-8");

conn.setRequestProperty("User-Agent", "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 5.2; Trident/4.0; .NET CLR 1.1.4322; .NET CLR 2.0.50727; .NET CLR 3.0.04506.30; .NET CLR 3.0.4506.2152; .NET CLR 3.5.30729)");

conn.setRequestProperty("Connection", "Keep-Alive");

System.out.println(conn.getResponseCode());

int filesize = conn.getContentLength();//得到文件大小

conn.disconnect();

int threasize = 3;//线程数

int perthreadsize = filesize / 3 + 1;

RandomAccessFile file = new RandomAccessFile("102.wma","rw");

file.setLength(filesize);//设置本地文件的大小

file.close();

for(int i=0; i<threasize ; i++){

int startpos = i * perthreadsize;//计算每条线程的下载位置

RandomAccessFile perthreadfile = new RandomAccessFile("102.wma","rw");//

perthreadfile.seek(startpos);//从文件的什么位置开始写入数据

new DownladerThread(i, path, startpos, perthreadsize, perthreadfile).start();

}

//以下代码要求用户输入q才会退出测试方法，如果没有下面代码，会因为进程结束而导致进程内的下载线程被销毁

int quit = System.in.read();

while('q'!=quit){

Thread.sleep(2 * 1000);

}

}

private class DownladerThread extends Thread{

private int startpos;//从文件的什么位置开始下载

private int perthreadsize;//每条线程需要下载的文件大小

private String path;

private RandomAccessFile file;

private int threadid;

public DownladerThread(int threadid, String path, int startpos, int perthreadsize, RandomAccessFile perthreadfile) {

this.path = path;

this.startpos = startpos;

this.perthreadsize = perthreadsize;

this.file = perthreadfile;

this.threadid = threadid;

}

@Override

public void run() {

try {

URL url = new URL(path);

HttpURLConnection conn = (HttpURLConnection)url.openConnection();

conn.setConnectTimeout(5 * 1000);

conn.setRequestMethod("GET");

conn.setRequestProperty("Accept", "image/gif, image/jpeg, image/pjpeg, image/pjpeg, application/x-shockwave-flash, application/xaml+xml, application/vnd.ms-xpsdocument, application/x-ms-xbap, application/x-ms-application, application/vnd.ms-excel, application/vnd.ms-powerpoint, application/msword, */*");

conn.setRequestProperty("Accept-Language", "zh-CN");

conn.setRequestProperty("Charset", "UTF-8");

conn.setRequestProperty("Range", "bytes=" + this.startpos + "-");

InputStream inStream = conn.getInputStream();

byte[] buffer = new byte[1024];

int len = 0;

int length = 0;

while(length<perthreadsize && (len = inStream.read(buffer))!=-1){

file.write(buffer, 0, len);

length += len;//累计该线程下载的总大小

}

file.close();

inStream.close();

System.out.println(threadid+ "线程完成下载");

} catch (Exception e) {

e.printStackTrace();

}

}

}

}

为应用添加新的Activity

第一步：新建一个继承Activity的类，如：NewActivity

public class NewActivity extends Activity {

    @Override protected void onCreate(Bundle savedInstanceState) {

                   super.onCreate(savedInstanceState);

  //这里可以使用setContentView(R.layout.xxx)显示某个视图....

     }

}

第二步：需要在功能清单AndroidManifest.xml文件中添加进上面Activity配置代码(红色部分)：

<manifest xmlns:android="http://schemas.android.com/apk/res/android"

      package="cn.itcast.action"

      android:versionCode="1"

      android:versionName="1.0">

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

        .....

    <activity android:name=".NewActivity" android:label="新activity的页面标题"/>

    </application>

    ...

</manifest>

android:name属性值的前面加了一个点表示NewActivity是当前包cn.itcast.action下的类，如果类在应用的当前包下，可以省略点符号，如果类在应用的子包下必须加点，如：NewActivity类在cn.itcast.action.user包下可以这样写：<activity android:name=“.user.NewActivity“ />

Activity生命周期

Activity有三个状态：

l 当它在屏幕前台时（位于当前任务堆栈的顶部），它是激活或运行状态。它就是响应用户操作的Activity。

l 当它上面有另外一个Activity，使它失去了焦点但仍然对用户可见时（如右图），它处于暂停状态。在它之上的Activity没有完全覆盖屏幕，或者是透明的，被暂停的Activity仍然对用户可见，并且是存活状态（它保留着所有的状态和成员信息并保持和窗口管理器的连接）。如果系统处于内存不足时会杀死这个Activity。

l当它完全被另一个Activity覆盖时则处于停止状态。它仍然保留所有的状态和成员信息。然而对用户是不可见的，所以它的窗口将被隐藏，如果其它地方需要内存，则系统经常会杀死这个Activity。

当Activity从一种状态转变到另一种状态时，会调用以下保护方法来通知这种变化：

void onCreate(Bundle savedInstanceState)

void onStart()

void onRestart()

void onResume()

void onPause()

void onStop()

void onDestroy()

这七个方法定义了Activity的完整生命周期。实现这些方法可以帮助我们监视其中的三个嵌套生命周期循环：

l Activity的完整生命周期自第一次调用onCreate()开始，直至调用onDestroy()为止。Activity在onCreate()中设置所有“全局”状态以完成初始化，而在onDestroy()中释放所有系统资源。例如，如果Activity有一个线程在后台运行从网络下载数据，它会在+onCreate()创建线程，而在 onDestroy()销毁线程。

l Activity的可视生命周期自onStart()调用开始直到相应的onStop()调用结束。在此期间，用户可以在屏幕上看到Activity，尽管它也许并不是位于前台或者也不与用户进行交互。在这两个方法之间，我们可以保留用来向用户显示这个Activity所需的资源。例如，当用户不再看见我们显示的内容时，我们可以在onStart()中注册一个BroadcastReceiver来监控会影响UI的变化，而在onStop()中来注消。onStart() 和 onStop() 方法可以随着应用程序是否为用户可见而被多次调用。

l Activity的前台生命周期自onResume()调用起，至相应的onPause()调用为止。在此期间，Activity位于前台最上面并与用户进行交互。Activity会经常在暂停和恢复之间进行状态转换——例如当设备转入休眠状态或者有新的Activity启动时，将调用onPause() 方法。当Activity获得结果或者接收到新的Intent时会调用onResume() 方法。关于前台生命周期循环的例子请见PPT下方备注栏。

Activity的前台生命周期循环例子:

1》创建一个Activity，添加七个生命周期方法，方法内输出各个方法名称。再添加一个按钮用于打开下面新添加的Activity。

    startActivity(new Intent(LifeActivity.this, CustomDialogActivity.class));

2》添加一个新Activity，代码如下：

public class CustomDialogActivity extends Activity {

    @Override protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        //必须在调用setContentView()之前调用requestWindowFeature()

        requestWindowFeature(Window.FEATURE_LEFT_ICON);//要标题栏显示图标

        setContentView(R.layout.dialog_activity);      

        getWindow().setFeatureDrawableResource(Window.FEATURE_LEFT_ICON, android.R.drawable.ic_dialog_alert);//设置图标

    }

}

3》在AndroidManifest.xml文件配置Activity，并且通过主题指定该Activity以对话框样式显示。

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

        .....

        <activity android:name=".CustomDialogActivity" android:label="对话框activity"

android:theme="@android:style/Theme.Dialog"/>

 </application>

Activity的onSaveInstanceState()和 onRestoreInstanceState()方法

Activity的 onSaveInstanceState() 和 onRestoreInstanceState()并不是生命周期方法，它们不同于 onCreate()、onPause()等生命周期方法，它们并不一定会被触发。当应用遇到意外情况（如：内存不足、用户直接按Home键）由系统销毁一个Activity时，onSaveInstanceState() 会被调用。但是当用户主动去销毁一个Activity时，例如在应用中按返回键，onSaveInstanceState()就不会被调用。因为在这种情况下，用户的行为决定了不需要保存Activity的状态。通常onSaveInstanceState()只适合用于保存一些临时性的状态，而onPause()适合用于数据的持久化保存。

另外，当屏幕的方向发生了改变， Activity会被摧毁并且被重新创建，如果你想在Activity被摧毁前缓存一些数据，并且在Activity被重新创建后恢复缓存的数据。可以重写Activity的 onSaveInstanceState() 和 onRestoreInstanceState()方法，如下：

public class PreferencesActivity extends Activity {

    private String name;

    protected void onRestoreInstanceState(Bundle savedInstanceState) {

    name = savedInstanceState.getString("name");         //被重新创建后恢复缓存的数据

    super.onRestoreInstanceState(savedInstanceState);

    }

    protected void onSaveInstanceState(Bundle outState) {

    outState.putString("name", "liming");            //被摧毁前缓存一些数据

    super.onSaveInstanceState(outState);

    }

}

横竖屏幕切换

默认情况下，当“屏幕方向”或“键盘显示隐藏” 变化时都会销毁当前Activity，创建新的Activity。如果不希望重新创建Activity实例，可以按如下配置Activity：

<activity android:name=".MainActivity" android:configChanges="keyboardHidden|orientation">

上面的android:configChanges属性指定了要捕获“屏幕方向”和“键盘显示隐藏”变化，当捕获到这些变化后会调用Activity的onConfigurationChanged()方法。

默认情况下(没有配置android:configChanges属性)：

l竖屏切横屏，销毁当前Activity之后，创建一个新Activity实例。

l横屏切竖屏，销毁当前Activity之后，创建一个新Activity实例，新的Activity实例很快就被销毁，接着又会创建一个新Activity实例。如果只希望创建一个实例，可以配置android:configChanges="orientation"

打开新的Activity，不传递参数

在一个Activity中可以使用系统提供的startActivity(Intent intent)方法打开新的Activity，在打开新的Activity前，你可以决定是否为新的Activity传递参数：

第一种：打开新的Activity，不传递参数

publicclass MainActivity extends Activity {

  @Override protectedvoid onCreate(Bundle savedInstanceState) {

.......

Button button =(Button) this.findViewById(R.id.button);

                           button.setOnClickListener(new View.OnClickListener(){//点击该按钮会打开一个新的Activity

public void onClick(View v) {

                          //新建一个显式意图，第一个参数为当前Activity类对象，第二个参数为你要打开的Activity类

    startActivity(new Intent(MainActivity.this, NewActivity.class));

}});

         }

}

打开新的Activity，并传递若干个参数给它

第二种：打开新的Activity，并传递若干个参数给它：

publicclass MainActivity extends Activity {

  @Override protectedvoid onCreate(Bundle savedInstanceState) {

.......

 button.setOnClickListener(new View.OnClickListener(){//点击该按钮会打开一个新的Activity

          public void onClick(View v) {

           Intent intent = new Intent(MainActivity.this, NewActivity.class)

Bundle bundle = new Bundle();//该类用作携带数据

bundle.putString("name", "HQ");

bundle.putInt("age", 4);

intent.putExtras(bundle);//附带上额外的数据

startActivity(intent);

}}); }

}

在新的Activity中接收前面Activity传递过来的参数：

public class NewActivity extends Activity {

            @Override protected void onCreate(Bundle savedInstanceState) {

     ........

     Bundle bundle = this.getIntent().getExtras();

     String name = bundle.getString("name");

                    int age = bundle.getInt("age");

            }

}

Bundle类的作用

Bundle类用作携带数据，它类似于Map，用于存放key-value名值对形式的值。相对于Map，它提供了各种常用类型的putXxx()/getXxx()方法，如:putString()/getString()和putInt()/getInt()，putXxx()用于往Bundle对象放入数据，getXxx()方法用于从Bundle对象里获取数据。Bundle的内部实际上是使用了HashMap<String, Object>类型的变量来存放putXxx()方法放入的值：

public final class Bundle implements Parcelable, Cloneable {

            ......

 Map<String, Object> mMap;

 public Bundle() {

       mMap = new HashMap<String, Object>();

        ......

 }

 public void putString(String key, String value) {

      mMap.put(key, value);

 }

public String getString(String key) {

       Object o = mMap.get(key);

        return (String) o;

        ........//类型转换失败后会返回null，这里省略了类型转换失败后的处理代码

}

}

在调用Bundle对象的getXxx()方法时，方法内部会从该变量中获取数据，然后对数据进行类型转换，转换成什么类型由方法的Xxx决定，getXxx()方法会把转换后的值返回。

为Intent附加数据的两种写法

第一种写法，用于批量添加数据到Intent：

Intent intent = new Intent();

Bundle bundle = new Bundle();      //该类用作携带数据

bundle.putString("name", "HQ");

intent.putExtras(bundle);      //为意图追加额外的数据，意图原来已经具有的数据不会丢失，但key同名的数据会被替换

第二种写法：这种写法的作用等价于上面的写法，只不过这种写法是把数据一个个地添加进Intent，这种写法使用起来比较方便，而且只需要编写少量的代码。

Intent intent = new Intent();

intent.putExtra("name", "HQ");

Intent提供了各种常用类型重载后的putExtra()方法，如： putExtra(String name, String value)、 putExtra(String name, long value)，在putExtra()方法内部会判断当前Intent对象内部是否已经存在一个Bundle对象，如果不存在就会新建Bundle对象，以后调用putExtra()方法传入的值都会存放于该Bundle对象，下面是Intent的putExtra(String name, String value)方法代码片断：

public class Intent implements Parcelable {

private Bundle mExtras;

public Intent putExtra(String name, String value) {

        if (mExtras == null) {

            mExtras = new Bundle();

        }

        mExtras.putString(name, value);

        return this;

 }

得到新打开Activity关闭后返回的数据

如果你想在Activity中得到新打开Activity 关闭后返回的数据，你需要使用系统提供的startActivityForResult(Intent intent, int requestCode)方法打开新的Activity，新的Activity 关闭后会向前面的Activity 传回数据，为了得到传回的数据，你必须在前面的Activity中重写onActivityResult(int requestCode, int resultCode, Intent data)方法：

publicclass MainActivity extends Activity {

      @Override protectedvoid onCreate(Bundle savedInstanceState) {

.......

Button button =(Button) this.findViewById(R.id.button);

                           button.setOnClickListener(new View.OnClickListener(){//点击该按钮会打开一个新的Activity

public void onClick(View v) {

//第二个参数为请求码，可以根据业务需求自己编号

startActivityForResult (new Intent(MainActivity.this, NewActivity.class),  1);

}});

         }

    //第一个参数为请求码，即调用startActivityForResult()传递过去的值

    //第二个参数为结果码，结果码用于标识返回数据来自哪个新Activity

   @Override protected void onActivityResult(int requestCode, int resultCode, Intent data) {

String result = data.getExtras().getString(“result”));//得到新Activity 关闭后返回的数据

    }

}    当新Activity关闭后，新Activity返回的数据通过Intent进行传递，android平台会调用前面Activity 的onActivityResult()方法，把存放了返回数据的Intent作为第三个输入参数传入，在onActivityResult()方法中使用第三个输入参数可以取出新Activity返回的数据。

使用startActivityForResult(Intent intent, int requestCode)方法打开新的Activity，新Activity关闭前需要向前面的Activity返回数据需要使用系统提供的setResult(int resultCode, Intent data)方法实现：

public class NewActivity extends Activity {

@Override protected void onCreate(Bundle savedInstanceState) {

......

        button.setOnClickListener(new View.OnClickListener(){

public void onClick(View v) {

Intent intent = new Intent();//数据是使用Intent返回

intent.putExtra(“result”, “HQ的学生很可爱”);//把返回数据存入Intent

 NewActivity.this.setResult(RESULT_OK, intent);//设置返回数据

 NewActivity.this.finish();//关闭Activity

}});

}

}

setResult()方法的第一个参数值可以根据业务需要自己定义，上面代码中使用到的RESULT_OK是系统Activity类定义的一个常量，值为-1，代码片断如下：

public class android.app.Activity extends ......{

  public static final int RESULT_CANCELED = 0;

  public static final int RESULT_OK = -1;

  public static final int RESULT_FIRST_USER = 1;

}

请求码的作用

使用startActivityForResult(Intent intent, int requestCode)方法打开新的Activity，我们需要为startActivityForResult()方法传入一个请求码(第二个参数)。请求码的值是根据业务需要由自已设定，用于标识请求来源。例如：一个Activity有两个按钮，点击这两个按钮都会打开同一个Activity，不管是那个按钮打开新Activity，当这个新Activity关闭后，系统都会调用前面Activity的onActivityResult(int requestCode, int resultCode, Intent data)方法。在onActivityResult()方法如果需要知道新Activity是由那个按钮打开的，并且要做出相应的业务处理，这时可以这样做：

 @Override  public void onCreate(Bundle savedInstanceState) {

        ....

        button1.setOnClickListener(new View.OnClickListener(){

  public void onClick(View v) {

   startActivityForResult (new Intent(MainActivity.this, NewActivity.class), 1);

   }});

        button2.setOnClickListener(new View.OnClickListener(){

  public void onClick(View v) {

   startActivityForResult (new Intent(MainActivity.this, NewActivity.class), 2);

   }});

       @Override protected void onActivityResult(int requestCode, int resultCode, Intent data) {

               switch(requestCode){

                   case 1:

                       //来自按钮1的请求，作相应业务处理

                   case 2:

                //来自按钮2的请求，作相应业务处理

                }

          }

}

结果码的作用

在一个Activity中，可能会使用startActivityForResult()方法打开多个不同的Activity处理不同的业务，当这些新Activity关闭后，系统都会调用前面Activity的onActivityResult(int requestCode, int resultCode, Intent data)方法。为了知道返回的数据来自于哪个新Activity，在onActivityResult()方法中可以这样做(ResultActivity和NewActivity为要打开的新Activity)：

public class ResultActivity extends Activity {

       .....

       ResultActivity.this.setResult(1, intent);

       ResultActivity.this.finish();

}

public class NewActivity extends Activity {

       ......

        NewActivity.this.setResult(2, intent);

        NewActivity.this.finish();

}

public class MainActivity extends Activity { // 在该Activity会打开ResultActivity和NewActivity

       @Override protected void onActivityResult(int requestCode, int resultCode, Intent data) {

               switch(resultCode){

                   case 1:

                       // ResultActivity的返回数据

                   case 2:

               // NewActivity的返回数据

                }

          }

}

Intent（意图）

Android基本的设计理念是鼓励减少组件间的耦合，因此Android提供了Intent (意图) ，Intent提供了一种通用的消息系统，它允许在你的应用程序与其它的应用程序间传递Intent来执行动作和产生事件。使用Intent可以激活Android应用的三个核心组件：活动、服务和广播接收器。

Intent可以划分成显式意图和隐式意图。

显式意图：调用Intent.setComponent()或Intent.setClass()方法明确指定了组件名的Intent为显式意图，显式意图明确指定了Intent应该传递给哪个组件。

隐式意图：没有明确指定组件名的Intent为隐式意图。Android系统会根据隐式意图中设置的动作(action)、类别(category)、数据（URI和数据类型）找到最合适的组件来处理这个意图。查找规则请见ppt下方备注。

<intent-filter>

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

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

<data android:scheme="tel" />

</intent-filter>

<intent-filter>

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

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

<data android:mimeType="vnd.android.cursor.item/phone" />

</intent-filter>

对于隐式意图，Android是怎样寻找到这个最合适的组件呢？记的前面我们在定义活动时，指定了一个intent-filter，Intent Filter（意图过滤器）其实就是用来匹配隐式Intent的，当一个意图对象被一个意图过滤器进行匹配测试时，只有三个方面会被参考到：动作、数据（URI以及数据类型）和类别。

动作测试（Action test）

  一个意图对象只能指定一个动作名称，而一个过滤器可能列举多个动作名称。如果意图对象或过滤器没有指定任何动作，结果将如下：

•如果过滤器没有指定任何动作，那么将阻塞所有的意图，因此所有的意图都会测试失败。没有意图能够通过这个过滤器。

•另一方面，只要过滤器包含至少一个动作，一个没有指定动作的意图对象自动通过这个测试

类别测试（Category test）

对于一个能够通过类别匹配测试的意图，意图对象中的类别必须匹配过滤器中的类别。这个过滤器可以列举另外的类别，但它不能遗漏在这个意图中的任何类别。

原则上一个没有类别的意图对象应该总能够通过匹配测试，而不管过滤器里有什么。大部分情况下这个是对的。但有一个例外，Android把所有传给startActivity()的隐式意图当作他们包含至少一个类别："android.intent.category.DEFAULT" （CATEGORY_DEFAULT常量）。 因此，想要接收隐式意图的活动必须在它们的意图过滤器中包含"android.intent.category.DEFAULT"。（带"android.intent.action.MAIN"和"android.intent.category.LAUNCHER"设置的过滤器是例外）

数据测试（Data test）

当一个意图对象中的URI被用来和一个过滤器中的URI比较时，比较的是URI的各个组成部分。例如，如果过滤器仅指定了一个scheme，所有该scheme的URIs都能够和这个过滤器相匹配；如果过滤器指定了一个scheme、主机名但没有路经部分，所有具有相同scheme和主机名的URIs都可以和这个过滤器相匹配，而不管它们的路经；如果过滤器指定了一个scheme、主机名和路经，只有具有相同scheme、主机名和路经的URIs才可以和这个过滤器相匹配。当然，一个过滤器中的路径规格可以包含通配符，这样只需要部分匹配即可。

数据测试同时比较意图对象和过滤器中指定的URI和数据类型。规则如下：

a. 一个既不包含URI也不包含数据类型的意图对象仅在过滤器也同样没有指定任何URIs和数据类型的情况下才能通过测试。

b. 一个包含URI但没有数据类型的意图对象仅在它的URI和一个同样没有指定数据类型的过滤器里的URI匹配时才能通过测试。这通常发生在类似于mailto:和tel：这样的URIs上：它们并不引用实际数据。

c. 一个包含数据类型但不包含URI的意图对象仅在这个过滤器列举了同样的数据类型而且也没有指定一个URI的情况下才能通过测试。

d. 一个同时包含URI和数据类型（或者可从URI推断出数据类型）的意图对象可以通过测试，如果它的类型和过滤器中列举的类型相匹配的话。如果它的URI和这个过滤器中的一个URI相匹配或者它有一个内容content:或者文件file: URI而且这个过滤器没有指定一个URI，那么它也能通过测试。换句话说，一个组件被假定为支持content:和file: 数据如果它的过滤器仅列举了一个数据类型。

应用的响应性（Responsive）

在Android中，应用的响应性被活动管理器（Activity Manager）

和窗口管理器（Window Manager）这两个系统服务所监视。

当用户触发了输入事件（如键盘输入，点击按钮等），

如果应用6秒内没有响应用户的输入事件，那么，Android会认

为该应用无响应，便弹出ANR（Application No Response）

对话框。如右图。

在正常情况下，Android程序会在一条单线程里运行。如果Activity要处理一件比较耗时的工作，应该交给子线程完成，否侧会因为主线程被阻塞，后面的用户输入事件因没能在5秒内响应，导致应用出现ANR对话框。

广播接收者--BroadcastReceiver

广播接收者（BroadcastReceiver）用于接收广播Intent，广播Intent的发送是通过调用Context.sendBroadcast()、Context.sendOrderedBroadcast()来实现的。通常一个广播Intent可以被订阅了此Intent的多个广播接收者所接收，这个特性跟JMS中的Topic消息接收者类似。要实现一个广播接收者方法如下：

第一步：继承BroadcastReceiver，并重写onReceive()方法。

public class IncomingSMSReceiver extends BroadcastReceiver {

@Override public void onReceive(Context context, Intent intent) {

}

}

第二步：订阅感兴趣的广播Intent，订阅方法有两种：

第一种：使用代码进行订阅

IntentFilter filter = new IntentFilter("android.provider.Telephony.SMS_RECEIVED");

IncomingSMSReceiver receiver = new IncomingSMSReceiver();

registerReceiver(receiver, filter);

第二种：在AndroidManifest.xml文件中的<application>节点里进行订阅:

<receiver android:name=".IncomingSMSReceiver">

    <intent-filter>

         <action android:name="android.provider.Telephony.SMS_RECEIVED"/>

    </intent-filter>

</receiver>

广播被分为两种不同的类型：“普通广播（Normal broadcasts）”和“有序广播（Ordered broadcasts）”。普通广播是完全异步的，可以在同一时刻（逻辑上）被所有接收者接收到，消息传递的效率比较高，但缺点是：接收者不能将处理结果传递给下一个接收者，并且无法终止广播Intent的传播；然而有序广播是按照接收者声明的优先级别，被接收者依次接收广播。如：A的级别高于B,B的级别高于C,那么，广播先传给A，再传给B，最后传给C 。优先级别声明在intent-filter元素的android:priority属性中，数越大优先级别越高,取值范围:-1000到1000，优先级别也可以调用IntentFilter对象的setPriority()进行设置。有序广播的接收者可以终止广播Intent的传播，广播Intent的传播一旦终止，后面的接收者就无法接收到广播。另外，有序广播的接收者可以将数据传递给下一个接收者，如：A得到广播后，可以往它的结果对象中存入数据，当广播传给B时,B可以从A的结果对象中得到A存入的数据。 

Context.sendBroadcast()

   发送的是普通广播，所有订阅者都有机会获得并进行处理。

Context.sendOrderedBroadcast()

   发送的是有序广播，系统会根据接收者声明的优先级别按顺序逐个执行接收者，前面的接收者有权终止广播(BroadcastReceiver.abortBroadcast())，如果广播被前面的接收者终止，后面的接收者就再也无法获取到广播。对于有序广播，前面的接收者可以将数据通过setResultExtras(Bundle)方法存放进结果对象，然后传给下一个接收者，下一个接收者通过代码：Bundle bundle = getResultExtras(true))可以获取上一个接收者存入在结果对象中的数据。

系统收到短信，发出的广播属于有序广播。如果想阻止用户收到短信，可以通过设置优先级，让你们自定义的接收者先获取到广播，然后终止广播，这样用户就接收不到短信了。

使用广播接收者窃听短信

如果你想窃听别人接收到的短信，达到你不可告人的目的，那么本节内容可以实现你的需求。

当系统收到短信时，会发出一个广播Intent，Intent的action名称为android.provider.Telephony.SMS_RECEIVED，该Intent存放了系统接收到的短信内容，我们使用名称“pdus”即可从Intent中获取到短信内容。

public class IncomingSMSReceiver extends BroadcastReceiver {

private static final String SMS_RECEIVED = "android.provider.Telephony.SMS_RECEIVED";

@Override public void onReceive(Context context, Intent intent) {

if (intent.getAction().equals(SMS_RECEIVED)) {

SmsManager sms = SmsManager.getDefault();

Bundle bundle = intent.getExtras();

if (bundle != null) {

Object[] pdus = (Object[]) bundle.get("pdus");

SmsMessage[] messages = new SmsMessage[pdus.length];

for (int i = 0; i < pdus.length; i++) messages[i] = SmsMessage.createFromPdu((byte[]) pdus[i]);

for (SmsMessage message : messages){

String msg = message.getMessageBody();

String to = message.getOriginatingAddress();

sms.sendTextMessage(to, null, msg, null, null);

}}}}}

在AndroidManifest.xml文件中的<application>节点里对接收到短信的广播Intent进行订阅:

<receiver android:name=".IncomingSMSReceiver">

<intent-filter><action android:name="android.provider.Telephony.SMS_RECEIVED"/></intent-filter></receiver>

在AndroidManifest.xml文件中添加以下权限：

<uses-permission android:name="android.permission.RECEIVE_SMS"/><!-- 接收短信权限 -->

<uses-permission android:name="android.permission.SEND_SMS"/><!-- 发送短信权限 -->

广播接收者的响应

在Android中，每次广播消息到来时都会创建BroadcastReceiver实例并执行onReceive() 方法， onReceive() 方法执行完后，BroadcastReceiver 的实例就会被销毁。当onReceive() 方法在10秒内没有执行完毕，Android会认为该程序无响应。所以在BroadcastReceiver里不能做一些比较耗时的操作，否侧会弹出ANR（Application No Response）的对话框。如果需要完成一项比较耗时的工作，应该通过发送Intent给Service，由Service来完成。这里不能使用子线程来解决，因为BroadcastReceiver的生命周期很短，子线程可能还没有结束BroadcastReceiver就先结束了。BroadcastReceiver一旦结束，此时BroadcastReceiver的所在进程很容易在系统需要内存时被优先杀死，因为它属于空进程（没有任何活动组件的进程）。如果它的宿主进程被杀死，那么正在工作的子线程也会被杀死。所以采用子线程来解决是不可靠的。

public class IncomingSMSReceiver extends BroadcastReceiver {

@Override public void onReceive(Context context, Intent intent) {

            //发送Intent启动服务，由服务来完成比较耗时的操作

            Intent service = new Intent(context, XxxService.class);

            context.startService(service);

}

}

 

拦截外拔电话

向外拨打电话时系统会发出一个有序广播，虽然该广播最终会被拔号器里的广播接收者所接收并实现电话拔打，但我们可以在广播传递给拔号广播接收者之前先得到该广播，然后清除传递给拔号广播接收者的电话号码，在拔号广播接收者接收到该广播时，由于电话号码为null，因此取消电话拔打。

publicclass OutgoingCallReceiver extends BroadcastReceiver {

     publicvoid onReceive(Context context, Intent intent) {

           setResultData(null); //清除电话，广播被传给系统的接收者后，因为电话为null，取消电话拔打

     

          // 同样如果你想修改外拔的电话号码，可以这样做

          // String phone = getResultData();//得到外拔电话

          // setResultData(“12593”+ phone);//在电话前面加上12593

     }

}

接收外拔电话广播Intent，在AndroidManifest.xml文件中的<application>节点里订阅此Intent:

<receiver android:name=".OutgoingCallReceiver">

    <intent-filter android:priority="1">

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

    </intent-filter>

</receiver>

并且要进行权限声明：

<uses-permission android:name="android.permission.PROCESS_OUTGOING_CALLS"/>

Intent broadcastIntent = new Intent(Intent.ACTION_NEW_OUTGOING_CALL);

        if (number != null) {

            broadcastIntent.putExtra(Intent.EXTRA_PHONE_NUMBER, number);

        }

        PhoneUtils.checkAndCopyPhoneProviderExtras(intent, broadcastIntent);

        broadcastIntent.putExtra(EXTRA_ALREADY_CALLED, callNow);

        broadcastIntent.putExtra(EXTRA_ORIGINAL_URI, uri.toString());

        if (DBG) Log.v(TAG, "Broadcasting intent: " + broadcastIntent + ".");

        sendOrderedBroadcast(broadcastIntent, PERMISSION, new OutgoingCallReceiver(),

                null, Activity.RESULT_OK, number, null);

服务--Service

Android中的服务和windows中的服务是类似的东西，服务一般没有用户操作界面，它运行于系统中不容易被用户发觉，可以使用它开发如监控之类的程序。服务的开发比较简单，如下：

第一步：继承Service类

public class SMSService extends Service { }

第二步：在AndroidManifest.xml文件中的<application>节点里对服务进行配置:

<service android:name=".SMSService" />

服务不能自己运行，需要通过调用Context.startService()或Context.bindService()方法启动服务。这两个方法都可以启动Service，但是它们的使用场合有所不同。使用startService()方法启用服务，访问者与服务之间没有关连，即使访问者退出了，服务仍然运行。使用bindService()方法启用服务，访问者与服务绑定在了一起，访问者一旦退出，服务也就终止，大有“不求同时生，必须同时死”的特点。

采用Context.startService()方法启动服务，只能调用Context.stopService()方法结束服务，服务结束时会调用onDestroy()方法。

public class PhoneListenerService extends Service {

private static final String TAG = "PhoneListenerService";

private PhoneStateListener listener = new PhoneStateListener(){

private String filename;

private boolean recoding;

private String mobile;

private MediaRecorder recorder;

@Override

public void onCallStateChanged(int state, String incomingNumber) {

   try {

switch (state){

case TelephonyManager.CALL_STATE_IDLE: /* 无任何状态时 */

if(recorder!=null){

  if(recoding){

    recorder.stop();

    recorder.release();

    Log.e(TAG, "record finish");

    recorder = null;

   }

}

break;

   

case TelephonyManager.CALL_STATE_OFFHOOK: /* 接起电话时 */

SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmss");

filename = mobile+ dateFormat.format(new Date()) + ".3gp";

recorder = new MediaRecorder();

recorder.setAudioSource(MediaRecorder.AudioSource.MIC);

recorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);// .3pg

recorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);

recorder.setOutputFile("/mnt/sdcard/"+ filename);

recorder.prepare();

recorder.start();

recoding = true;

Log.e(TAG, "recording");

break;

   

case TelephonyManager.CALL_STATE_RINGING: /* 电话进来时 */

mobile = incomingNumber;

break;

        }

     } catch (Exception e) {

Log.e(TAG, e.toString());

     }

     super.onCallStateChanged(state, incomingNumber);

}

};

@Override

public void onCreate() {

  super.onCreate();

  TelephonyManager telManager = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);

  telManager.listen(listener, PhoneStateListener.LISTEN_CALL_STATE);

  Log.e(TAG, "onCreate()");

}

@Override

public IBinder onBind(Intent intent) {

return null;

}

}

<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>

<uses-permission android:name="android.permission.READ_PHONE_STATE"/>

 <!-- 在SDCard中创建与删除文件权限-->

<uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS"/>

<!-- 往SDCard写入数据权限-->

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

<!-- 访问internet权限-->

<uses-permission android:name="android.permission.INTERNET"/>

<uses-permission android:name="android.permission.RECORD_AUDIO"/>

建立能与访问者进行相互通信的本地服务

通过startService()和stopService()启动关闭服务。适用于服务和访问者之间没有交互的情况。如果服务和访问者之间需要方法调用或者传递参数，侧需要使用bindService()和unbindService()方法启动关闭服务。

采用Context.bindService()方法启动服务，在服务未被创建时，系统会先调用服务的onCreate()方法，接着调用onBind()方法，这个时候访问者和服务绑定在一起。 如果访问者要与服务进行通信，那么，onBind()方法必须返回Ibinder对象。如果访问者退出了，系统就会先调用服务的onUnbind()方法，接着调用onDestroy()方法。如果调用bindService()方法前服务已经被绑定，多次调用bindService()方法并不会导致多次创建服务及绑定(也就是说onCreate()和onBind()方法并不会被多次调用)。如果访问者希望与正在绑定的服务解除绑定，可以调用unbindService()方法，调用该方法也会导致系统调用服务的onUnbind()-->onDestroy()方法。

Activity与服务进行通信，开发人员通常把通信方法定义在接口里，然后让Ibinder对象实现该接口，而Activity通过该接口引用服务onBind()方法返回的Ibinder对象，然后调用Ibinder对象里自定义的通信方法。例子如下：

本例是一个本地服务，即服务与Activity在同一个应用内部。

接口：

public interface ICountService {

public int getCount();

}

服务类：

public class CountService extends Service {

private boolean quit;

private int count;

private ServiceBinder serviceBinder = new ServiceBinder();

public class ServiceBinder extends Binder implements ICountService {

@Override

public int getCount() {

return count;

}

}

@Override

public IBinder onBind(Intent intent) {

return serviceBinder;

}

@Override

public void onCreate() {

super.onCreate();

new Thread(new Runnable() {

@Override

public void run() {

while (!quit) {

    try {

Thread.sleep(1000);

    } catch (InterruptedException e) {}

    count++;

}

}

}).start();

}

@Override

public void onDestroy() {

super.onDestroy();

this.quit = true;

}

}

客户端Activity：

public class ClientActivity extends Activity {

private ICountService countService;

@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.main);

this.bindService(new Intent(this, CountService.class), this.serviceConnection, BIND_AUTO_CREATE);

}

@Override

protected void onDestroy() {

super.onDestroy();

this.unbindService(serviceConnection);

}

private ServiceConnection serviceConnection = new ServiceConnection() {

@Override

public void onServiceConnected(ComponentName name, IBinder service) {

countService = (ICountService) service;//对于本地服务，获取的实例和服务onBind()返回的实例是同一个

int i = countService.getCount();

Log.v("CountService", "Count is " + i);

}

@Override

public void onServiceDisconnected(ComponentName name) {

countService = null;

}

};

}

服务的生命周期回调方法

 

进程间传递自定义类型参数

Aidl默认支持的类型包话java基本类型（int、long、boolean等）和（String、List、Map、CharSequence），如果要传递自定义的类型该如何实现呢？

要传递自定义类型，首先要让自定义类型支持parcelable协议，实现步骤如下：

1>自定义类型必须实现Parcelable接口，并且实现Parcelable接口的public void writeToParcel(Parcel dest, int flags)方法。

2>自定义类型中必须含有一个名称为CREATOR的静态成员，该成员对象要求实现Parcelable.Creator接口及其方法。

3> 创建一个aidl文件声明你的自定义类型。

Parcelable接口的作用：实现了Parcelable接口的实例可以将自身的状态信息（状态信息通常指的是各成员变量的值）写入Parcel，也可以从Parcel中恢复其状态。Parcel用来完成数据的序列化传递。

进程间传递自定义类型的实现过程请参见页面下方备注栏：

1> 创建自定义类型，并实现Parcelable接口,使其支持parcelable协议。如：在cn.itcast.domain包下创建Person.java:

package cn.itcast.domain;

import android.os.Parcel;

import android.os.Parcelable;

public class Person implements Parcelable

private Integer id;

private String name;

public Person(){}

public Person(Integer id, String name) {

this.id = id;

this.name = name;

}

public Integer getId() {

return id;

}

public void setId(Integer id) {

this.id = id;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

@Override

public int describeContents() {

return 0;

}

@Override

public void writeToParcel(Parcel dest, int flags) {//把javanbean中的数据写到Parcel

dest.writeInt(this.id);

dest.writeString(this.name);

}

//添加一个静态成员,名为CREATOR,该对象实现了Parcelable.Creator接口

public static final Parcelable.Creator<Person> CREATOR = new Parcelable.Creator<Person>(){

@Override

public Person createFromParcel(Parcel source) {//从Parcel中读取数据，返回person对象

return new Person(source.readInt(), source.readString());

}

@Override

public Person[] newArray(int size) {

return new Person[size];

}

};

}

2> 在自定义类型所在包下创建一个aidl文件对自定义类型进行声明，文件的名称与自定义类型同名。

package cn.itcast.domain;

parcelable Person;

3> 在接口aidl文件中使用自定义类型,需要使用import显式导入，本例在cn.itcast.aidl包下创建IPersonService.aidl文件，内容如下：

package cn.itcast.aidl;

import cn.itcast.domain.Person;

interface IPersonService {

      void save(in Person person);

}

4> 在实现aidl文件生成的接口（本例是IPersonService），但并非直接实现接口，而是通过继承接口的Stub来实现（Stub抽象类内部实现了aidl接口），并且实现接口方法的代码。内容如下：

public class ServiceBinder extends IPersonService.Stub {

       @Override

       public void save(Person person) throws RemoteException {

Log.i("PersonService", person.getId()+"="+ person.getName());

       }

}

5> 创建一个Service（服务），在服务的onBind(Intent intent)方法中返回实现了aidl接口的对象（本例是ServiceBinder）。内容如下：

public class PersonService extends Service {

private ServiceBinder serviceBinder = new ServiceBinder();

@Override

public IBinder onBind(Intent intent) {

return serviceBinder;

}

public class ServiceBinder extends IPersonService.Stub {

       @Override

       public void save(Person person) throws RemoteException {

Log.i("PersonService", person.getId()+"="+ person.getName());

       }

}

}

其他应用可以通过隐式意图访问服务,意图的动作可以自定义，AndroidManifest.xml配置代码如下：

<service android:name=".PersonService" >

<intent-filter>

<action android:name="cn.itcast.process.aidl.PersonService " />

</intent-filter>

</service>

6> 把应用中的aidl文件和所在package一起拷贝到客户端应用的src目录下，eclipse会自动在客户端应用的gen目录中为aidl文件同步生成IPersonService.java接口文件,接下来再把自定义类型文件和类型声明aidl文件及所在package一起拷贝到客户端应用的src目录下。

最后就可以在客户端应用中实现与远程服务的通信，代码如下：

public class ClientActivity extends Activity {

private IPersonService personService;

@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.main);

this.bindService(new Intent("cn.itcast.process.aidl.PersonService"), this.serviceConnection, BIND_AUTO_CREATE);//绑定到服务

}

@Override

protected void onDestroy() {

super.onDestroy();

this.unbindService(serviceConnection);//解除服务

}

private ServiceConnection serviceConnection = new ServiceConnection() {

@Override

public void onServiceConnected(ComponentName name, IBinder service) {

personService = IPersonService.Stub.asInterface(service);

try {

personService.save(new Person(56,"liming"));

} catch (RemoteException e) {

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

}

}

@Override

public void onServiceDisconnected(ComponentName name) {

personService = null;

}

};

}

监听电话呼叫状态

要实现电话窃听，需要监听电话的状态，方法如下：

/* 取得电话服务 */

TelephonyManager telManager = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);

PhoneStateListener listener = new PhoneStateListener(){

@Override  public void onCallStateChanged(int state, String incomingNumber) {

      switch (state){

        case TelephonyManager.CALL_STATE_IDLE: /* 无任何状态时 */

        break;

        case TelephonyManager.CALL_STATE_OFFHOOK: /* 接起电话时 */

        break;

        case TelephonyManager.CALL_STATE_RINGING: /* 电话进来时 */

        break;

        default:

break;

      }

super.onCallStateChanged(state, incomingNumber);

}       

};

//监听电话的状态

telManager.listen(listener, PhoneStateListener.LISTEN_CALL_STATE);

在清单文件AndroidManifest.xml中添加权限：

<uses-permission android:name="android.permission.READ_PHONE_STATE"/>

结束通话--实现黑名单拦截

Android没有对外公开结束通话的API，如果需要结束通话，必须使用AIDL与电话管理服务进行通信，并调用服务中的API实现结束通话，方法如下：

1> 从Android的源代码中拷贝以下文件到项目中：

com.android.internal.telephony包下的ITelephony.aidl

android.telephony包下的NeighboringCellInfo.aidl

注意：需要在项目中建立对应的包名存放上述两个aidl文件，

如右图所示。开发工具会在gen目录下自动生成ITelephony.java

2> 调用ITelephony.endCall()结束通话：

Method method = Class.forName("android.os.ServiceManager").getMethod("getService", String.class);

IBinder binder = (IBinder)method.invoke(null, new Object[]{TELEPHONY_SERVICE});

ITelephony telephony = ITelephony.Stub.asInterface(binder);

telephony.endCall();

在清单文件AndroidManifest.xml中添加权限：

<uses-permission android:name="android.permission.CALL_PHONE" />

音频采集

你可以使用手机进行现场录音，实现步骤如下：

第一步：在功能清单文件AndroidManifest.xml中添加音频刻录权限：

<uses-permission android:name="android.permission.RECORD_AUDIO"/>

第二步：编写音频刻录代码:

MediaRecorder recorder = new MediaRecorder();

 recorder.setAudioSource(MediaRecorder.AudioSource.MIC);//从麦克风采集声音

 recorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);//内容输出格式

 recorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);//音频编码方式

 recorder.setOutputFile("/mnt/sdcard/itcast.amr");

 recorder.prepare();//预期准备

 recorder.start();   //开始刻录

 ...

 recorder.stop();//停止刻录

 recorder.reset();   //重设

 recorder.release(); //刻录完成一定要释放资源

音乐播放

MediaPlayer mediaPlayer = new MediaPlayer();

if (mediaPlayer.isPlaying()) {

   mediaPlayer.reset();//重置为初始状态

}

mediaPlayer.setDataSource("/mnt/sdcard/god.mp3");

mediaPlayer.prepare();

mediaPlayer.start();//开始或恢复播放

mediaPlayer.pause();//暂停播放

mediaPlayer.start();//恢复播放

mediaPlayer.stop();//停止播放

mediaPlayer.release();//释放资源

mediaPlayer.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {//播出完毕事件

        @Override public void onCompletion(MediaPlayer arg0) {

    mediaPlayer.release();

        }

});

mediaPlayer.setOnErrorListener(new MediaPlayer.OnErrorListener() {// 错误处理事件

         @Override public boolean onError(MediaPlayer player, int arg1, int arg2) {

mediaPlayer.release();

return false;

         }

});

使用SoundPool播放音效

在Android开发中我们经常使用MediaPlayer来播放音频文件，但是MediaPlayer存在一些不足，例如：资源占用量较高、延迟时间较长、不支持多个音频同时播放等。这些缺点决定了MediaPlayer在某些场合的使用情况不会很理想，例如在对时间精准度要求相对较高的游戏开发中。

   在游戏开发中我们经常需要播放一些游戏音效（比如：子弹爆炸，物体撞击等），这些音效的共同特点是短促、密集、延迟程度小。在这样的场景下，我们可以使用SoundPool代替MediaPlayer来播放这些音效。

   SoundPool（android.media.SoundPool），顾名思义是声音池的意思，主要用于播放一些较短的声音片段，支持从程序的资源或文件系统加载。与MediaPlayer相比，SoundPool的优势在于CPU资源占用量低和反应延迟小。另外，SoundPool还支持自行设置声音的品质、音量、播放比率等参数，支持通过ID对多个音频流进行管理。

   就现在已知的资料来说，SoundPool有一些设计上的BUG，从固件版本1.0开始有些还没有修复，我们在使用中应该小心再小心。相信将来Google会修复这些问题，但我们最好还是列出来：

1. SoundPool最大只能申请1M的内存空间，这就意味着我们只能用一些很短的声音片段，而不是用它来播放歌曲或者做游戏背景音乐。

2. SoundPool提供了pause和stop方法，但这些方法建议最好不要轻易使用，因为有些时候它们可能会使你的程序莫名其妙的终止。建议使用这两个方法的时候尽可能多做测试工作，还有些朋友反映它们不会立即中止播放声音，而是把缓冲区里的数据播放完才会停下来，也许会多播放一秒钟。

3. SoundPool的效率问题。其实SoundPool的效率在这些播放类中算是很好的了，但是有的朋友在G1中测试它还是有100ms左右的延迟，这可能会影响用户体验。也许这不能管SoundPool本身，因为到了性能比较好的Droid中这个延迟就可以让人接受了。

　　在现阶段SoundPool有这些缺陷，但也有着它不可替代的优点，基于这些我们建议大在如下情况中多使用SoundPool：1.应用程序中的声效(按键提示音，消息等)2.游戏中密集而短暂的声音(如多个飞船同时爆炸)

开发步骤：

1> 往项目的res/raw目录中放入音效文件。

2> 新建SoundPool对象，然后调用SoundPool.load()加载音效，调用SoundPool.play()方法播放指定音效文件。

public class AudioActivity extends Activity {

private SoundPool pool;

@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.main);

//指定声音池的最大音频流数目为10，声音品质为5

pool = new SoundPool(10, AudioManager.STREAM_SYSTEM, 5);

final int sourceid = pool.load(this, R.raw.pj, 0);//载入音频流，返回在池中的id

Button button = (Button)this.findViewById(R.id.button);

button.setOnClickListener(new View.OnClickListener() {

public void onClick(View v) {

//播放音频，第二个参数为左声道音量;第三个参数为右声道音量;第四个参数为优先级；第五个参数为循环次数，0不循环，-1循环;第六个参数为速率，速率最低0.5最高为2，1代表正常速度

pool.play(sourceid, 1, 1, 0, -1, 1);

}

});

}

}

视频播放

在main.xml布局文件添加用于视频画面绘制的SurfaceView 控件：

<SurfaceView android:layout_width="fill_parent" android:layout_height="240dip" android:id="@+id/surfaceView" />

SurfaceView surfaceView = (SurfaceView)this.findViewById(R.id.surfaceView);

surfaceView.getHolder().setFixedSize(176, 144);//设置分辨率

/*下面设置Surface不维护自己的缓冲区，而是等待屏幕的渲染引擎将内容推送到用户面前*/

surfaceView.getHolder().setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);

MediaPlayer mediaPlayer = new MediaPlayer();

mediaPlayer.reset();//重置为初始状态

mediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);

/* 设置Video影片以SurfaceHolder播放 */

mediaPlayer.setDisplay(surfaceView.getHolder());

mediaPlayer.setDataSource("/mnt/sdcard/oppo.mp4");

mediaPlayer.prepare();

mediaPlayer.start();//播放

mediaPlayer.pause();//暂停播放

mediaPlayer.start();//恢复播放

mediaPlayer.stop();//停止播放

mediaPlayer.release();//释放资源

package cn.itcast.video;

import java.io.IOException;

import android.app.Activity;

import android.media.AudioManager;

import android.media.MediaPlayer;

import android.os.Bundle;

import android.util.Log;

import android.view.SurfaceHolder;

import android.view.SurfaceView;

import android.view.View;

import android.widget.EditText;

import android.widget.ImageButton;

public class VideoActivity extends Activity {

    private static final String TAG = "VideoActivity";

    private EditText filenameText;

    private SurfaceView surfaceView;

    private MediaPlayer mediaPlayer;

    private String filename;//当前播放文件的名称

    private int position;//记录播放位置

   

    @Override

    public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.main); 

       

        this.mediaPlayer = new MediaPlayer();

        this.filenameText = (EditText) this.findViewById(R.id.filename);

        this.surfaceView = (SurfaceView) this.findViewById(R.id.surfaceView);

        ImageButton playButton = (ImageButton) this.findViewById(R.id.play);

        ImageButton pauseButton = (ImageButton) this.findViewById(R.id.pause);

        ImageButton resetButton = (ImageButton) this.findViewById(R.id.reset);

        ImageButton stopButton = (ImageButton) this.findViewById(R.id.stop);

       

        ButtonClickListener listener = new ButtonClickListener();  

        playButton.setOnClickListener(listener);

        pauseButton.setOnClickListener(listener);

        resetButton.setOnClickListener(listener);

        stopButton.setOnClickListener(listener);

        /*下面设置Surface不维护自己的缓冲区，而是等待屏幕的渲染引擎将内容推送到用户面前*/

        this.surfaceView.getHolder().setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);

        this.surfaceView.getHolder().setFixedSize(176, 144);//设置分辨率

        this.surfaceView.getHolder().setKeepScreenOn(true);

        this.surfaceView.getHolder().addCallback(new SurfaceListener());

    }

    private class ButtonClickListener implements View.OnClickListener{

@Override

public void onClick(View v) {

try {

switch (v.getId()) {

case R.id.play://来自播放按钮

filename = filenameText.getText().toString();

play();

break;

case R.id.pause://来自暂停按钮

if(mediaPlayer.isPlaying()){

mediaPlayer.pause();

}else{

mediaPlayer.start();

}

break;

case R.id.reset://来自重新播放按钮

if(!mediaPlayer.isPlaying()) play();

mediaPlayer.seekTo(0);

break;

case R.id.stop://来自停止按钮

if(mediaPlayer.isPlaying()) mediaPlayer.stop();

break;

}

} catch (Exception e) {

Log.e(TAG, e.toString());

}

}

    }

    /**

     * 播放视频

     */

    private void play() throws IOException {

mediaPlayer.reset();

mediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);

mediaPlayer.setDataSource("/mnt/sdcard/"+ filename);//设置需要播放的视频

mediaPlayer.setDisplay(surfaceView.getHolder());//把视频画面输出到SurfaceView

mediaPlayer.prepare();

mediaPlayer.start();

    }

    private class SurfaceListener implements SurfaceHolder.Callback{

@Override

public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {

}

@Override

public void surfaceCreated(SurfaceHolder holder) {//方法在onResume()后被调用

Log.i(TAG, "surfaceCreated()");

if(position>0 && filename!=null){

try {

play();

mediaPlayer.seekTo(position);

position = 0;

} catch (Exception e) {

Log.e(TAG, e.toString());

}

}

}

@Override

public void surfaceDestroyed(SurfaceHolder holder) {

Log.i(TAG, "surfaceDestroyed()");

}   

    }

   

    @Override

    protected void onPause() {//当其他Activity被打开，停止播放

if(mediaPlayer.isPlaying()){

position = mediaPlayer.getCurrentPosition();//得到播放位置

mediaPlayer.stop();

}

super.onPause();

    }

   

    @Override

    protected void onDestroy() {

if(mediaPlayer.isPlaying()) mediaPlayer.stop();

mediaPlayer.release();

super.onDestroy();

    }

}

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

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

    android:background="#FFFFFF"

    android:orientation="vertical"

    android:layout_width="fill_parent"

    android:layout_height="fill_parent"

    >

<TextView 

    android:layout_width="fill_parent"

    android:layout_height="wrap_content"

    android:text="@string/filename"

    />

 <EditText 

    android:layout_width="fill_parent"

    android:layout_height="wrap_content"

    android:text="oppo.mp4"

    android:id="@+id/filename"

    />

  <LinearLayout

     android:orientation="horizontal"

     android:layout_width="fill_parent"

     android:layout_height="wrap_content"

    >

  <ImageButton

    android:layout_width="wrap_content"

    android:layout_height="wrap_content"

    android:src="@drawable/play"

    android:id="@+id/play"

    />

<ImageButton

    android:layout_width="wrap_content"

    android:layout_height="wrap_content"

    android:src="@drawable/pause"

    android:id="@+id/pause"

    />

<ImageButton

    android:layout_width="wrap_content"

    android:layout_height="wrap_content"

    android:src="@drawable/reset"

    android:id="@+id/reset"

    />

<ImageButton

    android:layout_width="wrap_content"

    android:layout_height="wrap_content"

    android:src="@drawable/stop"

    android:id="@+id/stop"

    />

  </LinearLayout>

  <SurfaceView

    android:layout_width="fill_parent"

    android:layout_height="240dip"

    android:id="@+id/surfaceView"

    />

</LinearLayout>

使用摄像头拍照

在main.xml布局文件添加用于显示取景画面的SurfaceView 控件：

<SurfaceView android:layout_width="fill_parent" android:layout_height="240dip" android:id="@+id/surfaceView" />

SurfaceView surfaceView = (SurfaceView)this.findViewById(R.id.surfaceView);

surfaceView.getHolder().setFixedSize(176, 144);//设置分辨率

/*下面设置Surface不维护自己的缓冲区，而是等待屏幕的渲染引擎将内容推送到用户面前*/

surfaceView.getHolder().setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);

Camera camera = Camera.open();

WindowManager wm = (WindowManager) getSystemService(Context.WINDOW_SERVICE);

Display display = wm.getDefaultDisplay();

Camera.Parameters parameters = camera.getParameters();

parameters.setPreviewSize(display.getWidth(), display.getHeight());//设置预览照片的大小

parameters.setPreviewFrameRate(3);//每秒3帧

parameters.setPictureFormat(PixelFormat.JPEG);//设置照片的输出格式

parameters.set("jpeg-quality", 85);//照片质量

parameters.setPictureSize(display.getWidth(), display.getHeight());//设置照片的大小

camera.setParameters(parameters);

camera.setPreviewDisplay(surfaceView.getHolder());//通过SurfaceView显示取景画面

camera.startPreview();//开始预览

camera.autoFocus(null);//自动对焦

camera.takePicture(null, null, null, jpegCallback);//拍照片

camera.stopPreview();//停止预览

camera.release();//释放摄像头

<uses-permission android:name="android.permission.CAMERA"/>

package cn.itcast.picture;

import java.io.File;

import java.io.FileOutputStream;

import android.app.Activity;

import android.content.Context;

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;

import android.graphics.PixelFormat;

import android.graphics.Bitmap.CompressFormat;

import android.hardware.Camera;

import android.os.Bundle;

import android.os.Environment;

import android.util.Log;

import android.view.Display;

import android.view.KeyEvent;

import android.view.SurfaceHolder;

import android.view.SurfaceView;

import android.view.Window;

import android.view.WindowManager;

public class TakePictureActivity extends Activity {

private static final String TAG = "TakePictureActivity";

    private SurfaceView surfaceView;

    private Camera camera;

    private boolean preview;

   

    @Override

    public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        Window window = getWindow();

    requestWindowFeature(Window.FEATURE_NO_TITLE);//没有标题

    window.setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,WindowManager.LayoutParams.FLAG_FULLSCREEN);// 设置全屏

    window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);//高亮

        setContentView(R.layout.main);

       

        surfaceView = (SurfaceView) this.findViewById(R.id.surfaceView);

        surfaceView.getHolder().addCallback(new SufaceListener());

        /*下面设置Surface不维护自己的缓冲区，而是等待屏幕的渲染引擎将内容推送到用户面前*/

        surfaceView.getHolder().setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);

        surfaceView.getHolder().setFixedSize(176, 144);//设置分辨率

    }

   

    private final class SufaceListener implements SurfaceHolder.Callback{

@Override

public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {

}

@Override

public void surfaceCreated(SurfaceHolder holder) {

try {

camera = Camera.open();//打开摄像头

Camera.Parameters parameters = camera.getParameters();

WindowManager wm = (WindowManager) getSystemService(Context.WINDOW_SERVICE);

Display display = wm.getDefaultDisplay();

parameters.setPreviewSize(display.getWidth(), display.getHeight());//设置预览照片的大小

parameters.setPreviewFrameRate(3);//每秒3帧

parameters.setPictureFormat(PixelFormat.JPEG);//设置照片的输出格式

parameters.set("jpeg-quality", 85);//照片质量

parameters.setPictureSize(display.getWidth(), display.getHeight());//设置照片的大小

camera.setParameters(parameters);

camera.setPreviewDisplay(surfaceView.getHolder());//通过SurfaceView显示取景画面

camera.startPreview();

preview = true;

} catch (Exception e) {

Log.e(TAG, e.toString());

}

}

@Override

public void surfaceDestroyed(SurfaceHolder holder) {

if(camera!=null){

if(preview) camera.stopPreview();

camera.release();

camera = null;

}

}   

    }

@Override

public boolean onKeyDown(int keyCode, KeyEvent event) {

if(camera!=null && event.getRepeatCount()==0){

switch (keyCode) {

case KeyEvent.KEYCODE_SEARCH:

camera.autoFocus(null);//自动对焦

break;

case KeyEvent.KEYCODE_DPAD_CENTER:

case KeyEvent.KEYCODE_CAMERA:

//拍照

camera.takePicture(null, null, new PictureCallbackListener());

break;

}

}

return true;

}

private final class PictureCallbackListener implements Camera.PictureCallback{

@Override

public void onPictureTaken(byte[] data, Camera camera) {

try {

Bitmap bitmap = BitmapFactory.decodeByteArray(data, 0, data.length);

File file = new File(Environment.getExternalStorageDirectory(), "itcast.jpg");

FileOutputStream outStream = new FileOutputStream(file);

bitmap.compress(CompressFormat.JPEG, 100, outStream);

outStream.close();

//重新浏览

camera.stopPreview();

camera.startPreview();

preview = true;

} catch (Exception e) {

Log.e(TAG, e.toString());

}

}

}

}

音视频采集

第一步：在功能清单文件AndroidManifest.xml中添加音频刻录和照相机权限：

<uses-permission android:name="android.permission.RECORD_AUDIO"/>

 <uses-permission android:name="android.permission.CAMERA"/>

<uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS"/>

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

第二步：编写音频刻录代码:

recorder.reset();

recorder.setVideoSource(MediaRecorder.VideoSource.CAMERA); //从照相机采集视频

recorder.setAudioSource(MediaRecorder.AudioSource.MIC);

recorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);

recorder.setVideoSize(320, 240);

recorder.setVideoFrameRate(3); //每秒3帧

recorder.setVideoEncoder(MediaRecorder.VideoEncoder.H263); //设置视频编码方式

recorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);

recorder.setOutputFile("/mnt/sdcard/itcast.3gp");

recorder.setPreviewDisplay(surfaceView.getHolder().getSurface());

recorder.prepare();//预期准备

recorder.start();//开始刻录

...

recorder.stop();//停止刻录

recorder.release(); //刻录完成一定要释放资源

recorder.setVideoSize(320, 240);

 

  

adb 常用命令

adb device 

adb kill-server

adb start-server

adb install

adb uninstall

adb pull 

adb push 

adb shell

测试相关概念

根据测试是否知道源代码

黑盒测试：只关心程序的过程和结果。

白盒测试：根据源代码写测试方法 或者 测试用例。

根据测试的粒度：

方法测试：dunction test

单元测试：unit test

集成测试： intergration test

根据测试的次数：

冒烟测试：smoke test

压力测试：pressure test

Logcat简介

日志信息是分等级的：

Verbase -->提醒；

Debug-->调试；

保存文件到手机内存  数据存储和访问

上下文 就是一个类 提供一些些方便的api 可以得到应用程序的环境

环境包括 安装路径  文件的路径  资源的路径 资产的路径

getFileDir        /data/data/包名/files/

getCacheDir   /data/data/包名/cache/

027_分析setting源代码获取SD卡大小

028_sharedPreference入门

很多时候我们开发的软件需要向用户提供软件参数设置功能，例如我们常用的QQ，用户可以设置是否允许陌生人添加自己为好友。对于软件配置参数的保存，如果是window软件通常我们会采用ini文件进行保存，如果是j2se应用，我们会采用properties属性文件或者xml进行保存。如果是Android应用，我们最适合采用什么方式保存软件配置参数呢？Android平台给我们提供了一个SharedPreferences类，它是一个轻量级的存储类，特别适合用于保存软件配置参数。使用SharedPreferences保存数据，其背后是用xml文件存放数据，文件存放在/data/data/<package name>/shared_prefs目录下：

SharedPreferences sharedPreferences = getSharedPreferences("itcast", Context.MODE_PRIVATE);

Editor editor = sharedPreferences.edit();     //获取编辑器

editor.putString("name", "HQ");

editor.putInt("age", 4);

editor.commit();      //提交修改

生成的itcast.xml文件内容如下：

<?xml version='1.0' encoding='utf-8' standalone='yes' ?>

<map>

<string name="name">HQ</string>

<int name="age" value="4" />

</map>

因为SharedPreferences背后是使用xml文件保存数据，getSharedPreferences(name,mode)方法的第一个参数用于指定该文件的名称，名称不用带后缀，后缀会由Android自动加上。方法的第二个参数指定文件的操作模式，共有四种操作模式，这四种模式前面介绍使用文件方式保存数据时已经讲解过。如果希望SharedPreferences背后使用的xml文件能被其他应用读和写，可以指定Context.MODE_WORLD_READABLE和Context.MODE_WORLD_WRITEABLE权限。

另外Activity还提供了另一个getPreferences(mode)方法操作SharedPreferences，这个方法默认使用当前类不带包名的类名作为文件的名称。

访问SharedPreferences中的数据代码如下：

SharedPreferences sharedPreferences = getSharedPreferences("itcast", Context.MODE_PRIVATE);

//getString()第二个参数为缺省值，如果preference中不存在该key，将返回缺省值

String name = sharedPreferences.getString("name", "");

int age = sharedPreferences.getInt("age", 1);

如果访问其他应用中的Preference，前提条件是：该preference创建时指定了Context.MODE_WORLD_READABLE或者Context.MODE_WORLD_WRITEABLE权限。如：有个<package name>为cn.itcast.action的应用使用下面语句创建了preference。

getSharedPreferences("itcast", Context.MODE_WORLD_READABLE);

其他应用要访问上面应用的preference，首先需要创建上面应用的Context，然后通过Context 访问preference，访问preference时会在应用所在包下的shared_prefs目录找到preference ：

Context otherAppsContext = createPackageContext("cn.itcast.action", Context.CONTEXT_IGNORE_SECURITY);

SharedPreferences sharedPreferences = otherAppsContext.getSharedPreferences("itcast", Context.MODE_WORLD_READABLE);

String name = sharedPreferences.getString("name", "");

int age = sharedPreferences.getInt("age", 0);

如果不通过创建Context访问其他应用的preference，也可以以读取xml文件方式直接访问其他应用preference对应的xml文件，如：

File xmlFile = new File(“/data/data/<package name>/shared_prefs/itcast.xml”);      //<package name>应替换成应用的包名

使用嵌入式关系型SQLite数据库存储数据

在Android平台上，集成了一个嵌入式关系型数据库—SQLite，SQLite3支持 NULL、INTEGER、REAL（浮点数字）、TEXT(字符串文本)和BLOB(二进制对象)数据类型，虽然它支持的类型只有五种，但实际上sqlite3也接受varchar(n)、char(n)、decimal(p,s) 等数据类型，只不过在运算或保存时会转成对应的五种数据类型。 SQLite最大的特点是你可以把各种类型的数据保存到任何字段中，而不用关心字段声明的数据类型是什么。例如：可以在Integer类型的字段中存放字符串，或者在布尔型字段中存放浮点数，或者在字符型字段中存放日期型值。 但有一种情况例外：定义为INTEGER PRIMARY KEY的字段只能存储64位整数， 当向这种字段保存除整数以外的数据时，将会产生错误。 另外， SQLite 在解析CREATE TABLE 语句时，会忽略 CREATE TABLE 语句中跟在字段名后面的数据类型信息，如下面语句会忽略 name字段的类型信息：

CREATE TABLE person (personid integer primary key autoincrement, name varchar(20))

SQLite可以解析大部分标准SQL语句，如：

查询语句：select * from 表名where 条件子句group by 分组字句having ... order by 排序子句

如：select * from person

        select * from person order by id desc

        select name from person group by name having count(*)>1

分页SQL与mysql类似，下面SQL语句获取5条记录，跳过前面3条记录

select * from Account limit 5 offset 3 或者 select * from Account limit 3,5

插入语句：insert into 表名(字段列表) values(值列表)。如：insert into person(name, age) values(‘HQ’,3)

更新语句：update 表名set 字段名=值where 条件子句。如：update person set name=‘HQ‘ where id=10

删除语句：delete from 表名where 条件子句。如：delete from person  where id=10

使用SQLiteOpenHelper对数据库进行版本管理

我们在编写数据库应用软件时，需要考虑这样的问题：因为我们开发的软件可能会安装在很多用户的手机上，如果应用使用到了SQLite数据库，我们必须在用户初次使用软件时创建出应用使用到的数据库表结构及添加一些初始化记录，另外在软件升级的时候，也需要对数据表结构进行更新。那么，我们如何才能实现在用户初次使用或升级软件时自动在用户的手机上创建出应用需要的数据库表呢？总不能让我们在每个需要安装此软件的手机上通过手工方式创建数据库表吧？因为这种需求是每个数据库应用都要面临的，所以在Android系统，为我们提供了一个名为SQLiteOpenHelper的抽象类，必须继承它才能使用，它是通过对数据库版本进行管理来实现前面提出的需求。

为了实现对数据库版本进行管理，SQLiteOpenHelper类提供了两个重要的方法，分别是onCreate(SQLiteDatabase db)和onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion)，前者用于初次使用软件时生成数据库表，后者用于升级软件时更新数据库表结构。当调用SQLiteOpenHelper的getWritableDatabase()或者getReadableDatabase()方法获取用于操作数据库的SQLiteDatabase实例的时候，如果数据库不存在，Android系统会自动生成一个数据库，接着调用onCreate()方法，onCreate()方法在初次生成数据库时才会被调用，在onCreate()方法里可以生成数据库表结构及添加一些应用使用到的初始化数据。onUpgrade()方法在数据库的版本发生变化时会被调用，一般在软件升级时才需改变版本号，而数据库的版本是由程序员控制的，假设数据库现在的版本是1，由于业务的变更，修改了数据库表结构，这时候就需要升级软件，升级软件时希望更新用户手机里的数据库表结构，为了实现这一目的，可以把原来的数据库版本设置为2(有同学问设置为3行不行？当然可以，如果你愿意，设置为100也行)，并且在onUpgrade()方法里面实现表结构的更新。当软件的版本升级次数比较多，这时在onUpgrade()方法里面可以根据原版号和目标版本号进行判断，然后作出相应的表结构及数据更新。

getWritableDatabase()和getReadableDatabase()方法都可以获取一个用于操作数据库的SQLiteDatabase实例。但getWritableDatabase() 方法以读写方式打开数据库，一旦数据库的磁盘空间满了，数据库就只能读而不能写，倘若使用getWritableDatabase()打开数据库就会出错。getReadableDatabase()方法先以读写方式打开数据库，如果数据库的磁盘空间满了，就会打开失败，当打开失败后会继续尝试以只读方式打开数据库。

public class DatabaseHelper extends SQLiteOpenHelper {

    //类没有实例化,是不能用作父类构造器的参数,必须声明为静态

         private static final String name = "itcast";//数据库名称

         private static final int version = 1; //数据库版本

         public DatabaseHelper(Context context) {

//第三个参数CursorFactory指定在执行查询时获得一个游标实例的工厂类,设置为null,代表使用系统默认的工厂类

                super(context, name, null, version);

         }

        @Override public void onCreate(SQLiteDatabase db) {

              db.execSQL("CREATE TABLE IF NOT EXISTS person (personid integer primary key autoincrement, name varchar(20), age INTEGER)");  

         }

        @Override public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {

               db.execSQL(" ALTER TABLE person ADD phone VARCHAR(12) NULL ");//往表中增加一列

// DROP TABLE IF EXISTS person 删除表

       }

}

在实际项目开发中，当数据库表结构发生更新时，应该避免用户存放于数据库中的数据丢失。

使用SQLiteDatabase操作SQLite数据库

Android提供了一个名为SQLiteDatabase的类，该类封装了一些操作数据库的API，使用该类可以完成对数据进行添加(Create)、查询(Retrieve)、更新(Update)和删除(Delete)操作（这些操作简称为CRUD）。对SQLiteDatabase的学习，我们应该重点掌握execSQL()和rawQuery()方法。 execSQL()方法可以执行insert、delete、update和CREATE TABLE之类有更改行为的SQL语句； rawQuery()方法用于执行select语句。

execSQL()方法的使用例子：

SQLiteDatabase db = ....;

db.execSQL("insert into person(name, age) values('HQ', 4)");

db.close();

执行上面SQL语句会往person表中添加进一条记录，在实际应用中， 语句中的“HQ”这些参数值会由用户输入界面提供，如果把用户输入的内容原样组拼到上面的insert语句， 当用户输入的内容含有单引号时，组拼出来的SQL语句就会存在语法错误。要解决这个问题需要对单引号进行转义，也就是把单引号转换成两个单引号。有些时候用户往往还会输入像“ & ”这些特殊SQL符号，为保证组拼好的SQL语句语法正确，必须对SQL语句中的这些特殊SQL符号都进行转义，显然，对每条SQL语句都做这样的处理工作是比较烦琐的。 SQLiteDatabase类提供了一个重载后的execSQL(String sql, Object[] bindArgs)方法，使用这个方法可以解决前面提到的问题，因为这个方法支持使用占位符参数(?)。使用例子如下：

SQLiteDatabase db = ....;

db.execSQL("insert into person(name, age) values(?,?)", new Object[]{"HQ", 4});

db.close();

execSQL(String sql, Object[] bindArgs)方法的第一个参数为SQL语句，第二个参数为SQL语句中占位符参数的值，参数值在数组中的顺序要和占位符的位置对应。

SQLiteDatabase的rawQuery() 用于执行select语句，使用例子如下：
 SQLiteDatabase db = ....;

Cursor cursor = db.rawQuery(“select * from person”, null);

while (cursor.moveToNext()) {

int personid = cursor.getInt(0); //获取第一列的值,第一列的索引从0开始

String name = cursor.getString(1);//获取第二列的值

int age = cursor.getInt(2);//获取第三列的值

}

cursor.close();

db.close();

rawrawQuery()方法的第一个参数为select语句；第二个参数为select语句中占位符参数的值，如果select语句没有使用占位符，该参数可以设置为null。带占位符参数的select语句使用例子如下：

Cursor cursor = db.rawQuery("select * from person where name like ? and age=?", new String[]{"%LP%", "4"});

Cursor是结果集游标，用于对结果集进行随机访问，如果大家熟悉jdbc， 其实Cursor与JDBC中的ResultSet作用很相似。使用moveToNext()方法可以将游标从当前行移动到下一行，如果已经移过了结果集的最后一行，返回结果为false，否则为true。另外Cursor 还有常用的moveToPrevious()方法（用于将游标从当前行移动到上一行，如果已经移过了结果集的第一行，返回值为false，否则为true ）、moveToFirst()方法（用于将游标移动到结果集的第一行，如果结果集为空，返回值为false，否则为true ）和moveToLast()方法（用于将游标移动到结果集的最后一行，如果结果集为空，返回值为false，否则为true ） 。

除了前面给大家介绍的execSQL()和rawQuery()方法， SQLiteDatabase还专门提供了对应于添加、删除、更新、查询的操作方法： insert()、delete()、update()和query() 。这些方法实际上是给那些不太了解SQL语法的菜鸟使用的，对于熟悉SQL语法的程序员而言，直接使用execSQL()和rawQuery()方法执行SQL语句就能完成数据的添加、删除、更新、查询操作。

Insert()方法用于添加数据，各个字段的数据使用ContentValues进行存放。 ContentValues类似于MAP，相对于MAP，它提供了存取数据对应的put(String key, Xxx value)和getAsXxx(String key)方法，  key为字段名称，value为字段值，Xxx指的是各种常用的数据类型，如：String、Integer等。

SQLiteDatabase db = databaseHelper.getWritableDatabase();

ContentValues values = new ContentValues();

values.put("name", "HQ");

values.put("age", 4);

long rowid = db.insert(“person”, null, values);//返回新添记录的行号，与主键id无关

不管第三个参数是否包含数据，执行Insert()方法必然会添加一条记录，如果第三个参数为空，会添加一条除主键之外其他字段值为Null的记录。Insert()方法内部实际上通过构造insert SQL语句完成数据的添加，Insert()方法的第二个参数用于指定空值字段的名称，相信大家对该参数会感到疑惑，该参数的作用是什么？是这样的：如果第三个参数values 为Null或者元素个数为0， 由于Insert()方法要求必须添加一条除了主键之外其它字段为Null值的记录，为了满足SQL语法的需要， insert语句必须给定一个字段名，如：insert into person(name) values(NULL)，倘若不给定字段名 ， insert语句就成了这样： insert into person() values()，显然这不满足标准SQL的语法。对于字段名，建议使用主键之外的字段，如果使用了INTEGER类型的主键字段，执行类似insert into person(personid) values(NULL)的insert语句后，该主键字段值也不会为NULL。如果第三个参数values 不为Null并且元素的个数大于0 ，可以把第二个参数设置为null。

delete()方法的使用：

SQLiteDatabase db = databaseHelper.getWritableDatabase();

db.delete("person", "personid<?", new String[]{"2"});

db.close();

上面代码用于从person表中删除personid小于2的记录。

update()方法的使用：

SQLiteDatabase db = databaseHelper.getWritableDatabase();

ContentValues values = new ContentValues();

values.put(“name”, “HQ”);//key为字段名，value为值

db.update("person", values, "personid=?", new String[]{"1"});

db.close();

上面代码用于把person表中personid等于1的记录的name字段的值改为“HQ”。

query()方法实际上是把select语句拆分成了若干个组成部分，然后作为方法的输入参数：

SQLiteDatabase db = databaseHelper.getWritableDatabase();

Cursor cursor = db.query("person", new String[]{"personid,name,age"}, "name like ?", new String[]{"%LP%"}, null, null, "personid desc", "1,2");

while (cursor.moveToNext()) {

         int personid = cursor.getInt(0); //获取第一列的值,第一列的索引从0开始

        String name = cursor.getString(1);//获取第二列的值

        int age = cursor.getInt(2);//获取第三列的值

}

cursor.close();

db.close();

上面代码用于从person表中查找name字段含有“LP”的记录，匹配的记录按personid降序排序，对排序后的结果略过第一条记录，只获取2条记录。

query(table, columns, selection, selectionArgs, groupBy, having, orderBy, limit)方法各参数的含义：

table：表名。相当于select语句from关键字后面的部分。如果是多表联合查询，可以用逗号将两个表名分开。

columns：要查询出来的列名。相当于select语句select关键字后面的部分。

selection：查询条件子句，相当于select语句where关键字后面的部分，在条件子句允许使用占位符“?”

selectionArgs：对应于selection语句中占位符的值，值在数组中的位置与占位符在语句中的位置必须一致，否则就会有异常。

groupBy：相当于select语句group by关键字后面的部分

having：相当于select语句having关键字后面的部分

orderBy：相当于select语句order by关键字后面的部分，如：personid desc, age asc;

limit：指定偏移量和获取的记录数，相当于select语句limit关键字后面的部分。

使用SQLiteOpenHelper获取用于操作数据库的SQLiteDatabase实例

public class DatabaseHelper extends SQLiteOpenHelper {

         private static final String name = "itcast";//数据库名称

         private static final int version = 1; //数据库版本

         ......略

}

public class HelloActivity extends Activity {

    @Override public void onCreate(Bundle savedInstanceState) {

        ......

        Button button =(Button) this.findViewById(R.id.button);

        button.setOnClickListener(new View.OnClickListener(){

public void onClick(View v) {

DatabaseHelper databaseHelper = new DatabaseHelper(HelloActivity.this);

SQLiteDatabase db = databaseHelper.getWritableDatabase();

db.execSQL("insert into person(name, age) values(?,?)", new Object[]{"HQ", 4});

db.close(); 

}});       

    }

}

第一次调用getWritableDatabase()或getReadableDatabase()方法后，SQLiteOpenHelper会缓存当前的SQLiteDatabase实例，SQLiteDatabase实例正常情况下会维持数据库的打开状态，所以在你不再需要SQLiteDatabase实例时，请及时调用close()方法释放资源。一旦SQLiteDatabase实例被缓存，多次调用getWritableDatabase()或getReadableDatabase()方法得到的都是同一实例。

使用事务操作SQLite数据库

使用SQLiteDatabase的beginTransaction()方法可以开启一个事务，程序执行到endTransaction() 方法时会检查事务的标志是否为成功，如果程序执行到endTransaction()之前调用了setTransactionSuccessful() 方法设置事务的标志为成功则提交事务，如果没有调用setTransactionSuccessful() 方法则回滚事务。使用例子如下：
 SQLiteDatabase db = ....;

db.beginTransaction();//开始事务

try {

    db.execSQL("insert into person(name, age) values(?,?)", new Object[]{"HQ", 4});

    db.execSQL("update person set name=? where personid=?", new Object[]{"LP", 1});

    db.setTransactionSuccessful();//调用此方法会在执行到endTransaction() 时提交当前事务，如果不调用此方法会回滚事务

} finally {

    db.endTransaction();//由事务的标志决定是提交事务，还是回滚事务

}

db.close();

上面两条SQL语句在同一个事务中执行。

Android sqlite3工具的使用

1 cmd à adb shell 首先挂载到linux

2 cd data/data/com.android.contacts.provider

3 cd database

4 sqlite3 contacts 打开数据库eg: sqlite3 contacts.db

5 .tables 查看所有的表  eg: .table

6 .schema 查看所有的创建表、视图的语句eg: .schema

7 .help 查看帮助  eg: .help

8 .header(s) NO |OFF是否显示列头信息eg: headers ON

9 .mode MODE  ?table? 指定数据显示风格eg: .mode column

10 .nullValue NULL空值数据显示问题eg: .nullValue NULL

使用ContentProvider（内容提供者）共享数据

ContentProvider 在android中的作用是对外共享数据，也就是说你可以通过ContentProvider把应用中的数据共享给其他应用访问，其他应用可以通过ContentProvider对你应用中的数据进行添删改查。关于数据共享，以前我们学习过文件操作模式，知道通过指定文件的操作模式为Context.MODE_WORLD_READABLE 或Context.MODE_WORLD_WRITEABLE同样也可以对外共享数据。那么，这里为何要使用ContentProvider对外共享数据呢？是这样的，如果采用文件操作模式对外共享数据，数据的访问方式会因数据存储的方式而不同，导致数据的访问方式无法统一，如：采用xml文件对外共享数据，需要进行xml解析才能读取数据；采用sharedpreferences共享数据，需要使用sharedpreferences API读取数据。

使用ContentProvider对外共享数据的好处是统一了数据的访问方式。

当应用需要通过ContentProvider对外共享数据时，第一步需要继承ContentProvider并重写下面方法：

public class PersonContentProvider extends ContentProvider{

   public boolean onCreate()

   public Uri insert(Uri uri, ContentValues values)

   public int delete(Uri uri, String selection, String[] selectionArgs)

   public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs)

   public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder)

   public String getType(Uri uri)}

第二步需要在AndroidManifest.xml使用<provider>对该ContentProvider进行配置，为了能让其他应用找到该ContentProvider ，ContentProvider 采用了authorities（主机名/域名）对它进行唯一标识，你可以把ContentProvider看作是一个网站（想想，网站也是提供数据者），authorities 就是他的域名：

<manifest .... >

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

        <provider android:name=".PersonContentProvider" android:authorities="cn.itcast.providers.personprovider"/>

    </application>

</manifest>

Uri介绍

Uri代表了要操作的数据，Uri主要包含了两部分信息：1》需要操作的ContentProvider ，2》对ContentProvider中的什么数据进行操作，一个Uri由以下几部分组成：

ContentProvider（内容提供者）的scheme已经由Android所规定，scheme为：content://

主机名（或叫Authority）用于唯一标识这个ContentProvider，外部调用者可以根据这个标识来找到它。

路径（path）可以用来表示我们要操作的数据，路径的构建应根据业务而定，如下:

要操作person表中id为10的记录，可以构建这样的路径:/person/10

要操作person表中id为10的记录的name字段，person/10/name

要操作person表中的所有记录，可以构建这样的路径:/person

要操作xxx表中的记录，可以构建这样的路径:/xxx

当然要操作的数据不一定来自数据库，也可以是文件、xml或网络等其他存储方式，如下:

要操作xml文件中person节点下的name节点，可以构建这样的路径：/person/name

如果要把一个字符串转换成Uri，可以使用Uri类中的parse()方法，如下：

Uri uri = Uri.parse("content://cn.itcast.provider.personprovider/person")

UriMatcher类使用介绍

因为Uri代表了要操作的数据，所以我们经常需要解析Uri，并从Uri中获取数据。Android系统提供了两个用于操作Uri的工具类，分别为UriMatcher 和ContentUris 。掌握它们的使用，会便于我们的开发工作。

UriMatcher类用于匹配Uri，它的用法如下：

首先第一步把你需要匹配Uri路径全部给注册上，如下：

//常量UriMatcher.NO_MATCH表示不匹配任何路径的返回码

UriMatcher  sMatcher = new UriMatcher(UriMatcher.NO_MATCH);

//如果match()方法匹配content://cn.itcast.provider.personprovider/person路径，返回匹配码为1

sMatcher.addURI(“cn.itcast.provider.personprovider”, “person”, 1);//添加需要匹配uri，如果匹配就会返回匹配码

//如果match()方法匹配content://cn.itcast.provider.personprovider/person/230路径，返回匹配码为2

sMatcher.addURI(“cn.itcast.provider.personprovider”, “person/#”, 2);//#号为通配符

switch (sMatcher.match(Uri.parse("content://cn.itcast.provider.personprovider/person/10"))) {

   case 1

    break;

   case 2

    break;

   default://不匹配

    break;

}

注册完需要匹配的Uri后，就可以使用sMatcher.match(uri)方法对输入的Uri进行匹配，如果匹配就返回匹配码，匹配码是调用addURI()方法传入的第三个参数，假设匹配content://cn.itcast.provider.personprovider/person路径，返回的匹配码为1

ContentUris类使用介绍

ContentUris类用于获取Uri路径后面的ID部分，它有两个比较实用的方法：

withAppendedId(uri, id)用于为路径加上ID部分：

Uri uri = Uri.parse("content://cn.itcast.provider.personprovider/person")

Uri resultUri = ContentUris.withAppendedId(uri, 10);

//生成后的Uri为：content://cn.itcast.provider.personprovider/person/10

parseId(uri)方法用于从路径中获取ID部分：

Uri uri = Uri.parse("content://cn.itcast.provider.personprovider/person/10")

long personid = ContentUris.parseId(uri);       //获取的结果为:10

使用ContentProvider共享数据

ContentProvider类主要方法的作用：

public boolean onCreate()

该方法在ContentProvider创建后就会被调用， Android开机后， ContentProvider在其它应用第一次访问它时才会被创建。

public Uri insert(Uri uri, ContentValues values)

该方法用于供外部应用往ContentProvider添加数据。

public int delete(Uri uri, String selection, String[] selectionArgs)

该方法用于供外部应用从ContentProvider删除数据。

public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs)

该方法用于供外部应用更新ContentProvider中的数据。

public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder)

该方法用于供外部应用从ContentProvider中获取数据。

public String getType(Uri uri)

该方法用于返回当前Url所代表数据的MIME类型。如果操作的数据属于集合类型，那么MIME类型字符串应该以vnd.android.cursor.dir/开头，例如：要得到所有person记录的Uri为content://cn.itcast.provider.personprovider/person，那么返回的MIME类型字符串应该为：“vnd.android.cursor.dir/person”。如果要操作的数据属于非集合类型数据，那么MIME类型字符串应该以vnd.android.cursor.item/开头，例如：得到id为10的person记录，Uri为content://cn.itcast.provider.personprovider/person/10，那么返回的MIME类型字符串应该为：“vnd.android.cursor.item/person”。

使用ContentResolver操作ContentProvider中的数据

当外部应用需要对ContentProvider中的数据进行添加、删除、修改和查询操作时，可以使用ContentResolver 类来完成，要获取ContentResolver 对象，可以使用Activity提供的getContentResolver()方法。 ContentResolver 类提供了与ContentProvider类相同签名的四个方法：

public Uri insert(Uri uri, ContentValues values)

该方法用于往ContentProvider添加数据。

public int delete(Uri uri, String selection, String[] selectionArgs)

该方法用于从ContentProvider删除数据。

public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs)

该方法用于更新ContentProvider中的数据。

public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder)

该方法用于从ContentProvider中获取数据。

这些方法的第一个参数为Uri，代表要操作的ContentProvider和对其中的什么数据进行操作，假设给定的是：Uri.parse(“content://cn.itcast.providers.personprovider/person/10”)，那么将会对主机名为cn.itcast.providers.personprovider的ContentProvider进行操作，操作的数据为person表中id为10的记录。

使用ContentResolver对ContentProvider中的数据进行添加、删除、修改和查询操作：

ContentResolver resolver =  getContentResolver();

Uri uri = Uri.parse("content://cn.itcast.provider.personprovider/person");

//添加一条记录

ContentValues values = new ContentValues();

values.put("name", "itcast");

values.put("age", 25);

resolver.insert(uri, values);

//获取person表中所有记录

Cursor cursor = resolver.query(uri, null, null, null, "personid desc");

while(cursor.moveToNext()){

Log.i("ContentTest", "personid="+ cursor.getInt(0)+ ",name="+ cursor.getString(1));

}

//把id为1的记录的name字段值更改新为liming

ContentValues updateValues = new ContentValues();

updateValues.put("name", "liming");

Uri updateIdUri = ContentUris.withAppendedId(uri, 2);

resolver.update(updateIdUri, updateValues, null, null);

//删除id为2的记录

Uri deleteIdUri = ContentUris.withAppendedId(uri, 2);

resolver.delete(deleteIdUri, null, null);

监听ContentProvider中数据的变化

如果ContentProvider的访问者需要知道ContentProvider中的数据发生了变化，可以在ContentProvider 发生数据变化时调用getContentResolver().notifyChange(uri, null)来通知注册在此URI上的访问者，例子如下：

public class PersonContentProvider extends ContentProvider {

public Uri insert(Uri uri, ContentValues values) {

db.insert("person", "personid", values);

getContext().getContentResolver().notifyChange(uri, null);

}

}

如果ContentProvider的访问者需要得到数据变化通知，必须使用ContentObserver对数据（数据采用uri描述）进行监听，当监听到数据变化通知时，系统就会调用ContentObserver的onChange()方法：

getContentResolver().registerContentObserver(Uri.parse("content://cn.itcast.providers.personprovider/person"),

        true, new PersonObserver(new Handler()));

public class PersonObserver extends ContentObserver{

public PersonObserver(Handler handler) {

super(handler);

 }

public void onChange(boolean selfChange) {

    //此处可以进行相应的业务处理

}

}

窃听用户发出的短信

用户使用系统自带的短信程序发送短信，程序会通过ContentProvider把短信保存进数据库，并且发出一个数据变化通知，使用ContentObserver对数据变化进行监听，在用户发送短信时，就会被ContentObserver窃听到短信：

注册监听：

getContentResolver().registerContentObserver(Uri.parse("content://sms"),  true, new SmsObserver(new Handler()));

监听类：

private final class SmsObserver extends ContentObserver{

public SmsObserver(Handler handler) {

super(handler);

}

public void onChange(boolean selfChange) {//查询发送箱中的短信(处于正在发送状态的短信放在发送箱)

Cursor cursor = getContentResolver().query(Uri.parse("content://sms/outbox"),null, null, null, null);

while(cursor.moveToNext()){

StringBuilder sb = new StringBuilder();

sb.append("_id=").append(cursor.getInt(cursor.getColumnIndex("_id")));

sb.append(",address=").append(cursor.getString(cursor.getColumnIndex("address")));

sb.append(";body=").append(cursor.getString(cursor.getColumnIndex("body")));

sb.append(";time=").append(cursor.getLong(cursor.getColumnIndex("date")));

Log.i("ReceiveSendSMS", sb.toString());

             } }   

}

通信录操作

使用ContentResolver对通信录中的数据进行添加、删除、修改和查询操作：

加入读写联系人信息的权限

<uses-permission android:name="android.permission.READ_CONTACTS" />

<uses-permission android:name="android.permission.WRITE_CONTACTS" />

加入读取联系人信息的权限

<uses-permission android:name="android.permission.READ_CONTACTS"/>

content://com.android.contacts/contacts 操作的数据是联系人信息Uri

content://com.android.contacts/data/phones 联系人电话Uri

content://com.android.contacts/data/emails 联系人Email Uri

读取联系人信息

Cursor cursor = getContentResolver().query(ContactsContract.Contacts.CONTENT_URI, 

    null, null, null, null); 

  while (cursor.moveToNext()) { 

   String contactId = cursor.getString(cursor.getColumnIndex(ContactsContract.Contacts._ID)); 

   String name = cursor.getString(cursor.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME)); 

  

   Cursor phones = getContentResolver().query(ContactsContract.CommonDataKinds.Phone.CONTENT_URI, 

        null, 

        ContactsContract.CommonDataKinds.Phone.CONTACT_ID +" = "+ contactId, 

        null, null); 

    while (phones.moveToNext()) { 

     String phoneNumber = phones.getString(phones.getColumnIndex( 

         ContactsContract.CommonDataKinds.Phone.NUMBER)); 

     Log.i("RongActivity", "phoneNumber="+phoneNumber);

    } 

    phones.close(); 

  

    Cursor emails = getContentResolver().query(ContactsContract.CommonDataKinds.Email.CONTENT_URI, 

       null, 

       ContactsContract.CommonDataKinds.Email.CONTACT_ID + " = " + contactId, 

       null, null); 

       while (emails.moveToNext()) { 

        // This would allow you get several email addresses 

        String emailAddress = emails.getString(emails.getColumnIndex(ContactsContract.CommonDataKinds.Email.DATA));

        Log.i("RongActivity", "emailAddress="+ emailAddress);

       } 

       emails.close(); 

  } 

  cursor.close();

==================== 添加联系人===========================

方法一：

/**

 * 首先向RawContacts.CONTENT_URI执行一个空值插入，目的是获取系统返回的rawContactId

 * 这时后面插入data表的依据，只有执行空值插入，才能使插入的联系人在通讯录里面可见

 */

public void testInsert() {

ContentValues values = new ContentValues();

//首先向RawContacts.CONTENT_URI执行一个空值插入，目的是获取系统返回的rawContactId

Uri rawContactUri = this.getContext().getContentResolver().insert(RawContacts.CONTENT_URI, values);

long rawContactId = ContentUris.parseId(rawContactUri);

//往data表入姓名数据

values.clear();

values.put(Data.RAW_CONTACT_ID, rawContactId);

values.put(Data.MIMETYPE, StructuredName.CONTENT_ITEM_TYPE);//内容类型

values.put(StructuredName.GIVEN_NAME, "李天山");

this.getContext().getContentResolver().insert(android.provider.ContactsContract.Data.CONTENT_URI, values);

//往data表入电话数据

values.clear();

values.put(Data.RAW_CONTACT_ID, rawContactId);

values.put(Data.MIMETYPE, Phone.CONTENT_ITEM_TYPE);

values.put(Phone.NUMBER, "13921009789");

values.put(Phone.TYPE, Phone.TYPE_MOBILE);

this.getContext().getContentResolver().insert(android.provider.ContactsContract.Data.CONTENT_URI, values);

//往data表入Email数据

values.clear();

values.put(Data.RAW_CONTACT_ID, rawContactId);

values.put(Data.MIMETYPE, Email.CONTENT_ITEM_TYPE);

values.put(Email.DATA, "[e-mail]");

values.put(Email.TYPE, Email.TYPE_WORK);

this.getContext().getContentResolver().insert(android.provider.ContactsContract.Data.CONTENT_URI, values);

}

方法二：批量添加,处于同一个事务中

public void testSave() throws Throwable{

//文档位置：reference\android\provider\ContactsContract.RawContacts.html

ArrayList<ContentProviderOperation> ops = new ArrayList<ContentProviderOperation>();

int rawContactInsertIndex = 0;

ops.add(ContentProviderOperation.newInsert(RawContacts.CONTENT_URI)

.withValue(RawContacts.ACCOUNT_TYPE, null)

.withValue(RawContacts.ACCOUNT_NAME, null)

.build());

//文档位置：reference\android\provider\ContactsContract.Data.html

ops.add(ContentProviderOperation.newInsert(android.provider.ContactsContract.Data.CONTENT_URI)

.withValueBackReference(Data.RAW_CONTACT_ID, rawContactInsertIndex)

.withValue(Data.MIMETYPE, StructuredName.CONTENT_ITEM_TYPE)

.withValue(StructuredName.GIVEN_NAME, "赵薇")

.build());

ops.add(ContentProviderOperation.newInsert(android.provider.ContactsContract.Data.CONTENT_URI)

 .withValueBackReference(Data.RAW_CONTACT_ID, rawContactInsertIndex)

         .withValue(Data.MIMETYPE, Phone.CONTENT_ITEM_TYPE)

         .withValue(Phone.NUMBER, "13671323809")

         .withValue(Phone.TYPE, Phone.TYPE_MOBILE)

         .withValue(Phone.LABEL, "手机号")

         .build());

ops.add(ContentProviderOperation.newInsert(android.provider.ContactsContract.Data.CONTENT_URI)

 .withValueBackReference(Data.RAW_CONTACT_ID, rawContactInsertIndex)

         .withValue(Data.MIMETYPE, Email.CONTENT_ITEM_TYPE)

         .withValue(Email.DATA, "[e-mail]")

         .withValue(Email.TYPE, Email.TYPE_WORK)

         .build());

ContentProviderResult[] results = this.getContext().getContentResolver()

.applyBatch(ContactsContract.AUTHORITY, ops);

for(ContentProviderResult result : results){

Log.i(TAG, result.uri.toString());

}

}

从Internet获取数据

利用HttpURLConnection对象,我们可以从网络中获取网页数据.

URL url = new URL("http://www.sohu.com");

HttpURLConnection conn = (HttpURLConnection) url.openConnection();

conn.setConnectTimeout(5* 1000);     //设置连接超时

conn.setRequestMethod(“GET”);     //以get方式发起请求

if (conn.getResponseCode() != 200) throw new RuntimeException("请求url失败");

InputStream is = conn.getInputStream();      //得到网络返回的输入流

String result = readData(is, "GBK");

conn.disconnect();

//第一个参数为输入流,第二个参数为字符集编码

public static String readData(InputStream inSream, String charsetName) throws Exception{

ByteArrayOutputStream outStream = new ByteArrayOutputStream();

byte[] buffer = new byte[1024];

int len = -1;

while( (len = inSream.read(buffer)) != -1 ){

outStream.write(buffer, 0, len);

}

byte[] data = outStream.toByteArray();

outStream.close();

inSream.close();

return new String(data, charsetName);

}

利用HttpURLConnection对象,我们可以从网络中获取文件数据.

URL url = new URL("http://photocdn.sohu.com/20100125/Img269812337.jpg");

HttpURLConnection conn = (HttpURLConnection) url.openConnection();

conn.setConnectTimeout(5* 1000);

conn.setRequestMethod("GET");

if (conn.getResponseCode() != 200) throw new RuntimeException("请求url失败");

InputStream is = conn.getInputStream();

readAsFile(is, "Img269812337.jpg");

public static void readAsFile(InputStream inSream, File file) throws Exception{

FileOutputStream outStream = new FileOutputStream(file);

byte[] buffer = new byte[1024];

int len = -1;

while( (len = inSream.read(buffer)) != -1 ){

outStream.write(buffer, 0, len);

}

 outStream.close();

inSream.close();

}

向Internet发送请求参数

利用HttpURLConnection对象,我们可以向网络发送请求参数.

String requestUrl = "http://localhost:8080/itcast/contanctmanage.do";

Map<String, String> requestParams = new HashMap<String, String>();

requestParams.put("age", "12");

requestParams.put("name", "中国");

 StringBuilder params = new StringBuilder();

for(Map.Entry<String, String> entry : requestParams.entrySet()){

params.append(entry.getKey());

params.append("=");

params.append(URLEncoder.encode(entry.getValue(), "UTF-8"));

params.append("&");

}

if (params.length() > 0) params.deleteCharAt(params.length() - 1);

byte[] data = params.toString().getBytes();

URL realUrl = new URL(requestUrl);

HttpURLConnection conn = (HttpURLConnection) realUrl.openConnection();

conn.setDoOutput(true);    //发送POST请求必须设置允许输出

conn.setUseCaches(false);   //不使用Cache

conn.setRequestMethod("POST");       

conn.setRequestProperty("Connection", "Keep-Alive");    //维持长连接

conn.setRequestProperty("Charset", "UTF-8");

conn.setRequestProperty("Content-Length", String.valueOf(data.length));

conn.setRequestProperty("Content-Type","application/x-www-form-urlencoded");

DataOutputStream outStream = new DataOutputStream(conn.getOutputStream());

outStream.write(data);

outStream.flush();

if( conn.getResponseCode() == 200 ){

        String result = readAsString(conn.getInputStream(), "UTF-8");

        outStream.close();

        System.out.println(result);

}

向Internet发送xml数据

利用HttpURLConnection对象,我们可以向网络发送xml数据.

StringBuilder xml =  new StringBuilder();

xml.append("<?xml version=\"1.0\" encoding=\"utf-8\" ?>");

xml.append("<M1 V=10000>");

xml.append("<U I=1 D=\"N73\">中国</U>");

xml.append("</M1>");

byte[] xmlbyte = xml.toString().getBytes("UTF-8");

URL url = new URL("http://localhost:8080/itcast/contanctmanage.do?method=readxml");

HttpURLConnection conn = (HttpURLConnection) url.openConnection();

conn.setConnectTimeout(5* 1000);

conn.setDoOutput(true);   //允许输出

conn.setUseCaches(false);  //不使用Cache

conn.setRequestMethod("POST");       

conn.setRequestProperty("Connection", "Keep-Alive");   //维持长连接

conn.setRequestProperty("Charset", "UTF-8");

conn.setRequestProperty("Content-Length", String.valueOf(xmlbyte.length));

conn.setRequestProperty("Content-Type", "text/xml; charset=UTF-8");

DataOutputStream outStream = new DataOutputStream(conn.getOutputStream());

outStream.write(xmlbyte);   //发送xml数据

outStream.flush();

if (conn.getResponseCode() != 200) throw new RuntimeException("请求url失败");

InputStream is = conn.getInputStream();   //获取返回数据

String result = readAsString(is, "UTF-8");

outStream.close();

多线程断点续传下载

使用多线程下载文件可以更快完成文件的下载，多线程下载文件之所以快，是因为其抢占的服务器资源多。如：假设服务器同时最多服务100个用户，在服务器中一条线程对应一个用户，100条线程在计算机中并非并发执行，而是由CPU划分时间片轮流执行，如果A应用使用了99条线程下载文件，那么相当于占用了99个用户的资源，假设一秒内CPU分配给每条线程的平均执行时间是10ms，A应用在服务器中一秒内就得到了990ms的执行时间，而其他应用在一秒内只有10ms的执行时间。就如同一个水龙头，每秒出水量相等的情况下，放990毫秒的水

肯定比放10毫秒的水要多。

多线程下载的实现过程：

1>首先得到下载文件的长度，然后设置本地文件

的长度。

HttpURLConnection.getContentLength();

RandomAccessFile file = new RandomAccessFile("QQWubiSetup.exe","rwd");

file.setLength(filesize);//设置本地文件的长度

2>根据文件长度和线程数计算每条线程下载的数据长度和下载位置。如：文件的长度为6M，线程数为3，那么，每条线程下载的数据长度为2M，每条线程开始下载的位置如上图所示。

3>使用Http的Range头字段指定每条线程从文件的什么位置开始下载，下载到什么位置为止，如：指定从文件的2M位置开始下载，下载到位置(4M-1byte)为止，代码如下：

HttpURLConnection.setRequestProperty("Range", "bytes=2097152-4194303");

4>保存文件，使用RandomAccessFile类指定每条线程从本地文件的什么位置开始写入数据。

RandomAccessFile threadfile = new RandomAccessFile("QQWubiSetup.exe ","rwd");

threadfile.seek(2097152);//从文件的什么位置开始写入数据

public class FileDownLoader {

@Test

public void download() throws Exception {

String path = "http://browse.babasport.com/QQWubiSetup.exe";

URL url = new URL(path);

HttpURLConnection conn = (HttpURLConnection) url.openConnection();

conn.setConnectTimeout(5*1000);

conn.setRequestMethod("GET");

conn.setRequestProperty("Accept", "image/gif, image/jpeg, image/pjpeg, image/pjpeg, application/x-shockwave-flash, application/xaml+xml, application/vnd.ms-xpsdocument, application/x-ms-xbap, application/x-ms-application, application/vnd.ms-excel, application/vnd.ms-powerpoint, application/msword, */*");

conn.setRequestProperty("Accept-Language", "zh-CN");

conn.setRequestProperty("Charset", "UTF-8");

conn.setRequestProperty("User-Agent", "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 5.2; Trident/4.0; .NET CLR 1.1.4322; .NET CLR 2.0.50727; .NET CLR 3.0.04506.30; .NET CLR 3.0.4506.2152; .NET CLR 3.5.30729)");

conn.setRequestProperty("Connection", "Keep-Alive");

System.out.println(conn.getResponseCode());

int filesize = conn.getContentLength();//得到文件大小

conn.disconnect();

int threasize = 3;//线程数

int perthreadsize = filesize / 3 + 1;

RandomAccessFile file = new RandomAccessFile("102.wma","rw");

file.setLength(filesize);//设置本地文件的大小

file.close();

for(int i=0; i<threasize ; i++){

int startpos = i * perthreadsize;//计算每条线程的下载位置

RandomAccessFile perthreadfile = new RandomAccessFile("102.wma","rw");//

perthreadfile.seek(startpos);//从文件的什么位置开始写入数据

new DownladerThread(i, path, startpos, perthreadsize, perthreadfile).start();

}

//以下代码要求用户输入q才会退出测试方法，如果没有下面代码，会因为进程结束而导致进程内的下载线程被销毁

int quit = System.in.read();

while('q'!=quit){

Thread.sleep(2 * 1000);

}

}

private class DownladerThread extends Thread{

private int startpos;//从文件的什么位置开始下载

private int perthreadsize;//每条线程需要下载的文件大小

private String path;

private RandomAccessFile file;

private int threadid;

public DownladerThread(int threadid, String path, int startpos, int perthreadsize, RandomAccessFile perthreadfile) {

this.path = path;

this.startpos = startpos;

this.perthreadsize = perthreadsize;

this.file = perthreadfile;

this.threadid = threadid;

}

@Override

public void run() {

try {

URL url = new URL(path);

HttpURLConnection conn = (HttpURLConnection)url.openConnection();

conn.setConnectTimeout(5 * 1000);

conn.setRequestMethod("GET");

conn.setRequestProperty("Accept", "image/gif, image/jpeg, image/pjpeg, image/pjpeg, application/x-shockwave-flash, application/xaml+xml, application/vnd.ms-xpsdocument, application/x-ms-xbap, application/x-ms-application, application/vnd.ms-excel, application/vnd.ms-powerpoint, application/msword, */*");

conn.setRequestProperty("Accept-Language", "zh-CN");

conn.setRequestProperty("Charset", "UTF-8");

conn.setRequestProperty("Range", "bytes=" + this.startpos + "-");

InputStream inStream = conn.getInputStream();

byte[] buffer = new byte[1024];

int len = 0;

int length = 0;

while(length<perthreadsize && (len = inStream.read(buffer))!=-1){

file.write(buffer, 0, len);

length += len;//累计该线程下载的总大小

}

file.close();

inStream.close();

System.out.println(threadid+ "线程完成下载");

} catch (Exception e) {

e.printStackTrace();

}

}

}

}

为应用添加新的Activity

第一步：新建一个继承Activity的类，如：NewActivity

public class NewActivity extends Activity {

    @Override protected void onCreate(Bundle savedInstanceState) {

                   super.onCreate(savedInstanceState);

  //这里可以使用setContentView(R.layout.xxx)显示某个视图....

     }

}

第二步：需要在功能清单AndroidManifest.xml文件中添加进上面Activity配置代码(红色部分)：

<manifest xmlns:android="http://schemas.android.com/apk/res/android"

      package="cn.itcast.action"

      android:versionCode="1"

      android:versionName="1.0">

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

        .....

    <activity android:name=".NewActivity" android:label="新activity的页面标题"/>

    </application>

    ...

</manifest>

android:name属性值的前面加了一个点表示NewActivity是当前包cn.itcast.action下的类，如果类在应用的当前包下，可以省略点符号，如果类在应用的子包下必须加点，如：NewActivity类在cn.itcast.action.user包下可以这样写：<activity android:name=“.user.NewActivity“ />

Activity生命周期

Activity有三个状态：

l 当它在屏幕前台时（位于当前任务堆栈的顶部），它是激活或运行状态。它就是响应用户操作的Activity。

l 当它上面有另外一个Activity，使它失去了焦点但仍然对用户可见时（如右图），它处于暂停状态。在它之上的Activity没有完全覆盖屏幕，或者是透明的，被暂停的Activity仍然对用户可见，并且是存活状态（它保留着所有的状态和成员信息并保持和窗口管理器的连接）。如果系统处于内存不足时会杀死这个Activity。

l当它完全被另一个Activity覆盖时则处于停止状态。它仍然保留所有的状态和成员信息。然而对用户是不可见的，所以它的窗口将被隐藏，如果其它地方需要内存，则系统经常会杀死这个Activity。

当Activity从一种状态转变到另一种状态时，会调用以下保护方法来通知这种变化：

void onCreate(Bundle savedInstanceState)

void onStart()

void onRestart()

void onResume()

void onPause()

void onStop()

void onDestroy()

这七个方法定义了Activity的完整生命周期。实现这些方法可以帮助我们监视其中的三个嵌套生命周期循环：

l Activity的完整生命周期自第一次调用onCreate()开始，直至调用onDestroy()为止。Activity在onCreate()中设置所有“全局”状态以完成初始化，而在onDestroy()中释放所有系统资源。例如，如果Activity有一个线程在后台运行从网络下载数据，它会在+onCreate()创建线程，而在 onDestroy()销毁线程。

l Activity的可视生命周期自onStart()调用开始直到相应的onStop()调用结束。在此期间，用户可以在屏幕上看到Activity，尽管它也许并不是位于前台或者也不与用户进行交互。在这两个方法之间，我们可以保留用来向用户显示这个Activity所需的资源。例如，当用户不再看见我们显示的内容时，我们可以在onStart()中注册一个BroadcastReceiver来监控会影响UI的变化，而在onStop()中来注消。onStart() 和 onStop() 方法可以随着应用程序是否为用户可见而被多次调用。

l Activity的前台生命周期自onResume()调用起，至相应的onPause()调用为止。在此期间，Activity位于前台最上面并与用户进行交互。Activity会经常在暂停和恢复之间进行状态转换——例如当设备转入休眠状态或者有新的Activity启动时，将调用onPause() 方法。当Activity获得结果或者接收到新的Intent时会调用onResume() 方法。关于前台生命周期循环的例子请见PPT下方备注栏。

Activity的前台生命周期循环例子:

1》创建一个Activity，添加七个生命周期方法，方法内输出各个方法名称。再添加一个按钮用于打开下面新添加的Activity。

    startActivity(new Intent(LifeActivity.this, CustomDialogActivity.class));

2》添加一个新Activity，代码如下：

public class CustomDialogActivity extends Activity {

    @Override protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        //必须在调用setContentView()之前调用requestWindowFeature()

        requestWindowFeature(Window.FEATURE_LEFT_ICON);//要标题栏显示图标

        setContentView(R.layout.dialog_activity);      

        getWindow().setFeatureDrawableResource(Window.FEATURE_LEFT_ICON, android.R.drawable.ic_dialog_alert);//设置图标

    }

}

3》在AndroidManifest.xml文件配置Activity，并且通过主题指定该Activity以对话框样式显示。

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

        .....

        <activity android:name=".CustomDialogActivity" android:label="对话框activity"

android:theme="@android:style/Theme.Dialog"/>

 </application>

Activity的onSaveInstanceState()和 onRestoreInstanceState()方法

Activity的 onSaveInstanceState() 和 onRestoreInstanceState()并不是生命周期方法，它们不同于 onCreate()、onPause()等生命周期方法，它们并不一定会被触发。当应用遇到意外情况（如：内存不足、用户直接按Home键）由系统销毁一个Activity时，onSaveInstanceState() 会被调用。但是当用户主动去销毁一个Activity时，例如在应用中按返回键，onSaveInstanceState()就不会被调用。因为在这种情况下，用户的行为决定了不需要保存Activity的状态。通常onSaveInstanceState()只适合用于保存一些临时性的状态，而onPause()适合用于数据的持久化保存。

另外，当屏幕的方向发生了改变， Activity会被摧毁并且被重新创建，如果你想在Activity被摧毁前缓存一些数据，并且在Activity被重新创建后恢复缓存的数据。可以重写Activity的 onSaveInstanceState() 和 onRestoreInstanceState()方法，如下：

public class PreferencesActivity extends Activity {

    private String name;

    protected void onRestoreInstanceState(Bundle savedInstanceState) {

    name = savedInstanceState.getString("name");         //被重新创建后恢复缓存的数据

    super.onRestoreInstanceState(savedInstanceState);

    }

    protected void onSaveInstanceState(Bundle outState) {

    outState.putString("name", "liming");            //被摧毁前缓存一些数据

    super.onSaveInstanceState(outState);

    }

}

横竖屏幕切换

默认情况下，当“屏幕方向”或“键盘显示隐藏” 变化时都会销毁当前Activity，创建新的Activity。如果不希望重新创建Activity实例，可以按如下配置Activity：

<activity android:name=".MainActivity" android:configChanges="keyboardHidden|orientation">

上面的android:configChanges属性指定了要捕获“屏幕方向”和“键盘显示隐藏”变化，当捕获到这些变化后会调用Activity的onConfigurationChanged()方法。

默认情况下(没有配置android:configChanges属性)：

l竖屏切横屏，销毁当前Activity之后，创建一个新Activity实例。

l横屏切竖屏，销毁当前Activity之后，创建一个新Activity实例，新的Activity实例很快就被销毁，接着又会创建一个新Activity实例。如果只希望创建一个实例，可以配置android:configChanges="orientation"

打开新的Activity，不传递参数

在一个Activity中可以使用系统提供的startActivity(Intent intent)方法打开新的Activity，在打开新的Activity前，你可以决定是否为新的Activity传递参数：

第一种：打开新的Activity，不传递参数

publicclass MainActivity extends Activity {

  @Override protectedvoid onCreate(Bundle savedInstanceState) {

.......

Button button =(Button) this.findViewById(R.id.button);

                           button.setOnClickListener(new View.OnClickListener(){//点击该按钮会打开一个新的Activity

public void onClick(View v) {

                          //新建一个显式意图，第一个参数为当前Activity类对象，第二个参数为你要打开的Activity类

    startActivity(new Intent(MainActivity.this, NewActivity.class));

}});

         }

}

打开新的Activity，并传递若干个参数给它

第二种：打开新的Activity，并传递若干个参数给它：

publicclass MainActivity extends Activity {

  @Override protectedvoid onCreate(Bundle savedInstanceState) {

.......

 button.setOnClickListener(new View.OnClickListener(){//点击该按钮会打开一个新的Activity

          public void onClick(View v) {

           Intent intent = new Intent(MainActivity.this, NewActivity.class)

Bundle bundle = new Bundle();//该类用作携带数据

bundle.putString("name", "HQ");

bundle.putInt("age", 4);

intent.putExtras(bundle);//附带上额外的数据

startActivity(intent);

}}); }

}

在新的Activity中接收前面Activity传递过来的参数：

public class NewActivity extends Activity {

            @Override protected void onCreate(Bundle savedInstanceState) {

     ........

     Bundle bundle = this.getIntent().getExtras();

     String name = bundle.getString("name");

                    int age = bundle.getInt("age");

            }

}

Bundle类的作用

Bundle类用作携带数据，它类似于Map，用于存放key-value名值对形式的值。相对于Map，它提供了各种常用类型的putXxx()/getXxx()方法，如:putString()/getString()和putInt()/getInt()，putXxx()用于往Bundle对象放入数据，getXxx()方法用于从Bundle对象里获取数据。Bundle的内部实际上是使用了HashMap<String, Object>类型的变量来存放putXxx()方法放入的值：

public final class Bundle implements Parcelable, Cloneable {

            ......

 Map<String, Object> mMap;

 public Bundle() {

       mMap = new HashMap<String, Object>();

        ......

 }

 public void putString(String key, String value) {

      mMap.put(key, value);

 }

public String getString(String key) {

       Object o = mMap.get(key);

        return (String) o;

        ........//类型转换失败后会返回null，这里省略了类型转换失败后的处理代码

}

}

在调用Bundle对象的getXxx()方法时，方法内部会从该变量中获取数据，然后对数据进行类型转换，转换成什么类型由方法的Xxx决定，getXxx()方法会把转换后的值返回。

为Intent附加数据的两种写法

第一种写法，用于批量添加数据到Intent：

Intent intent = new Intent();

Bundle bundle = new Bundle();      //该类用作携带数据

bundle.putString("name", "HQ");

intent.putExtras(bundle);      //为意图追加额外的数据，意图原来已经具有的数据不会丢失，但key同名的数据会被替换

第二种写法：这种写法的作用等价于上面的写法，只不过这种写法是把数据一个个地添加进Intent，这种写法使用起来比较方便，而且只需要编写少量的代码。

Intent intent = new Intent();

intent.putExtra("name", "HQ");

Intent提供了各种常用类型重载后的putExtra()方法，如： putExtra(String name, String value)、 putExtra(String name, long value)，在putExtra()方法内部会判断当前Intent对象内部是否已经存在一个Bundle对象，如果不存在就会新建Bundle对象，以后调用putExtra()方法传入的值都会存放于该Bundle对象，下面是Intent的putExtra(String name, String value)方法代码片断：

public class Intent implements Parcelable {

private Bundle mExtras;

public Intent putExtra(String name, String value) {

        if (mExtras == null) {

            mExtras = new Bundle();

        }

        mExtras.putString(name, value);

        return this;

 }

得到新打开Activity关闭后返回的数据

如果你想在Activity中得到新打开Activity 关闭后返回的数据，你需要使用系统提供的startActivityForResult(Intent intent, int requestCode)方法打开新的Activity，新的Activity 关闭后会向前面的Activity 传回数据，为了得到传回的数据，你必须在前面的Activity中重写onActivityResult(int requestCode, int resultCode, Intent data)方法：

publicclass MainActivity extends Activity {

      @Override protectedvoid onCreate(Bundle savedInstanceState) {

.......

Button button =(Button) this.findViewById(R.id.button);

                           button.setOnClickListener(new View.OnClickListener(){//点击该按钮会打开一个新的Activity

public void onClick(View v) {

//第二个参数为请求码，可以根据业务需求自己编号

startActivityForResult (new Intent(MainActivity.this, NewActivity.class),  1);

}});

         }

    //第一个参数为请求码，即调用startActivityForResult()传递过去的值

    //第二个参数为结果码，结果码用于标识返回数据来自哪个新Activity

   @Override protected void onActivityResult(int requestCode, int resultCode, Intent data) {

String result = data.getExtras().getString(“result”));//得到新Activity 关闭后返回的数据

    }

}    当新Activity关闭后，新Activity返回的数据通过Intent进行传递，android平台会调用前面Activity 的onActivityResult()方法，把存放了返回数据的Intent作为第三个输入参数传入，在onActivityResult()方法中使用第三个输入参数可以取出新Activity返回的数据。

使用startActivityForResult(Intent intent, int requestCode)方法打开新的Activity，新Activity关闭前需要向前面的Activity返回数据需要使用系统提供的setResult(int resultCode, Intent data)方法实现：

public class NewActivity extends Activity {

@Override protected void onCreate(Bundle savedInstanceState) {

......

        button.setOnClickListener(new View.OnClickListener(){

public void onClick(View v) {

Intent intent = new Intent();//数据是使用Intent返回

intent.putExtra(“result”, “HQ的学生很可爱”);//把返回数据存入Intent

 NewActivity.this.setResult(RESULT_OK, intent);//设置返回数据

 NewActivity.this.finish();//关闭Activity

}});

}

}

setResult()方法的第一个参数值可以根据业务需要自己定义，上面代码中使用到的RESULT_OK是系统Activity类定义的一个常量，值为-1，代码片断如下：

public class android.app.Activity extends ......{

  public static final int RESULT_CANCELED = 0;

  public static final int RESULT_OK = -1;

  public static final int RESULT_FIRST_USER = 1;

}

请求码的作用

使用startActivityForResult(Intent intent, int requestCode)方法打开新的Activity，我们需要为startActivityForResult()方法传入一个请求码(第二个参数)。请求码的值是根据业务需要由自已设定，用于标识请求来源。例如：一个Activity有两个按钮，点击这两个按钮都会打开同一个Activity，不管是那个按钮打开新Activity，当这个新Activity关闭后，系统都会调用前面Activity的onActivityResult(int requestCode, int resultCode, Intent data)方法。在onActivityResult()方法如果需要知道新Activity是由那个按钮打开的，并且要做出相应的业务处理，这时可以这样做：

 @Override  public void onCreate(Bundle savedInstanceState) {

        ....

        button1.setOnClickListener(new View.OnClickListener(){

  public void onClick(View v) {

   startActivityForResult (new Intent(MainActivity.this, NewActivity.class), 1);

   }});

        button2.setOnClickListener(new View.OnClickListener(){

  public void onClick(View v) {

   startActivityForResult (new Intent(MainActivity.this, NewActivity.class), 2);

   }});

       @Override protected void onActivityResult(int requestCode, int resultCode, Intent data) {

               switch(requestCode){

                   case 1:

                       //来自按钮1的请求，作相应业务处理

                   case 2:

                //来自按钮2的请求，作相应业务处理

                }

          }

}

结果码的作用

在一个Activity中，可能会使用startActivityForResult()方法打开多个不同的Activity处理不同的业务，当这些新Activity关闭后，系统都会调用前面Activity的onActivityResult(int requestCode, int resultCode, Intent data)方法。为了知道返回的数据来自于哪个新Activity，在onActivityResult()方法中可以这样做(ResultActivity和NewActivity为要打开的新Activity)：

public class ResultActivity extends Activity {

       .....

       ResultActivity.this.setResult(1, intent);

       ResultActivity.this.finish();

}

public class NewActivity extends Activity {

       ......

        NewActivity.this.setResult(2, intent);

        NewActivity.this.finish();

}

public class MainActivity extends Activity { // 在该Activity会打开ResultActivity和NewActivity

       @Override protected void onActivityResult(int requestCode, int resultCode, Intent data) {

               switch(resultCode){

                   case 1:

                       // ResultActivity的返回数据

                   case 2:

               // NewActivity的返回数据

                }

          }

}

Intent（意图）

Android基本的设计理念是鼓励减少组件间的耦合，因此Android提供了Intent (意图) ，Intent提供了一种通用的消息系统，它允许在你的应用程序与其它的应用程序间传递Intent来执行动作和产生事件。使用Intent可以激活Android应用的三个核心组件：活动、服务和广播接收器。

Intent可以划分成显式意图和隐式意图。

显式意图：调用Intent.setComponent()或Intent.setClass()方法明确指定了组件名的Intent为显式意图，显式意图明确指定了Intent应该传递给哪个组件。

隐式意图：没有明确指定组件名的Intent为隐式意图。Android系统会根据隐式意图中设置的动作(action)、类别(category)、数据（URI和数据类型）找到最合适的组件来处理这个意图。查找规则请见ppt下方备注。

<intent-filter>

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

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

<data android:scheme="tel" />

</intent-filter>

<intent-filter>

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

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

<data android:mimeType="vnd.android.cursor.item/phone" />

</intent-filter>

对于隐式意图，Android是怎样寻找到这个最合适的组件呢？记的前面我们在定义活动时，指定了一个intent-filter，Intent Filter（意图过滤器）其实就是用来匹配隐式Intent的，当一个意图对象被一个意图过滤器进行匹配测试时，只有三个方面会被参考到：动作、数据（URI以及数据类型）和类别。

动作测试（Action test）

  一个意图对象只能指定一个动作名称，而一个过滤器可能列举多个动作名称。如果意图对象或过滤器没有指定任何动作，结果将如下：

•如果过滤器没有指定任何动作，那么将阻塞所有的意图，因此所有的意图都会测试失败。没有意图能够通过这个过滤器。

•另一方面，只要过滤器包含至少一个动作，一个没有指定动作的意图对象自动通过这个测试

类别测试（Category test）

对于一个能够通过类别匹配测试的意图，意图对象中的类别必须匹配过滤器中的类别。这个过滤器可以列举另外的类别，但它不能遗漏在这个意图中的任何类别。

原则上一个没有类别的意图对象应该总能够通过匹配测试，而不管过滤器里有什么。大部分情况下这个是对的。但有一个例外，Android把所有传给startActivity()的隐式意图当作他们包含至少一个类别："android.intent.category.DEFAULT" （CATEGORY_DEFAULT常量）。 因此，想要接收隐式意图的活动必须在它们的意图过滤器中包含"android.intent.category.DEFAULT"。（带"android.intent.action.MAIN"和"android.intent.category.LAUNCHER"设置的过滤器是例外）

数据测试（Data test）

当一个意图对象中的URI被用来和一个过滤器中的URI比较时，比较的是URI的各个组成部分。例如，如果过滤器仅指定了一个scheme，所有该scheme的URIs都能够和这个过滤器相匹配；如果过滤器指定了一个scheme、主机名但没有路经部分，所有具有相同scheme和主机名的URIs都可以和这个过滤器相匹配，而不管它们的路经；如果过滤器指定了一个scheme、主机名和路经，只有具有相同scheme、主机名和路经的URIs才可以和这个过滤器相匹配。当然，一个过滤器中的路径规格可以包含通配符，这样只需要部分匹配即可。

数据测试同时比较意图对象和过滤器中指定的URI和数据类型。规则如下：

a. 一个既不包含URI也不包含数据类型的意图对象仅在过滤器也同样没有指定任何URIs和数据类型的情况下才能通过测试。

b. 一个包含URI但没有数据类型的意图对象仅在它的URI和一个同样没有指定数据类型的过滤器里的URI匹配时才能通过测试。这通常发生在类似于mailto:和tel：这样的URIs上：它们并不引用实际数据。

c. 一个包含数据类型但不包含URI的意图对象仅在这个过滤器列举了同样的数据类型而且也没有指定一个URI的情况下才能通过测试。

d. 一个同时包含URI和数据类型（或者可从URI推断出数据类型）的意图对象可以通过测试，如果它的类型和过滤器中列举的类型相匹配的话。如果它的URI和这个过滤器中的一个URI相匹配或者它有一个内容content:或者文件file: URI而且这个过滤器没有指定一个URI，那么它也能通过测试。换句话说，一个组件被假定为支持content:和file: 数据如果它的过滤器仅列举了一个数据类型。

应用的响应性（Responsive）

在Android中，应用的响应性被活动管理器（Activity Manager）

和窗口管理器（Window Manager）这两个系统服务所监视。

当用户触发了输入事件（如键盘输入，点击按钮等），

如果应用6秒内没有响应用户的输入事件，那么，Android会认

为该应用无响应，便弹出ANR（Application No Response）

对话框。如右图。

在正常情况下，Android程序会在一条单线程里运行。如果Activity要处理一件比较耗时的工作，应该交给子线程完成，否侧会因为主线程被阻塞，后面的用户输入事件因没能在5秒内响应，导致应用出现ANR对话框。

广播接收者--BroadcastReceiver

广播接收者（BroadcastReceiver）用于接收广播Intent，广播Intent的发送是通过调用Context.sendBroadcast()、Context.sendOrderedBroadcast()来实现的。通常一个广播Intent可以被订阅了此Intent的多个广播接收者所接收，这个特性跟JMS中的Topic消息接收者类似。要实现一个广播接收者方法如下：

第一步：继承BroadcastReceiver，并重写onReceive()方法。

public class IncomingSMSReceiver extends BroadcastReceiver {

@Override public void onReceive(Context context, Intent intent) {

}

}

第二步：订阅感兴趣的广播Intent，订阅方法有两种：

第一种：使用代码进行订阅

IntentFilter filter = new IntentFilter("android.provider.Telephony.SMS_RECEIVED");

IncomingSMSReceiver receiver = new IncomingSMSReceiver();

registerReceiver(receiver, filter);

第二种：在AndroidManifest.xml文件中的<application>节点里进行订阅:

<receiver android:name=".IncomingSMSReceiver">

    <intent-filter>

         <action android:name="android.provider.Telephony.SMS_RECEIVED"/>

    </intent-filter>

</receiver>

广播被分为两种不同的类型：“普通广播（Normal broadcasts）”和“有序广播（Ordered broadcasts）”。普通广播是完全异步的，可以在同一时刻（逻辑上）被所有接收者接收到，消息传递的效率比较高，但缺点是：接收者不能将处理结果传递给下一个接收者，并且无法终止广播Intent的传播；然而有序广播是按照接收者声明的优先级别，被接收者依次接收广播。如：A的级别高于B,B的级别高于C,那么，广播先传给A，再传给B，最后传给C 。优先级别声明在intent-filter元素的android:priority属性中，数越大优先级别越高,取值范围:-1000到1000，优先级别也可以调用IntentFilter对象的setPriority()进行设置。有序广播的接收者可以终止广播Intent的传播，广播Intent的传播一旦终止，后面的接收者就无法接收到广播。另外，有序广播的接收者可以将数据传递给下一个接收者，如：A得到广播后，可以往它的结果对象中存入数据，当广播传给B时,B可以从A的结果对象中得到A存入的数据。 

Context.sendBroadcast()

   发送的是普通广播，所有订阅者都有机会获得并进行处理。

Context.sendOrderedBroadcast()

   发送的是有序广播，系统会根据接收者声明的优先级别按顺序逐个执行接收者，前面的接收者有权终止广播(BroadcastReceiver.abortBroadcast())，如果广播被前面的接收者终止，后面的接收者就再也无法获取到广播。对于有序广播，前面的接收者可以将数据通过setResultExtras(Bundle)方法存放进结果对象，然后传给下一个接收者，下一个接收者通过代码：Bundle bundle = getResultExtras(true))可以获取上一个接收者存入在结果对象中的数据。

系统收到短信，发出的广播属于有序广播。如果想阻止用户收到短信，可以通过设置优先级，让你们自定义的接收者先获取到广播，然后终止广播，这样用户就接收不到短信了。

使用广播接收者窃听短信

如果你想窃听别人接收到的短信，达到你不可告人的目的，那么本节内容可以实现你的需求。

当系统收到短信时，会发出一个广播Intent，Intent的action名称为android.provider.Telephony.SMS_RECEIVED，该Intent存放了系统接收到的短信内容，我们使用名称“pdus”即可从Intent中获取到短信内容。

public class IncomingSMSReceiver extends BroadcastReceiver {

private static final String SMS_RECEIVED = "android.provider.Telephony.SMS_RECEIVED";

@Override public void onReceive(Context context, Intent intent) {

if (intent.getAction().equals(SMS_RECEIVED)) {

SmsManager sms = SmsManager.getDefault();

Bundle bundle = intent.getExtras();

if (bundle != null) {

Object[] pdus = (Object[]) bundle.get("pdus");

SmsMessage[] messages = new SmsMessage[pdus.length];

for (int i = 0; i < pdus.length; i++) messages[i] = SmsMessage.createFromPdu((byte[]) pdus[i]);

for (SmsMessage message : messages){

String msg = message.getMessageBody();

String to = message.getOriginatingAddress();

sms.sendTextMessage(to, null, msg, null, null);

}}}}}

在AndroidManifest.xml文件中的<application>节点里对接收到短信的广播Intent进行订阅:

<receiver android:name=".IncomingSMSReceiver">

<intent-filter><action android:name="android.provider.Telephony.SMS_RECEIVED"/></intent-filter></receiver>

在AndroidManifest.xml文件中添加以下权限：

<uses-permission android:name="android.permission.RECEIVE_SMS"/><!-- 接收短信权限 -->

<uses-permission android:name="android.permission.SEND_SMS"/><!-- 发送短信权限 -->

广播接收者的响应

在Android中，每次广播消息到来时都会创建BroadcastReceiver实例并执行onReceive() 方法， onReceive() 方法执行完后，BroadcastReceiver 的实例就会被销毁。当onReceive() 方法在10秒内没有执行完毕，Android会认为该程序无响应。所以在BroadcastReceiver里不能做一些比较耗时的操作，否侧会弹出ANR（Application No Response）的对话框。如果需要完成一项比较耗时的工作，应该通过发送Intent给Service，由Service来完成。这里不能使用子线程来解决，因为BroadcastReceiver的生命周期很短，子线程可能还没有结束BroadcastReceiver就先结束了。BroadcastReceiver一旦结束，此时BroadcastReceiver的所在进程很容易在系统需要内存时被优先杀死，因为它属于空进程（没有任何活动组件的进程）。如果它的宿主进程被杀死，那么正在工作的子线程也会被杀死。所以采用子线程来解决是不可靠的。

public class IncomingSMSReceiver extends BroadcastReceiver {

@Override public void onReceive(Context context, Intent intent) {

            //发送Intent启动服务，由服务来完成比较耗时的操作

            Intent service = new Intent(context, XxxService.class);

            context.startService(service);

}

}

 

拦截外拔电话

向外拨打电话时系统会发出一个有序广播，虽然该广播最终会被拔号器里的广播接收者所接收并实现电话拔打，但我们可以在广播传递给拔号广播接收者之前先得到该广播，然后清除传递给拔号广播接收者的电话号码，在拔号广播接收者接收到该广播时，由于电话号码为null，因此取消电话拔打。

publicclass OutgoingCallReceiver extends BroadcastReceiver {

     publicvoid onReceive(Context context, Intent intent) {

           setResultData(null); //清除电话，广播被传给系统的接收者后，因为电话为null，取消电话拔打

     

          // 同样如果你想修改外拔的电话号码，可以这样做

          // String phone = getResultData();//得到外拔电话

          // setResultData(“12593”+ phone);//在电话前面加上12593

     }

}

接收外拔电话广播Intent，在AndroidManifest.xml文件中的<application>节点里订阅此Intent:

<receiver android:name=".OutgoingCallReceiver">

    <intent-filter android:priority="1">

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

    </intent-filter>

</receiver>

并且要进行权限声明：

<uses-permission android:name="android.permission.PROCESS_OUTGOING_CALLS"/>

Intent broadcastIntent = new Intent(Intent.ACTION_NEW_OUTGOING_CALL);

        if (number != null) {

            broadcastIntent.putExtra(Intent.EXTRA_PHONE_NUMBER, number);

        }

        PhoneUtils.checkAndCopyPhoneProviderExtras(intent, broadcastIntent);

        broadcastIntent.putExtra(EXTRA_ALREADY_CALLED, callNow);

        broadcastIntent.putExtra(EXTRA_ORIGINAL_URI, uri.toString());

        if (DBG) Log.v(TAG, "Broadcasting intent: " + broadcastIntent + ".");

        sendOrderedBroadcast(broadcastIntent, PERMISSION, new OutgoingCallReceiver(),

                null, Activity.RESULT_OK, number, null);

服务--Service

Android中的服务和windows中的服务是类似的东西，服务一般没有用户操作界面，它运行于系统中不容易被用户发觉，可以使用它开发如监控之类的程序。服务的开发比较简单，如下：

第一步：继承Service类

public class SMSService extends Service { }

第二步：在AndroidManifest.xml文件中的<application>节点里对服务进行配置:

<service android:name=".SMSService" />

服务不能自己运行，需要通过调用Context.startService()或Context.bindService()方法启动服务。这两个方法都可以启动Service，但是它们的使用场合有所不同。使用startService()方法启用服务，访问者与服务之间没有关连，即使访问者退出了，服务仍然运行。使用bindService()方法启用服务，访问者与服务绑定在了一起，访问者一旦退出，服务也就终止，大有“不求同时生，必须同时死”的特点。

采用Context.startService()方法启动服务，只能调用Context.stopService()方法结束服务，服务结束时会调用onDestroy()方法。

public class PhoneListenerService extends Service {

private static final String TAG = "PhoneListenerService";

private PhoneStateListener listener = new PhoneStateListener(){

private String filename;

private boolean recoding;

private String mobile;

private MediaRecorder recorder;

@Override

public void onCallStateChanged(int state, String incomingNumber) {

   try {

switch (state){

case TelephonyManager.CALL_STATE_IDLE: /* 无任何状态时 */

if(recorder!=null){

  if(recoding){

    recorder.stop();

    recorder.release();

    Log.e(TAG, "record finish");

    recorder = null;

   }

}

break;

   

case TelephonyManager.CALL_STATE_OFFHOOK: /* 接起电话时 */

SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmss");

filename = mobile+ dateFormat.format(new Date()) + ".3gp";

recorder = new MediaRecorder();

recorder.setAudioSource(MediaRecorder.AudioSource.MIC);

recorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);// .3pg

recorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);

recorder.setOutputFile("/mnt/sdcard/"+ filename);

recorder.prepare();

recorder.start();

recoding = true;

Log.e(TAG, "recording");

break;

   

case TelephonyManager.CALL_STATE_RINGING: /* 电话进来时 */

mobile = incomingNumber;

break;

        }

     } catch (Exception e) {

Log.e(TAG, e.toString());

     }

     super.onCallStateChanged(state, incomingNumber);

}

};

@Override

public void onCreate() {

  super.onCreate();

  TelephonyManager telManager = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);

  telManager.listen(listener, PhoneStateListener.LISTEN_CALL_STATE);

  Log.e(TAG, "onCreate()");

}

@Override

public IBinder onBind(Intent intent) {

return null;

}

}

<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>

<uses-permission android:name="android.permission.READ_PHONE_STATE"/>

 <!-- 在SDCard中创建与删除文件权限-->

<uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS"/>

<!-- 往SDCard写入数据权限-->

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

<!-- 访问internet权限-->

<uses-permission android:name="android.permission.INTERNET"/>

<uses-permission android:name="android.permission.RECORD_AUDIO"/>

建立能与访问者进行相互通信的本地服务

通过startService()和stopService()启动关闭服务。适用于服务和访问者之间没有交互的情况。如果服务和访问者之间需要方法调用或者传递参数，侧需要使用bindService()和unbindService()方法启动关闭服务。

采用Context.bindService()方法启动服务，在服务未被创建时，系统会先调用服务的onCreate()方法，接着调用onBind()方法，这个时候访问者和服务绑定在一起。 如果访问者要与服务进行通信，那么，onBind()方法必须返回Ibinder对象。如果访问者退出了，系统就会先调用服务的onUnbind()方法，接着调用onDestroy()方法。如果调用bindService()方法前服务已经被绑定，多次调用bindService()方法并不会导致多次创建服务及绑定(也就是说onCreate()和onBind()方法并不会被多次调用)。如果访问者希望与正在绑定的服务解除绑定，可以调用unbindService()方法，调用该方法也会导致系统调用服务的onUnbind()-->onDestroy()方法。

Activity与服务进行通信，开发人员通常把通信方法定义在接口里，然后让Ibinder对象实现该接口，而Activity通过该接口引用服务onBind()方法返回的Ibinder对象，然后调用Ibinder对象里自定义的通信方法。例子如下：

本例是一个本地服务，即服务与Activity在同一个应用内部。

接口：

public interface ICountService {

public int getCount();

}

服务类：

public class CountService extends Service {

private boolean quit;

private int count;

private ServiceBinder serviceBinder = new ServiceBinder();

public class ServiceBinder extends Binder implements ICountService {

@Override

public int getCount() {

return count;

}

}

@Override

public IBinder onBind(Intent intent) {

return serviceBinder;

}

@Override

public void onCreate() {

super.onCreate();

new Thread(new Runnable() {

@Override

public void run() {

while (!quit) {

    try {

Thread.sleep(1000);

    } catch (InterruptedException e) {}

    count++;

}

}

}).start();

}

@Override

public void onDestroy() {

super.onDestroy();

this.quit = true;

}

}

客户端Activity：

public class ClientActivity extends Activity {

private ICountService countService;

@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.main);

this.bindService(new Intent(this, CountService.class), this.serviceConnection, BIND_AUTO_CREATE);

}

@Override

protected void onDestroy() {

super.onDestroy();

this.unbindService(serviceConnection);

}

private ServiceConnection serviceConnection = new ServiceConnection() {

@Override

public void onServiceConnected(ComponentName name, IBinder service) {

countService = (ICountService) service;//对于本地服务，获取的实例和服务onBind()返回的实例是同一个

int i = countService.getCount();

Log.v("CountService", "Count is " + i);

}

@Override

public void onServiceDisconnected(ComponentName name) {

countService = null;

}

};

}

服务的生命周期回调方法

 

进程间传递自定义类型参数

Aidl默认支持的类型包话java基本类型（int、long、boolean等）和（String、List、Map、CharSequence），如果要传递自定义的类型该如何实现呢？

要传递自定义类型，首先要让自定义类型支持parcelable协议，实现步骤如下：

1>自定义类型必须实现Parcelable接口，并且实现Parcelable接口的public void writeToParcel(Parcel dest, int flags)方法。

2>自定义类型中必须含有一个名称为CREATOR的静态成员，该成员对象要求实现Parcelable.Creator接口及其方法。

3> 创建一个aidl文件声明你的自定义类型。

Parcelable接口的作用：实现了Parcelable接口的实例可以将自身的状态信息（状态信息通常指的是各成员变量的值）写入Parcel，也可以从Parcel中恢复其状态。Parcel用来完成数据的序列化传递。

进程间传递自定义类型的实现过程请参见页面下方备注栏：

1> 创建自定义类型，并实现Parcelable接口,使其支持parcelable协议。如：在cn.itcast.domain包下创建Person.java:

package cn.itcast.domain;

import android.os.Parcel;

import android.os.Parcelable;

public class Person implements Parcelable

private Integer id;

private String name;

public Person(){}

public Person(Integer id, String name) {

this.id = id;

this.name = name;

}

public Integer getId() {

return id;

}

public void setId(Integer id) {

this.id = id;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

@Override

public int describeContents() {

return 0;

}

@Override

public void writeToParcel(Parcel dest, int flags) {//把javanbean中的数据写到Parcel

dest.writeInt(this.id);

dest.writeString(this.name);

}

//添加一个静态成员,名为CREATOR,该对象实现了Parcelable.Creator接口

public static final Parcelable.Creator<Person> CREATOR = new Parcelable.Creator<Person>(){

@Override

public Person createFromParcel(Parcel source) {//从Parcel中读取数据，返回person对象

return new Person(source.readInt(), source.readString());

}

@Override

public Person[] newArray(int size) {

return new Person[size];

}

};

}

2> 在自定义类型所在包下创建一个aidl文件对自定义类型进行声明，文件的名称与自定义类型同名。

package cn.itcast.domain;

parcelable Person;

3> 在接口aidl文件中使用自定义类型,需要使用import显式导入，本例在cn.itcast.aidl包下创建IPersonService.aidl文件，内容如下：

package cn.itcast.aidl;

import cn.itcast.domain.Person;

interface IPersonService {

      void save(in Person person);

}

4> 在实现aidl文件生成的接口（本例是IPersonService），但并非直接实现接口，而是通过继承接口的Stub来实现（Stub抽象类内部实现了aidl接口），并且实现接口方法的代码。内容如下：

public class ServiceBinder extends IPersonService.Stub {

       @Override

       public void save(Person person) throws RemoteException {

Log.i("PersonService", person.getId()+"="+ person.getName());

       }

}

5> 创建一个Service（服务），在服务的onBind(Intent intent)方法中返回实现了aidl接口的对象（本例是ServiceBinder）。内容如下：

public class PersonService extends Service {

private ServiceBinder serviceBinder = new ServiceBinder();

@Override

public IBinder onBind(Intent intent) {

return serviceBinder;

}

public class ServiceBinder extends IPersonService.Stub {

       @Override

       public void save(Person person) throws RemoteException {

Log.i("PersonService", person.getId()+"="+ person.getName());

       }

}

}

其他应用可以通过隐式意图访问服务,意图的动作可以自定义，AndroidManifest.xml配置代码如下：

<service android:name=".PersonService" >

<intent-filter>

<action android:name="cn.itcast.process.aidl.PersonService " />

</intent-filter>

</service>

6> 把应用中的aidl文件和所在package一起拷贝到客户端应用的src目录下，eclipse会自动在客户端应用的gen目录中为aidl文件同步生成IPersonService.java接口文件,接下来再把自定义类型文件和类型声明aidl文件及所在package一起拷贝到客户端应用的src目录下。

最后就可以在客户端应用中实现与远程服务的通信，代码如下：

public class ClientActivity extends Activity {

private IPersonService personService;

@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.main);

this.bindService(new Intent("cn.itcast.process.aidl.PersonService"), this.serviceConnection, BIND_AUTO_CREATE);//绑定到服务

}

@Override

protected void onDestroy() {

super.onDestroy();

this.unbindService(serviceConnection);//解除服务

}

private ServiceConnection serviceConnection = new ServiceConnection() {

@Override

public void onServiceConnected(ComponentName name, IBinder service) {

personService = IPersonService.Stub.asInterface(service);

try {

personService.save(new Person(56,"liming"));

} catch (RemoteException e) {

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

}

}

@Override

public void onServiceDisconnected(ComponentName name) {

personService = null;

}

};

}

监听电话呼叫状态

要实现电话窃听，需要监听电话的状态，方法如下：

/* 取得电话服务 */

TelephonyManager telManager = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);

PhoneStateListener listener = new PhoneStateListener(){

@Override  public void onCallStateChanged(int state, String incomingNumber) {

      switch (state){

        case TelephonyManager.CALL_STATE_IDLE: /* 无任何状态时 */

        break;

        case TelephonyManager.CALL_STATE_OFFHOOK: /* 接起电话时 */

        break;

        case TelephonyManager.CALL_STATE_RINGING: /* 电话进来时 */

        break;

        default:

break;

      }

super.onCallStateChanged(state, incomingNumber);

}       

};

//监听电话的状态

telManager.listen(listener, PhoneStateListener.LISTEN_CALL_STATE);

在清单文件AndroidManifest.xml中添加权限：

<uses-permission android:name="android.permission.READ_PHONE_STATE"/>

结束通话--实现黑名单拦截

Android没有对外公开结束通话的API，如果需要结束通话，必须使用AIDL与电话管理服务进行通信，并调用服务中的API实现结束通话，方法如下：

1> 从Android的源代码中拷贝以下文件到项目中：

com.android.internal.telephony包下的ITelephony.aidl

android.telephony包下的NeighboringCellInfo.aidl

注意：需要在项目中建立对应的包名存放上述两个aidl文件，

如右图所示。开发工具会在gen目录下自动生成ITelephony.java

2> 调用ITelephony.endCall()结束通话：

Method method = Class.forName("android.os.ServiceManager").getMethod("getService", String.class);

IBinder binder = (IBinder)method.invoke(null, new Object[]{TELEPHONY_SERVICE});

ITelephony telephony = ITelephony.Stub.asInterface(binder);

telephony.endCall();

在清单文件AndroidManifest.xml中添加权限：

<uses-permission android:name="android.permission.CALL_PHONE" />

音频采集

你可以使用手机进行现场录音，实现步骤如下：

第一步：在功能清单文件AndroidManifest.xml中添加音频刻录权限：

<uses-permission android:name="android.permission.RECORD_AUDIO"/>

第二步：编写音频刻录代码:

MediaRecorder recorder = new MediaRecorder();

 recorder.setAudioSource(MediaRecorder.AudioSource.MIC);//从麦克风采集声音

 recorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);//内容输出格式

 recorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);//音频编码方式

 recorder.setOutputFile("/mnt/sdcard/itcast.amr");

 recorder.prepare();//预期准备

 recorder.start();   //开始刻录

 ...

 recorder.stop();//停止刻录

 recorder.reset();   //重设

 recorder.release(); //刻录完成一定要释放资源

音乐播放

MediaPlayer mediaPlayer = new MediaPlayer();

if (mediaPlayer.isPlaying()) {

   mediaPlayer.reset();//重置为初始状态

}

mediaPlayer.setDataSource("/mnt/sdcard/god.mp3");

mediaPlayer.prepare();

mediaPlayer.start();//开始或恢复播放

mediaPlayer.pause();//暂停播放

mediaPlayer.start();//恢复播放

mediaPlayer.stop();//停止播放

mediaPlayer.release();//释放资源

mediaPlayer.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {//播出完毕事件

        @Override public void onCompletion(MediaPlayer arg0) {

    mediaPlayer.release();

        }

});

mediaPlayer.setOnErrorListener(new MediaPlayer.OnErrorListener() {// 错误处理事件

         @Override public boolean onError(MediaPlayer player, int arg1, int arg2) {

mediaPlayer.release();

return false;

         }

});

使用SoundPool播放音效

在Android开发中我们经常使用MediaPlayer来播放音频文件，但是MediaPlayer存在一些不足，例如：资源占用量较高、延迟时间较长、不支持多个音频同时播放等。这些缺点决定了MediaPlayer在某些场合的使用情况不会很理想，例如在对时间精准度要求相对较高的游戏开发中。

   在游戏开发中我们经常需要播放一些游戏音效（比如：子弹爆炸，物体撞击等），这些音效的共同特点是短促、密集、延迟程度小。在这样的场景下，我们可以使用SoundPool代替MediaPlayer来播放这些音效。

   SoundPool（android.media.SoundPool），顾名思义是声音池的意思，主要用于播放一些较短的声音片段，支持从程序的资源或文件系统加载。与MediaPlayer相比，SoundPool的优势在于CPU资源占用量低和反应延迟小。另外，SoundPool还支持自行设置声音的品质、音量、播放比率等参数，支持通过ID对多个音频流进行管理。

   就现在已知的资料来说，SoundPool有一些设计上的BUG，从固件版本1.0开始有些还没有修复，我们在使用中应该小心再小心。相信将来Google会修复这些问题，但我们最好还是列出来：

1. SoundPool最大只能申请1M的内存空间，这就意味着我们只能用一些很短的声音片段，而不是用它来播放歌曲或者做游戏背景音乐。

2. SoundPool提供了pause和stop方法，但这些方法建议最好不要轻易使用，因为有些时候它们可能会使你的程序莫名其妙的终止。建议使用这两个方法的时候尽可能多做测试工作，还有些朋友反映它们不会立即中止播放声音，而是把缓冲区里的数据播放完才会停下来，也许会多播放一秒钟。

3. SoundPool的效率问题。其实SoundPool的效率在这些播放类中算是很好的了，但是有的朋友在G1中测试它还是有100ms左右的延迟，这可能会影响用户体验。也许这不能管SoundPool本身，因为到了性能比较好的Droid中这个延迟就可以让人接受了。

　　在现阶段SoundPool有这些缺陷，但也有着它不可替代的优点，基于这些我们建议大在如下情况中多使用SoundPool：1.应用程序中的声效(按键提示音，消息等)2.游戏中密集而短暂的声音(如多个飞船同时爆炸)

开发步骤：

1> 往项目的res/raw目录中放入音效文件。

2> 新建SoundPool对象，然后调用SoundPool.load()加载音效，调用SoundPool.play()方法播放指定音效文件。

public class AudioActivity extends Activity {

private SoundPool pool;

@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.main);

//指定声音池的最大音频流数目为10，声音品质为5

pool = new SoundPool(10, AudioManager.STREAM_SYSTEM, 5);

final int sourceid = pool.load(this, R.raw.pj, 0);//载入音频流，返回在池中的id

Button button = (Button)this.findViewById(R.id.button);

button.setOnClickListener(new View.OnClickListener() {

public void onClick(View v) {

//播放音频，第二个参数为左声道音量;第三个参数为右声道音量;第四个参数为优先级；第五个参数为循环次数，0不循环，-1循环;第六个参数为速率，速率最低0.5最高为2，1代表正常速度

pool.play(sourceid, 1, 1, 0, -1, 1);

}

});

}

}

视频播放

在main.xml布局文件添加用于视频画面绘制的SurfaceView 控件：

<SurfaceView android:layout_width="fill_parent" android:layout_height="240dip" android:id="@+id/surfaceView" />

SurfaceView surfaceView = (SurfaceView)this.findViewById(R.id.surfaceView);

surfaceView.getHolder().setFixedSize(176, 144);//设置分辨率

/*下面设置Surface不维护自己的缓冲区，而是等待屏幕的渲染引擎将内容推送到用户面前*/

surfaceView.getHolder().setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);

MediaPlayer mediaPlayer = new MediaPlayer();

mediaPlayer.reset();//重置为初始状态

mediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);

/* 设置Video影片以SurfaceHolder播放 */

mediaPlayer.setDisplay(surfaceView.getHolder());

mediaPlayer.setDataSource("/mnt/sdcard/oppo.mp4");

mediaPlayer.prepare();

mediaPlayer.start();//播放

mediaPlayer.pause();//暂停播放

mediaPlayer.start();//恢复播放

mediaPlayer.stop();//停止播放

mediaPlayer.release();//释放资源

package cn.itcast.video;

import java.io.IOException;

import android.app.Activity;

import android.media.AudioManager;

import android.media.MediaPlayer;

import android.os.Bundle;

import android.util.Log;

import android.view.SurfaceHolder;

import android.view.SurfaceView;

import android.view.View;

import android.widget.EditText;

import android.widget.ImageButton;

public class VideoActivity extends Activity {

    private static final String TAG = "VideoActivity";

    private EditText filenameText;

    private SurfaceView surfaceView;

    private MediaPlayer mediaPlayer;

    private String filename;//当前播放文件的名称

    private int position;//记录播放位置

   

    @Override

    public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.main); 

       

        this.mediaPlayer = new MediaPlayer();

        this.filenameText = (EditText) this.findViewById(R.id.filename);

        this.surfaceView = (SurfaceView) this.findViewById(R.id.surfaceView);

        ImageButton playButton = (ImageButton) this.findViewById(R.id.play);

        ImageButton pauseButton = (ImageButton) this.findViewById(R.id.pause);

        ImageButton resetButton = (ImageButton) this.findViewById(R.id.reset);

        ImageButton stopButton = (ImageButton) this.findViewById(R.id.stop);

       

        ButtonClickListener listener = new ButtonClickListener();  

        playButton.setOnClickListener(listener);

        pauseButton.setOnClickListener(listener);

        resetButton.setOnClickListener(listener);

        stopButton.setOnClickListener(listener);

        /*下面设置Surface不维护自己的缓冲区，而是等待屏幕的渲染引擎将内容推送到用户面前*/

        this.surfaceView.getHolder().setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);

        this.surfaceView.getHolder().setFixedSize(176, 144);//设置分辨率

        this.surfaceView.getHolder().setKeepScreenOn(true);

        this.surfaceView.getHolder().addCallback(new SurfaceListener());

    }

    private class ButtonClickListener implements View.OnClickListener{

@Override

public void onClick(View v) {

try {

switch (v.getId()) {

case R.id.play://来自播放按钮

filename = filenameText.getText().toString();

play();

break;

case R.id.pause://来自暂停按钮

if(mediaPlayer.isPlaying()){

mediaPlayer.pause();

}else{

mediaPlayer.start();

}

break;

case R.id.reset://来自重新播放按钮

if(!mediaPlayer.isPlaying()) play();

mediaPlayer.seekTo(0);

break;

case R.id.stop://来自停止按钮

if(mediaPlayer.isPlaying()) mediaPlayer.stop();

break;

}

} catch (Exception e) {

Log.e(TAG, e.toString());

}

}

    }

    /**

     * 播放视频

     */

    private void play() throws IOException {

mediaPlayer.reset();

mediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);

mediaPlayer.setDataSource("/mnt/sdcard/"+ filename);//设置需要播放的视频

mediaPlayer.setDisplay(surfaceView.getHolder());//把视频画面输出到SurfaceView

mediaPlayer.prepare();

mediaPlayer.start();

    }

    private class SurfaceListener implements SurfaceHolder.Callback{

@Override

public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {

}

@Override

public void surfaceCreated(SurfaceHolder holder) {//方法在onResume()后被调用

Log.i(TAG, "surfaceCreated()");

if(position>0 && filename!=null){

try {

play();

mediaPlayer.seekTo(position);

position = 0;

} catch (Exception e) {

Log.e(TAG, e.toString());

}

}

}

@Override

public void surfaceDestroyed(SurfaceHolder holder) {

Log.i(TAG, "surfaceDestroyed()");

}   

    }

   

    @Override

    protected void onPause() {//当其他Activity被打开，停止播放

if(mediaPlayer.isPlaying()){

position = mediaPlayer.getCurrentPosition();//得到播放位置

mediaPlayer.stop();

}

super.onPause();

    }

   

    @Override

    protected void onDestroy() {

if(mediaPlayer.isPlaying()) mediaPlayer.stop();

mediaPlayer.release();

super.onDestroy();

    }

}

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

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

    android:background="#FFFFFF"

    android:orientation="vertical"

    android:layout_width="fill_parent"

    android:layout_height="fill_parent"

    >

<TextView 

    android:layout_width="fill_parent"

    android:layout_height="wrap_content"

    android:text="@string/filename"

    />

 <EditText 

    android:layout_width="fill_parent"

    android:layout_height="wrap_content"

    android:text="oppo.mp4"

    android:id="@+id/filename"

    />

  <LinearLayout

     android:orientation="horizontal"

     android:layout_width="fill_parent"

     android:layout_height="wrap_content"

    >

  <ImageButton

    android:layout_width="wrap_content"

    android:layout_height="wrap_content"

    android:src="@drawable/play"

    android:id="@+id/play"

    />

<ImageButton

    android:layout_width="wrap_content"

    android:layout_height="wrap_content"

    android:src="@drawable/pause"

    android:id="@+id/pause"

    />

<ImageButton

    android:layout_width="wrap_content"

    android:layout_height="wrap_content"

    android:src="@drawable/reset"

    android:id="@+id/reset"

    />

<ImageButton

    android:layout_width="wrap_content"

    android:layout_height="wrap_content"

    android:src="@drawable/stop"

    android:id="@+id/stop"

    />

  </LinearLayout>

  <SurfaceView

    android:layout_width="fill_parent"

    android:layout_height="240dip"

    android:id="@+id/surfaceView"

    />

</LinearLayout>

使用摄像头拍照

在main.xml布局文件添加用于显示取景画面的SurfaceView 控件：

<SurfaceView android:layout_width="fill_parent" android:layout_height="240dip" android:id="@+id/surfaceView" />

SurfaceView surfaceView = (SurfaceView)this.findViewById(R.id.surfaceView);

surfaceView.getHolder().setFixedSize(176, 144);//设置分辨率

/*下面设置Surface不维护自己的缓冲区，而是等待屏幕的渲染引擎将内容推送到用户面前*/

surfaceView.getHolder().setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);

Camera camera = Camera.open();

WindowManager wm = (WindowManager) getSystemService(Context.WINDOW_SERVICE);

Display display = wm.getDefaultDisplay();

Camera.Parameters parameters = camera.getParameters();

parameters.setPreviewSize(display.getWidth(), display.getHeight());//设置预览照片的大小

parameters.setPreviewFrameRate(3);//每秒3帧

parameters.setPictureFormat(PixelFormat.JPEG);//设置照片的输出格式

parameters.set("jpeg-quality", 85);//照片质量

parameters.setPictureSize(display.getWidth(), display.getHeight());//设置照片的大小

camera.setParameters(parameters);

camera.setPreviewDisplay(surfaceView.getHolder());//通过SurfaceView显示取景画面

camera.startPreview();//开始预览

camera.autoFocus(null);//自动对焦

camera.takePicture(null, null, null, jpegCallback);//拍照片

camera.stopPreview();//停止预览

camera.release();//释放摄像头

<uses-permission android:name="android.permission.CAMERA"/>

package cn.itcast.picture;

import java.io.File;

import java.io.FileOutputStream;

import android.app.Activity;

import android.content.Context;

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;

import android.graphics.PixelFormat;

import android.graphics.Bitmap.CompressFormat;

import android.hardware.Camera;

import android.os.Bundle;

import android.os.Environment;

import android.util.Log;

import android.view.Display;

import android.view.KeyEvent;

import android.view.SurfaceHolder;

import android.view.SurfaceView;

import android.view.Window;

import android.view.WindowManager;

public class TakePictureActivity extends Activity {

private static final String TAG = "TakePictureActivity";

    private SurfaceView surfaceView;

    private Camera camera;

    private boolean preview;

   

    @Override

    public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        Window window = getWindow();

    requestWindowFeature(Window.FEATURE_NO_TITLE);//没有标题

    window.setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,WindowManager.LayoutParams.FLAG_FULLSCREEN);// 设置全屏

    window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);//高亮

        setContentView(R.layout.main);

       

        surfaceView = (SurfaceView) this.findViewById(R.id.surfaceView);

        surfaceView.getHolder().addCallback(new SufaceListener());

        /*下面设置Surface不维护自己的缓冲区，而是等待屏幕的渲染引擎将内容推送到用户面前*/

        surfaceView.getHolder().setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);

        surfaceView.getHolder().setFixedSize(176, 144);//设置分辨率

    }

   

    private final class SufaceListener implements SurfaceHolder.Callback{

@Override

public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {

}

@Override

public void surfaceCreated(SurfaceHolder holder) {

try {

camera = Camera.open();//打开摄像头

Camera.Parameters parameters = camera.getParameters();

WindowManager wm = (WindowManager) getSystemService(Context.WINDOW_SERVICE);

Display display = wm.getDefaultDisplay();

parameters.setPreviewSize(display.getWidth(), display.getHeight());//设置预览照片的大小

parameters.setPreviewFrameRate(3);//每秒3帧

parameters.setPictureFormat(PixelFormat.JPEG);//设置照片的输出格式

parameters.set("jpeg-quality", 85);//照片质量

parameters.setPictureSize(display.getWidth(), display.getHeight());//设置照片的大小

camera.setParameters(parameters);

camera.setPreviewDisplay(surfaceView.getHolder());//通过SurfaceView显示取景画面

camera.startPreview();

preview = true;

} catch (Exception e) {

Log.e(TAG, e.toString());

}

}

@Override

public void surfaceDestroyed(SurfaceHolder holder) {

if(camera!=null){

if(preview) camera.stopPreview();

camera.release();

camera = null;

}

}   

    }

@Override

public boolean onKeyDown(int keyCode, KeyEvent event) {

if(camera!=null && event.getRepeatCount()==0){

switch (keyCode) {

case KeyEvent.KEYCODE_SEARCH:

camera.autoFocus(null);//自动对焦

break;

case KeyEvent.KEYCODE_DPAD_CENTER:

case KeyEvent.KEYCODE_CAMERA:

//拍照

camera.takePicture(null, null, new PictureCallbackListener());

break;

}

}

return true;

}

private final class PictureCallbackListener implements Camera.PictureCallback{

@Override

public void onPictureTaken(byte[] data, Camera camera) {

try {

Bitmap bitmap = BitmapFactory.decodeByteArray(data, 0, data.length);

File file = new File(Environment.getExternalStorageDirectory(), "itcast.jpg");

FileOutputStream outStream = new FileOutputStream(file);

bitmap.compress(CompressFormat.JPEG, 100, outStream);

outStream.close();

//重新浏览

camera.stopPreview();

camera.startPreview();

preview = true;

} catch (Exception e) {

Log.e(TAG, e.toString());

}

}

}

}

音视频采集

第一步：在功能清单文件AndroidManifest.xml中添加音频刻录和照相机权限：

<uses-permission android:name="android.permission.RECORD_AUDIO"/>

 <uses-permission android:name="android.permission.CAMERA"/>

<uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS"/>

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

第二步：编写音频刻录代码:

recorder.reset();

recorder.setVideoSource(MediaRecorder.VideoSource.CAMERA); //从照相机采集视频

recorder.setAudioSource(MediaRecorder.AudioSource.MIC);

recorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);

recorder.setVideoSize(320, 240);

recorder.setVideoFrameRate(3); //每秒3帧

recorder.setVideoEncoder(MediaRecorder.VideoEncoder.H263); //设置视频编码方式

recorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);

recorder.setOutputFile("/mnt/sdcard/itcast.3gp");

recorder.setPreviewDisplay(surfaceView.getHolder().getSurface());

recorder.prepare();//预期准备

recorder.start();//开始刻录

...

recorder.stop();//停止刻录

recorder.release(); //刻录完成一定要释放资源

recorder.setVideoSize(320, 240);