第一行代码（十）
第十章主要讲 Android 中四大组件的服务
一、什么是服务
??服务是 Android 中实现程序后台运行的解决方案，适合去执行那些不需要和用户交互而且要长期运行的任务，即使程序被切换到后台，或者用户打开了另一个应用程序，服务仍然能够保持正常运行。
注意：服务并不是运行在一个独立的进程当中，而是依赖于创建服务时所在的应用程序进程，当某个应用程序被进程杀掉时，所有依赖于该进程的服务也会停止运行。另外，服务并不会自动开启线程，所有的代码都是默认运行在主线程当中的，所以如果要进行耗时操作，我们需要在服务的内部手动创建子线程，否则就有可能出现主线程被阻塞的情况。二、Android 多线程编程 ??新建一个类继承自 Thread，然后重写 run()方法
public class MyThread extends Thread {@Override
public void run() {
super.run();
}}new MyThread().start();
但是使用继承的方式耦合性有点高，更多的时候我们会选择实现 Runnable 接口的方式来定义一个线程
public class MyThread implements Runnable {@Override
public void run() {}
}
MyThread myThread = new MyThread();
new Thread(myThread).start();
??知道了如何开启线程后，我们需要注意，Android 的 UI 是线程不安全的，因此，如果想要更新应用程序里的 UI 元素，必须在主线程中进行，否则会出现异常。如果在子线程中进行了 UI 更新的操作，会报错。
??对于这种情况，Android 提供了一套异步消息处理机制，完美地解决了在子线程中进行 UI 操作的问题。
三、异步消息处理机制
tv.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
new Thread(new Runnable() {
@Override
public void run() {
Message msg = Message.obtain();
msg.what = UPDATE_TEXT;
handler.sendMessage(msg);
}
}).start();
}
});
public static final int UPDATE_TEXT = 1;
private Handler handler = new Handler() {
/**
* 该方法是运行在主线程当中的
*/
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what) {
case UPDATE_TEXT:
tv.setText("这里是主线程，可以进行 UI 操作");
break;
default:
break;
}
}
};
??上面是异步消息的代码，下面来解析异步消息处理机制。Android 中的异步消息处理主要由4个部分组成：Message、Handler、MessageQueue 和 Looper
- Message：
??Message 是在线程之间传递的消息，内部可携带少量的信息，Message 不仅可以使用 what 字段，还可以使用 arg1和 arg2字段来携带一些整形数据，还可以使用 obj 字段携带一个 Object 对象。 - Handler：
??顾名思义，是处理者的意思，主要用于发送和处理消息，发送消息一般使用 Handler 的 sendMessage()方法，发出的消息经过辗转处理后，最终会传递到 Handler 的 handleMessage()方法中。 - MessageQueue：
??是消息队列的意思，主要用于存放所有通过 Handler 发送的消息，这部分消息一直会存在于消息队列中，等待被处理，每个线程中只会有一个 MessageQueue 对象。 - Looper：
??Looper 是每个线程中的 MessageQueue 的管家，调用 Looper 的 loop()方法后，就会进入到一个无限循环当中，然后每当发现 MessageQueue 中存在一条消息，就会将它取出，并传递到 Handler 的 handleMessage()方法中，每个线程中也只会有一个 Looper 对象。
整体梳理：首先在主线程中创建一个 Handler 对象，并重写 handleMessage()方法，然后当子线程中需要进行 UI 操作时，就创建一个 Message 对象，并通过 Handler 将这条消息发送出去。之后这条消息会被添加到 MessageQueue 的队列中等待被处理，而 Looper 则会一直尝试从 MessageQueue 中取出待处理的消息，然后分发回 Handler 的 handleMessage()方法中。由于 Handler 是在主线程中创建的，所以此时 handleMessage()方法中的代码也会在主线程中运行。
【第一行代码（十）】我们以前使用到的 runOnUiThread()方法其实就是一个异步消息处理机制的接口封装。四、使用 AsyncTask ??AsyncTask 背后的实现原理也是基于异步消息处理机制的，只是 Android 帮我们做了很好的封装而已，AsyncTask 是一个抽象类，所以我们要创建一个子类去继承它，在继承的时候可以为 AsyncTask 指定3个泛型参数（如果不需要，可以写 Void）：
- Params：在执行 AsyncTask 时传入的参数，可用于在后台任务中使用。
3.Result：当任务执行完毕后，如果需要对结果进行返回，则使用这里指定的泛型作为返回值类型。
public class DownloadTask extends AsyncTask {/**
* 在后台任务开始执行之前调用，用于进行一些界面上的初始化操作
*/
@Override
protected void onPreExecute() {
super.onPreExecute();
}/**
* 该方法中的所有代码都会在子线程中运行，任务一旦完成就可以通过
* return 语句来将任务的执行结果返回，如果 AsyncTask 的第三个
* 泛型参数指定的是 Void 就可以不反悔任务执行结果
* 注意：该方法中是不可以进行 UI 操作的，如果需要更新 UI
* 元素，比如反馈当前任务的执行进度，可以调用 publishProgress 方法来完成
*/
@Override
protected Boolean doInBackground(Void... integers) {
return null;
}/**
* 当在后台任务重调用了 publishProgress 方法后，该方法就会很快被
* 调用，该方法中携带的参数就是在后台任务重传递过来的。在该方法中
* 可以对 UI 进行操作。
*/
@Override
protected void onProgressUpdate(Integer... values) {
super.onProgressUpdate(values);
}/**
* 当后台任务执行完毕并通过 return 语句进行返回时，该方法就会很快调用，
* 返回的数据会作为参数传递到此方法中，可以利用返回的数据来进行一些 UI 操作，
* 比如提醒任务执行的结果，以及关闭进度条对话框等。
*/
@Override
protected void onPostExecute(Boolean aBoolean) {
super.onPostExecute(aBoolean);
}
}
new DownloadTask().execute();
整体来说，就是在 doInBackground()方法中执行具体的耗时任务，在 onProgressUpdate()方法中进行 UI 操作，在 onPostExecute()方法中执行一些任务的收尾工作。五、服务
文章图片
image.png
public class MyService extends Service {
public MyService() {
}/**
* 该方法是 Service 中唯一的一个抽象方法，必须要在子类中实现
*/
@Override
public IBinder onBind(Intent intent) {
// TODO: Return the communication channel to the service.
throw new UnsupportedOperationException("Not yet implemented");
}/**
* 创建服务的时候调用
*/
@Override
public void onCreate() {
super.onCreate();
}/**
* 每次服务启动的时候调用
*/
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
return super.onStartCommand(intent, flags, startId);
}/**
* 服务销毁的时候调用
*/
@Override
public void onDestroy() {
super.onDestroy();
}
}
启动和停止服务
findViewById(R.id.tv_start_service).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
/*
startService 定义在 Context 类中
*/
Intent intent = new Intent(FifthActivity.this,MyService.class);
startService(intent);
}
});
findViewById(R.id.tv_stop_service).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
/*
stopService 定义在 Context 类中
*/
Intent intent = new Intent(FifthActivity.this,MyService.class);
stopService(intent);
}
});
注意，这里完全是由活动来决定服务何时停止的，如果没有点击 Stop Service按钮，服务就会一直处于运行状态，如果让服务自己停下来，可以在 MyService 的任何一个位置调用 stopSelf()方法就行了。活动和服务进行通信
??如何让活动和服务进行通信呢？例如在活动中指挥服务去干什么，服务就去干什么，这就叫借助 onBind()方法了。
public class MyService extends Service {private static final String TAG = "MyService";
private DownloadBinder mBinder = new DownloadBinder();
/**
* 新建一个类继承自 Binder
*/
class DownloadBinder extends Binder{public void startDownload(){
System.out.println("abc : startDownload");
}public void getProgress(){
System.out.println("abc : getProgress");
}
}public MyService() {
}/**
* 该方法是 Service 中唯一的一个抽象方法，必须要在子类中实现
*/
@Override
public IBinder onBind(Intent intent) {
Log.d(TAG, "abc onBind: ");
//返回 DownloadBinder 实例对象
return mBinder;
}/**
* 创建服务的时候调用
*/
@Override
public void onCreate() {
super.onCreate();
System.out.println("abc : onCreate");
}/**
* 每次服务启动的时候调用
*/
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
System.out.println("abc : onStartCommand");
return super.onStartCommand(intent, flags, startId);
}/**
* 服务销毁的时候调用
*/
@Override
public void onDestroy() {
super.onDestroy();
System.out.println("abc : onDestroy");
}
}
private MyService.DownloadBinder downloadBinder;
/**
* 首先要创建 ServiceConnection 匿名类，重写 onServiceConnected()方法
* 和 onServiceDisconnected()方法，这两个方法分别会在活动和服务成功绑定
* 以及解除绑定的时候调用
*/
private ServiceConnection connection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
//向下转型获取 DownloadBinder 实例对象，有了该实例对象，我们就可以调用相应的方法了
downloadBinder = (MyService.DownloadBinder) iBinder;
downloadBinder.startDownload();
downloadBinder.getProgress();
}@Override
public void onServiceDisconnected(ComponentName componentName) {}
};
findViewById(R.id.tv_bind_service).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Intent intent = new Intent(FifthActivity.this,MyService.class);
/*
该方法接受三个参数
参1：Intent
参2：ServiceConnection
参3：BIND_AUTO_CREATE,表示在活动和服务进行绑定后自动创建服务
这就会使onCreate()方法得到执行，onStartCommand()方法不会执行。
*/
bindService(intent,connection,BIND_AUTO_CREATE);
//绑定服务
}
});
findViewById(R.id.tv_unbind_service).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
unbindService(connection);
//解绑服务
}
});
文章图片
image.png
注意：任何一个服务在整个应用程序范围内都是通用的，可以和任何一个其他的活动进行绑定，而且在绑定完成后他们都可以获取到相同的 DownloadBinder 实例对象服务的生命周期
??只要调用了 Context 的 startService()方法，相应的服务就会启动起来，并回调 onStartConmmand()方法，如果这个服务之前还没有创建过，onCreate()方法会先于 onStartCommand()方法执行。服务一旦启动之后，会一直保持运行状态，直到 stopService()或stopSelf()方法被调用。注意，虽然每调用一次 startService()方法，onStartCommand()就会执行一次，但实际上每个服务都只会存在一个实例，所以不管你调用多少次 startService()，只需调用一次 stopService()或stopSelf()方法，服务就会停下来。
??另外，还可以调用 Context 的 bindService()来获取一个服务的持久连接，这时就会回调服务中的 onBind()方法。类似的，如果服务之前还没有创建过，onCreate()方法会先于 onBind()方法执行。然后，调用方可以获取到 onBind()方法里返回的 IBinder 对象实例。只要调用方和服务之间的连接没有断开，服务就会一直保持运行状态。
??当调用了 startService()方法后，又去调用 stopService()方法，这时服务中 onDestroy()方法就会执行，表示服务已经销毁了。类似的，当调用了 bindService()方法后，又去调用 unbindService()方法，onDestroy()方法也会执行。但是，注意，我们可能一个服务既调用了 startService()又调用了 bindService()方法，那么该如何销毁服务呢？根据 Android 系统的机制，一个服务只要被启动或者被绑定了之后，就会一直处于运行状态，必须要让以上两种条件同时不满足，服务才能被销毁，所以，这种情况下要同时调用 stopService()和 unbindService()方法，onDetroy()方法才会执行。
六、服务的更多技巧 前台服务
??服务的系统优先级并不高，当系统出现内存不足的情况时，就有可能会回收掉正在后台运行的服务。如果你希望服务可以一直保持运行状态，而不会由于系统内存不足的原因导致被系统回收，就可以考虑使用前台服务。前台服务和普通服务最大的区别就在于，前台服务会一直有一个正在运行的图标在系统的状态栏显示，下拉状态栏后可以看到更加详细的信息，非常类似于通知的效果。
public class MyService extends Service {private static final String TAG = "MyService";
public MyService() {
}/**
* 该方法是 Service 中唯一的一个抽象方法，必须要在子类中实现
*/
@Override
public IBinder onBind(Intent intent) {
Log.d(TAG, "abc onBind: ");
//返回 DownloadBinder 实例对象
return mBinder;
}/**
* 创建服务的时候调用
*/
@Override
public void onCreate() {
super.onCreate();
System.out.println("abc : onCreate");
//创建 Intent
Intent intent = new Intent(this,FifthActivity.class);
//创建 PendingIntent
PendingIntent pendingIntent = PendingIntent.getActivity(this,0,intent,0);
//创建 Notification
Notification notification = new NotificationCompat.Builder(this)
.setContentText("this is text")
.setContentTitle("this is title")
.setWhen(System.currentTimeMillis())
.setSmallIcon(R.mipmap.ic_launcher)
.setContentIntent(pendingIntent)
.build();
/*
接收两个参数：
参1：通知的 id
参2：Notification 对象
*/
startForeground(1,notification);
}//...
}
使用 IntentService
??如果使用传统的 Service，如果要执行耗时操作，需要自己手动创建线程，而且在执行完毕要记得调动 stopSelf()方法关闭。为了可以简单地创建一个异步的、会自动停止的服务，Android 专门提供了一个 IntentService 类。
public class MyIntentService extends IntentService {/**
* 自己改成无参构造函数，并且必须在内部调用父类的
* 有参构造函数
*/
public MyIntentService() {
super("MyIntentService");
}/**
* 该方法是运行在子线程当中
*/
@Override
protected void onHandleIntent(@Nullable Intent intent) {
System.out.println("abc : onHandleIntent");
}@Override
public void onDestroy() {
super.onDestroy();
System.out.println("abc onDestroy");
}
}
findViewById(R.id.tv_intent_service).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Intent intent = new Intent(FifthActivity.this,MyIntentService.class);
startService(intent);
}
});
七、多线程断点下载
public class DownloadTask extends AsyncTask {private static final int TYPE_SUCCESS = 0;
private static final int TYPE_FAILED = 1;
private static final int TYPE_PAUSED = 2;
private static final int TYPE_CANCELED = 3;
private DownloadListener downloadListener;
private boolean isCanceled = false;
private boolean isPaused = false;
private int lastProgress;
public DownloadTask(DownloadListener downloadListener) {
this.downloadListener = downloadListener;
}@Override
protected Integer doInBackground(String... strings) {
InputStream is = null;
RandomAccessFile savedFile = null;
File file = null;
try {
long downloadedLength = 0;
//记录已下载的文件长度
/*
获取下载的 URL 地址，并根据 URL 地址解析出下载的文件名，
然后指定将文件下载到 Environment.DIRECTORY_DOWNLOADS 目录下，
也就是 SD 卡的 Download 目录
*/
String downloadUrl = strings[0];
String fileName = downloadUrl.substring(downloadUrl.lastIndexOf("/"));
String directory = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS)
.getParent();
file = new File(directory + fileName);
/*
判断该目录下是否已经存在要下载的文件,如果存在就获取该文件的字节数，
便于在后面启动断点续传的功能
*/
if (file.exists()) {
downloadedLength = file.length();
}
long contentLength = getContentLength(downloadUrl);
if (contentLength == 0) {//文件长度为0，说明文件有问题，下载失败
return TYPE_FAILED;
} else if (contentLength == downloadedLength) {//文件长度等于已下载的文件长度，则下载完成
return TYPE_SUCCESS;
}
//从网络下载文件，通过流的方式写入到本地
OkHttpClient okHttpClient = new OkHttpClient();
Request request = new Request.Builder()
//断点下载，指定从哪个字节开始下载
.addHeader("RANGE", "bytes=" + downloadedLength + "-")
.url(downloadUrl)
.build();
Response response = okHttpClient.newCall(request).execute();
if (response != null) {
is = response.body().byteStream();
savedFile = new RandomAccessFile(file, "rw");
byte[] b = new byte[1024];
int total = 0;
int len;
while ((len = is.read(b)) != -1) {
/*
判断用户有没有触发暂停或者取消的操作，
如果没有触发暂停或者取消的操作，就计算当前的下载进度
*/
if (isCanceled) {
return TYPE_CANCELED;
} else if (isPaused) {
return TYPE_PAUSED;
} else {
total += len;
}
savedFile.write(b, 0, len);
//计算已下载的百分比
int progress = (int) ((total + downloadedLength) * 100 / contentLength);
//通知更新界面
publishProgress(progress);
}
response.body().close();
}
return TYPE_SUCCESS;
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (is != null) {
is.close();
}
if(savedFile != null){
savedFile.close();
}
if(isCanceled && file != null){
file.delete();
}
} catch (IOException e) {
e.printStackTrace();
}}
return TYPE_FAILED;
}@Override
protected void onProgressUpdate(Integer... values) {
super.onProgressUpdate(values);
int progress = values[0];
if(progress > lastProgress){
downloadListener.onProgress(progress);
lastProgress = progress;
}
}/**
* 根据下载完成的状态来进行回调
*/
@Override
protected void onPostExecute(Integer status) {
super.onPostExecute(status);
switch (status){
case TYPE_SUCCESS:
downloadListener.onSuccess();
break;
case TYPE_FAILED:
downloadListener.onFailed();
break;
case TYPE_PAUSED:
downloadListener.onPaused();
break;
case TYPE_CANCELED:
downloadListener.onCanceled();
break;
default:
break;
}
}/**
* 暂停下载
*/
public void pauseDownload(){
isPaused = true;
}/**
* 取消下载
*/
public void cancelDownload(){
isCanceled = true;
}/**
* 获取下载文件的总长度
*/
private long getContentLength(String downloadUrl) throws IOException {
OkHttpClient okHttpClient = new OkHttpClient();
Request request = new Request.Builder()
.url(downloadUrl)
.build();
Response response = okHttpClient.newCall(request).execute();
if(response != null && response.isSuccessful()){
long contentLength = response.body().contentLength();
response.close();
return contentLength;
}
return 0;
}
}
public class DownloadService extends Service {private DownloadTask downloadTask;
private String downloadUrl;
private DownloadBinder mBinder = new DownloadBinder();
public DownloadService() {
}class DownloadBinder extends Binder {public void startDownload(String url) {
if (downloadTask == null) {
downloadUrl = url;
downloadTask = new DownloadTask(listener);
downloadTask.execute(downloadUrl);
startForeground(1, getNotification("Downloading...", 0));
Toast.makeText(DownloadService.this, "Downloading...", Toast.LENGTH_SHORT).show();
}
}public void pauseDownload() {
if (downloadTask != null) {
downloadTask.pauseDownload();
}
}public void cancelDownload() {
if (downloadTask != null) {
downloadTask.cancelDownload();
} else {
if(downloadUrl != null){
//取消下载时需将文件删除，并关闭通知
String fileName = downloadUrl.substring(downloadUrl.lastIndexOf("/"));
String directory = Environment.getExternalStoragePublicDirectory(
Environment.DIRECTORY_DOWNLOADS).getPath();
File file = new File(directory + fileName);
if(file.exists()){
file.delete();
}
getNotificationManager().cancel(1);
stopForeground(true);
Toast.makeText(DownloadService.this, "Canceled", Toast.LENGTH_SHORT).show();
}
}
}
}private DownloadListener listener = new DownloadListener() {
@Override
public void onProgress(int progress) {
getNotificationManager().notify(1, getNotification("Downloading...", progress));
}@Override
public void onSuccess() {
downloadTask = null;
//下载成功时将前台服务通知关闭，并创建一个下载成功的通知
stopForeground(true);
getNotificationManager().notify(1, getNotification("Download Success", -1));
Toast.makeText(DownloadService.this, "下载成功", Toast.LENGTH_SHORT).show();
}@Override
public void onFailed() {
downloadTask = null;
//下载失败时将前台服务通知关闭，并创建一个下载失败的通知
stopForeground(true);
getNotificationManager().notify(1, getNotification("Download Failed", -1));
Toast.makeText(DownloadService.this, "Download Failed", Toast.LENGTH_SHORT).show();
}@Override
public void onPaused() {
downloadTask = null;
Toast.makeText(DownloadService.this, "Download Pause", Toast.LENGTH_SHORT).show();
}@Override
public void onCanceled() {
downloadTask = null;
stopForeground(true);
Toast.makeText(DownloadService.this, "Download Cancel", Toast.LENGTH_SHORT).show();
}
};
@Override
public IBinder onBind(Intent intent) {
return mBinder;
}private NotificationManager getNotificationManager() {
return (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
}private Notification getNotification(String title, int progress) {
Intent intent = new Intent(this, MainActivity.class);
PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, intent, 0);
NotificationCompat.Builder builder = new NotificationCompat.Builder(this);
builder.setContentTitle(title)
.setSmallIcon(R.mipmap.ic_launcher)
.setContentIntent(pendingIntent)
.build();
if (progress >= 0) {
//当 progress > 0 或者 = 0 时才需显示下载进度
builder.setContentText(progress + "%");
/*
参1：通知的最大进度
参2：通知的当前进度
参3：是否使用模糊进度条
*/
builder.setProgress(100, progress, false);
}
return builder.build();
}
}
public class DownloadActivity extends AppCompatActivity implements View.OnClickListener{private DownloadService.DownloadBinder downloadBinder;
private ServiceConnection connection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
downloadBinder = (DownloadService.DownloadBinder) iBinder;
}@Override
public void onServiceDisconnected(ComponentName componentName) {}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_download);
TextView startDownload = (TextView) findViewById(R.id.tv_start_download);
TextView pauseDownload = (TextView) findViewById(R.id.tv_pause_download);
TextView cancelDownload = (TextView) findViewById(R.id.tv_cancel_download);
startDownload.setOnClickListener(this);
pauseDownload.setOnClickListener(this);
cancelDownload.setOnClickListener(this);
Intent intent = new Intent(this,DownloadService.class);
//启动服务，保证服务一直在后台运行
startService(intent);
//使活动和服务进行交互
bindService(intent,connection,BIND_AUTO_CREATE);
if(ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)
!= PackageManager.PERMISSION_GRANTED){
ActivityCompat.requestPermissions(this,new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},1);
}
}@Override
public void onClick(View view) {
switch (view.getId()){
case R.id.tv_start_download:
String url = "https://raw.githubusercontent.com/guolindev/eclipse/master/eclipse-inst-win64.exe";
downloadBinder.startDownload(url);
break;
case R.id.tv_pause_download:
downloadBinder.pauseDownload();
break;
case R.id.tv_cancel_download:
downloadBinder.cancelDownload();
break;
default:
break;
}
}@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
super.onRequestPermissionsResult(requestCode, permissions, grantResults);
switch (requestCode){
case 1:
if(grantResults.length > 0 && grantResults[0] != PackageManager.PERMISSION_GRANTED){
Toast.makeText(this, "拒绝权限将无法使用程序", Toast.LENGTH_SHORT).show();
}
break;
default:
break;
}
}@Override
protected void onDestroy() {
super.onDestroy();
//注意：一定要在活动销毁的时候解绑服务，否则会造成内存泄漏
unbindService(connection);
}
}
下一篇文章：https://www.jianshu.com/p/41ca26fb4f10
推荐阅读
- 第6.2章（设置属性）
- CVE-2020-16898|CVE-2020-16898 TCP/IP远程代码执行漏洞
- 2018-02-06第三天|2018-02-06第三天 不能再了，反思到位就差改变
- 第三节|第三节 快乐和幸福（12）
- EffectiveObjective-C2.0|EffectiveObjective-C2.0 笔记 - 第二部分
- android第三方框架（五）ButterKnife
- 开学第一天（下）
- 野营记-第五章|野营记-第五章 讨伐梦魇兽
- 2018年11月19日|2018年11月19日 星期一 亲子日记第144篇
- 第326天