MyService

MyService.java

import android.app.Service;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Binder;
import android.os.IBinder;
import android.util.Log;

public class MyService extends Service {
    
    //该方法是 Service 类中定义的抽象方法，必须实现
    //用于获取该 Service 对象，如果返回  null，则意味着该 Service 不支持  bind
    
    @Override
    public IBinder onBind(Intent arg0) {
        Log.i("SINFO", "onBind running.");
        return new MyIBinder();
    }
    

    //自定义类 继承 Binder，供 onBind 方法使用
    class MyIBinder extends Binder{
        MyService getService(){
            return MyService.this;
        }
    }
    
    @Override
    public void onCreate() {
        Log.i("SINFO", "onCreate running.");
        super.onCreate();
    }
    
    @Override
    public void onDestroy() {
        Log.i("SINFO", "onDestroy running.");
        super.onDestroy();
    }
    
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.i("SINFO", "onStartCommand running.");
        return super.onStartCommand(intent, flags, startId);
    }
    
    @Override
    public boolean onUnbind(Intent intent) {
        Log.i("SINFO", "onUnbind running.");
        return super.onUnbind(intent);
    }

}

当 Activity 使用 bindService 方法，绑定 Service 时，并不能直接获取到 Service 对象，需要借助 ServiceConnection 对象。onServiceConnected 方法会在绑定成功时执行。其中参数 IBinder 就是 Service 对象中 onBind 方法返回的对象。获取到 Service 对象后，就可以执行其中的方法了。

启动一个 Service 有两种方法：调用 Context.startService() 或 Context.bindService。

（1）在同一个应用程序任何位置调用 startService() 方法都能启动 Service。系统回调 Service 类的 onCreate() 方法以及 onStart() 方法。这种方式启动的 Service 会一直运行在后台，直到调用 Context.stopService 或者 selfStop() 方法。如果一个 Service 已经被启动，其它代码再试图调用 startService() 方法启动 Service ，将不执行 onCreate()，而是重新执行一次 onstart() 方法。

（2）bindService() 方法也可以启动 Service，并把这个 Service 和调用 Service 的应用程序绑定起来。如果调用 Service 的应用程序类被销毁，Service 也将被销毁。使用这个方法的一个好处是：bindService() 方法执行后 Service 会回调 onBind() 方法，可以从这里返回一个实现了 IBinder 接口的类，在应用程序中就可以通过这个类和 Service 通信，得到 Service 运行的状态或其他操作。如果 Service 没有运行，使用这个方法启动 Service 会调用 onCreate() 方法，但不会调用 onStart() 方法。

//用于连接 Activity 和 Service
    ServiceConnection sc = new ServiceConnection(){
        
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            //通过IBinder对象获取Service对象
            MyService ms = ((MyService.MyIBinder)service).getService();
            //此处  调用Service对象中的相应方法 即可
        }
        
        @Override
        public void onServiceDisconnected(ComponentName name) {
            
        }
    };
        
    @Override
    public void onClick(View v) {
        
        if(v.getId() == R.id.bt_service1){
            Intent intent = new Intent(this, MyService.class);
            this.startService(intent);
        }
        else if(v.getId() == R.id.bt_service2){
            Intent intent = new Intent(this, MyService.class);
            this.stopService(intent);
        }
        else if(v.getId() == R.id.bt_service3){
            Intent intent = new Intent(this, MyService.class);
            //绑定Service
            this.bindService(intent, sc, BIND_AUTO_CREATE);
            isUnbind = true;
        }
        else if(v.getId() == R.id.bt_service4){
            //解除绑定
            if(isUnbind){
                this.unbindService(sc);
                isUnbind = false;
            }
        }        
    }

 Context.bindService 第一个参数指明绑定的 Service，第二个参数是 ServiceConnection 对象，可以看作是 Activity 与 Service 的桥梁，第三个参数是绑定时的方式。如果重复执行解除绑定操作，会抛出异常信息。

Service 的两种启动方法有可能出现交叉调用的情况。如果出现这种情况，需要按照启动的顺序依次调用与启动对应的结束方式。例如：先调用 startService() ，然后再调用 bindService()，启动并绑定 Service 可以达到既保持和 Service 的通信，又使得 Service 不会随着 Activity 的退出而退出。当不需要绑定时，先调用 unbindService() 方法，此时 Service 会执行 onUnbind()，但不会把这个 Service 销毁。只有再调用 stopService() 时，Service 才会销毁。

在 Manifest 文件中添加 Service 的相关信息。

<!-- service声明 -->
        <service android:name=".MyService" android:enabled="true"></service>

 Service 启动后会运行在主线程中，如果有耗时操作，可以在 Service 中开启线程。根据所使用的区域不同，Service 分为 Local Service 和 Remote Service。

（1）Local Service（本地服务）用于应用程序内部，当不需要与 Service 交互时，可以采用 Context.startService() 方式启动；需要和Service 交互时，采用 Context.bindService() 方式启动。

import java.io.IOException;

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

public class PlayerService extends Service {
    MediaPlayer player;
    
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }
    
    @Override
    public void onCreate() {
        super.onCreate();
    
        //指定播放音乐文件
        player = new MediaPlayer();
        try {
            player.setDataSource("/sdcard/music/my love.mp3");
            player.prepare();
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalStateException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    
    @Override
    public void onDestroy() {
        super.onDestroy();
    
        //停止播放，释放资源
        if(player != null){
            player.stop();
            player.release();
        }
        Log.i("INFO", "Service destroy!");
    }
    
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.i("INFO", "onStartCommand" );
        if(intent != null){
            int op = intent.getIntExtra("op", 0);
            Log.i("INFO", "op=" + op);
            if(op == 1){
                play();
            }else if(op == 2){
                pause();
            }else if(op == 3){
                stop();
            }
        }
        return super.onStartCommand(intent, flags, startId);
    }
    
    //播放控制的方法
    private void stop() {
        Log.i("INFO", "stop op");
        if(player != null){
            player.stop();
            try {
                player.prepare();
            } catch (IllegalStateException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
    
    private void pause() {
        Log.i("INFO", "pause op");
        if(player != null && player.isPlaying())
            player.pause();
    }
    
    private void play() {
        Log.i("INFO", "play op");
        if(!player.isPlaying())
            player.start();
    }
    
    @Override
    public boolean onUnbind(Intent intent) {
        return super.onUnbind(intent);
    }
}

Activity 启动 Service 让播放器工作在 Service 中，这样即使 Activity 退出，播放依然会继续。在启动 Service 时需要向 Service 中传入数据，可以借助 Intent 来实现。

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.ImageButton;

public class PlayerActivity extends Activity implements OnClickListener {
    
    ImageButton ib1,ib2,ib3;
    Intent intent;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        // TODO Auto-generated method stub
        super.onCreate(savedInstanceState);
    
        setContentView(R.layout.playerlayout);
        ib1=(ImageButton) findViewById(R.id.ib_play);
        ib1.setOnClickListener(this);
    
        ib2=(ImageButton) findViewById(R.id.ib_pause);
        ib2.setOnClickListener(this);
        
        ib3=(ImageButton) findViewById(R.id.ib_stop);
        ib3.setOnClickListener(this);
    }
    
    @Override
    public void onClick(View v) {
        
        intent = new Intent(this,PlayerService.class) ;
        switch (v.getId()){
        case R.id.ib_play:
            intent.putExtra("op", 1);
            break;
        case R.id.ib_pause:
            intent.putExtra("op", 2);
            break;
        case R.id.ib_stop:
            intent.putExtra("op", 3);
            break;
        }
        //启动Service
        startService(intent);
    }
    
    @Override
    protected void onDestroy() {
        super.onDestroy();
    }
}

（2）Remote Service（远程服务）可以让其他应用程序访问该服务（Android 各应用程序都是互相独立的，数据独享），实际上就是可以进程间通信（RPC），这时需要使用 Android 提供的接口描述语言（AIDL）来定义远程服务的接口。

import java.util.Random;

import com.freshen.service.MessageInterface;
import com.freshen.service.MessageInterface.Stub;

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.os.RemoteException;
import android.util.Log;

public class MessageService extends Service {
    static final String TAG = "Tag";
    
    //内部类继承AIDL自动生成类的内部类Stub，并实现AIDL中声明的方法
    private class MessageInterfaceImp extends MessageInterface.Stub{
        Random r = new Random();
        
        @Override
        public String getMessage() throws RemoteException {
            Log.i(TAG, "return msg");
            return "msg " + r.nextInt(100);
        }
    }
    
    @Override
    public IBinder onBind(Intent arg0) {
        Log.i(TAG, "onBind run.");
        //返回AIDL接口实现
        return new MessageInterfaceImp();
    }
    
    @Override
    public void onCreate() {
        Log.i(TAG, "onCreate run.");
        super.onCreate();
    }
    
    @Override
    public void onDestroy() {
        Log.i(TAG, "onDestroy run.");
        super.onDestroy();
    }
    
    @Override
    public boolean onUnbind(Intent intent) {
        Log.i(TAG, "onUnBind run.");
        return super.onUnbind(intent);
    }
}

MessageInterface.aidl 文件

interface MessageInterface{
    String getMessage();
}