Service服务相关（1）

Service，服务，是android四大组件之一。使用场景：
1.一般用于执行长时间的事务。
2.可以在用户不可见的状态下处理事务。

使用：
1）通过 startService(intentS)方式启动服务：

package wy.bzt.com.phonehelper.service;

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.support.annotation.Nullable;
import android.util.Log;

/**
 * Created by wuyong on 2016/7/18.
 */
public class MyService extends Service {
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    @Override
    public void onCreate() {
        super.onCreate();
        Log.d("ss","service onCreate");
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.d("ss","service onStartCommand");
        return super.onStartCommand(intent, flags, startId);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.d("ss","service onDestroy");
    }
}

在activity中：

 intentS=new Intent(this, MyService.class);
        startService(intentS);

第一次启动服务，调用onCreate，onStartCommand，之后再启动服务，只会调用onStartCommand；注销服务，只需要stopService(intentS)，或者在service中stopSelf（）。

2）通过bind方式启动服务

public class MyBindService extends Service {

    @Override
    public void onCreate() {
        super.onCreate();
        Log.d("bbb","onCreate");
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        Log.d("bbb","onBind");
        return new MyBinder();

    }


    @Override
    public boolean onUnbind(Intent intent) {
        Log.d("bbb","onUnbind");
        return super.onUnbind(intent);
    }


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

    public class MyBinder extends Binder{

        public MyBindService getBindService(){
            return MyBindService.this;
        }
    }
}

在activity中：

MyServiceConnection myServiceConnection;
    MyBindService.MyBinder myBinder;
    MyBindService bindService;
    Intent bindintent;
    boolean bind;
    class MyServiceConnection implements ServiceConnection {

        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {

            myBinder= (MyBindService.MyBinder) service;
            bindService=myBinder.getBindService();

            bind=true;
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            bind=false;
        }
    }

 bindintent=new Intent(this,MyBindService.class);
        bindService(bindintent,myServiceConnection,Context.BIND_AUTO_CREATE);

启动bindservice会调用onCreate，onBind方法，之后再启动的话，不会进行回调，调用unbindService(myServiceConnection)会触发onUnbind和onDestroy，事实上，用bind方式启动服务时，服务的生命周期会跟随activity的生命周期，activity结束，服务也自动结束。

一种常用的写法是：activity中启动服务，在服务中添加延时启动功能，到时候通过intent启动广播，广播中可以继续跳转至service（一般通过startservice方法），可以不断触发onStartCommand方法，达到某种目的；或者在activity中延时发送广播，在广播中启动服务，服务中开线程处理事务等等。

一个常用的类：intentservice
在studio中系统的例子：

public class MyIntentService extends IntentService {
    // TODO: Rename actions, choose action names that describe tasks that this
    // IntentService can perform, e.g. ACTION_FETCH_NEW_ITEMS
    private static final String ACTION_FOO = "wy.bzt.com.phonehelper.service.action.FOO";
    private static final String ACTION_BAZ = "wy.bzt.com.phonehelper.service.action.BAZ";

    // TODO: Rename parameters
    private static final String EXTRA_PARAM1 = "wy.bzt.com.phonehelper.service.extra.PARAM1";
    private static final String EXTRA_PARAM2 = "wy.bzt.com.phonehelper.service.extra.PARAM2";

    public MyIntentService() {
        super("MyIntentService");
    }

    /**
     * Starts this service to perform action Foo with the given parameters. If
     * the service is already performing a task this action will be queued.
     *
     * @see IntentService
     */
    // TODO: Customize helper method
    public static void startActionFoo(Context context, String param1, String param2) {
        Intent intent = new Intent(context, MyIntentService.class);
        intent.setAction(ACTION_FOO);
        intent.putExtra(EXTRA_PARAM1, param1);
        intent.putExtra(EXTRA_PARAM2, param2);
        context.startService(intent);
    }

    /**
     * Starts this service to perform action Baz with the given parameters. If
     * the service is already performing a task this action will be queued.
     *
     * @see IntentService
     */
    // TODO: Customize helper method
    public static void startActionBaz(Context context, String param1, String param2) {
        Intent intent = new Intent(context, MyIntentService.class);
        intent.setAction(ACTION_BAZ);
        intent.putExtra(EXTRA_PARAM1, param1);
        intent.putExtra(EXTRA_PARAM2, param2);
        context.startService(intent);
    }

    @Override
    protected void onHandleIntent(Intent intent) {
        if (intent != null) {
            final String action = intent.getAction();
            if (ACTION_FOO.equals(action)) {
                final String param1 = intent.getStringExtra(EXTRA_PARAM1);
                final String param2 = intent.getStringExtra(EXTRA_PARAM2);
                handleActionFoo(param1, param2);
            } else if (ACTION_BAZ.equals(action)) {
                final String param1 = intent.getStringExtra(EXTRA_PARAM1);
                final String param2 = intent.getStringExtra(EXTRA_PARAM2);
                handleActionBaz(param1, param2);
            }
        }
    }

    /**
     * Handle action Foo in the provided background thread with the provided
     * parameters.
     */
    private void handleActionFoo(String param1, String param2) {
        // TODO: Handle action Foo
        throw new UnsupportedOperationException("Not yet implemented");
    }

    /**
     * Handle action Baz in the provided background thread with the provided
     * parameters.
     */
    private void handleActionBaz(String param1, String param2) {
        // TODO: Handle action Baz
        throw new UnsupportedOperationException("Not yet implemented");
    }
}

其中需要注意的是：
1.onHandlerIntent默认在新的线程中运行，不需要再另外启动线程处理事务；
2.IntentService处理事务是按照队列一个个处理；
3.处理完成后，会自动结束service，不需要自己去关闭。

service的特点：
1.本身运行在所在进程的主线程，一般启动服务是为了处理长期事务，则需要在服务中启动线程处理，往往IntentService是更好的选择；

2.service 通过start方式启动后，如果不主动关闭，会一直在后台运行，很多时候会引起用户不满，所以最好在不需要的时候关掉它；

eg:
在activity中定时，一段时间后弹出个通知，点击通知，弹出个活动窗口；
关键代码：

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.d("ss","service onStartCommand");

        NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(getApplicationContext())
                .setSmallIcon(R.mipmap.ic_launcher)
                .setContentTitle("new message")
                .setContentText("aaaaaaaa");
        mBuilder.setTicker("New message");//提示消息，显示在通知栏上，一会消失
        mBuilder.setNumber(12);
        //mBuilder.setLargeIcon();
        mBuilder.setAutoCancel(true);//自己维护通知的消失

        Intent resultIntent = new Intent(getApplicationContext(),MyActivity.class);
        PendingIntent resultPendingIntent = PendingIntent.getActivity(
                getApplicationContext(), 0, resultIntent,
                PendingIntent.FLAG_UPDATE_CURRENT);
        // 设置通知主题的意图
        mBuilder.setContentIntent(resultPendingIntent);
        //获取通知管理器对象
        NotificationManager mNotificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
        mNotificationManager.notify(0, mBuilder.build());

        return super.onStartCommand(intent, flags, startId);
    }