【Android】- Android Service的两种启动方式

时间：2021-02-09 16:42:55

1.Service的第一种启动方式：

开启服务的步骤：

1-1 定义一个类继承Service，重写其onBind()的方法

@Override
public IBinder onBind(Intent intent) {
throw new UnsupportedOperationException("Not yet implemented");
}

1-2 在清单文件中进行配置

<service
    android:name=".MusicService"
    android:enabled="true"
    android:exported="true"></service>

1.3 在Context中开启服务startService(intent)开启服务

1.4不需要时，关闭服务stopService(intent)

此种开启服务的方式，在Service中的生命周期是：onCreate() --> onStartCommand() --> onDestory()

服务开启时onCreate()方法只会调用一次，再开启时不会再次调用onCreate()，只会调用onStartCommand()，

服务关闭后调用onDestory()方法。

startService方式开启服务，服务一旦开启就和开启者没有关系了，此时当开启者关闭时，服务还会在后台继续执行，

开启者不可以调用服务中的方法。

2.Service的第二种启动方法：

开启服务的步骤：

2-1 定义一个类，继承Service

2-2 在清单文件中配置服务

2-3 在Context中以bindService(Intent,ServiceConnection,int)方式开启服务

2-4 不需要时，以unbindService(ServiceConnection)方式关闭服务

在Service中的生命周期是：onCreate() --> onBind() -- onUnbind() -- onDestory()

绑定服务时，不会执行onStartCommand()方法

绑定服务时，开启服务，绑定服务，绑定者关闭时，服务也会相应的关闭，绑定者可以调用服务中的方法。

3.绑定本地服务调用方法的步骤

3-1 在服务的内部创建一个内部类，提供一个方法，可以间接调用服务的方法

3-2 实现服务的onBind()的方法，返回的即为这个内部类

3-3 在Context中绑定服务

3-4 在服务成功绑定的回调方法中onServiceConnected，会传递过来一个IBinder对象

3-5 强制类型转化成我们自定义的接口类型，调用里面的方法


我们现在来实现一下：

创建服务：

public class MyService extends Service {

public MyService() {

    }

/**
     * 开启服务
     */
    @Override
    public void onCreate() {
super.onCreate();
    }
/**
     * 开启服务
     */
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
return super.onStartCommand(intent, flags, startId);
    }

/**
     * 关闭服务
     */
    @Override
    public void onDestroy() {
super.onDestroy();
    }

/**
     * 绑定服务
     */
    @Override
    public IBinder onBind(Intent intent) {
return new MyBinder();
    }

/**
     * 该IBinder是远程对象的基本接口，是为高性能而设计的轻量级远程调用机制的核心部分
     * 但它不仅用于远程调用，也用于进程内调用。这个接口定义了与远程对象交互的协议。
     * 该类提供了对外访问服务的方法
     */
    public class MyBinder extends Binder{
public MyService getService(){
return MyService.this;
        }
    }
}
配置Service: 

<service
    android:name=".MyService"
    android:enabled="true"
    android:exported="true"></service>

开启服务：

public class MainActivity extends AppCompatActivity {

private Intent intent;

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

private void initData() {
intent = new Intent();
intent.setClass(this,MyService.class);
        startService(intent);
    }

@Override
    protected void onDestroy() {
super.onDestroy();
        stopService(intent);
    }
}
绑定服务：
public class MainActivity extends AppCompatActivity {

private Intent intent;

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

private void initData() {
intent = new Intent();
intent.setClass(this,MyService.class);
        bindService(intent,serviceConnection, Context.BIND_AUTO_CREATE);
    }
//在Activity中，我们通过ServiceConnection接口来取得建立连接与连接丢失的回调
    ServiceConnection serviceConnection = new ServiceConnection() {
@Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
//建立连接
            //获取服务的操作对象
            MyService.MyBinder myBinder = (MyService.MyBinder) iBinder;
            myBinder.getService();//获取到的Service即MyService
        }

@Override
        public void onServiceDisconnected(ComponentName componentName) {
//连接断开
        }
    };

@Override
    protected void onDestroy() {
super.onDestroy();
    }
}

4.粘性服务和非粘性服务

粘性服务，这里需要提到 Service的onStartCommand返回值

START_STICKY：

sticky的意思是“粘性的”。使用这个返回值时，我们启动的服务跟应用程序"粘"在一起，

如果在执行完onStartCommand后，服务被异常kill掉，系统会自动重启该服务;

当再次启动服务时，传入的第一个参数将为null.

START_NOT_STICKY：

“非粘性的”。使用这个返回值时，如果在执行完onStartCommand后，服务被异常kill掉，

系统不会自动重启该服务。

START_REDELIVER_INTENT：

重传Intent。使用这个返回值时，如果在执行完onStartCommand后，服务被异常kill掉，

系统会自动重启该服务，并将Intent的值传入。


 



标签：

相关文章