Service几种情况介绍和使用

普通Service 后来运行执行普通操作
如果需要执行耗时操作必须开启线程
IntentService 自带线程可以执行耗时操作，不需开启线程

普通Service

1.startService()
2.stopService()

Service先执行onCreate方法 在执行onstartCommand 方法

如果执行stopService() Service 会执行 onDestory()

onStartCommand()方法必须返回一个整数，这个整数是一个描述了在系统的杀死事件中，系统应该如何继续这个服务的值

START_NOT_STICKY
如果系统在onStartCommand()方法返回之后杀死这个服务，那么直到接受到新的Intent对象，这个服务才会被重新创建。这是最安全的选项，用来避免在不需要的时候运行你的服务。

START_STICKY
如果系统在onStartCommand()返回后杀死了这个服务，系统就会重新创建这个服务并且调用onStartCommand()方法，但是它不会重新传递最后的Intent对象，系统会用一个null的Intent对象来调用onStartCommand()方法，在这个情况下，除非有一些被发送的Intent对象在等待启动服务。这适用于不执行命令的媒体播放器（或类似的服务），它只是无限期的运行着并等待工作的到来。

START_REDELIVER_INTENT
如果系统在onStartCommand()方法返回后，系统就会重新创建了这个服务，并且用发送给这个服务的最后的Intent对象调用了onStartCommand()方法。任意等待中的Intent对象会依次被发送。这适用于那些应该立即恢复正在执行的工作的服务，如下载文件

 Intent intent = new Intent(this, MusicService.class);
        intent.putExtra("action", "play");
        startService(intent);

package example.li_yuweii.servicedemmo.service;

import android.app.Service;
import android.content.Intent;
import android.media.MediaPlayer;
import android.net.Uri;
import android.os.IBinder;
import android.support.annotation.Nullable;
import android.util.Log;

import java.io.IOException;

import example.li_yuweii.servicedemmo.R;

/**
 * Created by li-yuweii on 16-9-21.
 */
public class MusicService extends Service {
    private MediaPlayer player;
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    @Override
    public void onCreate() {
        super.onCreate();
        //使用音乐资源来创建MediaPlayer，可以直接播放
//        player = MediaPlayer.create(this, R.raw.nobody);

        player = new MediaPlayer();
        //设置远程，文件网址
        try {
            player.setDataSource(this, Uri.parse("http://10.0.153.160:8080/nobody.mp3"));
            //设置准备歌曲资源，开启线程，加载网络数据
            player.prepareAsync();
//            player.setOnPreparedListener();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 服务启动的时候，调用startService()的时候，都会调用这个方法
     * 可以认为这个方法就是来接收其他组件传递的参数
     * @param intent  是startService()中的参数
     * @param flags
     * @param startId
     * @return  int 返回值能够控制服务是否自动复活，在程序意外终止的情况下
     */
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.d("MusicService", "onStartCommand: ");
        if (intent != null) {
            String action = intent.getStringExtra("action");
            if ("play".equals(action)) {
                player.start();
            } else if ("pause".equals(action)) {
                player.pause();
            }
        }

        return START_REDELIVER_INTENT; //模式
    }

    @Override
    public void onDestroy() {
        Log.d("MusicService", "onDestroy: ");
        //释放各种资源
        if (player.isPlaying()) {
            player.stop();
        }
        player.release();
        player = null;
        super.onDestroy();
    }
}

IntentService

发送意图开启service，传递值

        String s = mTextUrl.getText().toString();
        Intent intent = new Intent(this, DownloadService.class);
        intent.putExtra("url", s);
        startService(intent);

public class DownloadIntentService extends IntentService {

    /**
     * IntentService 内部包含一个线程，线程会一直处理Intent参数
     * 每一次startService 传递的Intent，都自动传递给线程，队列中保存，依次处理
     * 这个方法在子线程执行
     * @param intent
     */
    @Override
    protected void onHandleIntent(Intent intent) {
        String url = intent.getStringExtra("url");
        if (url != null) {
            //TODO: 下载文件，保存文件
        }
        Log.d("DownloadIntentService", "onHandleIntent: " + url);
        SystemClock.sleep(3000);

    }
}

BindService

发送意图

    bindService(intent, this, BIND_AUTO_CREATE);

service 里 写内部类 集成Bind onBind方法 返回内部类对象
发送意图方 可以接收到返回的对象

package example.li_yuweii.servicedemmo;

import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.IBinder;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.ProgressBar;
import android.widget.TextSwitcher;

import example.li_yuweii.servicedemmo.service.MusicBindService;

public class MusicActivity extends AppCompatActivity implements ServiceConnection,Runnable {

    private MusicBindService.MusicController mController;
    private ProgressBar mProgressBar;
    private boolean running;
    private Thread mThread;
    private TextSwitcher mTextSwitcher;

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

        mProgressBar = (ProgressBar) findViewById(R.id.music_progress);
        mTextSwitcher = (TextSwitcher) findViewById(R.id.textswitcher);
        mTextSwitcher.setInAnimation(this,android.R.anim.fade_in);


        //绑定服务，使用Context绑定，哪个界面需要绑定，就用哪个Activity

        Intent intent = new Intent(this, MusicBindService.class);

        //参数1 Intent代表需要绑定哪一个Service
        //参数2.回调接口，可以接收到Service连接成功和断开连接的回调
        //成功就可以取到对象
        //绑定服务，参数2就是服务和指定的对象绑定在一起
        bindService(intent, this, BIND_AUTO_CREATE);
    }

    @Override
    protected void onStart() {
        super.onStart();
        mThread = new Thread(this);
        mThread.start();
    }

    @Override
    protected void onStop() {
        super.onStop();
        running = false;
    }

    @Override
    protected void onDestroy() {
        //解除绑定
        unbindService(this);
        super.onDestroy();
    }
    //----------------------------------------

    @Override
    public void run() {
        running = true;
        try {
            while (running) {
                if (mController != null) {
                    long duration = mController.getDuration();
                    long currentPosition = mController.getCurrentPosition();
                    mProgressBar.setMax(((int) duration));
                    mProgressBar.setProgress(((int) currentPosition));
                    String time = currentPosition + "/" + duration;
                    mTextSwitcher.setText(time);

                    mTextSwitcher.post(new Runnable() {
                        @Override
                        public void run() {

                        }
                    });
                }
                Thread.sleep(300);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    //----------------------------------------
    public void btnMusicPlay(View view) {
        if (mController != null) {
            mController.play();
        }
    }

    public void btnMusicPause(View view) {
        if (mController != null) {
            mController.pause();
        }
    }

    //-----------------------------------------------
    //服务绑定与解除绑定的回调

    /**
     * 当服务与当前绑定对象，绑定成功，服务的onBind方法，调用并返回之后，回调给这个方法
     * @param name
     * @param service  IBind就是 服务onBind返回的对象
     */
    @Override
    public void onServiceConnected(ComponentName name, IBinder service) {
        mController = ((MusicBindService.MusicController) service);

    }

    @Override
    public void onServiceDisconnected(ComponentName name) {
        mController = null;
    }
}

BindService

package example.li_yuweii.servicedemmo.service;

import android.app.Service;
import android.content.Intent;
import android.media.MediaPlayer;
import android.os.Binder;
import android.os.IBinder;

import example.li_yuweii.servicedemmo.R;

public class MusicBindService extends Service {
    private MediaPlayer mPlayer;

    public MusicBindService() {
    }


    @Override
    public void onCreate() {
        super.onCreate();
        mPlayer = MediaPlayer.create(this, R.raw.nobody);
    }

    /*
     * 绑定服务的实现流程
     * 1.服务 onCreate，onBind，onDestory 方法
     * 2.onBind方法 需要返回一个IBinder对象，
     * 3.如果Activity绑定，Activity就可以取到IBind对象，可以直接调用对象的方法
     */
    //相同应用内部不同组件绑定，可以使用内部类以及Binder对象来返回
    public class MusicController extends Binder {
        public void play() {
            mPlayer.start();
        }

        public void pause() {
            mPlayer.pause();
        }

        public long getDuration() {
            return mPlayer.getDuration();
        }

        public long getCurrentPosition() {
            return mPlayer.getCurrentPosition();
        }
    }

    /**
     * 当绑定服务的时候自动回调这个方法，
     * 返回的对象可以直接操作Service内部的内容
     * @param intent
     * @return
     */
    @Override
    public IBinder onBind(Intent intent) {
        // TODO: Return the communication channel to the service.
        return new MusicController();
    }

    /**
     * 任意一次unbindService()方法，都会触发这个方法
     * 用于释放一些绑定时使用的资源
     * @param intent
     * @return
     */
    @Override
    public boolean onUnbind(Intent intent) {
        return super.onUnbind(intent);
    }

    @Override
    public void onDestroy() {
        if (mPlayer.isPlaying()) {
            mPlayer.stop();
        }
        mPlayer.release();
        mPlayer = null;
        super.onDestroy();
    }
}