Android面试，给正在找工作的安卓攻城师们 ... ...

从java基础技能到安卓进阶技能，有你想象不到的全面。

☆ JAVA技能

« 有良好的JAVA基础，熟练掌握面向对象思想：

理解面向对象：

面向对象是一种思想，是基于面向过程而言的，就是说面向对象是将功能等通过对象来实现，将功能封装进对象之中，让对象去实现具体的细节；这种思想是将数据作为第一位，而方法或者说是算法作为其次，这是对数据一种优化，操作起来更加的方便，简化了过程。面向对象有三大特征：封装性、继承性、多态性，其中封装性指的是隐藏了对象的属性和实现细节，仅对外提供公共的访问方式，这样就隔离了具体的变化，便于使用，提高了复用性和安全性。对于继承性，就是两种事物间存在着一定的所属关系，那么继承的类就可以从被继承的类中获得一些属性和方法；这就提高了代码的复用性。继承是作为多态的前提的。多态是说父类或接口的引用指向了子类对A象，这就提高了程序的扩展性，也就是说只要实现或继承了同一个接口或类，那么就可以使用父类中相应的方法，提高程序扩展性，但是多态有一点不好之处在于：父类引用不能访问子类中的成员。

举例来说：就是：比如说你要去饭店吃饭，你只需要饭店，找到饭店的服务员，跟她说你要吃什么，然后叫会给你做出来让你吃，你并不需要知道这个饭是怎么错的，你只需要面向这个服务员，告诉他你要吃什么，然后他也只需要面向你吃完收到钱就好，不需要知道你怎么对这个饭进行吃。

1、特点：

1：将复杂的事情简单化。

2：面向对象将以前的过程中的执行者，变成了指挥者。

3：面向对象这种思想是符合现在人们思考习惯的一种思想。

2、面向对象的三大特征：封装，继承、多态

1.封装：只隐藏对象的属性和实现细节，仅对外提供公共访问方式

好处：将变化隔离、便于使用、提高复用性、提高安全性

原则：将不需要对外提供的内容隐藏起来；把属性隐藏，提供公共方法对其访问

2.继承：提高代码复用性；继承是多态的前提

注：

①子类中所有的构造函数都会默认访问父类中的空参数的构造函数，默认第一行有super()；若无空参数构造函数，子类中需指定；另外，子类构造函数中可自己用this指定自身的其他构造函数。

3.多态

是父类或接口定义的引用变量可以指向子类或具体实现类的实例对象

好处：提高了程序的扩展性

弊端：当父类引用指向子类对象时，虽提高了扩展性，但只能访问父类中具备的方法，不可访问子类中的方法；即访问的局限性。

前提：实现或继承关系；覆写父类方法。

« 熟练使用集合、IO流及多线程

一、集合：

1、特点：存储对象；长度可变；存储对象的类型可不同；

2、集合框架：

2）Collection

（1）List：有序的；元素可重复，有索引

（add(index,element)、add(index,Collection)、remove(index)、set(index,element)、get(index)、subList(from, to)、listIterator()）

①ArrayList：底层是数组结构，查询快，增删慢，不同步。

②LinkedList：底层是链表结构，增删快，查询慢，不同步

addFist();addLast() getFirst();getLast()

removeFirst();removeLast()获取并删除元素，无元素将抛异常：NoSuchElementException

替代的方法(JDK1.6)：

offerFirst();offerLast();

peekFirst();peekLast();无元素返回null

pollFirst();pollLast();删除并返回此元素，无元素返回null

③Vector：底层是数组结构，线程同步，被ArrayList取代了

注：了对于判断是否存在，以及删除等操作，以依赖的方法是元素的hashCode和equals方法

ArrayList判断是否存在和删除操作依赖的是equals方法

（2）Set：无序的，无索引，元素不可重复

①HashSet：底层是哈希表，线程不同步，无序、高效

保证元素唯一性：通过元素的hashCode和equals方法。若hashCode值相同，则会判断equals的结果是否为true；hashCode不同，不会调用equals方法

LinkedHashSet：有序，是HashSet的子类

②TreeSet：底层是二叉树，可对元素进行排序，默认是自然顺序

保证唯一性：Comparable接口的compareTo方法的返回值

===》TreeSet两种排序方式：两种方式都存在时，以比较器为主

第一种：自然排序（默认排序）：

添加的对象需要实现Comparable接口，覆盖compareTo方法

第二种：比较器

添加的元素自身不具备比较性或不是想要的比较方式。将比较器作为参数传递进去。

定义一个类，实现Comparator接口，覆盖compare方法。当主要条件相同时，比较次要条件。

3）Map集合：

（1）HashTable：底层数据结构是哈希表，不可存入null键和null值。同步的

Properties继承自HashTable，可保存在流中或从流中加载，是集合和IO流的结合产物

（2）HashMap：底层数据结构是哈希表；允许使用null键和null值，不同步，效率高

TreeMap：

底层数据结构时二叉树，不同步，可排序

与Set很像，Set底层就是使用了Map集合

方法：

V put(K key, V value); void putAll(Map m)

void clear(); V remove(Object key)

booleancontainsKey(Object key); containsValue(Object key); isEmpty()

V get(Object key); intsize(); Collection<V> values()

Set<K>keySet(); Set<Map.Entry<K,V>> entrySet()

2.3、Map集合两种取出方式：

第一种：Set<K> keySet()

取出Map集合中的所有键放于Set集合中，然后再通过键取出对应的值

Set<String> keySet= map.keySet();

Iterator<String>it = keySet.iterator();

while(it.hasNext()){

String key = it.next();

String value = map.get(key);

//…..

}

第二种：Set<Map.Entry<K,V>> entrySet()

取出Map集合中键值对的映射放于Set集合中，然后通过Map集合中的内部接口，然后通过其中的方法取出

Set<Map.Entry<String,String>>entrySet = map.entrySet();

Iterator<Map.Entry<String,String>>it = entrySet.iterator();

While(it.hasNext()){

Map.Entry<String,String> entry = it.next();

String key = entry.getKey();

String value = entry.getValue();

//……

}

2.4、Collection和Map的区别：

Collection：单列集合，一次存一个元素

Map：双列集合，一次存一对集合，两个元素（对象）存在着映射关系

2.5、集合工具类：

Collections：操作集合（一般是list集合）的工具类。方法全为静态的

sort(List list);对list集合进行排序;sort(List list, Comparator c) 按指定比较器排序

fill(List list, T obj);将集合元素替换为指定对象；

swap(List list, int I,int j)交换集合指定位置的元素

shuffle(List list); 随机对集合元素排序

reverseOrder() ：返回比较器，强行逆转实现Comparable接口的对象自然顺序

reverseOrder(Comparatorc)：返回比较器，强行逆转指定比较器的顺序

2.6、Collection和Collections的区别：

Collections：java.util下的工具类，实现对集合的查找、排序、替换、线程安全化等操作。

Collection：是java.util下的接口，是各种单列集合的父接口，实现此接口的有List和Set集合，存储对象并对其进行操作。

3、Arrays：

用于操作数组对象的工具类，全为静态方法

asList()：将数组转为list集合

好处：可通过list集合的方法操作数组中的元素：

isEmpty()、contains()、indexOf()、set()

弊端：数组长度固定，不可使用集合的增删操作。

如果数组中存储的是基本数据类型，asList会将数组整体作为一个元素存入集合

集合转为数组：Collection.toArray()；

好处：限定了对集合中的元素进行增删操作，只需获取元素

二、IO流

1、结构：

字节流：InputStream，OutputStream

字符流：Reader，Writer

Reader：读取字符流的抽象类

BufferedReader：将字符存入缓冲区，再读取

LineNumberReader：带行号的字符缓冲输入流

InputStreamReader：转换流，字节流和字符流的桥梁，多在编码的地方使用

FileReader：读取字符文件的便捷类。

Writer：写入字符流的抽象类

BufferedWriter：将字符存入缓冲区，再写入

OutputStreamWriter：转换流，字节流和字符流的桥梁，多在编码的地方使用

FileWriter：写入字符文件的便捷类。

InputStream：字节输入流的所有类的超类

ByteArrayInputStream：含缓冲数组，读取内存中字节数组的数据，未涉及流

FileInputStream：从文件中获取输入字节。媒体文件

BufferedInputStream：带有缓冲区的字节输入流

DataInputStream：数据输入流，读取基本数据类型的数据

ObjectInputStream：用于读取对象的输入流

PipedInputStream：管道流，线程间通信，与PipedOutputStream配合使用

SequenceInputStream：合并流，将多个输入流逻辑串联。

OutputStream：此抽象类是表示输出字节流的所有类的超类

ByteArrayOutputStream：含缓冲数组，将数据写入内存中的字节数组，未涉及流

FileOutStream：文件输出流，将数据写入文件

BufferedOutputStream：带有缓冲区的字节输出流

PrintStream：打印流，作为输出打印

DataOutputStream：数据输出流，写入基本数据类型的数据

ObjectOutputStream：用于写入对象的输出流

PipedOutputStream：管道流，线程间通信，与PipedInputStream配合使用

2、流操作规律：

明确源和目的：

数据源：读取，InputStream和Reader

目的：写入：OutStream和Writer

数据是否是纯文本：

是：字符流，Reader，Writer

否：字节流，InputStream，OutStream

明确数据设备：

源设备：内存、硬盘、键盘

目的设备：内存、硬盘、控制台

是否提高效率：用BufferedXXX

3、转换流：将字节转换为字符，可通过相应的编码表获得

转换流都涉及到字节流和编码表

三、多线程

--à进程和线程：

1）进程是静态的，其实就是指开启的一个程序；而线程是动态的，是真正执行的单元，执行的过程。其实我们平时看到的进程，是线程在执行着，因为线程是作为进程的一个单元存在的。

2）同样作为基本的执行单元，线程是划分得比进程更小的执行单位。

3）每个进程都有一段专用的内存区域。与此相反，线程却共享内存单元（包括代码和数据），通过共享的内存单元来实现数据交换、实时通信与必要的同步操作。

1、创建线程的方式：

创建方式一：继承Thread

1：定义一个类继承Thread

2：覆盖Thread中的run方法（将线程运行的代码放入run方法中）。

3：直接创建Thread的子类对象

4：调用start方法（内部调用了线程的任务（run方法））；作用：启动线程，调用run方法

方式二：实现Runnable

1：定义类实现Runnable接口

2：覆盖Runnable接口中的run方法，将线程的任务代码封装到run中

3：通过Thread类创建线程对象

4、并将Runnable接口的子类对象作为Thread类的构造函数参数进行传递

作为参数传递的原因是让线程对象明确要运行的run方法所属的对象。

区别：

继承方式：线程代码放在Thread子类的run方法中

实现方式：线程存放在接口的子类run方法中；避免了单继承的局限性，建议使用。

2、线程状态：

新建：start()

临时状态：具备cpu的执行资格，但是无执行权

运行状态：具备CPU的执行权，可执行

冻结状态：通过sleep或者wait使线程不具备执行资格，需要notify唤醒，并处于临时状态。

消亡状态：run方法结束或者中断了线程，使得线程死亡。

3、多线程安全问题：

多个线程共享同一数据，当某一线程执行多条语句时，其他线程也执行进来，导致数据在某一语句上被多次修改，执行到下一语句时，导致错误数据的产生。

因素：多个线程操作共享数据；多条语句操作同一数据

解决：

原理：某一时间只让某一线程执行完操作共享数据的所有语句。

办法：使用锁机制：synchronized或lock对象

4、线程的同步：

当两个或两个以上的线程需要共享资源，他们需要某种方法来确定资源在某一刻仅被一个线程占用，达到此目的的过程叫做同步（synchronization）。

同步代码块：synchronized(对象){}，将需要同步的代码放在大括号中，括号中的对象即为锁。

同步函数：放于函数上，修饰符之后，返回类型之前。

5、wait和sleep的区别：（执行权和锁区分）

wait：可指定等待的时间，不指定须由notify或notifyAll唤醒。

线程会释放执行权，且释放锁。

sleep：必须制定睡眠的时间，时间到了自动处于临时（阻塞）状态。

即使睡眠了，仍持有锁，不会释放执行权。

Android下的进程与线程：

1、进程的生命周期：

1）、进程的创建及回收：

进程是被系统创建的，当内存不足的时候，又会被系统回收

2）、进程的级别：

Foreground Process 前台进程

Visible Process 可视进程

Service Process 服务进程：可以提高级别的

Background Process 后台进程

Empty Process 空进程（无组件启动，做进程缓存使用，恢复速度快）

☆ Android技能

« 熟练掌握Android四大组件，常用的布局文件，自定义控件等

Android中4大组件是：ContentProvider、Activity、BroadcastReceiver和Service

清单文件：

1、所有的应用程序必须要有清单文件

在manifest节点下需要声明当前应用程序的包名

2、包名：声明包的名字，必须唯一

如果两个应用程序的包名和签名都相同，后安装的会覆盖先安装的

3、声明的程序的组件（4大组件）

其中比较特殊的是广播接收者，可以不在清单文件中配置，可以通过代码进行注册

4、声明程序需要的权限：保护用户的隐私

5、可以控制服务在单独的进程中的，四大组件都可以配置这个属性process

在组件节点配置process：

如：android:process="xxx.ooo.xxx"

比如说：处理图片的时候，会很耗内存，就需要在单独的新的进程中，可以减少内存溢出的几率

一、ContentProvider内容提供者

1、特点

①、可以将应用中的数据对外进行共享；

②、数据访问方式统一，不必针对不同数据类型采取不同的访问策略；

③、内容提供者将数据封装，只暴露出我们希望提供给其他程序的数据（这点有点类似Javabeans）；

④、内容提供者中数据更改可被监听；

2、创建内容提供者

Ø 定义类继承ContentProvider，根据需要重写其内容方法(6个方法)：

l onCreate() 创建内容提供者时，会调用这个方法，完成一些初始化操作；

l crud相应的4个方法用于对外提供CRUD操作；

l getType() 返回当前Url所代表数据的MIME类型：

返回的是单条记录：以vnd.android.cursor.item/ 开头，如：vnd.android.cursor.item/person

返回的是多条记录：以vnd.android.cursor.dir/ 开头，如：vnd.android.cursor.dir/person

Ø 在清单文件的<application>节点下进行配置，<provider>标签中需要指定name、authorities、exported属性

l name：为全类名；

l authorities：是访问Provider时的路径，要唯一；

l exported：用于指示该服务是否能够被其他应用程序组件调用或跟它交互

Ø URI代表要操作的数据，由scheme、authorites、path三部分组成：

l content://com.itheima.sqlite.provider/person

l scheme：固定为content，代表访问内容提供者；

l authorites： <provider>节点中的authorites属性；

l path：程序定义的路径，可根据业务逻辑定义；

Ø 操作 URI的UriMather与ContentUris工具类：

当程序调用CRUD方法时会传入Uri

l UriMatcher：表示URI匹配器，可用于添加Uri匹配模式，与匹配Uri（见下代码）；

l ContentUris：用于操作Uri路径后面的ID部分,2个重要的方法：

1. withAppendedId(uri, id) 为路径加上ID部分；

2. parseId(uri) 用于从路径中获取ID部分；

示例代码（内容提供者类）：

public classHeimaProvider extends ContentProvider {

private static final int PERSON = 1; // 匹配码

private static final int STUDENT = 2; // 匹配码

private static final int PERSON_ID = 3; // 匹配码

private MyHelper helper;

/** Uri匹配器 */

private UriMatcher uriMatcher = newUriMatcher(UriMatcher.NO_MATCH);

@Override

public boolean onCreate() {

System.out.println("onCreate...");

helper = newMyHelper(getContext());

// == 添加 uri 匹配模式, 设置匹配码（参数3） Uri如果匹配就会返回相应的匹配码 ==

uriMatcher.addURI("com.itheima.sqlite.provider","person", PERSON);

uriMatcher.addURI("com.itheima.sqlite.provider","#", PERSON_ID); // #表示匹配数字，*表示匹配文本

uriMatcher.addURI("com.itheima.sqlite.provider","student", STUDENT);

return true;

}

@Override

public Uri insert(Uri uri, ContentValuesvalues) {

SQLiteDatabase db =helper.getWritableDatabase();

switch (uriMatcher.match(uri)) { // 匹配uri

case PERSON:

long id =db.insert("person", "id", values);

db.close();

returnContentUris.withAppendedId(uri, id); //在原uri上拼上id，生成新的uri并返回；

case STUDENT:

long insert =db.insert("student", "id", values);

System.out.println("数据文件中，没有student表，也不会报错");

db.close();

returnContentUris.withAppendedId(uri, insert); //为路径上，加上ID

default:

throw newIllegalArgumentException(String.format("Uri：%s 不是合法的uri地址", uri));

}

@Override

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

SQLiteDatabase db =helper.getWritableDatabase();

switch (uriMatcher.match(uri)) { // 匹配uri

case PERSON_ID:

long parseId =ContentUris.parseId(uri); // 获取传过来的ID值

selection = "id=?"; //设置查询条件

selectionArgs = newString[] { parseId + "" }; //查询条件值

case PERSON:

int delete =db.delete("person", selection, selectionArgs);

db.close();

return delete;

default:

throw newIllegalArgumentException(String.format("Uri：%s 不是合法的uri地址", uri));

}

@Override

public int update(Uri uri, ContentValuesvalues, String selection, String[] selectionArgs) {

SQLiteDatabase db =helper.getWritableDatabase();

switch (uriMatcher.match(uri)) {

case PERSON_ID:

long parseId =ContentUris.parseId(uri); //获取传过来的ID值

selection ="id=?"; //设置查询条件

selectionArgs = newString[] { parseId + "" }; //查询条件值

case PERSON:

int update =db.update("person", values, selection, selectionArgs);

db.close();

return update;

default:

throw newIllegalArgumentException(String.format("Uri：%s 不是合法的uri地址", uri));

}

@Override

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

SQLiteDatabase db =helper.getWritableDatabase();

switch (uriMatcher.match(uri)) {

case PERSON_ID:

// == 根据ID查询 ==

long parseId =ContentUris.parseId(uri); //获取传过来的ID值

selection ="id=?"; //设置查询条件

selectionArgs = newString[] { parseId + "" }; // 查询条件值

case PERSON:

Cursor cursor =db.query("person", projection, selection, selectionArgs, null, null,sortOrder);

// == 注意：此处的 db与cursor不能关闭 ==

return cursor;

default:

throw newIllegalArgumentException(String.format("Uri：%s 不是合法的uri地址", uri));

}

// 返回传入URI的类型，可用于测试URI是否正确

@Override

public String getType(Uri uri) {

switch (uriMatcher.match(uri)) {

case PERSON_ID:

return"vnd.android.cursor.item/person"; //表示单条person记录

case PERSON:

return"vnd.android.cursor.dir/person"; //表单多个person记录

default:

return null;

}

清单中的配置：

<provider

android:exported="true"

android:name="com.itheima.sqlite.provider.HeimaProvider"

android:authorities="com.itheima.sqlite.provider" />

authorities 可以配置成如下形式（系统联系人的）：

android:authorities="contacts;com.android.contacts"

“;” 表示的是可使用 contacts, 与 com.android.contacts

3、内容解析者ContentResolver

Ÿ 通过Context获得ContentResolver内容访问者对象（内容提供者的解析器对象）；

Ÿ 调用ContentResolver对象的方法即可访问内容提供者

测试类代码：

public class HeimaProviderTest extends AndroidTestCase {

/** 测试添加数据*/

public void testInsert() {

ContentResolver resolver =this.getContext().getContentResolver();

Uri uri =Uri.parse("content://com.itheima.sqlite.provider/person");

ContentValues values = newContentValues();

values.put("name","小翼");

values.put("balance",13000);

Uri insert = resolver.insert(uri,values); // 获取返回的uri，如：content://com.itheima.sqlite.provider/7

System.out.println(insert);

}

/** 测试删除*/

public void testRemove() {

ContentResolver resolver = this.getContext().getContentResolver();

Uri uri =Uri.parse("content://com.itheima.sqlite.provider/person");

int count = resolver.delete(uri,"id=?", new String[] { 3 + "" });

System.out.println("删除了" + count + "行");

}

/** 测试更新*/

public void testUpdate() {

ContentResolver resolver =this.getContext().getContentResolver();

Uri uri =Uri.parse("content://com.itheima.sqlite.provider/person");

ContentValues values = newContentValues();

values.put("name","小赵update");

values.put("balance",56789);

int update = resolver.update(uri,values, "id=?", new String[] { 6 + "" });

System.out.println("更新了" + update + "行");

}

/** 测试查询*/

public void testQueryOne() {

ContentResolver resolver =this.getContext().getContentResolver();

Uri uri = Uri.parse("content://com.itheima.sqlite.provider/person");

Cursor c = resolver.query(uri, newString[] { "name", "balance" }, "id=?", newString[] { 101 + "" }, null);

if (c.moveToNext()) {

System.out.print(c.getString(0));

System.out.println("" + c.getInt(1));

}

c.close();

}

/**测试查询全部*/

public void testQueryAll() {

ContentResolver resolver =this.getContext().getContentResolver();

Uri uri =Uri.parse("content://com.itheima.sqlite.provider/person");

Cursor c = resolver.query(uri, newString[] { "id", "name", "balance" }, null, null,"name desc");

while (c.moveToNext()) {

System.out.println(c.getInt(0)+ ", " + c.getString(1) + ", " + c.getInt(2));

}

c.close();

}

/** 测试查询一条*/

public void testQueryOneWithUriId() {

ContentResolver resolver =this.getContext().getContentResolver();

Uri uri =Uri.parse("content://com.itheima.sqlite.provider/3"); // 查询ID为3的记录

Cursor c = resolver.query(uri, newString[] { "id", "name", "balance" }, null, null,null);

if (c.moveToNext()) {

System.out.println(c.getInt(0)+ ", " + c.getString(1) + ", " + c.getInt(2));

}

c.close();

}

/** 测试获取内容提供者的返回类型*/

public void testGetType() {

ContentResolver resolver =this.getContext().getContentResolver();

System.out.println(resolver.getType(Uri.parse("content://com.itheima.sqlite.provider/2")));

System.out.println(resolver.getType(Uri.parse("content://com.itheima.sqlite.provider/person")));

}

4、监听内容提供者的数据变化

Ÿ 在内容提供者中可以通知其他程序数据发生变化

通过Context的getContentResolver()方法获取ContentResolver

调用其notifyChange()方法发送数据修改通知，发送到系统的公共内存（消息信箱中）

Ÿ 在其他程序中可以通过ContentObserver监听数据变化

通过Context的getContentResolver()方法获取ContentResolver

调用其registerContentObserver()方法指定对某个Uri注册ContentObserver

自定义ContentObserver，重写onChange()方法获取数据

示例代码（发通知部分）：

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

SQLiteDatabase db =helper.getWritableDatabase();

int delete =db.delete("person", selection, selectionArgs);

// == 通过内容访问者对象ContentResolve 发通知给所有的Observer ==

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

db.close();

returndelete;

}

监听部分：

// 注册内容观察者事件

private voidinitRegisterContentObserver() {

Uri uri =Uri.parse("content://com.itheima.sqlite.provider"); // 监听的URI

// == 第2个参数：true表示监听的uri的后代都可以监听到 ==

getContentResolver().registerContentObserver(uri,true, new ContentObserver(new Handler()) {

public voidonChange(boolean selfChange) { //接到通知就执行

personList =personDao.queryAll();

((BaseAdapter)personListView.getAdapter()).notifyDataSetChanged();

}

});

}

5、区别Provider/Resolver/Observer

1）ContentProvider：内容提供者

把一个应用程序的私有数据（如数据库）信息暴露给别的应用程序，让别的应用程序可以访问；

在数据库中有对应的增删改查的方法，如果要让别的应用程序访问，需要有一个路径uri：

通过content:// 路径对外暴露，uri写法：content://主机名/表名

2）ContentResolver：内容解析者

根据内容提供者的路径，对数据进行操作（crud）；

3）ContentObserver：内容观察者

可以理解成android系统包装好的回调，数据发送变化时，会执行回调中的方法；

ContentResolver发送通知，ContentObserver监听通知；

当A的数据发生变化的时候，A就会显示的通知一个内容观察者，不指定观察者，就会发消息给一个路径

二、Activity活动

描述：

1）表示用户交互的一个界面（活动），每一个activity对应一个界面

2）是所有View的容器：button,textview,imageview；我们在界面上看到的都是一个个的view

3）有个ActivityManager的管理服务类，用于维护与管理Activity的启动与销毁；

Activity启动时，会把Activity的引用放入任务栈中

4）一个应用程序可以被别的应用程序的activity开启

此时，是将此应用程序的引用加入到了开启的那个activity的任务栈中了

5） activity是运行在自己的程序进程里面的

在一个应用程序中，可以申请单独的进程，然此应用程序中的一个组件在新的进程中运行

6）可以在activity里面添加permission标签,调用者必须加入这个权限

与钱打交道的界面，都不允许被其他应用程序随意打开

如果觉得那个activity比较重要，可以在清单文件中配置，防止别人随意打开，需要配置一个权限

自定义权限：

在清单文件中配置permission，创建一个新的权限

创建后，就会在清单文件中生成这个权限了

此时，需要开启这个界面，就需要使用这个权限

Tips：

*不可使用中文文本，需要使用字符串，抽取出来

*声明之后，会在gen的目录下，多出来一个文件：Manifest的文件，系统也存在一个这样的文件

1、创建Activity

1）定义类继承自Activity类；

2）在清单文件中Application节点中声明<activity>节点；

<activity

android:name="com.itheima.activity.MainActivity"

android:label="@string/app_name" >

<intent-filter>

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

<categoryandroid:name="android.intent.category.LAUNCHER" /> <!—启动时，默认匹配 --

</intent-filter>

</activity>

2、启动Activity

通过意图（Intent）来启动一个Activity；

1）显示启动：

显示启动一般用于自己调用自己的情况（在当前应用找），这样的启动方式比较快速，创建Intent后指定包名和类名；

Intent intent = new Intent(this,OtherActivity.class);

startActivity(intent); // 启动新的Activity

或者：

Intent intent = new Intent();

intent.setClassName("com.itheima.activity","com.itheima.activity.OtherActivity"); // 包名、全类名

startActivity(intent); // 启动新的Activity

2）隐式启动：

一般用于调用别人的Activity，创建Intent后指定动作和数据以及类型；

// 电话

Intent intent = new Intent();

intent.setAction(Intent.ACTION_CALL); // 设置动作

intent.setData(Uri.parse("tel://123456")); // 设置数据

// 网页

intent.setAction(Intent.ACTION_VIEW);

intent.setData(Uri.parse("http://192.168.1.45:8080/androidWeb"));

// 音频/视频，设置type

intent.setAction(Intent.ACTION_VIEW);

intent.setDataAndType(Uri.parse("file:///mnt/sdcard/daqin.mp3"),"audio/*"); // 设置数据和数据类型，将启动音频播放器（vedio）

3）为隐式启动配置意图过滤器：

n 显式意图是指在创建意图时指定了组件，而隐式意图则不指定组件，通过动作、类型、数据匹配对应的组件；

n 在清单文件中定义<activity>时需要定义<intent-filter>才能被隐式意图启动；

n <intent-filter>中至少配置一个<action>和一个<category>，否则无法被启动；

n Intent对象中设置的action、category、data在<intent-filter>必须全部包含Activity才能启动；

n <intent-filter>中的<action>、<category>、<data>都可以配置多个，Intent对象中不用全部匹配，每样匹配一个即可启动；

n 如果一个意图可以匹配多个Activity，Android系统会提示选择；

<activity

android:name="com.itheima.activity.OtherActivity"

android:label="OtherActivity">

<intent-filter>

<actionandroid:name="android.intent.action.VIEW" /> <!—必须，表示动作为View -->

</intent-filter>

<intent-filter>

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

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

</intent-filter>

<intent-filter>

<dataandroid:scheme="file" android:mimeType="audio/*" /> <!—文件协议l类型 -->

<dataandroid:scheme="file" android:mimeType="video/*" />

</intent-filter>

</activity>

3、启动时传递数据

可通过意图Intent对象实现Activity之间的数据传递；

使用Intent.putExtra()方法装入一些数据, 被启动的Activity可在 onCreate方法中getIntent()获取；

可传输的数据类型: a.基本数据类型(数组), b. String(数组), c. Bundle(Map), d. Serializable(Bean), e.Parcelable（放在内存一个共享空间里）;

基本类型：

Intent intent = new Intent(this,OtherActivity.class);

intent.putExtra("name", "张飞"); // 携带数据

intent.putExtra("age", 12);

startActivity(intent);

一捆数据：

Intent intent = new Intent(this,OtherActivity.class);

Bundle b1 = new Bundle();

b1.putString("name", "赵云");

b1.putInt("age", 25);

Bundle b2 = new Bundle();

b2.putString("name", "关羽");

b2.putInt("age", 44);

intent.putExtra("b1", b1);

intent.putExtra("b2", b2);

序列化对象(须实现序列化接口)：

Intent intent = new Intent(this,OtherActivity.class);

Person p = new Person("张辽", 44);

intent.putExtra("p", p);

接收数据：

在OtherActivity 的onCreate()方法，通过 getIntent().get 相关的数据的方法来获取数据；

4、关闭时返回数据

基本流程：

l 使用startActivityForResult(Intentintent, int requestCode) 方法打开Activity；

l 重写onActivityResult(int requestCode, intresultCode, Intent data) 方法；

l 新Activity中调用setResult(int resultCode, Intent data) 设置返回数据之后，关闭Activity就会调用上面的onActivityResult方法；

注意：新的Activity的启动模式不能设置成 singleTask（如果已创建，会使用以前创建的）与singleInstance（单例，单独的任务栈），

不能被摧毁（执行不到finish方法），父Activity中的 onActivityResult方法将不会执行；

finish()：表示关闭当前Activity，会调用onDestroy方法；

Activity_A:

public void openActivityB(View v) {

Intent intent = new Intent(this, Activity_B.class);

Person p = new Person("张辽", 44);

intent.putExtra("p", p);

startActivityForResult(intent,100); // 此方法，启动新的Activity，等待返回结果, 结果一旦返回，自动执行onActivityResult()方法

}

protected void onActivityResult(intrequestCode, int resultCode, Intent data) {

if(data == null) { //没有数据，不执行

return;

}

System.out.println(requestCode +", " + resultCode); //code 可用来区分，哪里返回的数据

String name =data.getStringExtra("name");

int age =data.getIntExtra("age", -1);

}

Activity_B:

public void close(View v) {

// == 关闭当前Activity时，设置返回的数据 ==

Intent intent = new Intent();

intent.putExtra("name","典韦");

intent.putExtra("age",55);

setResult(200, intent);

finish(); // 关闭，类似于点击了后退

}

5、生命周期

1）Acitivity三种状态

a. 运行：activity在最前端运行;

b. 停止：activity不可见，完全被覆盖;

c. 暂停：activity可见，但前端还有其他activity<>，注意：在当前Activitiiy弹出的对话框是Activity的一部分，弹出时，不会执行onPause方法；

2）生命周期相关的方法（都是系统自动调用，都以on 开头）：

a. onCreate：创建时调用，或者程序在暂停、停止状态下被杀死之后重新打开时也会调用；

b. onStart： onCreate之后或者从停止状态恢复时调用；

c. onResume： onStart之后或者从暂停状态恢复时调用，从停止状态恢复时由于调用onStart，也会调用onResume（界面获得焦点）；

d. onPause：进入暂停、停止状态，或者销毁时会调用（界面失去焦点）；

e. onStop：进入停止状态，或者销毁时会调用；

f. onDestroy：销毁时调用；

g. onRestart：从停止状态恢复时调用；

3）生命周期图解：

应用启动时,执行onCreate onStart onResume，退出时执行：onPause onStop onDestroy;

6、横竖屏切换与信息的保存恢复

切换横竖屏时，会自动查找layout-port 、layout-land中的布局文件，默认情况下，

切换时，将执行摧毁onPause onStoponDestroy，再重置加载新的布局onCreate onStartonResume；

切换时如果要保存数据, 可以重写: onSaveInstanceState();

恢复数据时, 重写: onRestoreInstanceState();

è固定横屏或竖屏: android:screenOrientation="landscape"

è横竖屏切换, 不摧毁界面(程序继续执行) android:configChanges="orientation|keyboardHidden|screenSize"

保存信息状态的相关方法:

a. onSaveInstanceState：

在Activity被动的摧毁或停止的时候调用（如横竖屏切换,来电），用于保存运行数据，可以将数据存在在Bundle中；

b. onRestoreInstanceState：

该方法在Activity被重新绘制的时候调用，例如改变屏幕方向，onSavedInstanceState可为onSaveInstanceState保存的数据

7、启动模式

1）任务栈的概念

问：一个手机里面有多少个任务栈？

答：一般情况下，有多少个应用正在运行，就对应开启多少个任务栈；

一般情况下，每开启一个应用程序就会创建一个与之对应的任务栈；

二般情况下，如launchMode为 singleInstance，就创建自己单独的任务栈；

2）任务栈的作用：

它是存放Activity的引用的，Activity不同的启动模式，对应不同的任务栈的存放；

可通过getTaskId()来获取任务栈的ID，如果前面的任务栈已经清空，新开的任务栈ID+1，是自动增长的；

3）启动模式：

在AndroidManifest.xml中的<activity>标签中可以配置android:launchMode属性，用来控制Actvity的启动模式；

在Android系统中我们创建的Acitivity是以栈的形式呈现的：

①、standard：默认的，每次调用startActivity()启动时都会创建一个新的Activity放在栈顶；

②、singleTop：启动Activity时，指定Activity不在任务栈栈顶就创建，如在栈顶，则不会创建，会调用onNewInstance()，复用已经存在的实例

③、singleTask：在任务栈里面只允许一个实例，如果启动的Activity不存在就创建，如果存在直接跳转到指定的Activity所在位置，

如：栈内有ABCD，D想创建A, 即A上的BCD相应的Activity将移除；

④、singleInstance：（单例）开启一个新的任务栈来存放这个Activity的实例，在整个手机操作系统里面只有一个该任务栈的实例存在，此模式开启的Activity是运行在自己单独的任务栈中的；

4）应用程序、进程、任务栈的区别

①、应用程序：

四大组件的集合

在清单文件中都放在application节点下

对于终端用户而言，会将其理解为activity

②、进程：

操作系统分配的独立的内存空间，一般情况下，一个应用程序会对应一个进程，特殊情况下，会有多个进程

一个应用程序会对应一个或多个进程

③、任务栈：task stack（back stack）后退栈

记录用户的操作步骤，维护用户的操作体验，

专门针对于activity而言的，只用于activity

一般使用standard，其他情况用别的

5）启动模式的演示

1、创建两个activity，布局中设置两个按钮，分别开启两个activity

第一、standard启动模式的：开启几个就会在任务栈中存在几个任务

01和02都是存在于一个任务栈中的

第二、在清单文件中将02的启动模式改为singletop，

此时02处于栈顶，就只会创建一个02的任务，再开启02，也不会创建新的

第三、将02的启动模式改为singletask

如果02上面有其他任务栈，就会将其他的清除掉，利用这个已经创建的02

当开启02的时候，即先将01清除，然后利用下面的02

第四、将02的启动模式改为singleinstance

可以通过打印任务栈的id（调用getTaskId()方法）得知，两个activity不在同一个任务栈中

若先开启三个01，在开启02，任务栈如图：

再开启01，任务栈的示意图如下：

此时按返回键，会先一层一层清空01，最后再清空02

空进程：任务栈清空，意味着程序退出了，但进程留着，这个就是空进程，容易被系统回收；

8、内存管理

Android系统在运行多个进程时，如果系统资源不足，会强制结束一些进程,优先选择哪个进程来结束是有优先级的。

会按照以下顺序杀死：

①、空：进程中没有任何组件；

②、后台：进程中只有停止状态的Activity；

③、服务：进程中有正在运行的服务；

④、可见：进程中有一个暂停状态的Activity；

⑤、前台：进程中正在运行一个Activity；

Activity在退出的时候进程不会销毁, 会保留一个空进程方便以后启动.但在内存不足时进程会被销毁；

Activity中不要在Activity做耗时的操作, 因为Activity切换到后台之后（Activity停止了）, 内存不足时, 也容易被销毁；

三、BroadcastReceiver广播接收者

系统的一些事件，比如来电，来短信，等等，会发广播；可监听这些广播，并进行一些处理；

Android3.2以后，为了安全起见，对于刚安装的应用，需要通过点击进入应用（界面，用户确认之后），接收者才能起作用；

以后即使没有启动其界面，也能接收到广播；

1、定义广播接收者

1）定义类继承BroadcastReceiver，重写onReceive方法

2）清单文件中声明<receiver>，需要在其中配置<intent-filter>指定接收广播的类型；

3）当接收到匹配广播之后就会执行onReceive方法；

4）有序广播中，如果要控制多个接收者之间的顺序，可在<intent-filter>配置priority属性，系统默认为0，值越大，优先级越高；

5）BroadcastReceiver除了在清单文件中声明，也可以在代码中声明，使用registerReceiver方法注册Receiver；

<receiverandroid:name="com.itheima.ipdialer.CallReceiver" >

广播可中断，通过调用abortBroadcast()方法；

接收者之间可以传递数据；

3、广播接收者的注册方式

4大组件中，只有广播接收者是一个非常特殊的组件，其他3大组件都需要在清单文件中注册；

广播接收者，有2中注册方式：清单文件与代码方式，区别：

1）清单文件注册广播接收者，只要应用程序被部署到手机上，就立刻生效，不管进程是否处于运行状态；

2）代码方式，如果代码运行了，广播接收者才生效，如果代码运行结束，广播接收者，就失效；

这属于动态注册广播，临时用一下，用的时候，register，不用时unregister；

代码方式示例：

// 广播接收者

private class InnerReceiver extendsBroadcastReceiver {

@Override

public void onReceive(Contextcontext, Intent intent) {

String phone =getResultData();

String address =AddressDao.queryAddress(getApplicationContext(), phone);

showAddress(address);

}

// 注册示例代码

public void onCreate() {

// == 服务启动时，注册广播接收者 ==

innerReceiver = newInnerReceiver();

// 指定意图过滤器

IntentFilter filter = newIntentFilter(Intent.ACTION_NEW_OUTGOING_CALL);

this.registerReceiver(innerReceiver,filter);

}

// 销毁

public void onDestroy() {

// == 服务停止时，移除广播接收者 ==

this.unregisterReceiver(innerReceiver);

innerReceiver = null;

①、使用sendBroadcast()方法可发送普通广播；

②、通过Intent确定广播类型，可携带数据，所有接收者都可以接收到数据，数据不能被修改，不会中断；

接收者无序（试验测试，是按照安装顺序来接收的）;

③、广播时，可设置接收者权限，仅当接收者含有权限才能接收；

④、接收者的<receiver>也可设置发送方权限，只接受含有相应权限应用的广播；

发送者：

Intent intent = newIntent("com.itheima.broadcast.TEST"); //指定动作；接收者，需要配置intent filter才能接受到此广播

intent.setFlags(Intent.FLAG_INCLUDE_STOPPED_PACKAGES); // 包含未启动的过的应用（也可以收到广播），默认为不包含

intent.putExtra("data", "这是来着广播发送者发来的贺电"); // 广播发送者intent中的数据，接收者，修改不了

sendBroadcast(intent, null); // 发送无序广播，异步获取数据，不可中断，接收者之间不可传数据

接收者：

public class AReceiver extendsBroadcastReceiver {

publicvoid onReceive(Context context, Intent intent) {

System.out.println("AReceiver： " +intent.getStringExtra("data"));

}

<intent-filterandroid:priority="2" >

<actionandroid:name="com.itheima.broadcast.TEST" /> <!—接收指定动作的广播 -->

</intent-filter>

</receiver>

注意：

如果要在广播接收者中打开Activity，需要设置一下Intent.FLAG_ACTIVITY_NEW_TASK，因为广播接收者是没有Activity任务栈的

所以需要加上这个标记，方能在广播接收者中打开Activity，如：

public void onReceive(Context context,Intent intent) {

Log.i(TAG, "打电话了。。。");

String phone =this.getResultData();

if ("2008".equals(phone)){

// == 打开手机防盗功能界面 ==

Intent safeIntent = newIntent(context, LostFindActivity.class);

safeIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); // 使Activity也能在Receiver中启动

context.startActivity(safeIntent);

abortBroadcast(); // 中断广播

setResultData(null); //把电话号码设为null，就没有了通话记录

}

2）发送有序广播

a. sendOrderedBroadcast()发送有序广播；

b. 通过Intent确定广播类型, 携带数据，Intent的数据同样修改无效；

c. 跟普通广播一样，也可以设置相应的权限；

d. 接收者可在<intent-filter>定义android:priority定义优先级，数字越大，优先级越高；

e. 有序广播会被接收者逐个接收，中途可以中断，或添加、修改数据；

f. 可以指定一个自己的广播接收者, 这个接收者将最后一个收到广播、不会被中断、不需要任何权限、不需要配置；

g. 可以指定一个Handler用来在自己的接收者中进行线程通信；

发送者：

Intent intent = newIntent("com.itheima.broadcast.TEST"); //指定动作；接收者，需要配置intent filter才能接受到此广播

intent.setFlags(Intent.FLAG_INCLUDE_STOPPED_PACKAGES); // 包含未启动的过的应用（也可以收到广播），默认为不包含

intent.putExtra("data", "这是来着广播发送者发来的贺电"); // 广播发送者的intent中的数据，接收者，修改不了

// == 有序广播时，传递的数据可修改 ==

Bundle bundle = new Bundle();

bundle.putString("name", "关羽");

bundle.putInt("age", 22);

/* 定义权限，要求接收者，要有com.itheima.permission.broadcast.RECEIVE 才能接收；

* 配置了最后接收者，Creceiver,无论你们怎么弄，我都可以收到广播，而且我不要配置，不要权限

* handle为null,表示使用系统默认的

* 传递了数据 1， “MainActivity”, bundle 这些都是可以在接收者修改的

this.sendOrderedBroadcast(intent,"com.itheima.permission.broadcast.RECEIVE", new CReceiver(), null, 1,"MainActivity", bundle);

<permissionandroid:name="com.itheima.permission.broadcast.RECEIVE" >

</permission>

<!- 使用该权限-->

<uses-permissionandroid:name="com.itheima.permission.broadcast.RECEIVE" />

接收者AReceive：

public void onReceive(Context context,Intent intent) {

System.out.println("AReceiver： " +intent.getStringExtra("data"));

Bundle bundle =this.getResultExtras(true); // 设置为true，表示即使没有传递Bundle数据，不会出现空指针

String message =String.format("%s : %s : %s, %s", getResultCode(), getResultData(),bundle.getString("name"), bundle.getInt("age"));

System.out.println(message); // 如果优先级高于其他接收者，将打印发送者的数据

// == 修改有序发送者，发来的数据 ==

bundle.putString("name","赵子龙");

bundle.putInt("age",222);

this.setResult(2,"AReceiver", bundle);

// == 修改Intent中的数据，无效 ==

intent.putExtra("data","AReceiver 修改了数据");

this.setResultData("这是来自AReceiver的信息");

// this.abortBroadcast(); // 中断，比它优先级低的接收者，将不能接收到广播了

}

<receiver android:name="com.itheima.a.AReceiver"

android:permission="com.itheima.permission.broadcast.RECEIVE">

<intent-filterandroid:priority="2" >

<actionandroid:name="com.itheima.broadcast.TEST" />

</intent-filter>

</receiver>

接收者BReceive:代码及配置与上类似，只是优先级比A的低

5、广播的生命周期

a. 广播接收者的生命周期非常短暂的，在接收到广播的时候创建，onReceive()方法结束之后销毁；

b. 广播接收者中不要做一些耗时的工作，否则会弹出Application No Response错误对话框；

c. 最好也不要在广播接收者中创建子线程做耗时的工作，因为广播接收者被销毁后进程就成为了空进程，很容易被系统杀掉；

d. 耗时的较长的工作最好放在服务中完成；

四、Service服务

Service是一种在后台长期运行的，没有界面的组件，由其他组件调用开始运行；

服务不太会被kill，即使在内存不足时被kill，当内存恢复时，服务会自动复活，例如下载就可以放入服务中来做，下载时，启动服务，完成时，关闭服务；

1、创建与使用Service

1）、定义类继承Service, 清单文件中声明<service>，同样也可以配置意图过滤；

2）、使用Intent来开启Service，在其他组件中调用startService方法;

3）、停止Service，调用stopService方法;

2、生命周期

Service中的生命周期方法(Context调用执行)：

1）startService() 如果没创建就先onCreate()再startCommand(),如果已创建就只执行startCommand();

2）stopService() 执行onDestroy()

3）bindService() 如果没有创建就先onCreate()再onBind()

4）unbindService() 如果服务是在绑定时启动的, 先执行onUnbind()再执行onDestroy(). 如果服务在绑定前已启动, 那么只执行onUnbind()；

3、开启服务的2种方式

2种不同开启方式的区别：

1）startService：

开启服务，服务一旦开启，就长期就后台运行，即使调用者退出来，服务还会长期运行；

资源不足时，被杀死，资源足够时，又会复活；

2）bindService：

绑定服务，绑定服务的生命周期会跟调用者关联起来，调用者退出，服务也会跟着销毁；

通过绑定服务，可以间接的调用服务里面的方法（onBind返回IBinder）；

4、服务混合调用生命周期

一般的调用顺序：

①、start -> stop 开启–> 结束

②、bind -> unbind 绑定（服务开启） -> 解绑（服务结束）

混合调用：

①、start –> bind -> stop->unbind->ondestroy 通常不会使用这种模式

开启 –> 绑定 –> 结束（服务停不了）->解除绑定（服务才可停掉）

②、start –>bind -> unbind -> stop 经常使用

开启 –> 绑定 –> 解绑（服务继续运行）-> stop（不用时，再停止服务）

这样保证了服务长期后台运行，又可以调用服务中的方法

五、Android四大组件

1. ContentProvider

共享应用程序内的数据, 在数据修改时可以监听

1. Activity

供用户操作的界面

2. BroadcastReceiver

用来接收广播, 可以根据系统发生的一些时间做出一些处理

3. Service

长期在后台运行的, 没有界面的组件, 用来在后台执行一些耗时的操作

« 熟悉掌握ListView的优化及异步任务加载网络数据

一、异步任务加载网络数据：

在Android中提供了一个异步任务的类AsyncTask，简单来说，这个类中的任务是运行在后台线程中的，并可以将结果放到UI线程中进行处理，它定义了三种泛型，分别是Params、Progress和Result，分别表示请求的参数、任务的进度和获得的结果数据。

1、使用原因：

1）是其中使用了线程池技术，而且其中的方法很容易实现调用

2）可以调用相关的方法，在开启子线程前和后，进行界面的更新

3）一旦任务多了，不用每次都new新的线程，可以直接使用

2、执行的顺序：

onPreExecute()【执行前开启】--- > doInBackground() --- > onProgressUpdate() --- >onPostExecute()

3、执行过程：

当一个异步任务开启后，执行过程如下：

1）、onPreExecute()：

这个方法是执行在主线程中的。这步操作是用于准备好任务的，作为任务加载的准备工作。建议在这个方法中弹出一个提示框。

2）、doInBackground()：

这个方法是执行在子线程中的。在onPreExecute()执行完后，会立即开启这个方法，在方法中可以执行耗时的操作。需要将请求的参数传递进来，发送给服务器，并将获取到的数据返回，数据会传给最后一步中；这些值都将被放到主线程中，也可以不断的传递给下一步的onProgressUpdate()中进行更新。可以通过不断调用publishProgress()，将数据（或进度）不断传递给onProgressUpdate()方法，进行不断更新界面。

3）、onProgressUpdate()：

这个方法是执行在主线程中的。publishProgress()在doInBackground()中被调用后，才开启的这个方法，它在何时被开启是不确定的，执行这个方法的过程中，doInBackground()是仍在执行的，即子线程还在运行着。

4）、onPostExecute()：

这个方法是执行在主线程中的。当后台的子线程执行完毕后才调用此方法。doInBackground()返回的结果会作为参数被传递过来。可以在这个方法中进行更新界面的操作。

5）、execute()：

最后创建AsyncTask自定义的类，开启异步任务。

3、实现原理：

1）、线程池的创建：

在创建了AsyncTask的时候，会默认创建一个线程池ThreadPoolExecutor，并默认创建出5个线程放入到线程池中，最多可防128个线程；且这个线程池是公共的唯一一份。

2）、任务的执行：

在execute中，会执行run方法，当执行完run方法后，会调用scheduleNext()不断的从双端队列中轮询，获取下一个任务并继续放到一个子线程中执行，直到异步任务执行完毕。

3）、消息的处理：

在执行完onPreExecute()方法之后，执行了doInBackground()方法，然后就不断的发送请求获取数据；在这个AsyncTask中维护了一个InternalHandler的类，这个类是继承Handler的，获取的数据是通过handler进行处理和发送的。在其handleMessage方法中，将消息传递给onProgressUpdate()进行进度的更新，也就可以将结果发送到主线程中，进行界面的更新了。

4、需要注意的是：

①、这个AsyncTask类必须由子类调用

②、虽然是放在子线程中执行的操作，但是不建议做特别耗时的操作，如果操作过于耗时，建议使用线程池ThreadPoolExecutor和FutureTask

1. int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);

2. Log.d("TAG", "Max memory is " + maxMemory + "KB");

因此在展示高分辨率图片的时候，最好先将图片进行压缩。压缩后的图片大小应该和用来展示它的控件大小相近，在一个很小的ImageView上显示一张超大的图片不会带来任何视觉上的好处，但却会占用我们相当多宝贵的内存，而且在性能上还可能会带来负面影响。下面我们就来看一看，如何对一张大图片进行适当的压缩，让它能够以最佳大小显示的同时，还能防止OOM的出现。

BitmapFactory这个类提供了多个解析方法(decodeByteArray,decodeFile, decodeResource等)用于创建Bitmap对象，我们应该根据图片的来源选择合适的方法。比如SD卡中的图片可以使用decodeFile方法，网络上的图片可以使用decodeStream方法，资源文件中的图片可以使用decodeResource方法。这些方法会尝试为已经构建的bitmap分配内存，这时就会很容易导致OOM出现。为此每一种解析方法都提供了一个可选的BitmapFactory.Options参数，将这个参数的inJustDecodeBounds属性设置为true就可以让解析方法禁止为bitmap分配内存，返回值也不再是一个Bitmap对象，而是null。虽然Bitmap是null了，但是BitmapFactory.Options的outWidth、outHeight和outMimeType属性都会被赋值。这个技巧让我们可以在加载图片之前就获取到图片的长宽值和MIME类型，从而根据情况对图片进行压缩。如下代码所示：

[java] view plaincopy

1. BitmapFactory.Options options = new BitmapFactory.Options();

2. options.inJustDecodeBounds = true;

3. BitmapFactory.decodeResource(getResources(), R.id.myimage, options);

4. int imageHeight = options.outHeight;

5. int imageWidth = options.outWidth;

6. String imageType = options.outMimeType;

为了避免OOM异常，最好在解析每张图片的时候都先检查一下图片的大小，除非你非常信任图片的来源，保证这些图片都不会超出你程序的可用内存。

现在图片的大小已经知道了，我们就可以决定是把整张图片加载到内存中还是加载一个压缩版的图片到内存中。以下几个因素是我们需要考虑的：

预估一下加载整张图片所需占用的内存。
为了加载这一张图片你所愿意提供多少内存。
用于展示这张图片的控件的实际大小。
当前设备的屏幕尺寸和分辨率。

比如，你的ImageView只有128*96像素的大小，只是为了显示一张缩略图，这时候把一张1024*768像素的图片完全加载到内存中显然是不值得的。

那我们怎样才能对图片进行压缩呢？通过设置BitmapFactory.Options中inSampleSize的值就可以实现。比如我们有一张2048*1536像素的图片，将inSampleSize的值设置为4，就可以把这张图片压缩成512*384像素。原本加载这张图片需要占用13M的内存，压缩后就只需要占用0.75M了(假设图片是ARGB_8888类型，即每个像素点占用4个字节)。下面的方法可以根据传入的宽和高，计算出合适的inSampleSize值：

[java] view plaincopy

1. public static int calculateInSampleSize(BitmapFactory.Options options,

2. int reqWidth, int reqHeight) {

3. // 源图片的高度和宽度

4. final int height = options.outHeight;

5. final int width = options.outWidth;

6. int inSampleSize = 1;

7. if (height > reqHeight || width > reqWidth) {

8. // 计算出实际宽高和目标宽高的比率

9. final int heightRatio = Math.round((float) height / (float) reqHeight);

10. final int widthRatio = Math.round((float) width / (float) reqWidth);

11. // 选择宽和高中最小的比率作为inSampleSize的值，这样可以保证最终图片的宽和高

12. // 一定都会大于等于目标的宽和高。

13. inSampleSize = heightRatio < widthRatio ? heightRatio : widthRatio;

14. }

15. return inSampleSize;

16. }

使用这个方法，首先你要将BitmapFactory.Options的inJustDecodeBounds属性设置为true，解析一次图片。然后将BitmapFactory.Options连同期望的宽度和高度一起传递到到calculateInSampleSize方法中，就可以得到合适的inSampleSize值了。之后再解析一次图片，使用新获取到的inSampleSize值，并把inJustDecodeBounds设置为false，就可以得到压缩后的图片了。

[java] view plaincopy

1. public static Bitmap decodeSampledBitmapFromResource(Resources res, int resId,

2. int reqWidth, int reqHeight) {

3. // 第一次解析将inJustDecodeBounds设置为true，来获取图片大小

4. final BitmapFactory.Options options = new BitmapFactory.Options();

5. options.inJustDecodeBounds = true;

6. BitmapFactory.decodeResource(res, resId, options);

7. // 调用上面定义的方法计算inSampleSize值

8. options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);

9. // 使用获取到的inSampleSize值再次解析图片

10. options.inJustDecodeBounds = false;

11. return BitmapFactory.decodeResource(res, resId, options);

12. }

下面的代码非常简单地将任意一张图片压缩成100*100的缩略图，并在ImageView上展示。

[java] view plaincopy

1. mImageView.setImageBitmap(

2. decodeSampledBitmapFromResource(getResources(), R.id.myimage, 100, 100));

使用图片缓存技术

在你应用程序的UI界面加载一张图片是一件很简单的事情，但是当你需要在界面上加载一大堆图片的时候，情况就变得复杂起来。在很多情况下，（比如使用ListView, GridView 或者 ViewPager 这样的组件），屏幕上显示的图片可以通过滑动屏幕等事件不断地增加，最终导致OOM。

为了保证内存的使用始终维持在一个合理的范围，通常会把被移除屏幕的图片进行回收处理。此时垃圾回收器也会认为你不再持有这些图片的引用，从而对这些图片进行GC操作。用这种思路来解决问题是非常好的，可是为了能让程序快速运行，在界面上迅速地加载图片，你又必须要考虑到某些图片被回收之后，用户又将它重新滑入屏幕这种情况。这时重新去加载一遍刚刚加载过的图片无疑是性能的瓶颈，你需要想办法去避免这个情况的发生。

这个时候，使用内存缓存技术可以很好的解决这个问题，它可以让组件快速地重新加载和处理图片。下面我们就来看一看如何使用内存缓存技术来对图片进行缓存，从而让你的应用程序在加载很多图片的时候可以提高响应速度和流畅性。

内存缓存技术对那些大量占用应用程序宝贵内存的图片提供了快速访问的方法。其中最核心的类是LruCache (此类在android-support-v4的包中提供) 。这个类非常适合用来缓存图片，它的主要算法原理是把最近使用的对象用强引用存储在 LinkedHashMap 中，并且把最近最少使用的对象在缓存值达到预设定值之前从内存中移除。

在过去，我们经常会使用一种非常流行的内存缓存技术的实现，即软引用或弱引用 (SoftReference or WeakReference)。但是现在已经不再推荐使用这种方式了，因为从 Android 2.3 (API Level 9)开始，垃圾回收器会更倾向于回收持有软引用或弱引用的对象，这让软引用和弱引用变得不再可靠。另外，Android 3.0 (API Level 11)中，图片的数据会存储在本地的内存当中，因而无法用一种可预见的方式将其释放，这就有潜在的风险造成应用程序的内存溢出并崩溃。

为了能够选择一个合适的缓存大小给LruCache, 有以下多个因素应该放入考虑范围内，例如：

你的设备可以为每个应用程序分配多大的内存？
设备屏幕上一次最多能显示多少张图片？有多少图片需要进行预加载，因为有可能很快也会显示在屏幕上？
你的设备的屏幕大小和分辨率分别是多少？一个超高分辨率的设备（例如 Galaxy Nexus) 比起一个较低分辨率的设备（例如 Nexus S），在持有相同数量图片的时候，需要更大的缓存空间。
图片的尺寸和大小，还有每张图片会占据多少内存空间。
图片被访问的频率有多高？会不会有一些图片的访问频率比其它图片要高？如果有的话，你也许应该让一些图片常驻在内存当中，或者使用多个LruCache 对象来区分不同组的图片。
你能维持好数量和质量之间的平衡吗？有些时候，存储多个低像素的图片，而在后台去开线程加载高像素的图片会更加的有效。

并没有一个指定的缓存大小可以满足所有的应用程序，这是由你决定的。你应该去分析程序内存的使用情况，然后制定出一个合适的解决方案。一个太小的缓存空间，有可能造成图片频繁地被释放和重新加载，这并没有好处。而一个太大的缓存空间，则有可能还是会引起 java.lang.OutOfMemory 的异常。

下面是一个使用 LruCache 来缓存图片的例子：

[java] view plaincopy

1. private LruCache<String, Bitmap> mMemoryCache;

3. @Override

4. protected void onCreate(Bundle savedInstanceState) {

5. // 获取到可用内存的最大值，使用内存超出这个值会引起OutOfMemory异常。

6. // LruCache通过构造函数传入缓存值，以KB为单位。

7. int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);

8. // 使用最大可用内存值的1/8作为缓存的大小。

9. int cacheSize = maxMemory / 8;

10. mMemoryCache = new LruCache<String, Bitmap>(cacheSize) {

11. @Override

12. protected int sizeOf(String key, Bitmap bitmap) {

13. // 重写此方法来衡量每张图片的大小，默认返回图片数量。

14. return bitmap.getByteCount() / 1024;

15. }

16. };

17. }

18.

19. public void addBitmapToMemoryCache(String key, Bitmap bitmap) {

20. if (getBitmapFromMemCache(key) == null) {

21. mMemoryCache.put(key, bitmap);

22. }

23. }

24.

25. public Bitmap getBitmapFromMemCache(String key) {

26. return mMemoryCache.get(key);

27. }

在这个例子当中，使用了系统分配给应用程序的八分之一内存来作为缓存大小。在中高配置的手机当中，这大概会有4兆(32/8)的缓存空间。一个全屏幕的 GridView 使用4张 800x480分辨率的图片来填充，则大概会占用1.5兆的空间(800*480*4)。因此，这个缓存大小可以存储2.5页的图片。
当向 ImageView 中加载一张图片时,首先会在 LruCache 的缓存中进行检查。如果找到了相应的键值，则会立刻更新ImageView ，否则开启一个后台线程来加载这张图片。

[java] view plaincopy

1. public void loadBitmap(int resId, ImageView imageView) {

2. final String imageKey = String.valueOf(resId);

3. final Bitmap bitmap = getBitmapFromMemCache(imageKey);

4. if (bitmap != null) {

5. imageView.setImageBitmap(bitmap);

6. } else {

7. imageView.setImageResource(R.drawable.image_placeholder);

8. BitmapWorkerTask task = new BitmapWorkerTask(imageView);

9. task.execute(resId);

10. }

11. }

BitmapWorkerTask还要把新加载的图片的键值对放到缓存中。

[java] view plaincopy

1. class BitmapWorkerTask extends AsyncTask<Integer, Void, Bitmap> {

2. // 在后台加载图片。

3. @Override

4. protected Bitmap doInBackground(Integer... params) {

5. final Bitmap bitmap = decodeSampledBitmapFromResource(

6. getResources(), params[0], 100, 100);

7. addBitmapToMemoryCache(String.valueOf(params[0]), bitmap);

8. return bitmap;

9. }

10. }

掌握了以上两种方法，不管是要在程序中加载超大图片，还是要加载大量图片，都不用担心OOM的问题了!不过仅仅是理论地介绍不知道大家能不能完全理解，在后面的文章中我会演示如何在实际程序中灵活运用上述技巧来避免程序OOM

Android照片墙的实现：

照片墙这种功能现在应该算是挺常见了，在很多应用中你都可以经常看到照片墙的身影。它的设计思路其实也非常简单，用一个GridView控件当作“墙”，然后随着GridView的滚动将一张张照片贴在“墙”上，这些照片可以是手机本地中存储的，也可以是从网上下载的。制作类似于这种的功能的应用，有一个非常重要的问题需要考虑，就是图片资源何时应该释放。因为随着GridView的滚动，加载的图片可能会越来越多，如果没有一种合理的机制对图片进行释放，那么当图片达到一定上限时，程序就必然会崩溃。

今天我们照片墙应用的实现，重点也是放在了如何防止由于图片过多导致程序崩溃上面。主要的核心算法使用了Android中提供的LruCache类，这个类是3.1版本中提供的，如果你是在更早的Android版本中开发，则需要导入android-support-v4的jar包。

第一个要考虑的问题就是，我们从哪儿去收集这么多的图片呢？这里我从谷歌官方提供的Demo里将图片源取了出来，我们就从这些网址中下载图片，代码如下所示：

新建或打开activity_main.xml作为程序的主布局，加入如下代码：

[html] view plaincopy

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

2. xmlns:tools="http://schemas.android.com/tools"

3. android:layout_width="wrap_content"

4. android:layout_height="wrap_content" >

6. <GridView

7. android:id="@+id/photo_wall"

8. android:layout_width="match_parent"

9. android:layout_height="wrap_content"

10. android:columnWidth="90dip"

11. android:stretchMode="columnWidth"

12. android:numColumns="auto_fit"

13. android:verticalSpacing="10dip"

14. android:gravity="center"

15. ></GridView>

16.

17. </LinearLayout>

可以看到，我们在这个布局文件中仅加入了一个GridView，这也就是我们程序中的“墙”，所有的图片都将贴在这个“墙”上。

接着我们定义GridView中每一个子View的布局，新建一个photo_layout.xml布局，加入如下代码：

[html] view plaincopy

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

2. xmlns:tools="http://schemas.android.com/tools"

3. android:layout_width="wrap_content"

4. android:layout_height="wrap_content" >

6. <ImageView

7. android:id="@+id/photo"

8. android:layout_width="90dip"

9. android:layout_height="90dip"

10. android:src="@drawable/empty_photo"

11. android:layout_centerInParent="true"

12. />

13.

14. </RelativeLayout>

在每一个子View中我们就简单使用了一个ImageView来显示一张图片。这样所有的布局就已经定义好了。

接下来新建PhotoWallAdapter做为GridView的适配器，代码如下所示：

[java] view plaincopy

1. public class PhotoWallAdapter extends ArrayAdapter<String> implements OnScrollListener {

3. /**

4. * 记录所有正在下载或等待下载的任务。

5. */

6. private Set<BitmapWorkerTask> taskCollection;

8. /**

9. * 图片缓存技术的核心类，用于缓存所有下载好的图片，在程序内存达到设定值时会将最少最近使用的图片移除掉。

10. */

11. private LruCache<String, Bitmap> mMemoryCache;

12.

13. /**

14. * GridView的实例

15. */

16. private GridView mPhotoWall;

17.

18. /**

19. * 第一张可见图片的下标

20. */

21. private int mFirstVisibleItem;

22.

23. /**

24. * 一屏有多少张图片可见

25. */

26. private int mVisibleItemCount;

27.

28. /**

29. * 记录是否刚打开程序，用于解决进入程序不滚动屏幕，不会下载图片的问题。

30. */

31. private boolean isFirstEnter = true;

32.

33. public PhotoWallAdapter(Context context, int textViewResourceId, String[] objects,

34. GridView photoWall) {

35. super(context, textViewResourceId, objects);

36. mPhotoWall = photoWall;

37. taskCollection = new HashSet<BitmapWorkerTask>();

38. // 获取应用程序最大可用内存

39. int maxMemory = (int) Runtime.getRuntime().maxMemory();

40. int cacheSize = maxMemory / 8;

41. // 设置图片缓存大小为程序最大可用内存的1/8

42. mMemoryCache = new LruCache<String, Bitmap>(cacheSize) {

43. @Override

44. protected int sizeOf(String key, Bitmap bitmap) {

45. return bitmap.getByteCount();

46. }

47. };

48. mPhotoWall.setOnScrollListener(this);

49. }

50.

51. @Override

52. public View getView(int position, View convertView, ViewGroup parent) {

53. final String url = getItem(position);

54. View view;

55. if (convertView == null) {

56. view = LayoutInflater.from(getContext()).inflate(R.layout.photo_layout, null);

57. } else {

58. view = convertView;

59. }

60. final ImageView photo = (ImageView) view.findViewById(R.id.photo);

61. // 给ImageView设置一个Tag，保证异步加载图片时不会乱序

62. photo.setTag(url);

63. setImageView(url, photo);

64. return view;

65. }

66.

67. /**

68. * 给ImageView设置图片。首先从LruCache中取出图片的缓存，设置到ImageView上。如果LruCache中没有该图片的缓存，

69. * 就给ImageView设置一张默认图片。

70. *

71. * @param imageUrl

72. * 图片的URL地址，用于作为LruCache的键。

73. * @param imageView

74. * 用于显示图片的控件。

75. */

76. private void setImageView(String imageUrl, ImageView imageView) {

77. Bitmap bitmap = getBitmapFromMemoryCache(imageUrl);

78. if (bitmap != null) {

79. imageView.setImageBitmap(bitmap);

80. } else {

81. imageView.setImageResource(R.drawable.empty_photo);

82. }

83. }

84.

85. /**

86. * 将一张图片存储到LruCache中。

87. *

88. * @param key

89. * LruCache的键，这里传入图片的URL地址。

90. * @param bitmap

91. * LruCache的键，这里传入从网络上下载的Bitmap对象。

92. */

93. public void addBitmapToMemoryCache(String key, Bitmap bitmap) {

94. if (getBitmapFromMemoryCache(key) == null) {

95. mMemoryCache.put(key, bitmap);

96. }

97. }

98.

99. /**

100. * 从LruCache中获取一张图片，如果不存在就返回null。

101. *

102. * @param key

103. * LruCache的键，这里传入图片的URL地址。

104. * @return 对应传入键的Bitmap对象，或者null。

105. */

106. public Bitmap getBitmapFromMemoryCache(String key) {

107. return mMemoryCache.get(key);

108. }

109.

110. @Override

111. public void onScrollStateChanged(AbsListView view, int scrollState) {

112. // 仅当GridView静止时才去下载图片，GridView滑动时取消所有正在下载的任务

113. if (scrollState == SCROLL_STATE_IDLE) {

114. loadBitmaps(mFirstVisibleItem, mVisibleItemCount);

115. } else {

116. cancelAllTasks();

117. }

118. }

119.

120. @Override

121. public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount,

122. int totalItemCount) {

123. mFirstVisibleItem = firstVisibleItem;

124. mVisibleItemCount = visibleItemCount;

125. // 下载的任务应该由onScrollStateChanged里调用，但首次进入程序时onScrollStateChanged并不会调用，

126. // 因此在这里为首次进入程序开启下载任务。

127. if (isFirstEnter && visibleItemCount > 0) {

128. loadBitmaps(firstVisibleItem, visibleItemCount);

129. isFirstEnter = false;

130. }

131. }

132.

133. /**

134. * 加载Bitmap对象。此方法会在LruCache中检查所有屏幕中可见的ImageView的Bitmap对象，

135. * 如果发现任何一个ImageView的Bitmap对象不在缓存中，就会开启异步线程去下载图片。

136. *

137. * @param firstVisibleItem

138. * 第一个可见的ImageView的下标

139. * @param visibleItemCount

140. * 屏幕中总共可见的元素数

141. */

142. private void loadBitmaps(int firstVisibleItem, int visibleItemCount) {

143. try {

144. for (int i = firstVisibleItem; i < firstVisibleItem + visibleItemCount; i++) {

145. String imageUrl = Images.imageThumbUrls[i];

146. Bitmap bitmap = getBitmapFromMemoryCache(imageUrl);

147. if (bitmap == null) {

148. BitmapWorkerTask task = new BitmapWorkerTask();

149. taskCollection.add(task);

150. task.execute(imageUrl);

151. } else {

152. ImageView imageView = (ImageView) mPhotoWall.findViewWithTag(imageUrl);

153. if (imageView != null && bitmap != null) {

154. imageView.setImageBitmap(bitmap);

155. }

156. }

157. }

158. } catch (Exception e) {

159. e.printStackTrace();

160. }

161. }

162.

163. /**

164. * 取消所有正在下载或等待下载的任务。

165. */

166. public void cancelAllTasks() {

167. if (taskCollection != null) {

168. for (BitmapWorkerTask task : taskCollection) {

169. task.cancel(false);

170. }

171. }

172. }

173.

174. /**

175. * 异步下载图片的任务。

176. *

177. * @author guolin

178. */

179. class BitmapWorkerTask extends AsyncTask<String, Void, Bitmap> {

180.

181. /**

182. * 图片的URL地址

183. */

184. private String imageUrl;

185.

186. @Override

187. protected Bitmap doInBackground(String... params) {

188. imageUrl = params[0];

189. // 在后台开始下载图片

190. Bitmap bitmap = downloadBitmap(params[0]);

191. if (bitmap != null) {

192. // 图片下载完成后缓存到LrcCache中

193. addBitmapToMemoryCache(params[0], bitmap);

194. }

195. return bitmap;

196. }

197.

198. @Override

199. protected void onPostExecute(Bitmap bitmap) {

200. super.onPostExecute(bitmap);

201. // 根据Tag找到相应的ImageView控件，将下载好的图片显示出来。

202. ImageView imageView = (ImageView) mPhotoWall.findViewWithTag(imageUrl);

203. if (imageView != null && bitmap != null) {

204. imageView.setImageBitmap(bitmap);

205. }

206. taskCollection.remove(this);

207. }

208.

209. /**

210. * 建立HTTP请求，并获取Bitmap对象。

211. *

212. * @param imageUrl

213. * 图片的URL地址

214. * @return 解析后的Bitmap对象

215. */

216. private Bitmap downloadBitmap(String imageUrl) {

217. Bitmap bitmap = null;

218. HttpURLConnection con = null;

219. try {

220. URL url = new URL(imageUrl);

221. con = (HttpURLConnection) url.openConnection();

222. con.setConnectTimeout(5 * 1000);

223. con.setReadTimeout(10 * 1000);

224. con.setDoInput(true);

225. con.setDoOutput(true);

226. bitmap = BitmapFactory.decodeStream(con.getInputStream());

227. } catch (Exception e) {

228. e.printStackTrace();

229. } finally {

230. if (con != null) {

231. con.disconnect();

232. }

233. }

234. return bitmap;

235. }

236.

237. }

238.

239. }

PhotoWallAdapter是整个照片墙程序中最关键的一个类了，这里我来重点给大家讲解一下。首先在PhotoWallAdapter的构造函数中，我们初始化了LruCache类，并设置了最大缓存容量为程序最大可用内存的1/8，接下来又为GridView注册了一个滚动监听器。然后在getView()方法中，我们为每个ImageView设置了一个唯一的Tag，这个Tag的作用是为了后面能够准确地找回这个ImageView，不然异步加载图片会出现乱序的情况。之后调用了setImageView()方法为ImageView设置一张图片，这个方法首先会从LruCache缓存中查找是否已经缓存了这张图片，如果成功找到则将缓存中的图片显示在ImageView上，否则就显示一张默认的空图片。

看了半天，那到底是在哪里下载图片的呢？这是在GridView的滚动监听器中进行的，在onScrollStateChanged()方法中，我们对GridView的滚动状态进行了判断，如果当前GridView是静止的，则调用loadBitmaps()方法去下载图片，如果GridView正在滚动，则取消掉所有下载任务，这样可以保证GridView滚动的流畅性。在loadBitmaps()方法中，我们为屏幕上所有可见的GridView子元素开启了一个线程去执行下载任务，下载成功后将图片存储到LruCache当中，然后通过Tag找到相应的ImageView控件，把下载好的图片显示出来。

由于我们使用了LruCache来缓存图片，所以不需要担心内存溢出的情况，当LruCache中存储图片的总大小达到容量上限的时候，会自动把最近最少使用的图片从缓存中移除。

最后新建或打开MainActivity作为程序的主Activity，代码如下所示：

[java] view plaincopy

1. public class MainActivity extends Activity {

3. /**

4. * 用于展示照片墙的GridView

5. */

6. private GridView mPhotoWall;

8. /**

9. * GridView的适配器

10. */

11. private PhotoWallAdapter adapter;

12.

13. @Override

14. protected void onCreate(Bundle savedInstanceState) {

15. super.onCreate(savedInstanceState);

16. setContentView(R.layout.activity_main);

17. mPhotoWall = (GridView) findViewById(R.id.photo_wall);

18. adapter = new PhotoWallAdapter(this, 0, Images.imageThumbUrls, mPhotoWall);

19. mPhotoWall.setAdapter(adapter);

20. }

21.

22. @Override

23. protected void onDestroy() {

24. super.onDestroy();

25. // 退出程序时结束所有的下载任务

26. adapter.cancelAllTasks();

27. }

28.

29. }

MainActivity中的代码非常简单，没什么需要说明的了，在Activity被销毁时取消掉了所有的下载任务，避免程序在后台耗费流量。另外由于我们使用了网络功能，别忘了在AndroidManifest.xml中加入网络权限的声明。

« 能够对图片的优化进行相应的处理

1、利用“三级缓存”实现图片的优化

第一次是要从服务器获取的，以后每次显示图片，首先判断内存中获取，如果没有，再从本地缓存目录中获取，如果还没有，最后就需要发送请求从服务器获取。服务器端下载的图片是使用Http的缓存机制，每次执行将本地图片的时间发送给服务器，如果返回码是304，说明服务端的图片和本地的图片是相同的，直接使用本地保存的图片，如果返回码是200，则开始下载新的图片并实现缓存。在从服务器获取到图片后，需要再在本地和内存中分别存一份，这样下次直接就可以从内存中直接获取了，这样就加快了显示的速度，提高了用户的体验。

2、图片过大导致内存溢出：

模拟器的RAM比较小，由于每张图片先前是压缩的情况，放入到Bitmap的时候，大小会变大，导致超出RAM内存

★android 中用bitmap 时很容易内存溢出，报如下错误：Java.lang.OutOfMemoryError: bitmap size exceeds VM budget

解决：

方法1：主要是加上这段：等比例缩小图片

BitmapFactory.Optionsoptions = new BitmapFactory.Options();

options.inSampleSize =2;

1）通过getResource()方法获取资源：

//解决加载图片内存溢出的问题

//Options 只保存图片尺寸大小，不保存图片到内存

BitmapFactory.Options opts = new BitmapFactory.Options();

//缩放的比例，缩放是很难按准备的比例进行缩放的，其值表明缩放的倍数，SDK中建议其值是2的指数值,值越大会导致图片不清晰

opts.inSampleSize = 2;

Bitmap bmp = null;

bmp = BitmapFactory.decodeResource(getResources(),mImageIds[position],opts);

...

//回收

bmp.recycle();

2）通过Uri取图片资源

private ImageViewpreview;

BitmapFactory.Optionsoptions = new BitmapFactory.Options();

options.inSampleSize =2;//图片宽高都为原来的二分之一，即图片为原来的四分之一

Bitmap bitmap =BitmapFactory.decodeStream(cr.openInputStream(uri), null, options);

preview.setImageBitmap(bitmap);

以上代码可以优化内存溢出，但它只是改变图片大小，并不能彻底解决内存溢出。

3）通过路径获取图片资源

private ImageViewpreview;

private String fileName="/sdcard/DCIM/Camera/2010-05-14 16.01.44.jpg";

BitmapFactory.Optionsoptions = new BitmapFactory.Options();

options.inSampleSize =2;//图片宽高都为原来的二分之一，即图片为原来的四分之一

Bitmap b =BitmapFactory.decodeFile(fileName, options);

preview.setImageBitmap(b);

filePath.setText(fileName);

方法2：对图片采用软引用，及时地进行recyle()操作

SoftReference<Bitmap>bitmap;

bitmap = newSoftReference<Bitmap>(pBitmap);

if(bitmap != null){

if(bitmap.get() != null&& !bitmap.get().isRecycled()){

bitmap.get().recycle();

bitmap = null;

}

1、为何使用软引用：

由于创建的集合中存的都是强引用的对象，对于强引用的对象，垃圾回收器是绝对不会回收这个强引用的对象的，除非手动将对象置为null，垃圾回收器才会在适当的时候将其回收掉。当内存不足的时候，即使抛出了OOM异常，程序终止了也不会回收这个强引用对象。所以为了避免在低内存下缓存图片而导致OOM异常的出现，需要降低对象的引用级别，这就涉及到了软引用。

简单来说，软引用就相当于一个“袋子”，而强引用就相当于袋子中的内容，可以比喻为将手机(内容)存入到袋子中，即用软引用包裹强引用。软引用SoftReference的特点就在于它的实例保存了对一个java对象的软引用，该软引用的存在并不妨碍垃圾回收线程对该java对象的回收。SoftReference保存了对一个java对象的软引用后，在垃圾回收此java对象之前，SoftReference所提供的的get()方法返回的是java对象的强引用；一旦垃圾线程回收该java对象之后，get()返回的是null。

2、软引用的特点：

1）、在内存空间充足时，即使一个对象具有软引用，垃圾回收器也不会回收它。

2）、当内存不足时，会在出现OOM异常之前回收掉这些对象的内存空间。

3）、只要垃圾回收器没回收这个对象，则程序就可以继续使用这个对象，因此软引用可用来实现内存敏感的高速缓存。

4）、软引用和引用队列ReferenceQueue联合使用时，当软引用所引用的对象被垃圾回收器回收后，java虚拟机就会将这个软引用加入到与之关联的引用队列中。

需要说明的是，对于强引用对象（如new一个对象），如果被软引用所引用后，不为null时是作为强可及对象存在的，如果为null后，是作为软可及对象存在的；当垃圾回收的时候，不会因为这个对象被软引用所引用而保留该对象的。而是会在OOM异常之前优先回收掉长时间闲置的软可及对象，尽可能保留“新”的软可及对象。如果想重新获得对该实例的强引用，可以通过调用软引用的get()方法获得对象后继续使用。

3、引用队列ReferenceQueue：

虽然SoftReference对象具有保存软引用的特性，但是也还是具有java对象的一般性的。也就是说当软引用所引用的对象被回收之后，这个软引用的对象实际上并没有什么存在的价值了，这就需要一个适当的清除机制，避免由于大量的SoftReference对象的存在而带来新的内存泄露的问题。这就需要将这些“空袋子”回收掉，这就需要使用引用队列ReferenceQueue这个类。

使用方法：就是将创建的强引用和引用队列作为参数传递到软引用的构造方法中，从而实现在SoftReference所引用的object在被垃圾回收器回收的同时，这个软引用对象会被加入到引用队列ReferenceQueue之中。我们可以通过ReferenceQueue的poll()方法监控到是否有非强可及对象被回收了。当队列为空时，说明没有软引用加入到队列中，即没有非强可及引用被回收，否则poll()方法会返回队列中前面一个Reference对象。通过这个方法，我们就可以将无引用对象的软引用SoftReference回收掉，这就避免了大量SoftReference未被回收导致的内存泄露。

4、构建高级缓存：

在应用之中，当我们将图片加载到内存中，需要考虑内存的优化问题，同样会涉及到OOM的问题。如果图片过多的话，内存就吃不消了，这就需要考虑应用如何在低内存的情况下运行了，需要为应用构建高级缓存，来保证在低内存的情况下也能正常运行。首先，在缓存图片的时候，需要判断手机的当前可用内存是否充足，如果内存不足，就需要使用缓存的Map来存储，保证在高速缓存下运行。但是在java中并没有提供软引用的Map集合，只提供了一个WeakHashMap这个针对弱引用提供的实现类。这时候就需要我们手动创建一个具体的实现类，作为软引用的集合来使用。

1、自定义软引用集合，继承HashMap<K,V>，这就相当于一个“袋子”

2、在构造函数中初始化：

临时集合：创建一个临时的HashMap，其中的V应当作为软引用存在，即使用自定义的软引用的类[此类是加入队列的软引用]。可以理解为将手机（强引用）放入袋子（软引用）中，在将袋子贴上一个标签，放入队列中存储。

引用队列：创建存放软引用的队列ReferenceQueue。

3、重写用到集合的方法：put、get、以及containsKey等用到的方法（即在实际使用中用到了哪些方法），在put方法中，需要先创建一个软引用对象，接收传入的value，即包裹强引用对象；将这个软引用加入到临时的集合中，这样就可以操作软引用的集合了。同样的get方法也是从这个临时存储软引用的集合中取值。

4、回收“空袋子”。当强引用对象被回收后，软引用也需要被回收掉：通过调用引用队列中的poll方法，不断的循环，检测队列是否为空，即检测队列中是否有“空袋子”软引用，如果有则从临时的集合中移除掉。在get和containKey方法中调用此回收方法。】

« 掌握OOM异常的处理，并可以对应用进行相应的优化

一、内存溢出如何产生的

Android的虚拟机是基于寄存器的Dalvik，它的最大堆大小一般是16M，有的机器为24M。因此我们所能利用的内存空间是有限的。如果我们的内存占用超过了一定的水平就会出现OutOfMemory的错误。

内存溢出的几点原因总结：

1、资源释放问题：

程序代码的问题，长期保持某些资源（如Context）的引用，造成内存泄露，资源得不到释放

2、对象内存过大问题：

保存了多个耗用内存过大的对象（如Bitmap），造成内存超出限制

3、static：

static是Java中的一个关键字，当用它来修饰成员变量时，那么该变量就属于该类，而不是该类的实例。所以用static修饰的变量，它的生命周期是很长的，如果用它来引用一些资源耗费过多的实例（Context的情况最多），这时就要谨慎对待了。

public class ClassName{

private static Context mContext;

//省略

}

以上的代码是很危险的，如果将Activity赋值到mContext的话。那么即使该Activity已经onDestroy，但是由于仍有对象保存它的引用，因此该Activity依然不会被释放。

我们举Android文档中的一个例子。

private static DrawablesBackground;

@Override

protected void onCreate(Bundle state){

super.onCreate(state);

TextView label = newTextView(this);

label.setText("Leaksare bad");

if (sBackground ==null) {

sBackground =getDrawable(R.drawable.large_bitmap);

}

label.setBackgroundDrawable(sBackground);

setContentView(label);

}

sBackground, 是一个静态的变量，但是我们发现，我们并没有显式的保存Contex的引用，但是，当Drawable与View连接之后，Drawable就将View设置为一个回调，由于View中是包含Context的引用的，所以，实际上我们依然保存了Context的引用。这个引用链如下：

Drawable->TextView->Context

所以，最终该Context也没有得到释放，发生了内存泄露。

针对static的解决方案：

第一、应该尽量避免static成员变量引用资源耗费过多的实例，比如Context。

第二、Context尽量使用Application Context，因为Application的Context的生命周期比较长，引用它不会出现内存泄露的问题。

第三、使用WeakReference代替强引用。比如可以使用WeakReference<Context>mContextRef;

该部分的详细内容也可以参考Android文档中Article部分。

4、线程导致内存溢出：

线程产生内存泄露的主要原因在于线程生命周期的不可控。我们来考虑下面一段代码。

public class MyActivityextends Activity {

@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.main);

new MyThread().start();

}

private class MyThread extends Thread{

@Override

public void run() {

super.run();

//do somthing

}

这段代码很平常也很简单，是我们经常使用的形式。我们思考一个问题：假设MyThread的run函数是一个很费时的操作，当我们开启该线程后，将设备的横屏变为了竖屏，一般情况下当屏幕转换时会重新创建Activity，按照我们的想法，老的Activity应该会被销毁才对，然而事实上并非如此。

由于我们的线程是Activity的内部类，所以MyThread中保存了Activity的一个引用，当MyThread的run函数没有结束时，MyThread是不会被销毁的，因此它所引用的老的Activity也不会被销毁，因此就出现了内存泄露的问题。

有些人喜欢用Android提供的AsyncTask，但事实上AsyncTask的问题更加严重，Thread只有在run函数不结束时才出现这种内存泄露问题，然而AsyncTask内部的实现机制是运用了ThreadPoolExcutor,该类产生的Thread对象的生命周期是不确定的，是应用程序无法控制的，因此如果AsyncTask作为Activity的内部类，就更容易出现内存泄露的问题。

针对这种线程导致的内存泄露问题的解决方案：

第一、将线程的内部类，改为静态内部类。

第二、在线程内部采用弱引用保存Context引用。

二、避免内存溢出的方案：

1、图片过大导致内存溢出：

模拟器的RAM比较小，由于每张图片先前是压缩的情况，放入到Bitmap的时候，大小会变大，导致超出RAM内存

★android 中用bitmap 时很容易内存溢出，报如下错误：Java.lang.OutOfMemoryError: bitmap size exceeds VM budget

解决：

方法1：主要是加上这段：等比例缩小图片

BitmapFactory.Optionsoptions = new BitmapFactory.Options();

options.inSampleSize =2;

1）通过getResource()方法获取资源：

//解决加载图片内存溢出的问题

//Options 只保存图片尺寸大小，不保存图片到内存

BitmapFactory.Options opts = new BitmapFactory.Options();

//缩放的比例，缩放是很难按准备的比例进行缩放的，其值表明缩放的倍数，SDK中建议其值是2的指数值,值越大会导致图片不清晰

opts.inSampleSize = 2;

Bitmap bmp = null;

bmp = BitmapFactory.decodeResource(getResources(), mImageIds[position],opts);

...

//回收

bmp.recycle();

2）通过Uri取图片资源

private ImageViewpreview;

BitmapFactory.Optionsoptions = new BitmapFactory.Options();

options.inSampleSize =2;//图片宽高都为原来的二分之一，即图片为原来的四分之一

Bitmap bitmap =BitmapFactory.decodeStream(cr.openInputStream(uri), null, options);

preview.setImageBitmap(bitmap);

以上代码可以优化内存溢出，但它只是改变图片大小，并不能彻底解决内存溢出。

3）通过路径获取图片资源

private ImageViewpreview;

private StringfileName= "/sdcard/DCIM/Camera/2010-05-14 16.01.44.jpg";

BitmapFactory.Optionsoptions = new BitmapFactory.Options();

options.inSampleSize =2;//图片宽高都为原来的二分之一，即图片为原来的四分之一

Bitmap b =BitmapFactory.decodeFile(fileName, options);

preview.setImageBitmap(b);

filePath.setText(fileName);

方法2：对图片采用软引用，及时地进行recyle()操作

SoftReference<Bitmap>bitmap;

bitmap = newSoftReference<Bitmap>(pBitmap);

if(bitmap != null){

if(bitmap.get() != null&& !bitmap.get().isRecycled()){

bitmap.get().recycle();

bitmap = null;

}

具体见“各种引用的简单了解”中的示例

2、复用listView：

方法：对复杂的listview进行合理设计与编码：

Adapter中：

@Override

public View getView(int position, ViewconvertView, ViewGroup parent) {

ViewHolderholder;

if(convertView!=null&& convertView instanceof LinearLayout){

holder= (ViewHolder) convertView.getTag();

}else{

convertView= View.inflate(MainActivity.this, R.layout.item, null);

holder= new ViewHolder();

holder.tv= (TextView) convertView.findViewById(R.id.tv);

convertView.setTag(holder);

}

holder.tv.setText("XXXX");

holder.tv.setTextColor(Color.argb(180,position*4, position*5, 255-position*2));

returnconvertView;

}

class ViewHolder{

privateTextView tv;

}

3、界面切换

方法1：单个页面，横竖屏切换N次后 OOM

1、看看页面布局当中有没有大的图片，比如背景图之类的。

去除xml中相关设置，改在程序中设置背景图（放在onCreate()方法中）：

Drawable bg = getResources().getDrawable(R.drawable.bg);

XXX.setBackgroundDrawable(rlAdDetailone_bg);

在Activity destory时注意，bg.setCallback(null); 防止Activity得不到及时的释放

2. 跟上面方法相似，直接把xml配置文件加载成view 再放到一个容器里

然后直接调用 this.setContentView(Viewview);方法，避免xml的重复加载

方法2：在页面切换时尽可能少地重复使用一些代码

比如：重复调用数据库，反复使用某些对象等等......

4、内存分配：

方法1：Android堆内存也可自己定义大小和优化Dalvik虚拟机的堆内存分配

注意若使用这种方法：project build target 只能选择 <= 2.2 版本，否则编译将通不过。所以不建议用这种方式

private final staticint CWJ_HEAP_SIZE= 6*1024*1024;

private final staticfloat TARGET_HEAP_UTILIZATION = 0.75f;

VMRuntime.getRuntime().setMinimumHeapSize(CWJ_HEAP_SIZE);

VMRuntime.getRuntime().setTargetHeapUtilization(TARGET_HEAP_UTILIZATION);

常见的内存使用不当的情况

1、查询数据库没有关闭游标

程序中经常会进行查询数据库的操作，但是经常会有使用完毕Cursor后没有关闭的情况。如果我们的查询结果集比较小，对内存的消耗不容易被发现，只有在常时间大量操作的情况下才会复现内存问题，这样就会给以后的测试和问题排查带来困难和风险。

Cursor cursor =null;

try {

cursor = getContentResolver().query(uri ...);

if (cursor != null&& cursor.moveToNext()) {

... ...

}

} finally {

if(cursor != null) {

try {

cursor.close();

} catch (Exception e) {

//ignore this

}

2、构造Adapter时，没有使用缓存的 convertView

以构造ListView的BaseAdapter为例，在BaseAdapter中提供了方法：

public View getView(int position, ViewconvertView, ViewGroup parent)

来向ListView提供每一个item所需要的view对象。初始时ListView会从BaseAdapter中根据当前的屏幕布局实例化一定数量的 view对象，同时ListView会将这些view对象缓存起来。当向上滚动ListView时，原先位于最上面的list item的view对象会被回收，然后被用来构造新出现的最下面的list item。这个构造过程就是由getView()方法完成的，getView()的第二个形参 View convertView就是被缓存起来的list item的view对象(初始化时缓存中没有view对象则convertView是null)。

由此可以看出，如果我们不去使用convertView，而是每次都在getView()中重新实例化一个View对象的话，即浪费资源也浪费时间，也会使得内存占用越来越大。ListView回收list item的view对象的过程可以查看：

public View getView(int position, ViewconvertView, ViewGroup parent) {

View view = null;

if(convertView != null) {

view = convertView;

populate(view, getItem(position));

...

}else {

view = new Xxx(...);

...

}

return view;

}

3、Bitmap对象不在使用时调用recycle()释放内存

有时我们会手工的操作Bitmap对象，如果一个Bitmap对象比较占内存，当它不在被使用的时候，可以调用Bitmap.recycle()方法回收此对象的像素所占用的内存，但这不是必须的，视情况而定。可以看一下代码中的注释：

4、释放对象的引用

当一个生命周期较短的对象A，被一个生命周期较长的对象B保有其引用的情况下，在A的生命周期结束时，要在B中清除掉对A的引用。

示例A：

public class DemoActivity extends Activity{

... ...

private Handler mHandler = ...

private Object obj;

public void operation() {

obj = initObj();

...

[Mark]

mHandler.post(new Runnable() {

public void run() {

useObj(obj);

}

});

}

我们有一个成员变量 obj，在operation()中我们希望能够将处理obj实例的操作post到某个线程的MessageQueue中。在以上的代码中，即便是 mHandler所在的线程使用完了obj所引用的对象，但这个对象仍然不会被垃圾回收掉，因为DemoActivity.obj还保有这个对象的引用。所以如果在DemoActivity中不再使用这个对象了，可以在[Mark]的位置释放对象的引用，而代码可以修改为：

... ...

public void operation() {

obj = initObj();

...

final Object o = obj;

obj = null;

mHandler.post(new Runnable() {

public void run() {

useObj(o);

}

... ...

示例B:

假设我们希望在锁屏界面(LockScreen)中，监听系统中的电话服务以获取一些信息(如信号强度等)，则可以在LockScreen中定义一个 PhoneStateListener的对象，同时将它注册到TelephonyManager服务中。对于LockScreen对象，当需要显示锁屏界面的时候就会创建一个LockScreen对象，而当锁屏界面消失的时候LockScreen对象就会被释放掉。

但是如果在释放LockScreen对象的时候忘记取消我们之前注册的PhoneStateListener对象，则会导致LockScreen无法被垃圾回收。如果不断的使锁屏界面显示和消失，则最终会由于大量的LockScreen对象没有办法被回收而引起OutOfMemory,使得 system_process进程挂掉。

5、其他

Android应用程序中最典型的需要注意释放资源的情况是在Activity的生命周期中，在onPause()、onStop()、 onDestroy()方法中需要适当的释放资源的情况。由于此情况很基础，在此不详细说明，具体可以查看官方文档对Activity生命周期的介绍，以明确何时应该释放哪些资源。

三、Android性能优化的一些方案

1、优化Dalvik虚拟机的堆内存分配

1）首先内存方面，可以参考Android堆内存也可自己定义大小和优化Dalvik虚拟机的堆内存分配

对于Android平台来说，其托管层使用的Dalvik JavaVM从目前的表现来看还有很多地方可以优化处理，比如我们在开发一些大型游戏或耗资源的应用中可能考虑手动干涉GC处理，使用dalvik.system.VMRuntime类提供的setTargetHeapUtilization方法可以增强程序堆内存的处理效率。当然具体原理我们可以参考开源工程，这里我们仅说下使用方法：

private final staticfloatTARGET_HEAP_UTILIZATION = 0.75f;

在程序onCreate时就可以调用：

VMRuntime.getRuntime().setTargetHeapUtilization(TARGET_HEAP_UTILIZATION);

2）Android堆内存也可自己定义大小

对于一些大型Android项目或游戏来说在算法处理上没有问题外，影响性能瓶颈的主要是Android自己内存管理机制问题，目前手机厂商对RAM都比较吝啬，对于软件的流畅性来说RAM对性能的影响十分敏感。

除了上次Android开发网提到的优化Dalvik虚拟机的堆内存分配外，我们还可以强制定义自己软件的对内存大小，我们使用Dalvik提供的 dalvik.system.VMRuntime类来设置最小堆内存为例:

private final staticint CWJ_HEAP_SIZE = 6* 1024* 1024 ;

VMRuntime.getRuntime().setMinimumHeapSize(CWJ_HEAP_SIZE);//设置最小heap内存为6MB大小

当然对于内存吃紧来说还可以通过手动干涉GC去处理，我们将在下次提到具体应用。

2、基础类型上，因为Java没有实际的指针，在敏感运算方面还是要借助NDK来完成。

Android123提示游戏开发者，这点比较有意思的是Google 推出NDK可能是帮助游戏开发人员，比如OpenGLES的支持有明显的改观，本地代码操作图形界面是很必要的。

3、图形对象优化：

这里要说的是Android上的Bitmap对象销毁，可以借助recycle()方法显示让GC回收一个Bitmap对象，通常对一个不用的Bitmap可以使用下面的方式，如

if(bitmapObject.isRecycled()==false)//如果没有回收

bitmapObject.recycle();

4、处理GIF动画：

目前系统对动画支持比较弱智对于常规应用的补间过渡效果可以，但是对于游戏而言一般的美工可能习惯了GIF方式的统一处理

目前Android系统仅能预览GIF的第一帧，可以借助J2ME中通过线程和自己写解析器的方式来读取GIF89格式的资源。

5、对于大多数Android手机没有过多的物理按键可能我们需要想象下了做好手势识别 GestureDetector 和重力感应来实现操控。通常我们还要考虑误操作问题的降噪处理。

四、图片占用进程的内存算法简介

android中处理图片的基础类是Bitmap，顾名思义，就是位图。占用内存的算法如下：

图片的width*height*Config。

如果Config设置为ARGB_8888，那么上面的Config就是4。一张480*320的图片占用的内存就是480*320*4 byte。

在默认情况下android进程的内存占用量为16M，因为Bitmap除了java中持有数据外，底层C++的 skia图形库还会持有一个SKBitmap对象，因此一般图片占用内存推荐大小应该不超过8M。这个可以调整，编译源代码时可以设置参数。

五、内存监测工具DDMS --> Heap

无论怎么小心，想完全避免bad code是不可能的，此时就需要一些工具来帮助我们检查代码中是否存在会造成内存泄漏的地方。Android tools中的DDMS就带有一个很不错的内存监测工具Heap(这里我使用eclipse的ADT插件，并以真机为例，在模拟器中的情况类似)。

用 Heap监测应用进程使用内存情况的步骤如下：

1. 启动eclipse后，切换到DDMS透视图，并确认Devices视图、Heap视图都是打开的；

2. 将手机通过USB链接至电脑，链接时需要确认手机是处于“USB调试”模式，而不是作为“Mass Storage”；

3. 链接成功后，在DDMS的Devices视图中将会显示手机设备的序列号，以及设备中正在运行的部分进程信息；

4. 点击选中想要监测的进程，比如system_process进程；

5. 点击选中Devices视图界面中最上方一排图标中的“Update Heap”图标；

6. 点击Heap视图中的“Cause GC”按钮；

7. 此时在Heap视图中就会看到当前选中的进程的内存使用量的详细情况。

说明：

a) 点击“Cause GC”按钮相当于向虚拟机请求了一次gc操作；

b) 当内存使用信息第一次显示以后，无须再不断的点击“Cause GC”，Heap视图界面会定时刷新，在对应用的不断的操作过程中就可以看到内存使用的变化；

c) 内存使用信息的各项参数根据名称即可知道其意思，在此不再赘述。

如何才能知道我们的程序是否有内存泄漏的可能性呢。这里需要注意一个值：Heap视图中部有一个Type叫做data object，即数据对象，也就是我们的程序中大量存在的类类型的对象。在dataobject一行中有一列是“TotalSize”，其值就是当前进程中所有Java数据对象的内存总量，一般情况下，这个值的大小决定了是否会有内存泄漏。可以这样判断：

a) 不断的操作当前应用，同时注意观察data object的Total Size值；

b) 正常情况下TotalSize值都会稳定在一个有限的范围内，也就是说由于程序中的的代码良好，没有造成对象不被垃圾回收的情况，所以说虽然我们不断的操作会不断的生成很多对象，而在虚拟机不断的进行GC的过程中，这些对象都被回收了，内存占用量会会落到一个稳定的水平；

c) 反之如果代码中存在没有释放对象引用的情况，则data object的Total Size值在每次GC后不会有明显的回落，随着操作次数的增多Total Size的值会越来越大，

直到到达一个上限后导致进程被kill掉。

d) 此处已system_process进程为例，在我的测试环境中system_process进程所占用的内存的data object的Total Size正常情况下会稳定在2.2~2.8之间，而当其值超过3.55后进程就会被kill。

总之，使用DDMS的Heap视图工具可以很方便的确认我们的程序是否存在内存泄漏的可能性。

« 熟悉Android中的动画，选择器，样式和主题的使用

一、动画：

1、动画的分类：

1）、Tween动画：这种实现方式可以使视图组件移动、放大、缩小以及产生透明度的变化；

2）、Frame动画：传统的动画方法，通过顺序的播放排列好的图片来实现，类似电影。

1）Frame 帧动画 AnimationDrawable

【参考api文档实现示例：/sdk/docs/guide/topics/resources/animation-resource.html#Frame】

1、使用AnimationDrawable来操作：

在res目录下，新建drawable与anim目录：

drawable放入帧动画图片

anim目录下新建帧动画xml文件来表示帧动画；

布局文件：

<ImageView

android:id="@+id/iv"

android:onClick="start"

android:layout_width="wrap_content"

android:layout_height="wrap_content" />

帧动画文件rocket.xml：

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

<animation-listxmlns:android="http://schemas.android.com/apk/res/android"

android:oneshot="false" >

</animation-list>

代码：

publicclass MainActivity extends Activity {

privateImageView iv;

privateAnimationDrawable anim;

@Override

protectedvoid onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

iv= (ImageView) findViewById(R.id.iv);

iv.setBackgroundResource(R.anim.rocket); // 把动画设置为背景

anim= (AnimationDrawable) iv.getBackground(); //获取背景

}

publicvoid start(View v) {

if(anim.isRunning()){

anim.stop();

}

anim.start();

}

2）Tween动画：

①、有点类似以前弄的图片，处理，如旋转，缩放等，但Tween动画，注重的是动画过程，而不是结果；

②、创建方法：

使用xml文件来定义动画，然后通过AnimationUtils来加载，获取动画对象

使用代码方法，如：

//旋转动画(这里设置：围绕自己的中心点旋转)

RotateAnimationra = new RotateAnimation(0, 360, Animation.RELATIVE_TO_SELF, 0.5f,Animation.RELATIVE_TO_SELF, 0.5f);

ra.setDuration(1500); // 旋转一次时间

ra.setRepeatCount(Animation.INFINITE); // 重复次数无限

iv_scan.startAnimation(ra); // 开启动画

分类：

1、透明动画(alpha.xml)

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

android:shareInterpolator="false" >

<alpha

android:repeatMode="reverse" //反转,播放动画

android:repeatCount="infinite" // 重复播放

android:duration="1000"

android:fromAlpha="1"

android:toAlpha="0.2" />

</set>

2、缩放动画(scale.xml)

<set>

<scale

android:duration="1000"

android:fromXScale="1.0" //起始x缩放级别,

android:fromYScale="1.0" //起始y缩放级别

android:toXScale="2" // 目标x缩放级别, 这里设置为放大一倍

android:toYScale="2"

android:pivotX="0" // 动画中心点设置；0 基于左上角；50%基于自身中央，50%p基于父容器中央, 大于0基于此像素

android:pivotY="0"

android:repeatCount="infinite"

android:repeatMode="reverse"/>

</set>

3、位移动画(translate.xml)

<translate

android:duration="1000"

android:fromXDelta="0" // 起始位移位置

android:fromYDelta="0"

android:repeatCount="infinite"

android:repeatMode="reverse"

android:toXDelta="100%" // 移动到哪里，这里设置为，移动自身的右下角位置 100%

android:toYDelta="100%" />

4、旋转动画(rotate.xml)

<rotate

android:duration="1000"

android:fromDegrees="0" //旋转角度范围设置

android:toDegrees="360"

android:pivotX="50%" //动画中心点设置

android:pivotY="50%"

android:repeatCount="infinite"

android:repeatMode="restart"

5、组合动画(all.xml)

<rotate

android:duration="1000"

android:fromDegrees="0"

android:interpolator="@android:anim/linear_interpolator" // 动画篡改器，设置匀速转动，不出现完成后，停顿

android:pivotX="50%"

android:pivotY="50%"

android:repeatCount="infinite"

android:repeatMode="restart"

android:toDegrees="360" />

<scale

android:duration="1000"

android:fromXScale="1.0"

android:fromYScale="1.0"

android:pivotX="50%"

android:pivotY="50%"

android:repeatCount="infinite"

android:repeatMode="reverse"

android:toXScale="2"

android:toYScale="2"/>

<alpha

android:duration="1000"

android:fromAlpha="1"

android:repeatCount="infinite"

android:repeatMode="reverse"

android:toAlpha="0.2" />

代码：

publicclass MainActivity extends Activity {

privateImageView imageView;

@Override

protectedvoid onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

imageView= (ImageView) findViewById(R.id.imageView);

}

publicvoid onClick(View v) {

Animationanim = null; // 动画对象

switch(v.getId()) {

caseR.id.alphaBT: //透明动画

anim= AnimationUtils.loadAnimation(this, R.anim.alpha); // 根据xml获取动画对象

break;

caseR.id.rorateBT: //旋转动画

anim= AnimationUtils.loadAnimation(this, R.anim.rotate);

break;

caseR.id.scaleBT: //缩放动画

anim= AnimationUtils.loadAnimation(this, R.anim.scale);

break;

caseR.id.transalteBT: //位移动画

anim= AnimationUtils.loadAnimation(this, R.anim.translate);

break;

caseR.id.all:

anim= AnimationUtils.loadAnimation(this, R.anim.all);

break;

}

if(anim != null) {

imageView.startAnimation(anim); // 启动动画

}

动画篡改器interpolator

Interpolator 定义了动画的变化速度，可以实现匀速、正加速、负加速、无规则变加速等；有以下几类（更多参考API）：

AccelerateDecelerateInterpolator，延迟减速，在动作执行到中间的时候才执行该特效。

AccelerateInterpolator, 会使慢慢以(float)的参数降低速度。

LinearInterpolator，平稳不变的，上面旋转动画中使用到了；

DecelerateInterpolator，在中间加速,两头慢

CycleInterpolator，曲线运动特效，要传递float型的参数。

API Demo View 中有对应的动画插入器示例，可供参考；

xml实现动画插入器：

1、动画定义文件/res/anim/目录下shake.xml ：

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

android:duration="500"

android:fromXDelta="0"

android:interpolator="@anim/cycle_3"

android:toXDelta="10"/>

2、interpolator 指定动画按照哪一种方式进行变化, cycle_3文件如下：

<cycleInterpolatorxmlns:android="http://schemas.android.com/apk/res/android"android:cycles="3" />

表示循环播放动画3次；

3、使用动画的，程序代码：

Animation shake = AnimationUtils.loadAnimation(this,R.anim.shake);

et_phone.startAnimation(shake);

二、样式与主题

1、样式

1）、定义样式

设置样式，在values文件夹下的任意文件中的<resources>中配置<style>标签

<itemname="android:layout_width">match_parent</item>

<item name="android:layout_height">wrap_content</item>

</style>

2）、继承样式，在<style>标签中配置属性parent

<item name="android:gravity">center</item>

</style>

<item name="android:gravity">right</item>

</style>

3）、使用样式

在layout文件的标签中配置style属性

<TextView

style="@style/itheima1"

android:text="一段文本" />

2、主题

styles.xml中也可以为Activity定义属性

</style>

在AndroidManifest.xml文件中<activity>或者<application>节点上可以使用theme属性引用

<activity

android:name="com.itheima.style.MainActivity"

android:theme="@style/AppTheme" />

三、选择器：

一）、创建xml文件:

在drawable/xxx.xml下常见xml文件，在同目录下记得要放相关图片

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

<itemandroid:drawable="@drawable/pic1" />

<itemandroid:state_window_focused="false"

android:drawable="@drawable/pic1"/>

<itemandroid:state_focused="true" android:state_pressed="true" android:drawable= "@drawable/pic2" />

<itemandroid:state_focused="false" android:state_pressed="true" android:drawable="@drawable/pic3" />

<itemandroid:state_selected="true" android:drawable="@drawable/pic4" />

<itemandroid:state_focused="true" android:drawable="@drawable/pic5"/>

（1）在listview中配置android:listSelector="@drawable/xxx

（2）在listview的item中添加属性android：background="@drawable/xxx"

2）、方法二：

Drawable drawable =getResources().getDrawable(R.drawable.xxx);

ListView.setSelector(drawable);

但是这样会出现列表有时候为黑的情况，需要加上：

android:cacheColorHint="@android:color/transparent"使其透明。

2、相关属性：

android:state_selected ：是选中

android:state_focused ：是获得焦点

android:state_pressed ：是点击

android:state_enabled ：是设置是否响应事件,指所有事件

根据这些状态同样可以设置button的selector效果。也可以设置selector改变button中的文字状态。

3、Button文字效果

1）以下是配置button中的文字效果：

drawable/button_font.xml

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

<selectorxmlns:android="http://schemas.android.com/apk/res/android">

<itemandroid:state_selected="true" android:color="#FFF" />

<itemandroid:state_focused="true" android:color="#FFF" />

<itemandroid:state_pressed="true" android:color="#FFF" />

</selector>

2）Button还可以实现更复杂的效果，例如渐变

drawable/button_color.xml

<?xmlversion="1.0" encoding="utf-8"?>

<selectorxmlns:android="http://schemas.android.com/apk/res/android"> /

<itemandroid:state_pressed="true">//定义当button 处于pressed 状态时的形态。

<shape>

<padding android:left="10dp"android:top="10dp"

android:bottom="10dp"android:right="10dp"/>

</shape>

</item>

<itemandroid:state_focused="true">//定义当button获得 focus时的形态

<shape>

<gradientandroid:startColor="#eac100"/>

<strokeandroid:width="2dp"android:color="#333333" color="#ffffff"/>

<cornersandroid:radius="8dp" />

<paddingandroid:left="10dp" android:top="10dp"

android:bottom="10dp"android:right="10dp"/>

</shape>

</item>

</selector>

3）最后，需要在包含 button的xml文件里添加两项。

例如main.xml 文件，需要在<Button />里加两项

android：focusable="true"

android:background="@drawable/button_color"

三）语法示例：

1、文件位置：

res/color/filename.xml，文件名被做资源的ID

2、语法示例

<?xmlversion="1.0" encoding="utf-8"?>

<selectorxmlns:android="http://schemas.android.com/apk/res/android">

<itemandroid:state_selected="true" android:color="@color/white"/>

<itemandroid:state_focused="true" android:color="@color/white"/>

<itemandroid:state_pressed="true" android:color="@color/white"/>

<itemandroid:state_enabled="true"android:color="@color/black"/>

<itemandroid:state_window_focused="false"android:color="@color/black"/>

<itemandroid:color="@color/black" />

</selector>

3、属性

android:color：十六进制颜色，必须的。颜色是用RGB值来指定的，并且可选择alpha通道。

这个值始终是用#字符开头，后面跟的是Appha-Red-Green-Blue信息，格式如下：

android:state_pressed：一个布尔值

如果这个项目是在对象被按下时使用，那么就要设置为true。（如，按钮被触摸或点击时。）false应该用于默认的非按下状态。

android:state_focused：一个布尔值

如果这个项目是在对象获取焦点时使用，那么就要设置为true。如，一个选项标签被打开时。

如果这个项目要用于对象没有被被选择的时候，那么就要设置为false。

android:state_checkable：一个布尔值

如果这个项目要用于对象的可选择状态，那么就要设置为true。

如果这个项目要用于不可选状态，那么就要设置为false。（它只用于一个对象在可选和不可选之间的转换）。

android:state_checked：一个布尔值

如果这个项目要用于对象被勾选的时候，那么就要设置为true。否者设为false。

android:state_enabled：一个布尔值

如果这个项目要用于对象可用状态（接受触摸或点击事件的能力），那么就要设置为true，否者设置为false。

android:state_window_focused：一个布尔值

如果这个项目要用于应用程序窗口的有焦点状态（应用程序是在前台），那么就要设置为true，否者设置false。

4、注意

A：要记住，状态列表中一个与对象当前状态匹配的项目会被使用。因此，如果列表中的第一项没有包含以上任何一种状态属性，那么每次都会使用这个项目，因此默认设置应该始终被放到最后。

B：如果出现失去焦点，背景色延迟的情况，不要使用magin。

C：drawable下的selector可是设置状态背景列表(可以让view的背景在不同状态时变化)说明:也可以定义状态背景列表,但是是定义在drawable文件夹下,用的不是color属性,而是drawable属性。

四）

、自定义选择器

（shape和选择器如何同时使用。例如：如何让一个按钮即是圆角的，又能在点击的时候出现颜色变化。）

1、定义xml文件，RootElement选择shape

①创建view被按下的布局文件：

进行相应的属性配置，如：

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

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

android:shape="rectangle" >

</shape>

②创建view正常显示的布局（新建一个xml同），配置如下：

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

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

android:shape="rectangle" >

</shape>

2、创建背景选择器：（Root Element为selector）

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

<selectorxmlns:android="http://schemas.android.com/apk/res/android">

3、将上面定义好的布局文件设定到选择器中（红字）

在需要使用背景资源的布局文件中选择上面创建的背景选择器（selector）

设置布局的clickable为true，并设置点击事件

此时在界面中点击控件时就会变化颜色

« 熟悉android系统下消息推送机制

一、推送方式简介：

当前随着移动互联网的不断加速，消息推送的功能越来越普遍，不仅仅是应用在邮件推送上了，更多的体现在手机的APP上。当我们开发需要和服务器交互的应用程序时，基本上都需要获取服务器端的数据，比如《地震应急通》就需要及时获取服务器上最新的地震信息。

1、概念：

所谓的消息推送就是从服务器端向移动终端发送连接，传输一定的信息。比如一些新闻客户端，每隔一段时间收到一条或者多条通知，这就是从服务器端传来的推送消息；还比如常用的一些IM软件如微信、GTalk等，都具有服务器推送功能。

推送技术通过自动传送信息给用户，来减少用于网络上搜索的时间。它根据用户的兴趣来搜索、过滤信息，并将其定期推给用户，帮助用户高效率地发掘有价值的信息。

2、要获取服务器上不定时更新的信息，一般来说有两种方法：

第一种是客户端使用Pull（拉）的方式，就是隔一段时间就去服务器上获取一下信息，看是否有更新的信息出现。

第二种就是服务器使用Push（推送）的方式，当服务器端有新信息了，则把最新的信息Push到客户端上。这样，客户端就能自动的接收到消息。

虽然Pull和Push两种方式都能实现获取服务器端更新信息的功能，但是明显来说Push方式比Pull方式更优越。因为Pull方式更费客户端的网络流量，更主要的是费电量，还需要我们的程序不停地去监测服务端的变化。

二、常见消息推送方案的原理：

1、轮询(Pull)方式：

客户端定时向服务器发送询问消息，一旦服务器有变化则立即同步消息。应用程序应当阶段性的与服务器进行连接并查询是否有新的消息到达，你必须自己实现与服务器之间的通信，例如消息排队等。而且你还要考虑轮询的频率，如果太慢可能导致某些消息的延迟，如果太快，则会大量消耗网络带宽和电池。

2、SMS(Push)方式：

通过拦截SMS消息并且解析消息内容来了解服务器的命令。这个方案的好处是，可以实现完全的实时操作；但是问题是这个方案的成本相对比较高，且依赖于运营商。

3、持久连接(Push)方式：

客户端和服务器之间建立长久连接，这样就可以实现消息的及时行和实时性。

这个方案可以解决由轮询带来的性能问题，但是还是会消耗手机的电池。我们需要开一个服务来保持和服务器端的持久连接（苹果就和谷歌的C2DM是这种机制）。但是对于Android系统，当系统可用资源较低，系统会强制关闭我们的服务或者是应用，这种情况下连接会强制中断。（Apple的推送服务之所以工作的很好，是因为每一台手机仅仅保持一个与服务器之间的连接，事实上C2DM也是这么工作的。即所有的推送服务都是经由一个代理服务器完成的，这种情况下只需要和一台服务器保持持久连接即可。C2DM=Cloud to Device Messaging）。

　　相比之下第三种还是最可行的。为软件编写系统服务或开机启动功能；或者如果系统资源较低，服务被关闭后可以在onDestroy ()方法里面再重启该服务，进而实现持久连接的方式。

三、消息推送解决方案概述

1、C2DM云端推送方案

在Android手机平台上，Google提供了C2DM（Cloudto Device Messaging）服务。Android Cloud to DeviceMessaging (C2DM)是一个用来帮助开发者从服务器向Android应用程序发送数据的服务。该服务提供了一个简单的、轻量级的机制，允许服务器可以通知移动应用程序直接与服务器进行通信，以便于从服务器获取应用程序更新和用户数据。C2DM服务负责处理诸如消息排队等事务并向运行于目标设备上的应用程序分发这些消息。

C2DM操作过程示例图：

这个服务存在很大的问题：

1）C2DM内置于Android的2.2系统上，无法兼容老的1.6到2.1系统。

2）C2DM需要依赖于Google官方提供的C2DM服务器，由于国内的网络环境，这个服务经常不可用，如果想要很好的使用，我们的App Server必须也在国外，这个恐怕不是每个开发者都能够实现的。

3) 不像在iPhone中，他们把硬件系统集成在一块了。所以对于我们开发者来说，如果要在我们的应用程序中使用C2DM的推送功能，因为对于不同的这种硬件厂商平台，比如摩托罗拉、华为、中兴做一个手机，他们可能会把Google的这种服务去掉，尤其像在国内就很多这种，把Google这种原生的服务去掉。买了一些像什么山寨机或者是华为这种国产机，可能Google的服务就没有了。而像在国外出的那些可能会内置。

即然C2DM无法满足我们的要求，那么我们就需要自己来实现Android手机客户端与App Server之间的通信协议，保证在App Server想向指定的Android设备发送消息时，Android设备能够及时的收到。

2、MQTT协议实现Android推送

　　采用MQTT协议实现Android推送功能也是一种解决方案。MQTT是一个轻量级的消息发布/订阅协议，它是实现基于手机客户端的消息推送服务器的理想解决方案。

　　wmqtt.jar 是IBM提供的MQTT协议的实现。我们可以从如下站点下载（http://www-01.ibm.com/support/docview.wss?rs=171&uid=swg24006006）它。可以将该jar包加入自己的Android应用程序中。可以从这里（https://github.com/tokudu/AndroidPushNotificationsDemo）下载该项目的实例代码，并且可以找到一个采用PHP书写的服务器端实现（https://github.com/tokudu/PhpMQTTClient）。

架构如下图所示：

3、RSMB实现推送功能

　　Really SmallMessage Broker (RSMB) ，是一个简单的MQTT代理，同样由IBM提供，其查看地址是：http://www.alphaworks.ibm.com/tech/rsmb。缺省打开1883端口，应用程序当中，它负责接收来自服务器的消息并将其转发给指定的移动设备。SAM是一个针对MQTT写的PHP库。我们可以从这个http://pecl.php.net/package/sam/download/0.2.0地址下载它。send_mqtt.php是一个通过POST接收消息并且通过SAM将消息发送给RSMB的PHP脚本。

4、XMPP协议实现Android推送

1）XMPP：

XMPP全称Extensible Messaging and Presence Protocol，前身是Jabber项目，是一种以XML为基础的开放式即时通讯协议。XMPP因为被Google Talk和网易泡泡应用而被广大网民所接触。XMPP的关键特色是，分散式的即时通讯系统，以及使用XML串流。XMPP目前被IETF国际标准组织完成了标准化工作。

2）Android push notification(androidpn)

AndroidPN 是一个基于XMPP协议的java开源实现，它包含了完整的客户端和服务器端。该服务器端基本是在另外一个开源工程openfire基础上修改实现的。

androidpn实现意图如下图所示：

androidpn客户端需要用到一个基于java的开源XMPP协议包asmack，这个包同样也是基于openfire下的另外一个开源项目smack，不过我们不需要自己编译，可以直接把androidpn客户端里面的asmack.jar拿来使用。客户端利用asmack中提供的XMPPConnection类与服务器建立持久连接，并通过该连接进行用户注册和登录认证，同样也是通过这条连接，接收服务器发送的通知。

3）androidpn服务器端：

androidpn服务器端也是java语言实现的，基于openfire开源工程，不过它的Web部分采用的是spring框架，这一点与openfire是不同的。Androidpn服务器包含两个部分，一个是侦听在5222端口上的XMPP服务，负责与客户端的XMPPConnection类进行通信，作用是用户注册和身份认证，并发送推送通知消息。另外一部分是Web服务器，采用一个轻量级的HTTP服务器，负责接收用户的Web请求。服务器的这两方式，意义非凡：当相应的TCP端口被防火墙封闭，可以使用轮询的方式进行访问，因此又有助于通过防火墙。

服务器架构如下：

最上层包含四个组成部分，分别是SessionManager，Auth Manager，PresenceManager以及Notification Manager。SessionManager负责管理客户端与服务器之间的会话，Auth Manager负责客户端用户认证管理，Presence Manager负责管理客户端用户的登录状态，NotificationManager负责实现服务器向客户端推送消息功能。

这个解决方案的最大优势就是简单，我们不需要象C2DM那样依赖操作系统版本，也不会担心某一天Google服务器不可用。利用XMPP协议我们还可以进一步的对协议进行扩展，实现更为完善的功能。采用这个方案，我们目前只能发送文字消息，不过对于推送来说一般足够了，因为我们不能指望通过推送得到所有的数据，一般情况下，利用推送只是告诉手机端服务器发生了某些改变，当客户端收到通知以后，应该主动到服务器获取最新的数据，这样才是推送服务的完整实现。 XMPP协议书相对来说还是比较简单的，值得我们进一步研究。

4）androidpn不足：

androidpn是一个基于XMPP协议的java开源Android push notification实现。它包含了完整的客户端和服务器端。但也存在一些不足之处：

①、比如时间过长时，就再也收不到推送的信息了。

②、性能上也不够稳定。

③、如果将消息从服务器上推送出去，就不再管理了，不管消息是否成功到达客户端手机上。

如果我们要使用androidpn，则还需要做大量的工作，需要理解XMPP协议、理解Androidpn的实现机制，需要调试内部存在的BUG。

5、使用第三方平台

　　目前国内、国外有一些推送平台可供使用，但是涉及到收费问题、保密问题、服务质量问题、扩展问题等等，又不得不是我们望而却步。

6、自己搭建一个推送平台。

　　这不是一件轻松的工作，当然可以根据各自的需要采取合适的方案。

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

四、Android PushNotification实现信息推送使用

　AndroidPn项目就是使用XMPP协议实现信息推送的一个开源项目。在这里介绍其使用过程。

1、Apndroid Push Notification的特点：

1）快速集成:提供一种比C2DM更加快捷的使用方式，避免各种限制.

2）无需架设服务器:通过使用"云服务"，减少额外服务器负担.

3）可以同时推送消息到网站页面，android 手机

4）耗电少，占用流量少.

2、具体配置过程：

1）下载并解压androidpn的压缩包

①、首先，我们需要下载androidpn-client-0.5.0.zip和androidpn-server-0.5.0-bin.zip。

　　下载地址：http://sourceforge.net/projects/androidpn/

②、解压两个包，Eclipse导入client，配置好目标平台，打开raw/androidpn.properties文件，配置客户端程序。

2）配置：

A、如果是模拟器来运行客户端程序，把xmppHost配置成10.0.2.2[模拟器把10.0.2.2认为是所在主机的地址，127.0.0.1是模拟器本身的回环地址，10.0.2.1表示网关地址，10.0.2.3表示DNS地址，10.0.2.15表示目标设备的网络地址]，关于模拟器的详细信息，大家可参阅相关资料。

　　xmppPort=5222是服务器的xmpp服务监听端口

　　运行androidpn-server-0.5.0\bin\run.bat启动服务器，从浏览器访问http://127.0.0.1:7070/index.do (androidPN Server有个轻量级的web服务器，在7070端口监听请求，接受用户输入的文本消息)

　　运行客户端，客户端会向服务器发起连接请求，注册成功后，服务器能识别客户端，并维护和客户端的IP长连接。

B、如果是在同一个局域网内的其他机器的模拟器测试(或者使用同一无线路由器wifi上网的真机) ，则需要把这个值设置为服务器机器的局域网ip

　　例如：你的电脑和android手机都通过同一个无线路由器wifi上网，电脑的ip地址为 192.168.1.2 而手机的ip地址为192.168.1.3，这个时候需要把这个值修改为xmppHost=192.168.1.1 或是电脑的IP地址，就可以在手机上使用了.

C、如果是不在同一个局域网的真机测试，我们需要将这个值设置为服务器的IP地址。

具体配置如下图所示：

3）示例：

　　我的电脑IP是：192.168.8.107

A、服务器运行主界面：

B、推送信息如下界面所示：

C、测试结果如下图所示：

« 熟悉掌握常见的设计模式：单例模式、工厂模式、策略模式、代理模式、装饰模式、模板模式

« 熟悉UML设计，可以设计程序的用例图、类图、活动图等

« 对Cocos2d游戏引擎有一定的了解和实践，并接触过处理3D图形和模型库的OpenGL

在进行游戏界面的绘制工作中，需要处理大量的工作，这些工作有很多共性的操作；并且对于游戏界面的切换，元素动作的处理，都已经有人做好了这些工作，并将其封装到框架中，其中Cocos2d-android就是这样一个框架。

Cocos2d实现游戏的绘制：

1、实现步骤：

首先来说，要想绘制出游戏界面，按照谷歌文档中的说明，需要实现两步操作：

①、所有的SurfaceView和SurfaceHolder.Callback，被UI Thread调用

也就是说需要接收用户的操作

②、确保所绘制的进程是有效的：

就要调用SurfaceHolder.Callback中的创建方法creat被调用和销毁方法destroy被调用

2、具体的实现：

1）、Cocos2d中有CCGLSurfaceView这个类，是继承于SurfaceView的，并实现了SurfaceHolder.Callback的接口。创建出这个对象，就有了绘制游戏界面的容器。

2）、绘制容器中的画面和元素，还要接受用户的操作；就需要将绘制的操作放在一个子线程中执行，UI Thread这个线程接收用户的操作；通过GLThread这个类实现不断的绘制界面的操作。

GLThread绘制线程的实现：

①、复写了run方法，在run方法中调用了GLThread自己的run方法：guardedRun

此方法中，通过while(true)不停的绘制，其中有相应的标记进行控制

绘制的方法：mRenderer.onDrawFrame(gl);【绘制一帧】

【void org.cocos2d.opengl.GLSurfaceView.Renderer.onDrawFrame(GL10gl)】

②、Canvas和GL10这个接口如何进行处理绘制的：

在Canvas中，Bitmap和GL是互斥的，一个为null，另一个必须不为null

Cocos2d底层用到的是OpenGL的信息，所以方法中传递的是gl的接口

③、GLThread的开启：

@、在GLSurfaceView中的setRenderer方法中开启的：

mGLThread = new GLThread(renderer);

mGLThread.start();

@、在CCDirector（继承了GLSurfaceView.Renderer）的initOpenGLViewWithView方法中调用了setRenderer

@、的调用是由attachInView(View view)方法返回的

最终是由导演CCDirector进行调用，这是导演的第一个工作，

attachInView(View view)的作用是将导演和SurfaceView进行绑定，绑定时，将绘制线程开启起来

（3）由此，大致过程如下：

①、创建出CCGLSurfaceView（即对应的SurfaceView），设置显示setContentView(surfaceView)

②、紧随其后，创建出导演CCDirector【通过单例获取：director=CCDirector.sharedDirector();】

③、通过调用导演中的attachInView(surfaceView)，传入surfaceView：

这样就建立了CCDirector和SurfaceView之间的关系

并且还开启了绘制线程，进行绘制：

attachInView(Viewview)方法调用了initOpenGLViewWithView方法【都是导演中的方法】

initOpenGLViewWithView方法调用了setRenderer【开启绘制线程用的】

在setRenderer中创建了绘制线程，并开启起来

mGLThread = new GLThread(renderer);

mGLThread.start();

3、界面元素的展示：

上面的操作只是创建出界面，可以不断绘制界面中的内容，要想丰富界面，就需要添加元素到界面中。

Cocos2的架构：

①、Cocos2D Graphic图形引擎②、CocosDenshion Audio声音引擎③、物理引擎④、Lua脚本库

其中对于图形引擎，在Cocos2d中，绘制游戏就相当于在拍电影
由导演类CCDirector控制这个游戏元素的展现和消失；其中还包括场景类CCScene和精灵类CCSprite

说明：

1）CCDirector（导演）：

引擎的控制者，控制场景的切换，游戏引擎属性的设置【管理整棵大树】

2）CCScene （场景）：场景类

例如游戏的闪屏，主菜单，游戏主界面等。【类似于树根，树干】

3）CCLayer（布景）：图层类

每个图层都有自己的触发事件，该事件只能对其拥有的元素有效，而图层之上的元素所包含的元素，是不受其事件管理的【类似于树枝】

4）CCSprite（人物）：精灵类，

界面上显示的最小单元【类似于树叶】

5）CCNode：

引擎中最重要的元素，所有可以被绘制的东西都是派生于此。它可以包含其它CCNode，可以执行定时器操作，可以执行CCAction。

CCScene，CCLayer，CCSprite的父类

6）CCAction（动作）：动作类

如平移、缩放、旋转等动作

示例代码：

publicclass MainActivity extends Activity {

private CCDirector director;

@Override

protected void onCreate(BundlesavedInstanceState) {

super.onCreate(savedInstanceState);

//创建surfaceView

CCGLSurfaceView surfaceView = newCCGLSurfaceView(this);

setContentView(surfaceView);

//创建导演

director =CCDirector.sharedDirector();

/* 设置相关参数

//横屏显示

director.setDeviceOrientation(CCDirector.kCCDeviceOrientationLandscapeLeft);

//设置屏幕大小

director.setScreenSize(480, 320);

//显示帧率

director.setDisplayFPS(true);

//①建立CCDirector和SurfaceView之间的关系；开启绘制线程

director.attachInView(surfaceView);

* 管理显示内容

//创建场景

CCScene scene = CCScene.node();

// FirstLayer layer = new FirstLayer();

// ActionLayer layer = newActionLayer();

DemoLayer layer = new DemoLayer();

//添加场景中的layer

scene.addChild(layer);

director.runWithScene(scene);

}

@Override

protected void onResume() {

director.onResume();

super.onResume();

}

@Override

protected void onPause() {

director.onPause();

super.onPause();

}

@Override

protected void onDestroy() {

director.end();

super.onDestroy();

}

publicclass FirstLayer extends CCLayer {

private static final String TAG ="FristLayer";

private int count;

public FirstLayer(){

// 一个场景里面只能有一个layer可以处理用户的Touch

this.setIsTouchEnabled(true);

private void init() {

//创建精灵

CCSprite sprite =CCSprite.sprite("z_1_01.png");

this.addChild(sprite);

sprite.setAnchorPoint(0, 0);

CCSprite spritex =CCSprite.sprite("z_1_01.png");

spritex.setFlipX(true);

spritex.setAnchorPoint(0, 0);

spritex.setPosition(100, 0);

this.addChild(spritex, 0, 10);

CCSprite spritey =CCSprite.sprite("z_1_01.png");

spritey.setFlipY(true);

spritey.setAnchorPoint(0, 0);

spritey.setPosition(0, 100);

this.addChild(spritey);

}

@Override

public boolean ccTouchesBegan(MotionEventevent) {

// 坐标转换：将MotionEvent封装的手机屏幕坐标系的坐标信息转换成Cocos2D的坐标系

CGPoint touchPos=this.convertTouchToNodeSpace(event);

CCSprite sprite = (CCSprite)this.getChildByTag(10);

boolean containsPoint =CGRect.containsPoint(sprite.getBoundingBox(), touchPos);

if(containsPoint){

// sprite.setOpacity(newRandom().nextInt(255));

// count++;

// sprite.setVertexZ(1.0f+count);//最大132？

// Log.i(TAG,"count=="+count);

//移除精灵

// sprite.removeSelf();

//隐藏精灵

sprite.setVisible(false);

* Tips:此处不能使用sprite.removeSelf();

* 否则在第二次点击的时候，就会挂掉，因为再次点击的时候，精灵已经从layer中移除出去了

}

returnsuper.ccTouchesBegan(event);

1、Android应用程序支持横竖屏幕的切换，android中每次屏幕的切换动会重启Activity，所以应该在Activity销毁（执行onPause()方法和onDestroy()方法）前保存当前活动的状态；在Activity再次创建的时候载入配置，那样，进行中的游戏就不会自动重启了！有的程序适合从竖屏切换到横屏，或者反过来，这个时候怎么办呢？可以在配置Activity的地方进行如下的配置android:screenOrientation="portrait"（landscape是横向，portrait是纵向）。这样就可以保证是竖屏总是竖屏了。

2、而有的程序是适合横竖屏切换的。如何处理呢？首先要在配置Activity的时候进行如下的配置：

android:configChanges="keyboardHidden|orientation"，

另外需要重写Activity的onConfigurationChanged方法。

实现方式如下：

@Override

publicvoidonConfigurationChanged(ConfigurationnewConfig){

super.onConfigurationChanged(newConfig);

if(this.getResources().getConfiguration().orientation==Configuration.ORIENTATION_LANDSCAPE){

//landdonothingisok

}elseif(this.getResources().getConfiguration().orientation==Configuration.ORIENTATION_PORTRAIT){

//portdonothingisok

}

二、分辨率问题：

对于分辨率问题，官方给的解决办法是创建不同的layout文件夹，这就需要对每种分辨率的手机都要写一个布局文件，虽然看似解决了分辨率的问题，但是如果其中一处或多处有修改了，就要每个布局文件都要做出修改，这样就造成很大的麻烦。那么可以通过以下几种方式解决：

一）使用layout_weight

目前最为推荐的Android多屏幕自适应解决方案。

该属性的作用是决定控件在其父布局中的显示权重，一般用于线性布局中。其值越小，则对应的layout_width或layout_height的优先级就越高（一般到100作用就不太明显了）；一般横向布局中，决定的是layout_width的优先级；纵向布局中，决定的是layout_height的优先级。

传统的layout_weight使用方法是将当前控件的layout_width和layout_height都设置成fill_parent,这样就可以把控件的显示比例完全交给layout_weight；这样使用的话，就出现了layout_weight越小，显示比例越大的情况（即权重越大，显示所占的效果越小）。不过对于2个控件还好，如果控件过多，且显示比例也不相同的时候，控制起来就比较麻烦了，毕竟反比不是那么好确定的。于是就有了现在最为流行的0px设值法。看似让人难以理解的layout_height=0px的写法，结合layout_weight，却可以使控件成正比例显示，轻松解决了当前Android开发最为头疼的碎片化问题之一。

先看下面的styles（style_layout.xml）

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

<stylename="layout_full">

<itemname="android:layout_width">fill_parent</item>

<itemname="android:layout_height">fill_parent</item>

</style>

<item name="android:layout_width">wrap_content</item>

<itemname="android:layout_height">wrap_content</item>

可以看到，layout_width和layout_height两个属性被我封装成了4个style，根据实际布局情况，选用当中的一种，不需要自己设置

二）清单文件配置：【不建议使用这种方式，需要对不同的界面写不同的布局】

需要在AndroidManifest.xml文件的<manifest>元素如下添加子元素

<supports-screensandroid:largeScreens="true"

android:normalScreens="true"

android:anyDensity="true"

android:smallScreens="true"

android:xlargeScreens="true">

</supports-screens>

以上是为我们的屏幕设置多分辨率支持（更准确的说是适配大、中、小三种密度）。

Android:anyDensity="true"，这一句对整个的屏幕都起着十分重要的作用，值为true，我们的应用程序当安装在不同密度的手机上时，程序会分别加载hdpi,mdpi,ldpi文件夹中的资源。相反，如果值设置为false，即使我们在hdpi,mdpi,ldpi，xdpi文件夹下拥有同一种资源，那么应用也不会自动地去相应文件夹下寻找资源。而是会在大密度和小密度手机上加载中密度mdpi文件中的资源。

有时候会根据需要在代码中动态地设置某个值，可以在代码中为这几种密度分别设置偏移量,但是这种方法最好不要使用，最好的方式是在xml文件中不同密度的手机进行分别设置。这里地图的偏移量可以在values-xpdi，values-hpdi,values-mdpi,values-ldpi四种文件夹中的dimens.xml文件进行设置。

三）、其他：

说明：

在不同分辨率的手机模拟器下，控件显示的位置会稍有不同

通过在layout中定义的布局设置的参数，使用dp（dip），会根据不同的屏幕分辨率进行适配

但是在代码中的各个参数值，都是使用的像素（px）为单位的

技巧：

1、尽量使用线性布局，相对布局，如果屏幕放不下了，可以使用ScrollView（可以上下拖动）

ScrowView使用的注意：

在不同的屏幕上显示内容不同的情况，其实这个问题我们往往是用滚动视图来解决的，也就是ScrowView；需要注意的是ScrowView中使用layout_weight是无效的，既然使用ScrowView了，就把它里面的控件的大小都设成固定的吧。

2、指定宽高的时候，采用dip的单位，dp单位动态匹配

3、由于android代码中写的单位都是像素，所有需要通过工具类进行转化

4、尽量使用9-patch图，可以自动的依据图片上面显示的内容被拉伸和收缩。其中在编辑的时候，灰色区域是被拉伸的，上下两个点控制水平方向的拉伸，左右两点控制垂直方向的拉伸

工具在adt-bundle-windows-x86-20130522\sdk\tools目录下的draw9patch.bat

三、手机分辨率px和dp的关系：

dp：是dip的简写，指密度无关的像素。

指一个抽象意义上的像素，程序用它来定义界面元素。一个与密度无关的，在逻辑尺寸上，与一个位于像素密度为160DPI的屏幕上的像素是一致的。要把密度无关像素转换为屏幕像素，可以用这样一个简单的公式：pixels=dips*(density/160)。举个例子，在DPI为240的屏幕上，1个DIP等于1.5个物理像素。

/**

* 根据手机的分辨率从 px(像素) 的单位转成为 dp

public static int px2dip(Context context,float pxValue) {

final float scale = context.getResources().getDisplayMetrics().density;

return (int) (pxValue / scale +0.5f);

}

/**

* 根据手机的分辨率从 dip 的单位转成为 px(像素)

public static int dip2px(Context context,float dpValue) {

final float scale = context.getResources().getDisplayMetrics().density;

return (int) (dpValue * scale +0.5f);

}

« 对OAuth2认证有一定的了解

转到分享界面后，进行OAuth2认证：

以新浪为例：

第一步、WebView加载界面，传递参数

使用WebView加载登陆网页，通过Get方法传递三个参数：应用的appkey、回调地址和展示方式display(如手机设备为mobile)；

如：https://auth.sina.com.cn/oauth2/authorize?client_id=1750636396&redirect_uri=http://vdisk.weibo.com/&display=mobile

第二步、回调地址获取code

当点击登陆（或授权）的时候，会将自定义的回调地址发送到相应的服务器端，这个回调地址只是为了从相应的服务器端（如新浪）获取到一个code；可以在WebViewClient的shouldOverrideUrlLoading方法中捕获到，然后获取到这个跳转的URL后，截取其中的code，如：http://vdisk.weibo.com/?code=3ea97ac6d5c1016a70d1c16e98b6f9ca

第三步、获取token

通过这个code到相应的服务器获取到token【当然不仅仅是获取到token这个认证令牌，还有令牌有效期、uid，如果有权限的话，有的还会返回刷新令牌的token】，这些数据需要加密后保存在本地。

然后下次再登陆的时候，就可以直接登陆，然后通过发送给服务器端token等数据，获取到相应的数据

« 对Android底层有一定的认识，研究过相关的Android源码

我将从以下几方面简单说明：

一、系统架构：

一）、系统分层：（由下向上）【如图】

1、安卓系统分为四层，分别是Linux内核层、Libraries层、FrameWork层，以及Applications层；

其中Linux内核层包含了Linux内核和各种驱动；

Libraries层包含各种类库（动态库（也叫共享库）、android运行时库、Dalvik虚拟机），编程语言主要为C或C++

FrameWork层大部分使用java语言编写，是android平台上Java世界的基石

Applications层是应用层，我们在这一层进行开发，使用java语音编写

2、Dalvik VM和传统JVM的区别：

传统的JVM：编写.java文件à编译为.class文件à打包成.jar文件

Dalvik VM：编写.java文件à编译为.class文件à打包成.dex文件à打包成.apk文件(通过dx工具)

将所有的类整合到一个文件中，提高了效率。更适合在手机上运行

1、Linux内核层[LINUX KERNEL]：

包含Linux内核和驱动模块（比如USB、Camera、蓝牙等）。

Android2.2（代号Froyo）基于Linux内核2.6版本。

2、Libraries层[LIBRARIES]：

这一层提供动态库（也叫共享库）、android运行时库、Dalvik虚拟机等。

编程语言主要为C或C++，所以可以简单的看成Native层。

3、FrameWork层[APPLICATION FRAMEWORK]：

这一层大部分用java语言编写，它是android平台上Java世界的基石。

4、Applications层[APPLICATION]：应用层

如图所示：

系统分层的图整体简化为下面的一张图，对应如下：

FrameWork层 --------à Java世界

Libraries层 --------à Native世界

Linux内核层 --------à Linux OS

Java世界和Native世界间的通信是通过JNI层

JNI层和Native世界都可以直接调用系统底层

二）、系统编译：

1、主要步骤：系统环境的准备，下载源码、编译源码、输出结果：

目前系统的编译环境只支持Ubuntu 以及 Mac OS 两种操作系统，磁盘的控件要足够大

在下载源码的时候，由于Android源码使用Git进行管理，需要下载一些工具，如apt-get installgit-core curl

源码下载好后，进行编译：首先搭建环境，部署JDK（不同的源码编译时需要的JDK版本不同，如2.2需要JDK5，2.3需要1.6），

然后设置编译环境：使用.build/envsetup.sh脚本；选择编译目标（可以根据自己需要的版本进行不同的搭配）

最后通过make –j4的命令进行编译。（make是编译的函数即命令，j4指的是cpu处理器的核数：单核的是j4 x i；双核的是j8）

最后将编译好的结果进行输出：所有的编译产物都位于 /out 目录下

2、编译流程图

二、系统的启动：

通过Linux内核将Linux系统中用户空间的第一个进程init启动起来，这是安卓世界第一个被启动的进程；

然后在init中会加载init.rc的配置文件，并开启系统的守护进程（守护media（多媒体的装载）和孵化器zygote（Java世界的开启）），其实此时调试桥的守护进程也被开启起来了；

然后会处理一些动作执行，在app_main.cpp中会将Zygote孵化器（Zygote是整个java世界的基础，整个安卓世界中（包括framework和app等apk）都是由孵化器启动的）启动起来：

在app_main中，会调用AppRuntime的start方法开启AppRuntime，其实开启的是其父类AndroidRuntime的start方法被调用，zygote由此就被调用了，此时Native层的右上角有一块区域即ANDROID RUNTIME就启动起来了；

与此同时，AppRuntime会调用ZygoteInit的main方法启动ZygoteInit（整个的APPLICATION和FRAMEWORK都会由ZygoteInit带起来的，JNI也被启动起来）：

在ZygoteInit中会调用SystemServer这个类，在SystemServer的main方法中启动init1()方法，将system_init.cpp开启起来，在init1()方法中，将整个Native世界（即LIBRARIES层）开启起来了

然后在system_init.cpp会调用SystemServer的init2()方法开启ServerThread，通过ServerThread将framework层开启起来（所有的就全部开启起来了），即java世界（APPLICATION FRAMEWORK）就被启动了；此时ActivityManager，WindowManager，PackageManager（最主要，所有的清单文件及apk都有它管理）等等framework层全部开启起来

一）安卓系统的总体启动顺序：

1、通过LINUX内核，将init进程启动起来（是Linux系统中用户空间的第一个进程）

2、将ANDROIDRUNTIME这一块的内容启动完毕

3、分为两步分别启动LIBRARIES（即Native世界）和APPLICATION FRAMEWORK（即java世界）

1）先启动LIBRARIES（即Native世界）

2）后启动APPLICATIONFRAMEWORK（即java世界）【ActivityManager，WindowManager，电源管理等等】

二）具体启动流程

一）、启动流程：

1、init进程：——安卓世界第一个被启动的进程

加载一堆配置文件，核心加载的init.rc配置文件，其中包含了孵化器和守护进程都被开启了

1）、启动服务：开启ServerManager

守护进程启动（DaemonProcess）：/system/bin/servicemanager

守护的是：

①、Java世界的开启：onrestart restart zygote

②、多媒体的装载：onrestart restart media

@、adbd的守护也被开启起来了，即调试桥的守护进程也被开启起来了

2）、启动孵化器Zygote

在app_main中启动孵化器Zygote，整个安卓世界中（包括framework和app等apk）都是由孵化器启动的

【此时虚拟机还没开启起来，只是配置了一些vm的参数】

3、app_main：——开启孵化器

app_main中，调用AppRuntime的start方法，将Native层的右上角有一块区域，即ANDROIDRUNTIME启动起来

其中的start方法实际是其父类AndroidRuntime的start方法

【此时VM虚拟机被开启起来了，通过start方法开启，在AndroidRuntime中并设置了默认的内存大小16M】

【注册JNI，并启动孵化器Zygote】

4、ZygoteInit开启

AppRuntime被启动后，会调用ZygoteInit的main方法，启动ZygoteInit；

然后，整个的APPLICATION 和FRAMEWORK都会由ZygoteInit带起来的

5、SystemServer启动：

ZygoteInit调用SystemServer这个类，在SystemServer的main方法中启动init1()方法，将system_init.cpp开启起来

在init1()方法中，将整个Native世界开启起来了

6、ServerThread启动（开启framework层）

调用SystemServer的init2()方法开启ServerThread，通过ServerThread将framework层开启起来（所有的就全部开启起来了）

此时ActivityManager，WindowManager，PackageManager（最主要，所有的清单文件及apk都有它管理）等等framework层全部开启起来

二）、具体介绍：

1、启动入口：init进程

@、源码位置：/system/core/init/init.c

@、进程入口：main方法

1）创建文件夹，挂载设备【通过mkdir的命令创建，挂载一些系统设备后】

2）重定向输入输出，如错误信息输出【设置了一些输入输出的处理】

3）设置日志输出【一些系统的日志】

4）init.rc系统启动的配置文件【加载了相关的信息，不同版本的手机所特有的配置信息】

①、文件位置：/system/core/rootdir

②、守护进程启动（DaemonProcess）：/system/bin/servicemanager

守护的是

Java世界的开启：onrestart restart zygote

多媒体的装载：onrestart restart media

adbd守护也被开启起来了，即调试桥（adb[Android Debug Bridge]）的守护进程（adbd[Android Debug Bridge Daemon]）也被开启起来了

③、启动Zygote——app_main.cpp【Zygote是整个java世界的基础】

当编译之后，在system/bin/app_process下会有孵化器的启动Xzygote

守护进程被开启之后，紧接着Zygote也被启动起来了

5）解析和当前设备相关的配置信息（/init.%s.rc）

Tips：

当解析完init.rc和设备配置信息后会获取到一系列Action

Init将动作的执行划分为四个阶段（优先级由大到小）:

6）处理动作执行：这个阶段Zygote将被启动

7）无限循环阶段，等待一些事情发生

2、Zygote简介：

@、Zygote启动：app_main.cpp

①、Main方法中AppRuntime.start(),工作由父类AndroidRuntime来完成

②、在AndroidRuntime中开启了如下内容：

@startVM——开启虚拟机（查看堆内存设置）：默认16M【】

@注册JNI函数【此时还在Native层，需要将连接java和c的桥（即JNI）搭建好】

@启动“com.android.internal.os.ZygoteInit”的main方法

【系统级别的包（由runtime的start方法开启的这个包）】

start方法实际是其父类AndroidRuntime的

@进入java世界的入口

3、ServiceThread的简介：（java世界所做的事情）

1）preloadClasses();：预加载class

读取一个preloaded-classes的配置文件

此文件的内容非常多，这就是安卓系统启动慢的原因之一

此时会有一个垃圾回收的操作gc()，将无用的回收掉

2）ZygoteInit在main方法中利用JNI开启com.android.server.SystemServer

3）启动system_init.cpp处理Native层的服务

4）然后调用SystemServer的init2()

5）启动ServiceThread，启动android服务

6）Launcher启动

三、开机时的时间消耗：

1、ZygoteInit.main()中会预加载类

目录：framework/base/preload-class

ZygoteInit.main()会加载很多的类，将近1800多个（安卓2.3的）

2、开机时会对系统所有的apk进行扫描

需要将所有的应用展现给用户，就需要对apk进行扫描，扫描所有的包

data目录下有个apk的包

system目录下有个apk的包

framework目录下也有相关的包

3、SystemServer创建的那些Service

四、安卓工程的启动过程

1、Eclipse将.java源文件编译成.class

2、使用dx工具将所有.class文件转换为.dex文件

3、再将.dex文件和所有资源打包成.apk文件

4、将.apk文件安装到虚拟机完成程序安装

5、启动程序 – 开启进程 – 开启主线程

6、创建Activity对象 – 执行OnCreate()方法

7、按照main.xml文件初始化界面

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

应用程序启动：

一、解析清单文件并加载

应用程序的启动需要从PackageManagerService说起，由于应用程序是有PackageManager管理的，可以简单认为PackageManagerService是为应用程序启动的做了一些准备工作，才能将应用程序开启起来。

1、PackageManagerService(资料)读取所有应用程序的Mainfest信息，并且建立信息库存储在系统级共享内存中

1）解析：

PackageManagerService在启动后，会进行解析的工作，它会重点监控一些文件：system/framework、system/app、data/app、data/app_private；一旦将数据存入到这些文件中，就会去解析

2）权限分配：

PackageManagerService会建立底层userids和groupids同上层permissions之间的映射，就会给一些底层用户分配权限，

进行权限的映射，UID和GroupID，都会分配相应的权限

3）保存数据：

PackageManagerService还有重要的一个操作就是将解析的每个apk的信息保存到packages.xml和packages.list文件里，

在packages.list记录了如下数据:pkgName，userId，debugFlag，dataPath(包的数据路径)

【下次再开机的时候，不会再扫描每个apk了，只需要读取packages.xml和packages.list文件即可】

除了这两个主要的工作外，还会进行一些其他的操作，如检测文件等

2、Launcher就将PackageManagerService已经解析并处理好的数据都加载到内存中，从内存中就能获取到相应的数据，

并展示到手机上【之所以可以展示在手机桌面上，就是因为在清单文件中配置了如下的内容：】

<actionandroid:name="android.intent.action.MAIN" />：应用程序的入口

<category android:name="android.intent.category.LAUNCHER"/>：配置了这个属性就可以显示在列表中

点击图标，应用就被开启起来了：

二、Activity的启动与生命周期的监控

应用程序被开启后，是需要开启并创建Activity，加载相应的view，从而展示出应用程序

1、Activity是通过startActivity开启起来的，startActivity是由有Context调用的，其具体的实现类是ContextImpl

在ContextImpl中的startActivity方法中，会调用ActivityThread的相关方法【mMainThread.getInstrumentation().execStartActivity()】；可以追溯到Instrumentation这个类，其中的execStartActivity()的方法中实现了startActivity的调用：ActivityManagerNative.getDefault().startActivity，由此可以看出是底层进行处理。

2、ActivityMonitor监控Activity

当Activity实例创建的时候，就会给Activity配置一个监视器ActivityMonitor，监控Activity的声明周期：

在Instrumentation的execStartActivity()的方法中，上来先判断ActivityMonitor是否为null：在第一次开启Activity的时候，ActivityMonitor还是null的，就会调用ActivityManagerNative.getDefault().startActivity(…..)，是在操作native底层的信息，从而执行startActivity，再去开启一个Activity。

简单来说，就是通过调用JNI，调用startActivity方法，开启Activity；创建好了之后，随即也创建好了Activity的监视器ActivityMonitor

3、在ActivityMonitor中就有Activity各种生命周期的监控

①、在newActivity方法中：

可以通过拿到Activity的字节码，创建一个Activity，并将这个Activity返回

还会调用attach方法，传入ActivityThread的线程

②、在各种生命周期的方法中，调用activity的各自的生命周期的方法

总结：

1、通过PackageManagerService将所有用到的资源加载进内存中

2、在Launcher中，将view等控件加载到ViewGroup中，点击每个item会有相应的操作

3、在公开的文档中是找不到具体调用startActivity的类的，而是由系统完成调用的，实现了Activity的启动

实际就是通过Context的实现类ContextImpl进行调用的，一步步转到底层（ActivityManagerNative）实现调用

4、另一个重要的类就是ActivityMonitor，监控Activity生命周期的；在其newActivity方法中创建了Activity，并调用了attach方法；

也就是说当一个Activity被创建的时候，就会绑定一个ActivityMonitor，用来监控Activity的生命周期

三、应用程序启动的时序图：

« 对Activity、Window和View三者间的关系有一定的见解

一、简述如何将Activity展现在手机上

Tips：

Activity本身是没办法处理显示什么控件（view）的，是通过PhoneWindow进行显示的

换句话说：activity就是在造PhoneWindow，显示的那些view都交给了PhoneWindow处理显示

1、在Activity创建时调用attach方法：

2、attach方法中会调用PolicyManager.makeNewWindow()

实际工作的是IPolicy接口的makeNewWindow方法

①、其中创建了一个window（可以比喻为一个房子上造了一个窗户）：mWindow =PolicyManager.makeNewWindow(this);

②、在window这个类中，才调用了setContentView()，这是最终的调用

在Activity的setContentView方法中，实际上是调用：getWindow().setContentView(view,params);

这里的getWindow()就是获取到一个Window对象

Tips：

为啥attch优先于onCreate调用，就是由于在attch方法中，会创建window，有了window才能调用setContentView

3、在IPolicy的实现类中创建了PhoneWindow：

①、由mWindow = PolicyManager.makeNewWindow(this);，

②、这里的makeNewWindow(this);方法中，返回的是：returnsPolicy.makeNewWindow(context);

③、这个sPolicy实际是一个接口，其实现类是Policy，其中只是创建了一个PhoneWindow

4、在PhoneWindow的setContentView中向ViewGroup（root）中添加了需要显示的内容

①、PhoneWindow是继承Window的

②、setContentView这个方法中，需要先判断一个mContentParent是否为空，因为在默认进来的时候，什么都没创建呢

此时需要创建：installDecor()，DecorView是最根上的显示的

可以通过adt中的的tools中有个hierarchyviewer.bat的工具，可以查看手机的结构

③、DecorView：是继承与FrameLayout的，作为parent存在，最初显示的

④、下次再加载的时候，mContentParent就不为空了，会将其中的所有的view移除掉，然后在通过布局填充器加载布局

二、三者关系：

1、在Activity中调用attach，创建了一个Window

2、创建的window是其子类PhoneWindow，在attach中创建PhoneWindow

3、在Activity中调用setContentView(R.layout.xxx)

4、其中实际上是调用的getWindow().setContentView()

5、调用PhoneWindow中的setContentView方法

6、创建ParentView：

作为ViewGroup的子类，实际是创建的DecorView(作为FramLayout的子类）

7、将指定的R.layout.xxx进行填充

通过布局填充器进行填充【其中的parent指的就是DecorView】

8、调用到ViewGroup

9、调用ViewGroup的removeAllView()，先将所有的view移除掉

10、添加新的view：addView()

Tips:

①、Activity就是在造“窗户”，即创建PhoneWindow

②、PhoneWindow才是进行显示view的操作，主要就是setContentView()

« 有良好的编码能力和代码规范，可以快速阅读英文技术文档

« 备用：熟悉HTTP,TCP/IP等常见网络协议，熟悉XML,JSON解析