Service

什么是服务？

windows下的服务：没有界面、长期运行在后台的应用程序；
android下的服务：应用程序的一个组件，没有界面activity，长期运行在后台；

进程：是应用程序运行的载体。
进程与应用程序之间的关系： linux操作系统创建一个进程，这个进程负责运行dalvik虚拟机,Android的应用程序都是运行在dalvik虚拟机上的。

进程的生命周期：

1、应用程序一启动的时候就创建了进程；
2、当应用程序退出的时候进程并没有退出；
3、只有手工停止这个进程，进程才会结束；如果是自动关闭，内存充足就会重启。

操作系统尽量长时间的运行应用程序的进程，为了保证内从空间不被大量占用，它会按照进程的优先级，从低到高一级一级的杀死进程，直到内存空间被清理的差不多。

进程的等级：

1. Foreground process（前台进程）

应用程序，用户正在操作，activity的onResume方法被执行了，可以相应点击事件。(onResume)

2. Visible process （可视进程）

应用程序的ui界面，用户还可以看到，但是不能操作了。(onPause)

3. Service process （服务进程）

应用程序没有界面，但是有一个后台的服务还处于运行状态.

4. Background process（后台进程）

应用程序没有服务处于运行状态，应用程序被最小化了，activity执行了onstop方法.(onStop)

5. Empty process （空进程）

没有任何组件运行，所有的activity都关闭了，任务栈清空了

服务的特点

服务被创建时调用onCreate、onStartCommand；
服务只能被创建一次，可以开启多次onStartCommand；
服务只能被停止一次 onDestroy;
没有onPause、onStop、onResume、onRestart方法，因为service没有界面，长期运行在后台。

生命周期的方法：

onCreate()--->onStartCommand()--->onDestroy()(stopService())

onCreate:服务被创建的时候调用这个方法；
onStartCommand ：开启服务
onDestroy：销毁服务

电话qietingqi的模板代码(重点)

步骤：

1、在工程中添加一个服务Service，重写onCreate方法；

2、在清单文件中配置服务；

3、在activity中开启服务，在onCreate方法中使用TelephonyManager监听电话的状态；

4、创建一个广播接收者，开机即开启录音服务；

5、在清单文件中配置广播接收者

6、在清单配置文件中添加权限

代码：

package com.ahu.lichang.recorderservice;

import android.app.Service;
import android.content.Intent;
import android.media.MediaRecorder;
import android.os.IBinder;
import android.support.annotation.Nullable;
import android.telephony.PhoneStateListener;
import android.telephony.TelephonyManager;

/**
 * Created by ahu_lichang on 2017/3/24.
 */
public class RecorderService extends Service{
    private MediaRecorder recorder;
    /**
     * 绑定服务时，要调用此方法
     * @param intent
     * @return
     */
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    /**
     * 创建服务时，调用此方法
     */
    @Override
    public void onCreate() {
        super.onCreate();
        //拿到系统服务电话管理器
        TelephonyManager tm = (TelephonyManager) getSystemService(TELEPHONY_SERVICE);
        //监听电话状态
        tm.listen(new MyPhoneStateListener(), PhoneStateListener.LISTEN_CALL_STATE);
    }
    class MyPhoneStateListener extends PhoneStateListener {
        @Override
        public void onCallStateChanged(int state, String incomingNumber) {
            super.onCallStateChanged(state, incomingNumber);
            switch (state){
                case TelephonyManager.CALL_STATE_IDLE://空闲状态
                    if(recorder != null){
                        recorder.stop();
                        recorder.release();
                        recorder = null;
                    }
                    break;
                case TelephonyManager.CALL_STATE_RINGING://响铃状态
                    if(recorder == null){
                        //创建录音机
                        recorder = new MediaRecorder();
                        //设置声音来源
                        recorder.setAudioSource(MediaRecorder.AudioSource.MIC);//MIC:只能录自己的声音
                        //设置音频文件格式
                        recorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);
                        recorder.setOutputFile("storage/sdcard/luyin.3gp");
                        //设置音频文件编码
                        recorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);
                        try {
                            recorder.prepare();
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                    break;
                case TelephonyManager.CALL_STATE_OFFHOOK://摘机状态
                    if(recorder != null){
                        recorder.start();
                    }
                    break;
            }
        }
    }

    /**
     * 开启服务时，调用此方法
     * @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();
    }
}

package com.ahu.lichang.recorderservice;

import android.content.Intent;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;

public class MainActivity extends AppCompatActivity {

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

    public void click(View view){
        Intent intent = new Intent(this,RecorderService.class);
        startService(intent);
    }
}

package com.ahu.lichang.recorderservice;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;

/**
 * Created by ahu_lichang on 2017/3/24.
 */

public class RecorderReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        //开机启动时，开启录音服务
        Intent i = new Intent(context,RecorderService.class);
        context.startService(i);
    }
}

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.ahu.lichang.recorderservice">
    <uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS"/>
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
    <uses-permission android:name="android.permission.READ_PHONE_STATE"/>
    <uses-permission android:name="android.permission.RECORD_AUDIO"/>

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

        <receiver android:name=".RecorderReceiver">
            <intent-filter>
                <!--开机启动-->
                <action android:name="android.intent.action.BOOT_COMPLETED"/>
            </intent-filter>
        </receiver>

        <service android:name=".RecorderService">
        </service>
    </application>

</manifest>

服务的两种开启方式：

1、startService方式开启服务

服务启动之后，跟启动他的组件没有关系。该方法启动的服务所在进程属于服务进程。

2、bindService方式开启服务（重点）

bindService绑定服务、unBindService解除绑定的服务；
服务是在被绑定的时候被创建，调用oncreate、onbind方法；
服务只能被绑定一次；
服务只能被解除一次，解除绑定的时候调用onUnbind、onDestrory方法，如果多次解除绑定会抛出异常；

推荐的方式：跟他启动的组件同生共死，该方法启动的服务所在进程不属于服务进程

startService：开启并创建一个服务，服务长期运行在后台；
bindService:绑定服务，可以调用服务里面的方法；
unBindService：解除服务，停止服务里面的方法；
stopService：停止服务，销毁服务对象；

为什么要引入bindservice的API？

为了调用服务中的业务逻辑方法。

绑定服务调用服务方法的过程

通过bindservice方式实现调用服务里面业务逻辑方法：
步骤：

1、在服务类中创建一个中间人MyBinder，继承了Binder，Binder实现了IBinder接口：

public class MyBinder extends Binder{

}

2、在服务类里面创建了一个MyBinder的成员变量：
      private MyBinder myBinder;

3、在MyBinder类中写一个方法用于调用服务的业务逻辑方法：
      public class MyBinder extends Binder{

      //使用中间人调用服务里的方法
      public void callMethodInService(){
               methodInService();
       }

     }

4、在activity中bindService时，定义了ServiceConnection，在这个连接中实现了两个方法：

            private class MyConn implements ServiceConnection {

    /**
    * 服务连接成功时调用这个方法
    */
    @Override
    public void onServiceConnected(ComponentName name, IBinder service) {
                    //得到服务绑定成功后返回的中间人MyBinder对象
                    myBinder = (MyBinder) service;

     }

    /**
     * 服务断开成功时调用这个方法
     */
    @Override
     public void onServiceDisconnected(ComponentName name) {
            System.out.println("-------onServiceDisconnected-------");

     }

}

5、通过在activity中通过中间人调用服务的业务逻辑方法：
            myBinder.callMethodInService();

绑定服务抽取接口（重点）

接口（interface）： 对外开放暴露的功能，但是不会暴露功能实现的细节；
让中间人实现服务接口的目的：只对外暴露接口里面业务逻辑方法，隐藏中间人里面的其他方法；

步骤：

1、创建一个服务的接口类，里面包含需要对外暴露的业务逻辑方法：
public interface IService {
　　public void callMethodInService();
}

2、让服务中的中间人实现了服务的接口类：
　　private class MyBinder extends Binder implements IService{

　　//(实现服务接口中的方法)使用中间人调用服务里的方法
　　public void callMethodInService(){
　　　　methodInService();
　　　　}
　　}

3、在activity中声明接口的成员变量：
　　private IService myBinder;

4、强制转换成服务的接口类型
　　private class MyConn implements ServiceConnection {

　　/**
　　* 服务连接成功时调用这个方法
　　*/
　　@Override
　　public void onServiceConnected(ComponentName name, IBinder service) {
　　　　//强制转换成服务的接口类型
　　　　myBinder = (IService) service;
　　}

5、在activity中通过接口的成员变量调用服务的业务逻辑方法：
　　public void call(View view){
　　　　myBinder.callMethodInService();

　　}

案例：在activity里面不能直接去调用服务中的方法，所以要想调用服务里面的方法必须通过一个中间人，通过中间人的牵线才能去调用服务里的方法。

PublicBusiness接口是服务LeaderService的接口类，对象暴露出中间人的业务逻辑方法QianXian()，隐藏了中间人的其他方法daMaJiang()。

public interface PublicBusiness {

    void QianXian();
}

public class LeaderService extends Service {

    @Override
    public IBinder onBind(Intent intent) {
        // 返回一个Binder对象，这个对象就是中间人对象
        return new ZhouMi();
    }

    class ZhouMi extends Binder implements PublicBusiness{
        public void QianXian(){
            banZheng();//banZheng()方法是服务中的方法
        }
        
        public  void daMaJiang(){
            System.out.println("陪李处打麻将");
        }
    }
    
    public void banZheng(){
        System.out.println("李处帮你来办证");
    }
}

public class MainActivity extends Activity {

    private Intent intent;
    private MyServiceConn conn;
    PublicBusiness pb;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        intent = new Intent(this, LeaderService.class);
        conn = new MyServiceConn();
        //绑定领导服务
        bindService(intent, conn, BIND_AUTO_CREATE);
    }
    
    public void click(View v){
        //调用服务的办证方法
        pb.QianXian();
    }

    class MyServiceConn implements ServiceConnection{

        //连接服务成功，此方法调用
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            // TODO Auto-generated method stub
            pb = (PublicBusiness) service;
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            // TODO Auto-generated method stub
            
        }
        
    }
    
}

两种启动方式混合使用

用服务实现音乐播放时，因为音乐播放必须运行在服务进程中，可是音乐服务中的方法，需要被前台activity所调用，所以需要混合启动音乐服务。

//混合调用
//为了把服务所在进程变成服务进程
startService(intent);//先开启服务进程------------>只是在之前的程序中多了这句代码！！！
//为了拿到中间人对象
bindService(intent, new MusicServiceConn(), BIND_AUTO_CREATE);//拿到中间人对象

先startService,后bindService,销毁时先unbind,在stop。

绑定服务的应用场景

1、需要在后台运行一定的业务逻辑，而且需要与服务器端交互数据，都是写在服务里面的。
2、天气预报、股票行情软件；

利用服务注册广播接收者

操作频繁的广播事件，如果只是在清单配置文件配置，是不生效的。需要使用代码注册才能生效；

步骤：

// 1、得到广播接收者的对象

ScreenBroadCastReceiver screenReceiver = new ScreenBroadCastReceiver();

// 2、创建一个intentFilter对象
IntentFilter filter = new IntentFilter();

// 3、注册接收的事件类型
filter.addAction("android.intent.action.SCREEN_ON");
filter.addAction("android.intent.action.SCREEN_OFF");

// 4、注册广播接收者
this.registerReceiver(screenReceiver, filter);

远程服务aidl的写法（重点）

本地服务：写在自己的应用程序的工程里的服务 ，使用自己应用程序的进程运行这个服务；

远程服务：写在别的应用程序的工程里的服务，使用别的应用程序的进程运行这个服务（安装在同一个手机上的应用程序）；

IPC： Inter Process Communication（进程间的通讯）；

aidl: Android Interface definition language 安卓接口定义语言；安卓接口语言作用是用于跨进程间通信。
aidl的接口类里面不需要public 、protected、private 等修饰符，默认是公开共享；

步骤：

1、创建一个服务的接口类，里面包含需要对外暴露的业务逻辑方法

2、让服务中的中间人实现了服务的接口类

3、修改并拷贝接口文件

4、在本地服务的工程中的activity里，绑定服务
5、通过接口调用远程服务的方法