Service Lifecycle

后台服务于Activity，服务不能自己运行,需要通过Context.startService()或Context.bindService()启动服务。
通过startService()方法启动的服务与调用者没有关系,即使调用者关闭了,服务仍然运行。
想停止服务要调用Context.stopService(),此时系统会调用onDestory()。
使用此方法启动时,服务首次启动系统先调用服务的onCreate()–>onStartCommand(),
如果服务已经启动再次调用只会触发onStartCommad()方法,销毁时调用onDestroy()方法;
使用bindService()启动的服务与调用者绑定,只要调用者关闭服务就终止。
使用此方法启动时,服务首次启动系统先调用服务的onCreate()–>onBind(),
如果服务已经启动再次调用不会再触发这2个方法,调用者退出时系统会调用服务的onUnbind()–>onDestory(),
想主动解除绑定可使用Contex.unbindService(),系统依次调用onUnbind()–>onDestory();
Android系统中运行Service两种方式：
1. 通过Context的bindService()方法启动Service，访问者与Service绑定在一起，访问者一旦退出，Service也就终止了。如果访问者与Service之间需要进行方法调用或交换数据，则应使用bindServiec()和unbindService()方法启动、关闭Service。对于Service的onBind()方法所返回的IBinder对象，可当作是Service的代领对象，Service允许Activity通过IBinder对象来访问Service内部数据，这样就实现Activity与Service之间的通信。

public class BindServie extends Service{

    private int count;
    private boolean quit = false;
    //定义onBinder方法所返回的对象
    private MyBinder binder = new MyBinder();

    class MyBinder extends Binder{
        public int getCount(){
            //获取Service的运行状态count
            return count;
        }
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        Log.i("lifecycle","Service is Binded");
        return binder;
    }

    //Service被创建时回调该方法
    @Override
    public void onCreate() {
        super.onCreate();
        Log.i("lifecycle","Service is Create");
        new Thread(){
            @Override
            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("lifecycle","Service is Unbinded");
        return true;
    }

    //Service被关闭之前回调该方法
    @Override
    public void onDestroy() {
        super.onDestroy();
        this.quit = true;
        Log.i("lifecycle","Service is Destroy");
    }
}

public class MainActivity extends AppCompatActivity {

    Button bind,unbind,getServiceStatus;
    BindServie.MyBinder binder;

    private ServiceConnection conn = new ServiceConnection() {

        //当Activity与Service连接成功时回调该方法
        @Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
            Log.i("lifecycle","-----Service Connected-----");
            //获取Service的onBind方法所返回的MyBinder对象
            binder = (BindServie.MyBinder)iBinder;
        }

        //当Activity与Service断开连接时回调该方法
        @Override

        public void onServiceDisconnected(ComponentName componentName) {
            Log.i("lifecycle","-----Service Disconnected-----");
        }
    };
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Log.i("lifecycle","Activity onCreate");
        bind = (Button)findViewById(R.id.bindserviceBtn);
        unbind = (Button)findViewById(R.id.unbindserviceBtn);
        getServiceStatus = (Button)findViewById(R.id.getBtn);
        final Intent intent = new Intent(this,BindServie.class);
        bind.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
/*
intent指定要启动的Service
conn是一个ServiceConnection对象，监听访问者与Service之间的连接情况。连接成功则调用
onServiceConnected()方法；当Service所在的宿主进程由于异常中止或其他原因中止，导致
该Service与访问者之间断开连接时回调onServiceDisconnected()方法
Service.BIND_AUTO_CREATE自动创建Service
*/
                bindService(intent,conn, Service.BIND_AUTO_CREATE);
            }
        });
        unbind.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                unbindService(conn);
            }
        });

        getServiceStatus.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Toast.makeText(MainActivity.this,"Service的count值为：" + binder.getCount(),
                        Toast.LENGTH_SHORT).show();
            }
        });
    }
}

注：onBind()方法所返回的IBinder对象将传到onServiceConnected()方法的iBinder参数。

运行结果分析：
启动app
09-19 10:59:24.245 28247-28247/? I/lifecycle: Activity onCreate

点击绑定Service按钮
10:59:57.285 28247-28247/servicedemo.example.com.myapplication I/lifecycle: Service is Create
10:59:57.295 28247-28247/servicedemo.example.com.myapplication I/lifecycle: Service is Binded
10:59:57.295 28247-28247/servicedemo.example.com.myapplication I/lifecycle: -----Service Connected-----

点击解除绑定按钮
 28247-28247/servicedemo.example.com.myapplication I/lifecycle: Service is Unbinded
 28247-28247/servicedemo.example.com.myapplication I/lifecycle: Service is Destroy

当调用着主动通过unBindService()方法断开与Service的连接时，ServiceConnection对象中的
onServiceDisconnected()方法并不会被调用

1. 通过Context的startService()方法启动Service，访问者与Service之间没有关联，即使访问者已经退出了，Service仍然运行。

public class MainActivity extends AppCompatActivity {

    Button start,stop;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Log.i("lifecycle","Activity onCreate");
        start = (Button)findViewById(R.id.startBtn);
        stop = (Button)findViewById(R.id.stopBtn);
        final Intent intent = new Intent(this,FirstService.class);
        start.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                startService(intent);
            }
        });
        stop.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                stopService(intent);
            }
        });
    }
}

public class FirstService extends Service
{
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        Log.i("lifecycle","Service onBind");
        return null;
    }

    @Override
    public void onCreate() {
        super.onCreate();
        Log.i("lifecycle","Service onCreate");
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.i("lifecycle","Service onStartCommand");
        return super.onStartCommand(intent, flags, startId);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.i("lifecycle","Service onDestroy");
    }
}

运行结果：
app启动
09-19 09:26:03.515 30210-30210/servicedemo.example.com.myapplication I/lifecycle: Activity onCreate

点击start按钮
09:26:09.415 30210-30210/servicedemo.example.com.myapplication I/lifecycle: Service onCreate
09:26:09.415 30210-30210/servicedemo.example.com.myapplication I/lifecycle: Service onStartCommand

点击stop按钮
09-19 09:26:14.235 30210-30210/servicedemo.example.com.myapplication I/lifecycle: Service onDestroy

连续点击start按钮
09:37:15.405 30210-30210/servicedemo.example.com.myapplication I/lifecycle: Service onStartCommand
09:37:16.275 30210-30210/servicedemo.example.com.myapplication I/lifecycle: Service onStartCommand

结果分析，每当Service被创建时会回调onCreate()方法，每次Service被启动时都会回调onStartComman()方法。
多次启动一个已有的Service组件不会再调用onCreate()方法，但每次启动时都会回调onStartCommand()。