Введение в этот раздел

Итак, в предыдущих трёх разделах мы изучали Activity в Android. Думаю, все получили много пользы! В этом разделе мы продолжим знакомство со вторым компонентом Android: Service. Что ж, не будем тянуть, начнём материал этого раздела!


1. Понятия, связанные с потоками

Прежде чем начать изучение Service, давайте сначала разберёмся с некоторыми понятиями о потоках!

1) Связанные понятия:

  • Программа: набор инструкций, написанных на определённом языке для выполнения конкретной задачи (наборстатического кода)
  • Процесс:Выполняемая программа, единица системного планирования и распределения ресурсовнезависимая единица, операционная система выделяет каждому процессу сегмент памяти! Последовательное динамическое выполнение программы — это полный процесс загрузки, выполнения и завершения кода!
  • Поток: единица выполнения меньше процесса. Каждый процесс может иметь несколько потоков,Потокдолжен быть помещён впроцесс, чтобы выполняться,Потоками управляет программа, тогда какпроцессы планируются системой!
  • Понимание многопоточности:Параллельновыполнять несколько инструкций и распределятькванты процессорного временимежду потоками согласно алгоритму планирования. Фактически эторазделение временивыполнения, но время переключения очень короткое, поэтому пользователи просто чувствуют, что это «одновременно»!

2) Жизненный цикл потока:

3) Три способа создания потоков:

  1. Наследование класса Thread
  2. Реализовать интерфейс Runnable
  3. Реализовать интерфейс CallableЕсли: используя поток, созданный в пункте 2, его можно запустить напрямую так:
    new Thread(myThread).start();
    
    Чаще мы предпочитаем использовать анонимные классы, то есть следующий стиль:
    new Thread(new Runnable(){
         public void run();
             }).start();

2. Различия между Service и Thread

На самом деле между ними не так уж много общего, но многие часто путают эти два понятия! Thread — это поток, наименьшая единица выполнения программы и базовая единица распределения CPU! Service — это компонент, предоставляемый Android, который позволяет долго находиться в фоновом режиме. Чаще всего его используют для выполнения операций опроса! Или если вы хотите сделать что-то в фоне, например фоновую загрузку обновлений! Запомните: не путайте эти два понятия!


3. Диаграмма жизненного цикла Service


4. Анализ жизненного цикла

Итак, из приведённой выше диаграммы жизненного цикла мы можем узнать, что в Android есть два способа использования Service:

1)StartService() для запуска Service
2)BindService() для запуска Service
PS: Есть ещё один способ — привязать Service после его запуска!


1) Подробное объяснение связанных методов:

  • onCreate()onCreate(): Когда Service создаётся впервые, этот метод вызывается сразу; этот метод будет вызван только один раз за весь жизненный цикл!
  • onDestory()onDestroy(): Когда Service закрывается, этот метод вызывается; этот метод будет вызван только один раз!
  • onStartCommand(intent,flag,startId)onStartCommand(): В более ранних версиях это был onStart(intent, startId). Когда клиент вызывает метод startService(Intent), он будет вызван. Метод StartService можно вызывать несколько раз, но новый объект Service создаваться не будет; вместо этого повторно используется ранее созданный объект Service, однако метод onStartCommand() будет продолжать вызываться!
  • IBinder onOnbind(intent)onBind(): Этот метод является методом, который должны реализовать все компоненты Service. Этот метод возвращает объект IBinder, через который приложение взаимодействует с компонентом Service!
  • onUnbind(intent)onUnbind(): Этот метод вызывается, когда все клиенты, привязанные к Service, отключаются!

2) StartService для запуска Service

①При первом запуске будет создан экземпляр Service, и методы onCreate() и onStartCommand() будут вызваны последовательно. В этот момент Service переходит в рабочее состояние. Если снова вызвать StartService для запуска Service, новый объект Service создаваться не будет. Система напрямую повторно использует ранее созданный объект Service и вызовет его метод onStartCommand()!
②Но такой Service не имеет необходимой связи с тем, кто его вызвал. То есть, когда вызывающая сторона завершает свой жизненный цикл, Service продолжит работать, если только не будет вызван stopService!
③Независимо от того, сколько раз был запущен Service, достаточно один раз вызвать StopService, чтобы остановить Service.


3) BindService для запуска Service

①Когда Service впервые привязывается с помощью bindService, система создаёт экземпляр Service и вызывает его методы onCreate() и onBind(). Затем вызывающий может взаимодействовать с Service через IBinder. После этого, если bindService снова используется для привязки Service, система не создаст новый экземпляр Service и не вызовет метод onBind() повторно; она просто передаст объект IBinder напрямую другим клиентам, добавленным позже!
②Если мы хотим отвязаться от сервиса, нам просто нужно вызвать unbindService(). В этот момент будут вызваны методы onUnbind и onDestroy! Это случай для одного клиента. Если несколько клиентов привязываются к одному и тому же Service, ситуация следующая: после того как клиент завершает взаимодействие с сервисом, он вызывает метод unbindService(), чтобы отвязаться. Когда все клиенты отвяжутся от сервиса, система уничтожит сервис. (Если только сервис не был также запущен методом startService().)
③Кроме того, в отличие от вышеописанной ситуации, Service в режиме bindService взаимосвязан с вызывающим. Это можно понять как «кузнечики, привязанные к одной верёвке» — если один умирает, все умирают вместе. После bindService, как только вызывающий будет уничтожен, Service также немедленно завершится!
Анализ Context.bindService() при вызове Service через BindServicebindService(Intent Service,ServiceConnection conn,int flags)
service: Service, который нужно запустить, задаётся через этот intent.
conn: объект ServiceConnection, используемый для отслеживания соединения между посетителем и Service. При успешном соединении вызывается метод onServiceConnected(ComponentName, IBinder) в этом объекте; если хост, в котором находится Service, завершается из-за аварийного завершения или по другим причинам, что приводит к разрыву соединения между Service и посетителем, вызовитеonServiceDisconnected(ComponentName) — метод; при активном отсоединении через методunBindService()вышеуказанный метод вызываться не будет!
flags:Указывает, следует ли автоматически создавать Service при привязке (если Service ещё не создан). Параметр может быть 0 (не создавать автоматически) или BIND_AUTO_CREATE (создавать автоматически).4) Привязка через bindService после запуска Service с помощью StartService


4) Привязка через bindService после запуска Service с помощью StartService

Предварительное условие: метод onUnbind() возвращает true!!!
onCreate( )->onStartCommand( )->onBind( )->onUnbind( )->onRebind( )
PS:Здесь некоторые читатели могут запутаться. После вызова unbindService разве Service не должен вызвать метод onDestroy()? На самом деле это потому, что этот Service был запущен нашим StartService, поэтому если вы вызовете метод onUnbind() для отвязки, Service тоже не завершится!
Вывод:Если мы используем bindService для привязки к уже запущенному Service, обратите внимание, что это уже запущенный Service!!! Система только передаёт внутренний объект IBinder этого Service в Activity и не привязывает жизненный цикл Service к Activity. Поэтому при вызове unBindService() для отвязки Service не будет уничтожен!


5. Проверка жизненного цикла

Далее давайте напишем код для проверки жизненного цикла:

1) Проверить порядок вызовов при запуске Service с помощью StartService

Сначала мы определяем пользовательский Service, переопределяем соответствующие методы и выводим проверку в logcat:

TestService1.java

public class TestService1 extends Service {  
    private final String TAG = "TestService1";    
    //必须要实现的方法  
    @Override  
    public IBinder onBind(Intent intent) {  
        Log.i(TAG, "onBind方法被调用!");  
        return null;  
    }  
  
    //Service被创建时调用  
    @Override  
    public void onCreate() {  
        Log.i(TAG, "onCreate方法被调用!");  
        super.onCreate();  
    }  
      
    //Service被启动时调用  
    @Override  
    public int onStartCommand(Intent intent, int flags, int startId) {  
        Log.i(TAG, "onStartCommand方法被调用!");  
        return super.onStartCommand(intent, flags, startId);  
    }  
      
    //Service被关闭之前回调  
    @Override  
    public void onDestroy() {  
        Log.i(TAG, "onDestory方法被调用!");  
        super.onDestroy();  
    }  
}

Полная регистрация Service в AndroidManifest.xml

<!-- 配置Service组件,同时配置一个action -->  
<service android:name=".TestService1">  
            <intent-filter>  
                <action android:name="com.jay.example.service.TEST_SERVICE1"/>  
            </intent-filter>  
</service>  

Далее — простой файл разметки с двумя кнопками, и наконец MainActivity. В обработчиках нажатия кнопок вызывайте соответственно startService() и stopService()!

public class MainActivity extends Activity {  
  
    private Button start;  
    private Button stop;  
      
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
          
        start = (Button) findViewById(R.id.btnstart);  
        stop = (Button) findViewById(R.id.btnstop);  
        //创建启动Service的Intent,以及Intent属性  
        final Intent intent = new Intent();  
        intent.setAction("com.jay.example.service.TEST_SERVICE1");  
        //为两个按钮设置点击事件,分别是启动与停止service  
        start.setOnClickListener(new OnClickListener() {              
            @Override  
            public void onClick(View v) {  
                startService(intent);                 
            }  
        });  
          
        stop.setOnClickListener(new OnClickListener() {           
            @Override  
            public void onClick(View v) {  
                stopService(intent);  
                  
            }  
        });  
    }  
}

Скриншот выполнения:

Нажмите, чтобы запустить Service:

От нечего делать нажмите ещё несколько раз:

Наконец, нажмите, чтобы остановить Service:

Анализ результатов:

Из приведённых выше результатов выполнения мы можем проверить то, что было объяснено на нашей диаграмме жизненного цикла: мы видим, что метод onBind() не вызывается. Кроме того, многократное нажатие для запуска Service будет только повторно вызывать метод onStartCommand! Сколько бы раз мы ни запускали Service, один stopService остановит Service!


2) Проверка порядка запуска Service с помощью BindService:

Прежде чем начать писать код, нам нужно сначала разобраться с несколькими вещами: во-первых, это метод bindService класса Context, приведённый под первой большой диаграммой:

  • Объект ServiceConnection: отслеживает соединение между клиентом и Service. Если соединение успешно, происходит обратный вызов onServiceConnected(). Если соединение аварийно завершается или по иным причинам Service отключается от клиента, происходит обратный вызов метода onServiceDisconnected. Вызов unBindService() не приведёт к вызову этого метода!
  • В методе onServiceConnected есть объект IBinder, который можно использовать для взаимодействия с привязанным Service! Когда мы разрабатываем класс Service, нам нужно по умолчанию реализовать метод IBinder onBind(). Объект IBinder, возвращаемый этим методом, передаётся в параметр onServiceConnected объекта ServiceConnection. Здесь мы можем взаимодействовать с Service через этот IBinder!

Итог:
Шаг 1:В пользовательском Service наследуйте Binder, чтобы реализовать собственный объект IBinder.
Шаг 2:Верните собственный объект IBinder через метод onBind().
Шаг 3:В классе, который привязывает Service, определите объект ServiceConnection и переопределите два метода — onServiceConnected и onDisconnected! Затем просто напрямую прочитайте параметры, переданные через IBinder!

Хорошо, далее напишем код для проверки. Здесь мы определим Service для измерения времени, а затем продемонстрируем использование BindService и поток вызовов методов! Код относительно простой, поэтому мы не будем его объяснять!

TestService2.java:

public class TestService2 extends Service {  
    private final String TAG = "TestService2";  
    private int count;  
    private boolean quit;  
      
    //定义onBinder方法所返回的对象  
    private MyBinder binder = new MyBinder();  
    public class MyBinder extends Binder  
    {  
        public int getCount()  
        {  
            return count;  
        }  
    }  
      
    //必须实现的方法,绑定改Service时回调该方法  
    @Override  
    public IBinder onBind(Intent intent) {  
        Log.i(TAG, "onBind方法被调用!");  
        return binder;  
    }  
  
    //Service被创建时回调  
    @Override  
    public void onCreate() {  
        super.onCreate();  
        Log.i(TAG, "onCreate方法被调用!");  
        //创建一个线程动态地修改count的值  
        new Thread()  
        {  
            public void run()   
            {  
                while(!quit)  
                {  
                    try  
                    {  
                        Thread.sleep(1000);  
                    }catch(InterruptedException e){e.printStackTrace();}  
                    count++;  
                }  
            };  
        }.start();  
          
    }  
      
    //Service断开连接时回调  
    @Override  
    public boolean onUnbind(Intent intent) {  
        Log.i(TAG, "onUnbind方法被调用!");  
        return true;  
    }  
      
    //Service被关闭前回调  
    @Override  
    public void onDestroy() {  
        super.onDestroy();  
        this.quit = true;  
        Log.i(TAG, "onDestroyed方法被调用!");  
    }  
      
    @Override  
    public void onRebind(Intent intent) {  
        Log.i(TAG, "onRebind方法被调用!");  
        super.onRebind(intent);  
    }  
} 

Зарегистрируйте компонент Service в AndroidManifest.xml:

<service android:name=".TestService2" android:exported="false">  
        <intent-filter>  
            <action android:name="com.jay.example.service.TEST_SERVICE2"/>  
        </intent-filter>  
</service>  

MainActivity.java:

public class MainActivity extends Activity {  
  
    private Button btnbind;  
    private Button btncancel;  
    private Button btnstatus;  
      
    //保持所启动的Service的IBinder对象,同时定义一个ServiceConnection对象  
    TestService2.MyBinder binder;  
    private ServiceConnection conn = new ServiceConnection() {  
          
        //Activity与Service断开连接时回调该方法  
        @Override  
        public void onServiceDisconnected(ComponentName name) {  
            System.out.println("------Service DisConnected-------");  
        }  
          
        //Activity与Service连接成功时回调该方法  
        @Override  
        public void onServiceConnected(ComponentName name, IBinder service) {  
            System.out.println("------Service Connected-------");  
            binder = (TestService2.MyBinder) service;  
        }  
    };  
      
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
        btnbind = (Button) findViewById(R.id.btnbind);  
        btncancel = (Button) findViewById(R.id.btncancel);  
        btnstatus  = (Button) findViewById(R.id.btnstatus);  
        final Intent intent = new Intent();  
        intent.setAction("com.jay.example.service.TEST_SERVICE2");  
        btnbind.setOnClickListener(new OnClickListener() {            
            @Override  
            public void onClick(View v) {  
                //绑定service  
                bindService(intent, conn, Service.BIND_AUTO_CREATE);                  
            }  
        });  
          
        btncancel.setOnClickListener(new OnClickListener() {  
            @Override  
            public void onClick(View v) {  
                //解除service绑定  
                unbindService(conn);                  
            }  
        });  
          
        btnstatus.setOnClickListener(new OnClickListener() {  
            @Override  
            public void onClick(View v) {  
                Toast.makeText(getApplicationContext(), "Service的count的值为:"  
                        + binder.getCount(), Toast.LENGTH_SHORT).show();  
            }  
        });  
    }  
}  

Скриншот выполнения:

Нажмите, чтобы привязать Service:

Продолжаем нажимать привязку: без изменений.

Получите текущий статус Service:

Отвязать:

Если мы напрямую закроем Activity после привязки, появится ошибка, а затем автоматически вызовутся методы onUnbind и onDestroy!

。。。

Из приведённых выше результатов выполнения подтверждается следующее на диаграмме жизненного цикла:

При использовании BindService для привязки Service вызываются по порядку методы onCreate() и onBind(). В методе onBind() можно вернуть пользовательский объект IBinder. Затем вызывается метод onServiceConnected() объекта ServiceConnection, в котором можно получить объект IBinder для соответствующих операций. Когда Service отвязывается, автоматически вызываются методы onUnbind и onDestroy. Конечно, если привязано несколько клиентов, необходимо отвязать их всех, прежде чем будет вызван метод onDestroy для уничтожения!