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

最新推荐文章于 2024-05-28 12:12:46 发布

android_zier

最新推荐文章于 2024-05-28 12:12:46 发布

阅读量842

点赞数 1

分类专栏： Android

本文链接：https://blog.csdn.net/baidu_35701759/article/details/70257661

版权

Android 专栏收录该内容

23 篇文章 1 订阅

订阅专栏

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();
    }
}