第二行程式碼學習筆記——第十章:後臺默默的勞動者——探究服務

阿新 • • 發佈：2019-01-10

本章要點

Android沿用了諾基亞系統的Symbian作業系統的老習慣，從一開始就支援後臺功能，這使得應用程式即使在關閉的情況下仍然可以在後臺繼續執行。後臺功能屬於四大元件之一，重要程度言不可寓。

10.1 服務是什麼

服務（Service）是Android中是實現程式後臺執行的解決方案，它非常適合執行那些不需要與使用者進行互動還需要長期執行的任務。服務的介面不依賴於任何使用者介面，即使程式被切換到後臺，或者使用者打開了一個應用程式，服務仍然能保持正常執行。

服務並不是執行在一個獨立的程序中的，而是依賴於建立服務時所在的應用程式程序。當某個應用程式程序被殺掉時，所以依賴於該程序的服務也會停止執行。

預設在主執行緒，可能會造成主執行緒阻塞的問題。

10.2 Android多執行緒程式設計

當我們執行耗時操作，就必須放在子執行緒中執行，避免執行緒阻塞的問題，增強使用者的體驗度。

10.2.1 執行緒的基本用法

Android多執行緒與Java多執行緒使用語法相同。比如說，定義一個執行緒只需要定義一個類繼承自Thread，然後重寫父類的run()方法，並在裡面編寫耗時邏輯即可，如下：

class MyThread extends Thread {

    @Override
    public void run(){
    //處理具體的邏輯
    }
}

啟動這個執行緒，new出MyThread的例項，然後呼叫start()方法，這樣run()方法就執行在子執行緒中了，如下：

new MyThread().start();

當然，使用繼承的方式高耦合，更多的時候我們選擇實現Runable介面的方式來定義一個執行緒，如下：

class MyThread implements Runable {

   @Override
   public void run() {
     //處理具體的邏輯
   }
}

那麼啟動方式如下：

MyThread myThread = new MyThread();
new Thread(myThread).start();

常見的實現方式如下：

new Thread(new Runable() {

 @Override 

   public void run() {
     //處理具體的邏輯
   }
}).start();

以上就是執行緒的基本用法。在Java中建立和啟動執行緒的方式是一樣的。

10.2.2 在子執行緒中更新UI

更新應用程式中的UI元素，必須放在主執行緒。否則就會出現異常。

那我們就來驗證下吧。新建AndroidThreadTest專案，修改activity_main.xml中的程式碼如下：

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <Button
        android:id="@+id/btn_change_tv"
        android:text="Change Text"
        android:textAllCaps="false"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" />
    <TextView
        android:id="@+id/tv"
        android:layout_centerInParent="true"
        android:text="Hello World"
        android:textSize="20sp"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" />

</RelativeLayout>

接下來我們對Hello World 進行修改，修改MainActivity中的程式碼如下：

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    private Button btn_change_tv;
    private TextView tv;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        btn_change_tv= (Button) findViewById(R.id.btn_change_tv);
        tv= (TextView) findViewById(R.id.tv);
        btn_change_tv.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()){
            case R.id.btn_change_tv:
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        tv.setText("Nice to meet you");
                    }
                }).start();
                break;
            default:
                break;
        }
    }
}

我們在子執行緒中更新UI，執行程式，點選Change Text按鈕，我們會發現程式崩潰。觀察logcat日誌，可以看到原因是由於在子執行緒中更新UI操作，如下：

由此我們證明了Android不能在子執行緒中更新UI操作。有時候我們會在耗時操作返回的結果需要進行相應的UI更新。那麼我們通過Android提供的非同步訊息處理機制，完美解決在子執行緒中更新UI操作。

使用非同步處理訊息的方法。
修改MainActivity中的程式碼如下：

public class MainActivity extends AppCompatActivity implements View.OnClickListener {
    private static final int UPDATE_TEXT=1; //表示更新TextView的動作

    private Button btn_change_tv;
    private TextView tv;

    private Handler handler=new Handler(){
        @Override
        public void handleMessage(Message msg) { //4.主執行緒
            switch (msg.what){
                case UPDATE_TEXT: //5.判斷是否相等，進行操作
                    //在這裡進行UI操作
                    tv.setText("Nice to meet you");
                    break;
                default:
                    break;
            }
        }
    };
    ...
    @Override
    public void onClick(View v) {
        switch (v.getId()){
            case R.id.btn_change_tv:
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        Message message=new Message(); //1.建立Message物件
                        message.what=UPDATE_TEXT; //2.指定what值
                        handler.sendMessage(message); //3.將Message物件傳送過去
                    }
                }).start();
                break;
            default:
                break;
        }
    }
}

重新執行程式，點選Change Text按鈕，Hello World就會變成Nice to meet you。如圖：

changetext

使用Handler機制順利的解決了在子執行緒中更新UI的問題。

10.2.3 解析非同步訊息處理機制

Android中的非同步訊息處理主要有4部分組成：Message，Handler，MessageQueue，Looper。

Message
Message是線上程之間傳遞的訊息，它可以攜帶少量的資訊，用於在不同執行緒之間交換資料。Message的what欄位，arg1和arg2欄位攜帶整型資料，obj欄位攜帶一個Object物件。
Handler
Handler處理者，主要用於傳送和處理訊息。傳送訊息Handler的sendMessage()方法，傳送的訊息最終會傳遞到Handler的handleMessage()方法中。
MessageQueue
MessageQueue訊息列隊，主要用於存放所有通過Handler傳送的訊息。這部分訊息一直會存在於訊息列隊中，等待被處理。每個執行緒中只會有一個MessageQueue物件。
Looper
Looper是每個執行緒中的MessageQueue的管家，呼叫Looper的lop方法後，就會進入到無線迴圈中，然後每當傳送MessageQueue中存在的一條訊息，就會將它取出，並傳遞到Handler中的handleMessage()方法中。每個執行緒中也只會有一個Looper物件。

非同步訊息處理的整個流程：首先需要在主執行緒中建立一個Handler物件，並重寫handleMessage()方法。然後在子執行緒中進行需要UI操作時，就建立一個Message物件，並通過Handler將這條訊息傳送出去。之後這條訊息被新增在MessageQueue訊息列隊中等待被處理，而Looper會一直嘗試者從MessageQueue中取出待處理的訊息，最後傳送給Handel的handleMessage方法。由於Handler是在主執行緒中建立的，所以此時handleMessage()方法也會在主執行緒中執行，就可以進行UI操作了。整個非同步訊息處理機制流程圖：
handler

整個非同步訊息處理的核心思想：一條Message經過一個流程的輾轉呼叫後，也就從子執行緒進入到了主執行緒，從不能更新UI操作，變成了可以更新UI操作。

之前我們使用的runOnUiThread()方法就是一個非同步訊息處理機制的介面封裝。原理跟上圖描述的一樣。

10.2.4 使用AsyncTask

Android為了更加方便在子執行緒中更新UI操作，使用AsyncTask。它的實現原理也是基於非同步訊息處理機制的封裝。

AsyncTask的基本用法，AsyncTask是一個抽象類，我們必須建立一個類繼承它。繼承時可以為AsyncTask指定3個泛型引數。

Params。在執行AsyncTask時傳入的引數，可用於在後臺的使用。
Progress。後臺執行任務時，如果需要在介面顯示當前的進度條，則使用這裡指定的泛型作為進度單位。
Result。任務執行完畢，如果需要對結果進行返回，則使用這裡指定的泛型作為返回值型別。

一個完整的自定義AsyncTask如下：

class DownloadTask extends AsyncTask<Void, Integer, Boolean> {

    /**
     * 開始執行任務之前，用於初始化見介面。例如：顯示一個進度條
     */
    @Override
    protected void onPreExecute() {
        progressDialog.show();//顯示進度對話方塊
    }

    /**
     * 在子執行緒中執行，處理耗時操作。
     * 如果需要更新UI元素，則呼叫publishProgress()
     *
     * @param params
     * @return
     */
    @Override
    protected Boolean doInBackground(Void... params) {
        try {
            while (true) {
                int downloadPercent = doDownlod(); //這是一個虛方法
                publishProgress(downloadPercent);
                if (downloadPercent >= 100) {
                    break;
                }
            }
        } catch (Exception e) {
            return false;
        }
        return true;
    }

    /**
     * 當在後臺中呼叫了publishProgress()方法後，onProgressUpdate()很快就會呼叫，
     * 該方法攜帶的引數就是從後臺傳過來的。在這裡執行對UI操作。
     *
     * @param values
     */
    @Override
    protected void onProgressUpdate(Integer... values) {
        //在這裡執行下載進度
        progressDialog.setMessage("Download" + values[0] + "%");
    }

    /**
     * 當後臺執行完畢返回進行返回時。利用返回資料更新UI操作。
     * 比如：提醒任務執行的結果，以及關閉對話方塊等。
     *
     * @param result
     */
    @Override
    protected void onPostExecute(Boolean result) {
        progressDialog.dismiss(); //關閉進度對話方塊
        //在這裡提醒下載結果
        if (result) {
            Toast.makeText(content, "Download succeeded", Toast.LENGTH_SHORT).show();
        } else {
            Toast.makeText(content, "Download failed", Toast.LENGTH_SHORT).show();
        }
    }
}

第一個泛型引數Void，表示不需要傳入引數給後臺任務。
第二個泛型引數指定為Integer，表示使用整型資料型別作為進度顯示單位。
第三個泛型引數指定為Boolean，表示返回回饋的結果。

在這個DownloadTask中，在doInBackground()方法執行具體的下載任務（子執行緒）。doDownload()方法是一個虛方法，計算當前的下載進度並返回，並讓它顯示到介面中。我們通過呼叫 publishProgress()方法並將下載進度傳進來。這樣onProgressUpdate()就會呼叫，進行UI操作。下載完成後，doInBackground()返回的是布林值，然後通過onPostExecute()彈出相應的Toast提示。完成非同步載入任務。

簡單的來說，在AsyncTask中，doInBackground()進行耗時操作；onProgressUpdate()更新UI操作，onPostExecute()執行收尾工作。

啟動這個任務，程式碼如下：

new DownloadTask().execute();

本章最佳實踐，完善下載這個功能。

10.3 服務的基本用法

Android四大元件之一 —— 服務。

10.3.1 定義一個服務

新建ServiceTest專案，點選包—>New—>Service—>Service。彈出如下視窗：

service
Enabled：表示是否啟動這個服務。 Exported：是否允許除了當前程式之外的程式進行訪問這個服務。全部勾選，點選Finish完成建立。

MyService的程式碼如下：

public class MyService extends Service {
    public MyService() {
    }

    @Override
    public IBinder onBind(Intent intent) {
        throw new UnsupportedOperationException("Not yet implemented");
    }
}

MyService類繼承自Service。onBind()方法是Service中唯一的一個抽象方法。

處理事情，定義Service其他方法，程式碼如下：

public class MyService extends Service {

     ...
    /**
     * 建立服務的時候呼叫
     */
    @Override
    public void onCreate() {
        super.onCreate();
    }

    /**
     * 每次啟動的服務的時候呼叫
     * @param intent
     * @param flags
     * @param startId
     * @return
     */
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        return super.onStartCommand(intent, flags, startId);
    }

    /**
     * 銷燬服務的時候呼叫
     */
    @Override
    public void onDestroy() {
        super.onDestroy();
    }
}

每個服務都需要在AndroidManifest.xml註冊是才能夠使用，這是Android四大元件的共同點。建立服務的時候Android Studio已經幫我們智慧的建立完成了。開啟AndroidManifest.xml，程式碼如下：

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.hjw.servicetest">

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        ...
        <service
            android:name=".MyService"
            android:enabled="true"
            android:exported="true"></service>
    </application>

</manifest>

這樣，我們就定義好了一個服務。

10.3.2 啟動和停止服務

藉助Intent來啟動和停止這個服務，在ServiceTest專案中來實現吧。

修改activity_main.xml中的程式碼如下：

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <Button
        android:id="@+id/btn_start_service"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Start Service"
        android:textAllCaps="false" />

    <Button
        android:id="@+id/btn_stop_service"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Stop Service"
        android:textAllCaps="false" />


</LinearLayout>

修改MainActivity中的程式碼如下：

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    private Button btn_start_service, btn_stop_service;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        btn_start_service = (Button) findViewById(R.id.btn_start_service);
        btn_stop_service = (Button) findViewById(R.id.btn_stop_service);

        btn_start_service.setOnClickListener(this);
        btn_stop_service.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.btn_start_service:
                Intent startIntent = new Intent(this, MyService.class);
                startService(startIntent); //啟動服務
                break;
            case R.id.btn_stop_service:
                Intent stopIntent = new Intent(this, MyService.class);
                stopService(stopIntent); //停止服務
                break;
            default:
                break;
        }
    }
}

測試服務啟動或停止，我們在MyService中的方法加入日誌，如下所示：

public class MyService extends Service {
    private static final String TAG = "MyService";
    ...
    /**
     * 建立服務的時候呼叫
     */
    @Override
    public void onCreate() {
        super.onCreate();
        Log.d(TAG, "onCreate: executed");
    }

    /**
     * 每次啟動的服務的時候呼叫
     *
     * @param intent
     * @param flags
     * @param startId
     * @return
     */
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.d(TAG, "onStartCommand: executed");
        return super.onStartCommand(intent, flags, startId);
    }

    /**
     * 銷燬服務的時候呼叫
     */
    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.d(TAG, "onDestroy: executed");
    }
}

接下來我們執行程式，如下：

點選Start Service按鈕，觀察logcat日誌如下：

start
這時這個服務已經啟動了，我們開啟設定—>開發者選項—>正在執行的服務，如圖：

run

然後我們點選Stop Service按鈕，觀察日誌如下：

stopservice

可以看出MyService的確停止服務了。

onCreate()和onStartCommand()區別，onCreate()會在第一次建立的時候呼叫，而onStartCommand()則在每次建立服務的時候呼叫。當我們點選多次Start Service按鈕，第一次會執行兩個方法，而以後只會執行onStartCommand()方法。

10.3.3 活動和服務進行通訊

藉助onBind()方法，使我們的服務與活動關聯起來。

我們希望實現MyService實現一個下載功能，在活動中決定合適開始下載，以及檢視進度。那我們建立一個Binder物件對下載功能進行管理。修改MyService中的程式碼如下：

public class MyService extends Service {
    private static final String TAG = "MyService";

    public MyService() {
    }

    private DownloadBinder mBinder=new DownloadBinder();

    @Override
    public IBinder onBind(Intent intent) {

        return mBinder;

    }


    class DownloadBinder extends Binder{

        /**
         * 模擬方法
         */
        public void startDownload(){
            Log.d(TAG, "startDownload: executed");
        }

        public int getProgress(){
            Log.d(TAG, "getProgress: executed");
            return 0;
        }
    }
    ...
}

新建DownloadBinder類，並繼承Binder，再裡面實現下載和檢視進度的模擬方法（這裡我們分別列印一行日誌）。

在MyService中建立DownloadBinder的例項，然後在onBind()返回例項。做完MyService工作了。

在活動中呼叫服務裡的方法。新增兩個按鈕（繫結服務，解綁服務），修改activity_main中的檔案：

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">
    ...
    <Button
        android:id="@+id/btn_bind_service"
        android:textAllCaps="false"
        android:text="Bind Service"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" />

    <Button
        android:id="@+id/btn_unbind_service"
        android:textAllCaps="false"
        android:text="unBind Service"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" />


</LinearLayout>

當一個活動和服務繫結之後，就可以呼叫服務裡的Binder提供的方法，修改MainActivity中的程式碼如下：

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    private Button btn_start_service, btn_stop_service,btn_bind_service,btn_unbind_service;

    private MyService.DownloadBinder downloadBinder;

    private ServiceConnection connection=new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
             //指定服務去幹什麼
            downloadBinder= (MyService.DownloadBinder) service;
            downloadBinder.startDownload();
            downloadBinder.getProgress();
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {

        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        ...
        btn_bind_service= (Button) findViewById(R.id.btn_bind_service);
        btn_unbind_service= (Button) findViewById(R.id.btn_unbind_service);

        ...
        btn_bind_service.setOnClickListener(this);
        btn_unbind_service.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            ...
            case R.id.btn_bind_service:
                Intent bindIntent = new Intent(this, MyService.class);
                bindService(bindIntent,connection,BIND_AUTO_CREATE); //繫結服務
                break;
            case R.id.btn_unbind_service:
                unbindService(connection); //解綁服務
                break;
            default:
                break;
        }
    }
}

首先建立一個ServiceConnection匿名類，重寫了onServiceConnected()和onServiceDisconnected()方法，與服務成功繫結和解綁的時候呼叫。通過向下轉型得到了DownloadBinder的例項，接下來在onServiceConnected()中呼叫DownloadBinder的startDownload()和getProgress()方法。

繫結服務：binderService()接受三個引數，第一個引數Intent，第二個引數ServiceConnection，第三個引數BIND_AUTO_CREATE（表示在活動和服務進行繫結後自動建立服務）。這樣MyService中的onCreate()會得到執行，但onStartCommand()方法不會執行。

解除繫結：unBinderService()方法。

執行程式，點選Bind Service中的按鈕，觀察logcat日誌如下：

bindservice

這樣就完成了我們的繫結服務，任何一個服務在應用範圍內都是通用的（一個服務可以和任意一個活動繫結）。

10.4 服務的生命週期

服務也有自己的生命週期，官方給出兩種服務的生命週期，一目瞭然，如圖：

servicelife

10.5 服務的更多技巧

接下來我們學習服務高階使用技巧。

10.5.1 使用前臺服務

希望服務一直保持執行，而不希望系統記憶體不足而被回收，我們可以使用前臺服務。前臺服務和普通服務的最大的區別就在與，它會一直有一個正在執行的圖示在系統的狀態列顯示，下拉選單顯示詳情內容，類似於通知。

建立前臺服務，修改MyService中的程式碼如下：

public class MyService extends Service {
     ...

    /**
     * 建立服務的時候呼叫
     */
    @Override
    public void onCreate() {
        super.onCreate();
        Log.d(TAG, "onCreate: executed");
        Intent intent=new Intent(this,MainActivity.class);
        PendingIntent pi=PendingIntent.getActivity(this,0,intent,0);
        Notification notification=new NotificationCompat.Builder(this)
                .setContentTitle("This is content title")
                .setContentText("This is content text")
                .setWhen(System.currentTimeMillis())
                .setSmallIcon(R.mipmap.ic_launcher)
                .setLargeIcon(BitmapFactory.decodeResource(getResources(),R.mipmap.ic_launcher))
                .setContentIntent(pi)
                .build();

        startForeground(1,notification);
    }
    ...
}

呼叫startForeground()方法來顯示通知，就會讓MyService變成一個前臺服務，顯示在系統的狀態列。

執行程式，並點選Start Service或Bind Service按鈕，就會啟動前臺服務。如圖：

qtservice

10.5.2 使用IntentService

服務的程式碼預設在主執行緒，如果在服務裡進行一些耗時操作，很容易出現ANR（Application Not Responding）的情況。

為了解決ANR，我們必須在每個服務的每個具體方法裡開啟一個子執行緒，去處理一些耗時的操作。一個標準的服務的程式碼如下：

public class MyService extends Service {
     ...
    /**
     * 每次啟動的服務的時候呼叫
     *
     * @param intent
     * @param flags
     * @param startId
     * @return
     */
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                //處理具體的邏輯
                stopSelf();
            }
        }).start();
        return super.onStartCommand(intent, flags, startId);
    }
    ...
}

為了解決我們忘記開啟子執行緒，或忘記呼叫stopSelf()方法。Android提供了一個非同步的，會自動停止服務的IntentService類。

新建MyIntentService類繼承自IntentService，程式碼如下：

public class MyIntentService extends IntentService {

    public MyIntentService() {
        super("MyIntentService"); //呼叫父類的有參建構函式
    }

    @Override
    protected void onHandleIntent(@Nullable Intent intent) {
        //列印當前執行緒的id
        Log.d("MyIntentService", "Thread id is "+ Thread.currentThread().getId());
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.d("MyIntentService", "onDestroy: executed ");
    }
}

首先我們提供一個無參的建構函式，並且必須呼叫內部父類的有參建構函式。然後在子類中去實現onHandleIntent()抽象方法，在這個方法中處理具體的邏輯，這個方法在子執行緒中執行（解決了ARN問題）。

接下來修改activity_main.xml中的程式碼，加入一個啟動MyiIntentStart按鈕，如下所示：

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">
    ...
    <Button
        android:id="@+id/btn_start_intent_service"
        android:textAllCaps="false"
        android:text="Start IntentService"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" />

</LinearLayout>

修改MainActivity中的程式碼如下：

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    private Button btn_start_service, btn_stop_service,btn_bind_service,btn_unbind_service,btn_start_intent_service;

    ...
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ...
        btn_start_intent_service= (Button) findViewById(R.id.btn_start_intent_service);
        ...
        btn_start_intent_service.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            ...
            case R.id.btn_start_intent_service:
            Log.d("MainActivity", "Thread id is " + Thread.currentThread().getId());//列印主執行緒的id
                Intent intentService=new Intent(this,MyIntentService.class);
                startService(intentService);
                break;
            default:
                break;
        }
    }
}

在AndroidManifest.xml中註冊服務，程式碼如下：

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.hjw.servicetest">

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        ...
        <service android:name=".MyIntentService"/>
    </application>

</manifest>

執行程式，點選Start IntentService按鈕，觀察logcat日誌，如下：

我們可以看到MyIntentService和MainActivity中的所線上程的id不一樣，而且onDestory()也得到了執行。集開啟執行緒和自動停止與一身，IntentService是我們的最愛。

10.6 服務的最佳實踐 — 完整版的下載

實現服務中經常使用到的功能個——下載功能。

建立一個ServiceBestPractice專案。

新增OkHttp依賴庫，如下：

compile 'com.squareup.okhttp3:okhttp:3.8.0'

接下來定義一個DownloadListener介面回撥，用於對下載過程中的各種狀態進行監聽。如下：

public interface DownloadListener {

    void onProgress(int progress);

    void onSuccess();

    void onFailed();

    void onPaused();

    void onCanceled();
}

編寫下載功能，新建DownloadTask繼承自AysncTask，程式碼如下：

public class DownloadTask extends AsyncTask<String, Integer, Integer> {

    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 listener;

    private boolean isCanceled = false;
    private boolean isPaused = false;

    private int lastProgress;


    public DownloadTask(DownloadListener listener) {
        this.listener = listener;
    }


    @Override
    protected Integer doInBackground(String... params) {
        InputStream is = null;
        RandomAccessFile savedFile = null;
        File file = null;

        try {
            long downloadLength = 0;  //記錄已下載的檔案長度
            String downloadUrl = params[0];
            String fileName = downloadUrl.substring(downloadUrl.lastIndexOf("/"));
            String directory = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS)
                    .getPath();
            file = new File(directory + fileName);
            if (file.exists()) {
                downloadLength = file.length();
            }
            long contentLength = getContentLength(downloadUrl);
            if (contentLength == 0) {
                return TYPE_FAILED;
            } else if (contentLength == downloadLength) {
                //已下載位元組和檔案總位元組相等，就等於已經下載完了
                return TYPE_SUCCESS;
            }

            OkHttpClient client = new OkHttpClient();
            Request request = new Request.Builder()
                    //斷點下載，指定從哪個子節點開始下載
                    .addHeader("RANGE", "bytes=" + downloadLength + "-")
                    .url(downloadUrl).build();
            Response response = client.newCall(request).execute();
            if (request != null) {
                is = response.body().byteStream();
                savedFile = new RandomAccessFile(file, "rw");
                savedFile.seek(downloadLength); //跳過已下載的位元組
                byte[] bytes = new byte[1024];
                int total = 0;
                int len;
                while ((len = is.read(bytes)) != -1) {
                    if (isCanceled) {
                        return TYPE_CANCELED;
                    } else if (isPaused) {
                        return TYPE_PAUSED;
                    } else {
                        total += len;
                        savedFile.write(bytes, 0, len);
                        //計算已下載的百分比
                        int progress = (int) ((total + downloadLength) * 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) {
        int progress = values[0];
        if (progress > lastProgress) {
            listener.onProgress(progress);
            lastProgress = progress;
        }
    }

    @Override
    protected void onPostExecute(Integer status) {
        switch (status) {
            case TYPE_SUCCESS:
                listener.onSuccess();
                break;
            case TYPE_FAILED:
                listener.onFailed();
                break;

 
 
              
           
              
              
            
            相關推薦
			   
            
            
            
 

    

    
    第二行程式碼學習筆記——第十章:後臺默默的勞動者——探究服務
      
							
							
							本章要點

Android沿用了諾基亞系統的Symbian作業系統的老習慣，從一開始就支援後臺功能，這使得應用程式即使在關閉的情況下仍然可以在後臺繼續執行。後臺功能屬於四大元件之一，重要程度言不可寓。





10.1 服務是什麼

服務（Service）是A 

  
 

    

    
    第二行程式碼學習筆記——第三章:軟體也要拼臉蛋——UI開發的點點滴滴
      
							
							
							本章要點

使用Android提供的UI來編寫程式介面。本章的內容就是學習UI方面的知識。



3.1 如何編寫程式介面

Android種編寫程式介面的方式： 
1.  視覺化編輯器（不推薦） 
2.  編寫XML程式碼（推薦）





3.2 常用控制元 

  
 

    

    
    第二行程式碼學習筆記——第六章:資料儲存全方案——詳解持久化技術
      
							
							
							本章要點

任何一個應用程式，總是不停的和資料打交道。 
瞬時資料：指儲存在記憶體當中，有可能因為程式關閉或其他原因導致記憶體被回收而丟失的資料。 
資料持久化技術，為了解決關鍵性資料的丟失。



6.1 持久化技術簡介

資料持久化技術：指那些記憶體中的瞬時 

  
 

    

    
    第二行程式碼學習筆記——第四章:手機平板要相容——探究碎片
      
							
							
							本章要點

作為一名專業的Android開發人員，能夠同時相容手機和平板的開發時我們必須要做到的事情。





4.1 碎片是什麼

碎片（Fragment）是一種可以巢狀在活動當中的UI片段，它能讓程式更加合理和充分的利用大螢幕的控制元件。





4.2 

  
 

    

    
    第二行程式碼學習筆記——第一章:開始啟程——你的第一行Android程式碼
      
							
							
							筆者前言

最近在讀郭霖大神的第二行程式碼，藉助第二行程式碼，在這裡我認真梳理Android知識，為了形成自己的知識體系。堅持寫一系列關於第二行程式碼的學習筆記，一是來提升自己的學習能力，堅持每天學習; 二是給自己整理一份資料，方便以後的查閱與複習。希望能夠幫助 

  
 

    

    
    o'Reill的SVG精髓（第二版）學習筆記——第四章
      使用   還需要   第四章   會有   屬性   輪廓   4.4   www.   進行   第四章：基本形狀
4.1線段
SVG可以使用<line>元素畫出一條直線段。使用時只需要指定線段起止點的x和y坐標即可。指定坐標時可以不帶單位，此時會使用用戶坐標，也可以帶上單位，如em、in等。
 

  
 

    

    
    CLR via C#學習筆記-第十章-有參屬性
      get   類型參數   第十章   自動   spa   ...   ring   歧義   訪問性   10.2 有參屬性
屬性的get訪問器不接受參數，因此稱為無參屬性。
C#還支持有參屬性，他的get訪問器方法接受一個或多個參數，set訪問器方法接收兩個或多個參數，C#稱之為索引器。
C#使用數組風格 

  
 

    

    
    深度學習花書學習筆記 第十章 序列建模：迴圈神經網路
       
 
 展開計算圖 
 就是將迴圈圖展開成展開圖而已。 
 迴圈神經網路 
  
  
   
 就是如上網路，將某一層不斷重複，輸出重新作為輸入的一部分。 
 雙向RNN 
 應用於上下文環境都影響結果的場景，如語音識別，文章翻譯等 
 基於編碼-解碼的序列到序列架構 
 可以將可變長度的輸入轉 

  
 

    

    
    C++ primer學習筆記——第十章 泛型演算法
      
                標準庫容器定義的操作集合驚人的小。標準庫並未給每個容器新增大量功能，而是提供了一組演算法，這些演算法中的大多數都獨立於任何特定的容器。這些演算法是通用的（generic，或稱泛型的）：它們可以用於不同型別的容器和不同型別的元素

一、概述

大多數演算法都定義在標頭檔案alg 

  
 

    

    
    《資料結構與演算法分析》學習筆記-第十章-演算法設計技巧
      [toc]
***

## 10.1 貪婪演算法
貪婪演算法分階段的工作，在每個階段，可以認為所做決定是最好的，而不考慮將來的後果。一般來說，這意味著選擇的是某個區域性的最優。當演算法終止時，我們希望區域性最優就是全域性最優。如果是這樣的話，那麼演算法就是正確的，否則，演算法得到的是一個次最優解。如果不要求絕 

  
 

    

    
    第一行程式碼學習筆記第二章——探究活動
      
							
							
							知識點目錄





知識點回顧



2.1 活動是什麼


  是一種包含使用者介面的元件，主要用於和使用者進行互動。




2.2 活動的基本用法

Android Studio一個工作區間只允許開啟一個專案，故點選導航欄File –> Close 

  
 

    

    
    學習筆記 第十四章 使用CSS3動畫
      進行   delay   簡單的   angle   新版   chrome   tor   3.0   :focus   第14章   使用CSS3動畫
【學習重點】

設計2D動畫
設計3D動畫
設計過渡動畫
設計幀動畫
能夠使用CSS3動畫功能設計頁面特效樣式

14.1  設計2D動畫
CSS2D T 

  
 

    

    
    學習筆記 第十五章 JavaScript基礎
      continue   分隔符   全部   scrip   允許   非循環   元素   當前   避免   第15章   JavaScript基礎
【學習重點】

了解JavaScript基礎知識
熟悉常量和變量
能夠使用表達式和運算符
正確使用語句
能夠掌握數據類型和轉換的基本方法
正確使用函數、對象、 

  
 

    

    
    CLR via C#學習筆記-第四章-類型基礎-運行時的相互關系
      分配內存   ring   type類   實現   語句   初始化   sem   strong   允許   4.4 運行時的相互關系
已加載CLR的一個Windows進程，該進程可能有多個線程。線程創建時會分到1MB的棧。棧空間用於向方法傳遞實參，方法內部定義的局部變量也在棧上。
以下是方法M1和M2 

  
 

    

    
    CLR via C#學習筆記-第十二章-泛型
      vat   message   靜態   定義   泛型接口   void   失敗   internal   運行時   泛型是CLR和編程語言提供的一種特殊機制，他支持另一種形式的代碼重用，即算法重用。
CLR允許創建泛型引用類型和泛型值類型，但不允許創建泛型枚舉類型。
此外CLR還允許創建泛型接口和泛型 

  
 

    

    
    CLR via C#學習筆記-第十二章-泛型基礎結構
      12.2 泛型基礎結構 
12.2.1 開放型別和封閉型別 
具有泛型型別引數的型別仍然是型別，CLR同樣會為他建立內部的型別物件。 
然而具有泛型型別引數的型別稱為開放型別，CLR禁制構造開放型別的任何例項。類似於CLR禁止構造介面型別的例項。 
程式碼引用泛型類時可指定一組泛型型別實參。為所有型 

  
 

    

    
    CLR via C#學習筆記-第十二章-泛型接口、委托
      pre   類型安全   sealed   2.4   span   接口   triangle   泛型類   保持   12.3 泛型接口
泛型接口的意義
顯然，泛型的主要作用就是定義泛型的引用類型和值類型。
然而對泛型接口的支持對CLR來說也很重要。沒有泛型接口，每次用非泛型接口如IComparable 

  
 

    

    
    CLR via C#學習筆記-第十二章-泛型方法和其他成員
      12.6 泛型方法 
方法和類可以各自定義型別引數 
定義泛型類、結構或介面時，型別中定義的任何方法都可以引用型別指定的型別引數。 
型別引數可以作為方法引數、返回值或方法內部定義的區域性變數的型別使用。 
CLR還允許方法指定他自己的型別引數，這些引數也可以作為引數、返回值或區域性變數的型別使用。 
在下例 

  
 

    

    
    CLR via C#學習筆記-第十二章-可驗證性和約束
      12.8 可驗證性和約束 
where關鍵字 
編譯器和CLR支援稱為約束的機制，可通過它使泛型變得真正有用。 
約束的作用限制能指定成泛型實參的型別數量，通過限制類型的數量，可以對那些型別執行更多操作： 
 
 public static T Min<T>(T o1,T o2) whe 

  
 

    

    
    強化學習（RLAI）讀書筆記第十章On-Policy Control with Approximation
       
 
 目前繼續考慮on-policy的帶逼近的control演算法。這章主要介紹半梯度Sarsa演算法，也就是半梯度TD(0)演算法對於動作值估計以及on-policy control演算法的自然延伸。雖然這個延伸對於episodic的情況是很自然的，但是對於continuing的情況，我們需要再次考慮對

第二行程式碼學習筆記——第十章:後臺默默的勞動者——探究服務

本章要點

10.1 服務是什麼

10.2 Android多執行緒程式設計

10.2.1 執行緒的基本用法

10.2.2 在子執行緒中更新UI

10.2.3 解析非同步訊息處理機制

10.2.4 使用AsyncTask

10.3 服務的基本用法

10.3.1 定義一個服務

10.3.2 啟動和停止服務

10.3.3 活動和服務進行通訊

10.4 服務的生命週期

10.5 服務的更多技巧

10.5.1 使用前臺服務

10.5.2 使用IntentService

10.6 服務的最佳實踐 — 完整版的下載

第二行程式碼學習筆記——第十章:後臺默默的勞動者——探究服務

第二行程式碼學習筆記——第三章:軟體也要拼臉蛋——UI開發的點點滴滴

第二行程式碼學習筆記——第六章:資料儲存全方案——詳解持久化技術

第二行程式碼學習筆記——第四章:手機平板要相容——探究碎片

第二行程式碼學習筆記——第一章:開始啟程——你的第一行Android程式碼

o'Reill的SVG精髓（第二版）學習筆記——第四章

CLR via C#學習筆記-第十章-有參屬性

深度學習花書學習筆記第十章序列建模：迴圈神經網路

C++ primer學習筆記——第十章泛型演算法

《資料結構與演算法分析》學習筆記-第十章-演算法設計技巧

第一行程式碼學習筆記第二章——探究活動

學習筆記第十四章使用CSS3動畫

學習筆記第十五章 JavaScript基礎

CLR via C#學習筆記-第四章-類型基礎-運行時的相互關系

CLR via C#學習筆記-第十二章-泛型

CLR via C#學習筆記-第十二章-泛型基礎結構

CLR via C#學習筆記-第十二章-泛型接口、委托

CLR via C#學習筆記-第十二章-泛型方法和其他成員

CLR via C#學習筆記-第十二章-可驗證性和約束

強化學習（RLAI）讀書筆記第十章On-Policy Control with Approximation