《第一行代码》读书笔记

摘要：

主要内容：
对书上的重点和难点内容进行总结和回顾；

任务列表：

• 优化文档结构(2016.05.26)

第二章

每一次学习 ， 都会有新的收获；
我相信我看到的奇迹，没有是平白无故产生的，它们是源于环环相扣的逻辑巧妙组合而成。

隐藏标题栏（p35）

在调用 setContentView（）之前，写上下面代码：
requestWindowFeature(Window.FEATURE_NO_TITLE);

========== 更新 2016.05.23 10:42:53 =============
也可以通过配置主题的方式应用到所有 Activity 中：
在AppTheme中添加：

<item name="android:windowNoTitle">true</item>
<item name="android:windowBackground">@android:color/white</item>

隐式 Intent（p44）

隐式里的 category 和 data 就像是更精确的过滤器

保存临时数据 （p67）

当启动新的活动时，当前的活动数据如果不加以保存，那么就会有可能丢失掉数据（系统回收）。
这样的用户体验不好，可以通过在onSaveInstanceState()方法中保存数据来解决这个问题。（重要的数据还是在 onPause 中保存的好，在 onPause 中不要进行耗时操作）
相应的，在onCreate(Bundle)中进行恢复操作。

活动启动模式（p68）

使用方式：在 Manifest.xml 的对应 activity 中添加android:launchMode="standard|singleTop|singleTask|singleInstance"
参数说明：

1. standard 模式：无论返回栈中是否存在该活动，每次启动都会创建一个新的实例（例如，自己启动自己，也会创建多个实例出来）
2. singleTop 模式：如果返回栈的栈顶是要启动的活动，则直接使用它，而不是再创建一个新的活动实例出来。
3. singleTask 模式：使该活动在整个应用程序的上下文中只存在一个实例，如果不在栈顶，则将该活动上面的所有活动出栈，如果没有该活动，则创建一个活动实例。
4. singleInstance 模式：指定为该模式的活动就启用新的返回栈来管理这个活动。（还不是很了解）

技巧：

进入某个界面在日志中打印对应的 Activity 的名称（方便定位） （p77）：

原理： 简单来说是通过 java 的重写机制 。
具体步骤：

1. 创建一个基类 Activity，例如BaseActivity；
2. 在基类 Activity 的 onCreate()方法中，添加代码Log.d("BaseActivity", getClass().getSimpleName())

随时随地退出程序（p78）：

利用 List 作为保存 Activity 的容器：一旦有 Activity 被创建，就加入到容器中；对应的，一旦 Activity 被销毁，就从容器中移除 。在想要退出的地方，逐个结束容器中的 Activity. activity.finish()
参考网址： 2.6.2 　随时随地退出程序

启动活动（p80）：

给 Activity 添加一个封装优美的，静态的，清晰的启动方法。
步骤：

1. 在 Activity 中定义一个静态的方法

private static String mArg0;
private static Object mArg1;
public static void startActivity(Activity context, String arg0, Object arg1){
     mArg0 = arg0;
     mArg1 = arg1;
     context.startActivity( this.getClass() );
}

2. 在需要启动 SecondActivity 的地方调用：

SecondActivity.startActivity(mContext, arg0, arg1);

---

第三章

从整体到局部，从构架到细节。

宽度，高度（p84）

match_parent：表示让当前控件的大小和父控件的大小一样
fill_parent：match_parent 的别名
wrap_content：使当前控件的大小正好包含住控件的内容（文字，图片 ） 等。

控件可见性（p98）

在 xml 布局中控制：

为控件添加属性（所有控件均支持），android:visibility="visible|invisible|gone"
visible 或者不写：可见，占空间
invisible：不可见，占空间（透明状态）
gone：不可见，不占空间

Java 代码中控制：

动态控制可见性：View.setVisibility(View.VISIBLE|View.INVISIBLE|View.GONE)
效果同 xml
另外，可以通过getVisibility()方法获取当前的控件状态，根据比较的结果，可以做一些特定的操作；

View view = findViewById(R.id.tv_main);
if(view.getVisibility() == View.GONE){
    // TODO 如果视图是隐藏的，do：
} else if(view.getVisibility() == View.VISIBLE) {
    // TODO 如果视图是显示的， do：
}

LinearLayout 重要属性说明（p105）

• android:orientation=”vertical|horizontal”；控制 LinearLayout 的排列方向 （该属性用在 LinearLayout 本身上）
• android:layout_gravity=”left|right|top|bottom|center_vertical|center_horizontal”；控件在父控件中的对齐方式。（该属性用在 LinearLayout 的子控件中）
• android:layout_weight=”1”；通过比例的方式控制控件的大小。 （该属性用在 LinearLayout 的子控件中，剩余空间按比例分配。适配方案还得靠它）

易混淆的属性（p107）
android:layout_gravity和android:gravity属性区别：

1. android:layout_gravity属性：用于指定该控件在父控件中的对齐方式（可选值：top|bottom|left|right|center|center_vertical|center_horizontal ）
2. android:gravity属性：用于指定控件中的内容在控件中的对齐方式（ 可选值：top|bottom|left|right|center|center_vertical|center_horizontal ）
3. 注意：layout_gravity，当父控件 LinearLayout 排列方向是 horizontal 时，
   只有垂直方向的对齐方式才会生效（bottom, top, center_vertical）；
   当父控件 LinearLayout 排列方向是 vertical 时，只有水平方向的对齐方式才会生效（left，right，center_horizontal）

RelaviteLayout 布局

相对于父布局进行定位：

• android:layout_alignParentTop=”true”
• android:layout_alignParentBottom=”true”
• android:layout_alignParentLeft=”true”
• android:layout_alignParentRight=”true”
• android:layout_centerInParent=”true”

相对于其他控件进行布局：

• android:layout_above=”@id/view3”
• android:layout_below=”@id/view3”
• android:layout_toRightOf=”@id/view3”
• android:layout_toLeftOf=”@id/view3”

相对于其他控件的边缘进行对齐显示：

• android:layout_alignRight= “@id/view3”
• android:layout_alignLeft= “@id/view3”
• android:layout_alignTop= “@id/view3”
• android:layout_alignBottom= “@id/view3”

其他：

• android:layout_centerVertical=”true”
• android:layout_centerHorizontal=”true”

注意 1：通过@id/tv_view引用的控件一定要先定义；而通过@+id/tv_view引用的控件也可以出现在后面。
注意 2：可以在一个控件中使用上面的一个或多个。例如，相对于父布局的“左上”布局，
就需要填写两个属性android:layout_alignParentTop="true";android:layout_alignParentLeft="true"。

TableLayout 布局

• TableLayout 中的每一个 TableRow 都表示表格中的一行，每一个子控件表示一列。
• TableRow 中的控件不可以指定宽度。
• 在 TableLayout 中添加属性：
  • android:stretchColumns="1"，使指定的那一列拉伸，以自动适应屏幕的宽度。（0 表示第一列，1 表示第二列）
  • android:shrinkColumns="0"，收缩指定的列；
  • android:collapseColumns="0"，隐藏指定的列；

其他布局

• FrameLayout 布局
  （所有控件默认摆放在左上角；多个子控件情况下下面的控件覆盖上面的控件；可通过 gravity 和 layout_gravity 来控制子控件的对齐方式）
• AbsoluteLayout 布局（不推荐使用）

ListView 控件（p127）

需要的元素：

1. 数据源
2. 单个 item 的 layout 布局
3. 适配器（简单的名称显示可继承自 ArrayAdapter，更丰富的布局可继承自 BaseAdapter）

**优化 **

1. 利用 android 自带的缓存机制，convertView；
2. 使用 ViewHolder 和 Tag；每一个 View 都可以存储一个 Tag 对象（看源码 mTag），对控件对应的实体进行缓存。当需要实体的时候，从 tag 中获取；
3. 推荐阅读：【Android】通用系列 —— 用简单通用的方式操作 ListView

其他补充：

• 为 listview 绑定适配器：lv.setAdapter(mAdapter);
• 数据发生变化，要及时更新界面：mAdapter.notifyDataSetChanged();
• 定位到某一项（即在屏幕上显示这一项）：lv.setSelection(num);
• 点击事件：setOnItemClickListener(OnItemClickListener ocl);
• 给 ListView 项的分割线设置为透明色：android:divider=”@null”
• 不显示滚动条：android:scrollbars="none"
• 平滑滚动到指定条目：mLv.smoothScrollToPosition(pItem);
• 设置 ListView 不可用：mLv.setEnable(false)
• 设置 listView 不可滑动（可以通过拦截触摸事件，和mLv.setEnable(false)达到的效果不同）：

public static void setListViewCannotSlide(ListView lv) {
    lv.setOnTouchListener(new OnTouchListener() {
        @Override
        public boolean onTouch(View v, MotionEvent event) {
            return event.getAction() == MotionEvent.ACTION_MOVE;
        }
    });
}

• 点击效果：设置 listSelector 和设置 item 的 layout 两种方式。(最好不要混用，推荐使用第二种方式)
• 取消点击效果：andrdoi:listSelector="@android:color/transparent"
• 动态取消点击效果：mLv.setSelector(new ColorDrawable(Color.TRANSPARENT));
• 动态设置点击效果：mLv.setSelector(R.drawable.item_selector);

外部链接

• Android 美工坊–listview 更改选中时 item 背景色
• Android ListView listSelector not working

---

第四章 Fragment 碎片

第一遍：不知道自己不知道。
第二遍：知道自己不知道，或不知道自己知道。
第三遍：知道自己知道。

简而言之，碎片（Fragment）是一种可以嵌入在活动当中的 UI 片段，它能让程序更加合理和充分地利用大屏幕空间。
学习资料：

• Android Fragment 完全解析，关于碎片你所需知道的一切
• Android Fragment 真正的完全解析（上）
• [Android Fragment 真正的完全解析（下）]
• Android Fragment 你应该知道的一切

要点难点：

1. 通信–数据传递。
2. 抽象成一个公用的类。
3. 回退栈（remove，add，hide，show 等方法的区别）
4. 屏幕适配：限定符；
5. 双页单页模式（p182）

---

第五章 广播机制

注册广播：

1. 动态注册 （p190）

新建一个类，继承 BroadcastReceiver，重写父类的 onReceive 方法。
自定义的 MainActivity 中通过 Context 的registerReceiver（BroadCastReceiver bc，IntentFilter if）方法来注册 。
说明：其中参数 bc 是刚才新建类的实例，参数 if 是广播发送过来的 action 值包装成 IntentFilter 对象。

注意： 用完之后需要销毁，在 activity 的 onDestroy()方法中调用 unregisterReceiver()方法。
注意： 当访问的内容涉及到系统的关键性信息，那么需要在配置文件中配置相应的权限 permission （ http://developer.android.com/reference/android/Manifest.permission.html）。
注意： 应用程序发送的广播是可以被其他应用程序接收到的。跨进程通信。

2. 静态注册

• 创建一个集成自 BroadCast 的类，并重写 onReceive（）方法
• 类似于 activity 的注册，使用标签，使用 android:name 来指定刚才创建的广播接收器（即实现了 BroadCast 的类的实例）
• 在标签中添加想要接收的广播。

另外： 使用静态注册可以达到开机启动的目的。静态注册在程序未启动的时候也可以接收广播。
注意： 监听某些广播也是需要声明权限的。

注意： 不要在 onReceive()中添加过多的逻辑或者任何的耗时操作，因为在广播接收器中是不允许开启线程的（如果运行时间较长，程序会报错）。
应用场合： 启动其他组件，例如创建一条状态栏通知，或启动一个服务等。

发送广播

标准广播
例如在 MainActivity 中点击按钮时发送广播：

Intent intent = new Intent("com.lyloou.broadcasttest.MY_BROADCAST");//还可以绑定一些数据到Intent中供接收者使用；
sendBroadcast(intent);

有序广播

• 区别于标准广播的sendBroadcast(Intent intent), 有序广播是sendOrderedBroadcast(Intent intent, String receiverPermission )。 (可以参考 Context 的 API 文档看更详细内容)
• 广播接收器的先后顺序，是通过在注册的时候设定的。例如，<intent-filter android:priority="100">。
• 有序广播是可以截断的。在 onRecevie（）中调用abortBroadcast();方法将广播截断，后续的接收器就无法接收到该条广播。
  （only works with broadcasts sent through Context.sendOrderedBroadcast. ）

本地广播（p202）

• 区别于一般的广播，本地广播只允许本应用程序接收本应用程序发送的广播，解决了广播的安全性问题。
  其他程序的广播无法发送到我们程序的内部，更安全。比全局广播更高效。
• 与一般的广播的动态注册方式类似。（一般广播，这里指的是全局广播）
• 区别于一般广播的接收方式registerReceiver()，本地广播使用：

LocalBroadcastManager  localBroadCastManager =  LocalBroadcastManager.getInstance(Context c);
localBroadCastManager.registerReceiver(BroadcastReceiver br, Intent i);

• 区别于一般广播的发送方式sendBroadcast(intent),本地广播使用：localBroadCastManager.sendBroadcast(intent)
• 注意：也需要 unregister 进行注销处理。
• 注意：本地广播无法通过静态方式注册接收, 静态注册在程序未启动的时候也可以接收广播，而本地广播肯定是在启动程序之后发送，所以不需要静态注册 。
• 注意：不可以混用系统广播和本地广播，（例如通过 localBroadCastManager.registerReceiver 来注册蓝牙广播，是不对的，
  如果非得这样做，onReceiver 中将无法接收到蓝牙开启和关闭的广播）

其他

在广播接收器写一个弹框（p210）。
从广播接收器中启动活动需要注意的内容（p211）：给 Intent 加入 FLAG_ACTIVITY_NEW_TASK 标识。

---

第六章 数据存储

持久化的方式

• 文件存储：存储简单的文本数据和二进制数据。
• SharePreference 存储 ：存储的是键值对。
• 数据库–SQLITE： 存储复杂关系型的数据。

文件存储（p221）

核心方法：Context 提供的 openFileInput()和 openFileOutput()方法；
注意：不适用于存储复杂类型的数据。

SharePreference 存储（p228）

• 使用键值对的方式存储。

• 使用 xml 格式来对数据进行管理。

• 获取 SharePreference（下面三种方法不同之处在于参数和存储地址）

  1. Context 类中的 getSharedPreference（String filename, MODE_PRIVATE|MODE_MULTI_PROCESS），
     在系统中的具体表现：/data/data/<package name>/shared_prefs/filename参数名
  2. Activity 类中的 getPreference（MODE_PRIVATE|MODE_MULTI_PROCESS），文件名以当前活动的类名起名。
  3. PreferenceManager 类中的 getDefaultSharedPreference（ MODE_PRIVATE|MODE_MULTI_PROCESS ），文件名以包名起名。

• 保存数据步骤：

  1. 通过获取到的 SharePreference 对象实例 sp，引用其 edit（）方法，SharedPreferences.Editor editor = sp.edit();
  2. editor.putInt(“age”,18);
  3. editor.putString(“name”,”Bob”);
  4. …
  5. editor.commit();

• 获取数据步骤：

  1. 同样首先获取到 SharePreference 对象实例 sp；
  2. int age = sp.getInt(“age”, 0);
  3. String name = sp.getString(“name”, “”);
  4. …
  5. 获取到数据后的其他操作。

数据库（SQLITE-p238）

• 创建一个 继承自 SQLiteOpenHelper 类的帮助类，重写 onCreate()和 onUpgrate()方法，在这两个方法中实现创建表和升级数据库的逻辑。
• 通过帮助类获取实例：getReadableDatabase()和 getWritableDatabase()方法获取实例。两者的区别是前者在磁盘满的时候以只读方式打开数据库，而后者直接抛出异常。
• 通过 db.execSQL（）可以直接执行数据库语句。
• 事务保证数据安全：进行读写操作，要使用事务（读数据就不需要事务了）；
• 数据库创建后，将不再重新创建，这意味着在客户端，onCreate()方法只执行一次。 除非卸载掉重新安装，
  如果是覆盖安装的话，修改了了数据库结构，就要通过onUpgrade()方法来控制了。

CRUD – 添加数据

利用 ContentValues 组件一组数据，通过 insert 来添加到数据库中。
ContentValues 利用键值的方式添加：，

ContentValues contentValues = new ContentValues();
contentValues.put("name", "think in java");
contentValues.put("version", 3);
db.insert("Book", null, contentValues);

CRUD – 更改数据

利用 ContentValues 组件一组数据，通过 update 来添加到数据库中。
ContentValues 利用键值的方式更新：，

ContentValues contentValues = new ContentValues();
contentValues.put("version", 4);
db.update("Book", contentValues, "name=?" , new String[]{"think in java"});

CRUD – 删除数据

获取到 db 实例后，即可执行删除操作

SQLiteDatabase db = dbHelper.getWritableDatabase();
db.delete("Book", "version < ?", new String[]{"4"});

CRUD – 查询数据

利用 db 的 query 方法来得到一个 Cursor 实例。对 Cursor 进行取值操作，即可得到想要的值。
cursor.moveToFirst(); 指针移动到第一行；
cursor.moveToNext(); 指针移动到下一个；

Cursor cursor = db.query("Book", null , null , null , null , null , null );
cursor.moveToFirst();
Log.d("LOU",cursor.getString(cursor.getColumnIndex( "name" )));
Log.d("LOU",cursor.getInt( cursor.getColumnIndex( "version" )) );
cursor.close();

技巧： 利用 switch 来优化数据库升级（p264）。

---

第七章 内容提供器（p268）

首先作为一个客户端程序员，来使用 API，接着创建自己的 API；

• 内容提供器主要用于在不同的应用程序之间实现数据共享，目前内容提供器是 Android 实现跨程序共享数据的标准方式。

• ContentProvider 比起文件和 SharedPreference 的 MODE_WORLD_READABLE 和 MODE_WORLD_WRITEABLE 两种操作模式要更安全可靠。
  因为你只提供想要给其他程序访问的数据，其他数据就不会有任何影响。

• ContentResolver 对象获取方式：‘’以通过 Context 的 getContentResolver()来获取。

• ContentResolver 提供的一些方法进行 CRUD 操作。
  （基本类似于数据库的 CRUD，最明显的区别就是：
  数据库中的 CRUD 方法传入的参数是 表名，而 ContentResolver 中的传入的参数是 Uri，
  对应的继承自 ContentProvider 的自定义内容提供器里面的 CRUD 方法设置的参数也是 Uri。）

• 内容提供器的用法有两种：

  1. 使用现有的提供器来读取和操作某程序的数据。（作为客户端）
  2. 自己创建 ContentProvider 给自己的程序或其他程序提供外部访问接口，以供其读取和操作数据。（客户端和 API 端都有）

• Uri：区别于 SQLiteDatabase 接受的参数table，ContentResolver 接受的参数是“URI”，
  要对某程序的数据进行读取和操作，需要制定其Uri。

• URI 格式：由两部分组成，权限 authority 和路径 path（p269） + 通配符的使用 （p277）

• UriMatcher 的使用（p279）

• Uri 的 getPathSegments()方法可以将字符串按照“/”分割成字符串列表，通过 get(0)这种方式访问列表中的字符串。

• 所有内容提供者必须提供的方法（getType()），getType()方法的实现，用于获取 Uri 对象所对应的 MIME 类型；（p280）

• 自定义的 ContentProvider 需要注册到 Manifest 中（p286）。

注意： 在每次创建内容提供者的时候，都要提醒自己，是不是真的需要这样做。
因为只有真正需要将数据共享出去的时候我们才应该创建内容提供器，
仅仅是用于内部程序访问的数据没必要使用内容提供者。

Lou: ContentProvider 扮演的是程序和程序之间数据传递的桥梁角色。
A 程序规定好自己的哪些数据内容可以访问，并设置好对应的 Uri，
B 程序借助 ContentProvider 提供器传入 A 程序规定好的 Uri 来读取和操作 A 程序的数据。
在 ContentProvider 中操作数据库，
就好像是 ContentProvider 提供了一个包装，
在其内根据传入的 Uri 来进行具体的数据库操作，
对外只需要提供一个接口即可（接口需要有正确的参数，例如 Uri、过滤条件等）。

---

第八章 多媒体

通知

使用步骤：

1. 得到 manager：NotificationManager manager = (NotificationManager)getSystemService(NOTIFICATION_SERVICE);
2. 得到 notification 实例：Notification notification = new Notification(R.drawable.ic_launcher, "This is ticker text", System.currentTimeMillis());
3. 设置通知里的布局：notification.setLatesEventInfor(this, "This is content title", "This is content text", null);，
   其中第四个参数是用来设置点击通知触发的逻辑，用 PendingIntent 来设定。
4. 利用 manager 发出通知：manager.notify(1, notification);，其中 1 是该通知的唯一标志，可以用于之后的取消。

取消通知栏的通知

NotificationManager manager = (NotificationManager)getSystemService(NOTIFICATION_SERVICE);
manager.cancel(1); //其中1表示刚才设置的通知唯一标志。

通知栏点击事件处理

使用 PendingIntent（p302）

• 被延迟执行的 Intent。（Intent 倾向于立即执行某个动作，PendingIntent 倾向于在某个合适的时机去执行某个动作）
• 通过 getActivity()，或 getBroadCast()，或 getService()来获取 PendingIntent 实例，
  PendingIntent 结合第二个参数 Intent 来构建出“意图”，当被点击时执行相应的逻辑。 （p302） 1. 如果使用的是 getActivity()，那么就执行 startActivity(intent); 其中 intent：Intent intent = new Intent(getActivity(), MyActivity.class)，指定其目标 Activity。 2. 如果使用的是 getBroadCast()，那么就调用 sendBroadCast(intent); 其中 intent：Intent intent = new Intent("com.example.broadcasttext.MY_BROADCAST"),指定其 action。 3. 如果使用的是 getService()，那么就调用 startService(intent);其中 intent：Intent intent = new Intent(getActivity(), MyService.class)，指定目标 service。
• 将得到的实例作为notification.setLatesEvenInfor()的第四个参数以实现点击通知的逻辑（启动一个 Activity、发送一条广播、启动某个服务等等 ）。

通知的交互处理（p305）

• 添加声音：

Uri soundUri = Uri.fromFile(new File("/system/media/audio/ringtones/Basic_tone.ogg"));
notification.sound = sounUri;

• 添加振动：

long[] vibrates = {0, 1000, 1000, 1000};
notification.vibrate = vibrates;
// 注意：需要添加震动权限 <uses-permission android:name="android.permission.VIBRATE"/>

• 添加 LED 通知

notification.ledARGB = Color.GREEN;
notification.ledOnMS = 1000;
notification.ledOffMS = 1000;
notification.flags = Notification.FLAG_SHOW_LIGHTS;

• 设置默认通知类型：

notification.defaults = Notification.DEFAUT_ALL

• 扩展：
  点亮屏幕

---

第九章 服务

多线程编程

子线程中不允许进行 UI 操作。

异步消息处理机制：

• handler
• AsyncTask
• Activity.runOnUIThread(Runnable runnable)
• IntentService

Handler（p348）

1. 在主线程中创建 Handler 实例，并重写 handMessage()方法。
2. 在子线程中通过 handler 发送消息（handler.sendMessage(msg);）
3. msg 会被添加到 MessageQueue 等待处理。
4. Looper 不断的监测 MessageQueue 中是否有 Message，如果有那么就取出来分发到 handler 的 handleMessage()方法中处理。
5. 在 handler.handleMessage()方法中进行 UI 操作。

AsyncTask（p349）

1. AsyncTask 是一个抽象类，需要去继承才能用。

2. 三个泛型参数

   • Params：执行 AsyncTask 任务需要的参数（例如进行网络操作的 URL 字符串）；
   • Progress：后台执行任务的百分比；
   • Result：任务的执行完成后的返回值（例如 Bitmap）

3. 常用的方法（重写）

   • onPreExecute()，任务执行之前的初始化操作（可以进行 UI 更新）。
   • doInBackground(Params…)，耗时操作（不可用进行 UI 更新）
   • onProgressUpdate(Progress…)，当在 doInBackground 方法里调用 publishProgres(Progress…)时会被调用，用于更新当前的 UI 状态。（可以进行 UI 更新）
   • onPostExecute(Result)，当执行完 doInBackground()方法之后，返回 Result 值给 onPostExecute()方法。用于善后操作。（可以进行 UI 更新）

4. 执行方式：new MyAsyncTask().execute();

服务

• 间接继承自 Context
• 不要因为服务是后台的概念，就把服务和线程搞混了，服务依然是在主线程中运行（即和活动共用一个线程）
  外部连接里有不错的解释：
  如果服务中用到耗时操作，依然需要使用子线程：
• 外部连接：
  • Service 和 Thread 的关系。
  • android service 与子线程之浅谈

既然在 Service 里也要创建一个子线程，那为什么不直接在 Activity 里创建呢？
这是因为 Activity 很难对 Thread 进行控制，当 Activity 被销毁之后，
就没有任何其它的办法可以再重新获取到之前创建的子线程的实例。
而且在一个 Activity 中创建的子线程，另一个 Activity 无法对其进行操作。
但是 Service 就不同了，所有的 Activity 都可以与 Service 进行关联，
然后可以很方便地操作其中的方法，即使 Activity 被销毁了，之后只要重新与 Service 建立关联，
就又能够获取到原有的 Service 中 Binder 的实例。
因此，使用 Service 来处理后台任务，Activity 就可以放心地 finish，
完全不需要担心无法对后台任务进行控制的情况。

两种方式创建服务

1. startService(serviceIntent);
2. bindService(bindIntent, connection, BIND_AUTO_CREATE);

• 我们完全有可能对一个服务既调用了 startService()方法，有调用了 bindService()方法。
  这种情况如何销毁服务？需要同时调用 stopService()（或者 stopself()）和 unBindService()方法才行。（p364）
• stopself()可以在 MyService 的任何位置调用，以停止服务。
• stopService()跟 startService()一样，需要根据传入的参数来确定 stop 哪个服务。

Intent stopIntent = new Intent(this, MyService.class);
stopService(stopIntent);

注意事项

• 需要在 Manifest 中注册服务。
• 通过 bindService 的方式创建的服务，可以更方便的控制它。
• IntentService，一个异步的，可以自动停止的服务。（p367）。
  在重写的方法 onHandleIntent()里的进行耗时操作；

服务的应用

定时任务（Alarm）

外部连接

• Android 基本功：IntentService 的使用
• Android Service 的生命周期
• Android Service 的绑定 续篇：关于绑定的补充说明
• 深入理解 Android 的 startservice 和 bindservice

---

第十章 网络技术

使用 Http 协议访问网络（注意要添加网络权限）

HttpURLConnection（p380）

get 数据

private void sendRequestWithHttpURLConnection(){
    new Thread(
        @Override
        public void run(){
            HttpURLConnection connection = null;
            try{
                URL url = new URL("http://www.lyloou.com");
                connection = (HttpURLConnection)url.openConnection();

                // Get表示希望从服务器获取数据；Post表示希望提交数据给服务器
                connection.setRequestMethod("GET");

                // 设置连接超时
                connection.setConnectionTimeout(8000);

                // 设置读取超时
                connection.setReadTimeout(8000);

                // 获取输入流
                InputStream in = connection.getInputStream();

                // 对输入流进行读取操作
                BufferReader reader = new BufferReader(new InputStreamReader(in));
                StringBuilder response = new StringBuilder();
                String line;
                while((line=reader.readline()) != null){
                    response.append(line);
                }

                // 将结果返回
                Message msg = new Message();
                msg.what = 1;
                msg.obj = response.toString();
                handler.sendMessage(msg);
            } catch(Exception e) {
                e.printStackTrace();
            } finally {
                if(connection != null){
                    connection.disconnect();
                }
            }
        }
    ).start();
}

post 数据

// 获取输出流并写出数据。
DataOutputStream out =  new  DataOutputStream( connection.getOutputStream());
out.writeBytes("username=admin&password=123456");

HttpClient（p385 ）

get 数据

private void sendRequestWithHttpClient(){
    new Thread(
        @Override
        public void run(){
            HttpClient httpClient = null;
            try{
                httpClient = new DefaultHttpClient();
                HttpGet httpGet = new HttpGet("http://www.baidu.com");
                HttpResponse httpResponse = httpClient.execute(httpGet);

                if(httpResponse.getStatusLine().getStatusCode() == 200) {
                    HttpEntity entity = httpResponse.getEntity();

                    // 将entity转换为字符串，并指定字符集编码
                    String response = EntityUtils.toString(entity, "utf-8");

                    // 将结果返回
                    Message msg = new Message();
                    msg.what = 1;
                    msg.obj = response.toString();
                    handler.sendMessage(msg);
                }
            } catch(Exception e) {
                e.printStackTrace();
            } finally {
                if(client != null){
                    client.disconnect();
                }
            }
        }
    ).start();
}

post 数据

HttpPost httpPost = new HttpPost(" http://www.baidu.com");

List<NameValuePair> params = new ArrayList<NameValuePair>();
params.add(new BasicNameValuePair("username", "admin"));
params.add(new BasicNameValuePair("password", "123456"));

UrlEncodedFormEntity entity = new UrlEncodedFormEntity(param, "utf-8");
httpPost.setEntity(entity);
HttpResponse httpResponse  =  httpClient.execute(httpPost);

回调机制（p406，真牛）

public interface HttpCallbackListener{
    void onFinish(String response);
    void onError(Exception e);
}
private void sendRequest(final String address, final HttpCallbackListener listener){
  new Thread(
      @Override
      public void run(){
          HttpURLConnection connection = null;
          try{
              URL url = new URL( address );
              connection = (HttpURLConnection)url.openConnection();

              // Get表示希望从服务器获取数据；Post表示希望提交数据给服务器
              connection.setRequestMethod("GET");

              // 设置连接超时
              connection.setConnectionTimeout(8000);

              // 设置读取超时
              connection.setReadTimeout(8000);

              // 获取输入流
              InputStream in = connection.getInputStream();

              // 对输入流进行读取操作
              BufferReader reader = new BufferReader(new InputStreamReader(in));
              StringBuilder response = new StringBuilder();
              String line;
              while((line=reader.readline()) != null){
                  response.append(line);
              }

             // 将结果回调到参数中去处理，而不是return的方式返回数据（return的数据可能因为主线程先执行完而不能接受到，而通过参数就一定会执行了）。
             if( listener != null){
                 listener.onFinish(response.toString());
             }
          } catch(Exception e) {
             if( listener != null){
                 listener.onError(e);
             }
          } finally {
              if(connection != null){
                  connection.disconnect();
              }
          }
      }
  ).start();
}

XML 解析

<apps>
<app>
<id>1</id>
<name>Google Maps</name>
<version>1.0</version>
</app>

<app>
<id>2</id>
<name>Chrome</name>
<version>1.0</version>
</app>

<app>
<id>3</id>
<name>Google Play</name>
<version>2.3</version>
</app>

</apps>

PULL 方式（p391 ）

private void parseXMLWithPull(String xmlData){
    try{
        XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
        XmlPullParser xmlPullParser = factory.newPullParser();
        xmlPullParser.setInput(new StringReader(xmlData));
        int eventType = xmlPullParser.getEventType();
        String id = "";
        String name = "";
        String version = "";

        while (eventType != XmlPullParser.END_DOCUMENT) {
            String nodename = xmlPullParser.getName();
            switch(eventType) {
            case XmlPullParser.START_TAG:{
                if("id".equals(nodename)){
                    id = xmlPullParser.nextText();
                } else if("name".equals(nodename)){
                    name = xmlPullParser.nextText();
                } else if("version".equals(nodename)){
                    version = xmlPullParser.nextText();
                }
                break;
            }

            case XmlPullParser.END_TAG:{
                if("app".equals(nodename)){
                    Log.d("MainActivity", "id is " + id);
                    Log.d("MainActivity", "name is " + name);
                    Log.d("MainActivity", "version is " + version);
                }
                break;
            }
            default:
                break;
            }
            eventType = xmlPullParser.next();
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

SAX 方式（p394）

private void parseXMLWithSAX(String xmlData){
    try{
        SAXParserFactory factory = SAXParserFactory.newInstance();
        XMLReader xmlReader = factory.newSAXParser().getXMLReader();
        ContentHandler contentHandler = new ContentHandler();

        xmlReader.setContentHandler(contentHandler);
        xmlReader.parse(new InputSource(new StringReader(xmlData)));
    } catch (Exception e) {
        e.printStackTrace();
    }
}
// ......
public class ContentHandler extend DefaultHandler{
    private String nodeName;
    private StringBuilder id;
    private StringBuilder name;
    private StringBuilder version;

    // startDocument会在开始XML解析的时候调用
    @Override
    public void startDocument() throws SAXException{
        id = new StringBuilder();
        name = new StringBuilder();
        version = new StringBuilder();
    }

    // startElement会在解析某个节点的时候调用
    @Override
    public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException{
        nodeName = localName;
    }

    // characters会在获取节点内容的时候调用，可能会调用多次，需要对澶蠕动char进行控制
    @Override
    public void characters(char[] ch, int start, int length) throws SAXException{
        if("id".equals(nodeName)){
            id.append(ch, start, length);
        } else if("name".equals(nodeName)){
            name.append(ch, start, length);
        } else if("version".equals(nodeName)){
            version.append(ch, start, length);
        }
    }

    // endElement会在完成解析某个节点的时候调用
    @Override
    public void endElement(String uri, String localName, String qName) throws SAXException{
        if("app".equals(localName)){
            Log.d("ContentHandler", "id is " + id.toString().trim());
            Log.d("ContentHandler", "name is " + name.toString().trim());
            Log.d("ContentHandler", "version is " + version.toString().trim());

            // 清空还原数据
            id.setLength(0);
            name.setLength(0);
            version.setLength(0);
        }
    }

    // endDocument会在完成解析XML的时候调用
    @Override
    public void endDocument() throws SAXException{
        Log.d("ContentHandler", "completed!!!");
    }
}

扩展：DOM 方式

解析 JSON

[
  { "id": "5", "version": "5.5", "name": "Angry Birds" },
  { "id": "6", "version": "7.0", "name": "Clash of Clans" },
  { "id": "7", "version": "3.5", "name": "Hey Day" }
]

JSONObject 方式（p399）

private void parseJSONWithJSONObject(String jsonData){
    try{
        JSONArray jsonArray = new JSONArray(jsonData);
        for (int i = 0; i<jsonArray.length(); i++) {
            JSONObject jsonObject = jsonArray.getJSONObject(i);

            String id = jsonObject.getString("id");
            String version = jsonObject.getString("version");
            String name = jsonObject.getString("name");

            Log.d("MainActivity", "id is " + id);
            Log.d("MainActivity", "version is " + version);
            Log.d("MainActivity", "name is " + name);
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

GSON 方式（p401）

class App{
    private int id;
    private String name;
    private String version;

    public void setId(int id){
        this.id = id;
    }
    public void setName(String name){
        this.name = name;
    }
    public void setVersion(String version){
        this.version = version;
    }
    public int getId(){
        return this.id;
    }
    public String getName(){
        return this.name;
    }
    public String getVersion(){
        return this.version;
    }
}

//......
private void parseJSONWithGSON(String jsonData){
    Gson gson = new Gson();
    List<App> appList = gson.fromJson(jsonData, new TypeToken<List<App>>(){}.getType());

    for (App app : appList) {
        Log.d("MainActivity", "id is " + app.getId());
        Log.d("MainActivity", "name is " + app.getName());
        Log.d("MainActivity", "version is " + app.getVersion());
    }
}

扩展：Jackson 方式，FastJSON 方式