心得笔记网站首页 心得笔记

64_利用bindservice调用服务里面的方法

发布时间：2021-03-08 14:42:19编辑：雪饮阅读（）

服务绑定与解绑

通过服务的绑定与解绑也可以实现类似服务启动与停止的功能，则实现如：

activity_main.xml:

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">
    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical">
        <Button
            android:id="@+id/button"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="开启服务" />
        <Button
            android:id="@+id/button2"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="关闭服务" />
        <Button
            android:id="@+id/button3"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="绑定服务" />
        <Button
            android:id="@+id/button4"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="解除绑定服务" />
    </LinearLayout>
</androidx.constraintlayout.widget.ConstraintLayout>

MainActivity.java:

package com.example.servicelifecycle;
 import androidx.appcompat.app.AppCompatActivity;
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
 import android.content.ServiceConnection;
 import android.os.Bundle;
 import android.os.IBinder;
 import android.view.View;
 import android.widget.Button;
 public class MainActivity extends AppCompatActivity implements View.OnClickListener {
     Button bt_start;
     Button bt_stop;
     Button bt_bind_service; //绑定服务
     Button bt_unbind_service; //解除绑定服务
     Intent intent ;
     MyConn conn;
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_main);
         bt_start = (Button) this.findViewById(R.id.button);
         bt_stop = (Button) this.findViewById(R.id.button2);
         bt_bind_service = (Button) this.findViewById(R.id.button3);
         bt_unbind_service = (Button) this.findViewById(R.id.button4);
         bt_start.setOnClickListener(this);
         bt_stop.setOnClickListener(this);
         bt_bind_service.setOnClickListener(this);
         bt_unbind_service.setOnClickListener(this);
         //自定义MyService实现服务意图
         intent = new Intent(this,MyService.class);
         conn = new MyConn();
     }
     @Override
     public void onClick(View v) {
         switch (v.getId()) {
             case R.id.button: // 开启服务
                 startService(intent);
                 break;
             case R.id.button2: //停止服务
                 stopService(intent);
                 System.out.println("服务 click button2");
                 break;
             case R.id.button3: // 绑定服务
                 System.out.println("服务 click button3");
                 //Context.BIND_AUTO_CREATE：当被绑定的服务不存在时候则自动创建对应服务
                 //conn ServiceConnection的实例化对象，用于服务连接成功与连接中断的处理接口
                 bindService(intent, conn, Context.BIND_AUTO_CREATE);
                 break;
             case R.id.button4: //解除绑定服务
                 unbindService(conn);
                 break;
         }
     }
     private class MyConn implements ServiceConnection {
         //绑定一个服务成功的时候 调用 onServiceConnected
         @Override
         public void onServiceConnected(ComponentName name, IBinder service) {}
         @Override
         public void onServiceDisconnected(ComponentName name) {}
     }
 }

MyService.java:

package com.example.servicelifecycle;
 import android.app.Service;
 import android.content.Intent;
 import android.os.IBinder;
 public class MyService extends Service {
    @Override
    public IBinder onBind(Intent intent) {
       System.out.println("服务 on bind");
       return null;
    }
    @Override
    public boolean onUnbind(Intent intent) {
       System.out.println("服务 on  unbind");
       return super.onUnbind(intent);
    }
    @Override
    public void onCreate() {
       System.out.println("服务 oncreate");
       super.onCreate();
    }
    @Override
    public void onStart(Intent intent, int startId) {
       System.out.println("服务 onstart");
       super.onStart(intent, startId);
    }
    //
    @Override
    public void onDestroy() {
       System.out.println("服务 ondestroy");
       super.onDestroy();
    }
 }

AndroidManifest.xml:

<?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     package="com.example.servicelifecycle">
     <application
         android:allowBackup="true"
         android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"
         android:roundIcon="@mipmap/ic_launcher_round"
         android:supportsRtl="true"
         android:theme="@style/Theme.Servicelifecycle">
         <activity android:name=".MainActivity">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
                 <category android:name="android.intent.category.LAUNCHER" />
             </intent-filter>
         </activity>
         <service android:name=".MyService"></service>
     </application>
 </manifest>

然后将项目部署到设备中

当第一次顺序操作了服务绑定、解除绑定经历了oncreate、onbind、unbind、ondestroy

不断的这样的操作步骤，可以发现每次绑定都要create，这说明每次解绑时候和onstop有点类似，直接把服务给删除了，因为我们这里绑定的时候是添加了Context.BIND_AUTO_CREATE绑定模式的，即当服务不存在的时候就自动创建。

再来看看在已绑定服务的情况下继续绑定服务的操作

当已绑定服务的时候再次绑定服务的时候就不会产生任何生命周期的日志了，这里是已经绑定的情况下，筛选“服务”关键字的日志，随着你不断的点击绑定服务，会发现永远也不会再次运行生命周期的相关方法了

服务绑定与服务开启的区别

服务绑定则服务会随着activity的关闭而自动销毁，例如这里我退出程序了（在这个项目中相当于把activity关闭了），服务就自动解绑了

不过即便不用服务绑定的方式，用普通的服务启动的方式，也可以在activity的onDestroy（在activity被销毁时执行）方法的覆写中编写让对应服务停止的操作。

例如MainActivity.java:

package com.example.servicelifecycle;
 import androidx.appcompat.app.AppCompatActivity;
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
 import android.content.ServiceConnection;
 import android.os.Bundle;
 import android.os.IBinder;
 import android.view.View;
 import android.widget.Button;
 public class MainActivity extends AppCompatActivity implements View.OnClickListener {
     Button bt_start;
     Button bt_stop;
     Button bt_bind_service; //绑定服务
     Button bt_unbind_service; //解除绑定服务
     Intent intent ;
     MyConn conn;
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_main);
         bt_start = (Button) this.findViewById(R.id.button);
         bt_stop = (Button) this.findViewById(R.id.button2);
         bt_bind_service = (Button) this.findViewById(R.id.button3);
         bt_unbind_service = (Button) this.findViewById(R.id.button4);
         bt_start.setOnClickListener(this);
         bt_stop.setOnClickListener(this);
         bt_bind_service.setOnClickListener(this);
         bt_unbind_service.setOnClickListener(this);
         //自定义MyService实现服务意图
         intent = new Intent(this,MyService.class);
         conn = new MyConn();
     }
     @Override
     public void onClick(View v) {
         switch (v.getId()) {
             case R.id.button: // 开启服务
                 startService(intent);
                 break;
             case R.id.button2: //停止服务
                 stopService(intent);
                 System.out.println("服务 click button2");
                 break;
             case R.id.button3: // 绑定服务
                 System.out.println("服务 click button3");
                 //Context.BIND_AUTO_CREATE：当被绑定的服务不存在时候则自动创建对应服务
                 //conn ServiceConnection的实例化对象，用于服务连接成功与连接中断的处理接口
                 bindService(intent, conn, Context.BIND_AUTO_CREATE);
                 break;
             case R.id.button4: //解除绑定服务
                 unbindService(conn);
                 break;
         }
     }
     private class MyConn implements ServiceConnection {
         //绑定一个服务成功的时候 调用 onServiceConnected
         @Override
         public void onServiceConnected(ComponentName name, IBinder service) {}
         @Override
         public void onServiceDisconnected(ComponentName name) {}
     }
     @Override
     protected void onDestroy() {
         stopService(intent);
         super.onDestroy();
     }
 }

然后部署到设备上操作开启服务、然后退出到桌面

另外据说即便是在以绑定服务的方式时候也要覆写activity的onDestroy方法中编写使对应服务解除绑定的操作，不然在activity关闭后会报错包含“android.app.ServiceConnectionLeaked”信息的一个错误信息。

例如可以覆写如：

MainActivity.java:

package com.example.servicelifecycle;
 import androidx.appcompat.app.AppCompatActivity;
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
 import android.content.ServiceConnection;
 import android.os.Bundle;
 import android.os.IBinder;
 import android.view.View;
 import android.widget.Button;
 public class MainActivity extends AppCompatActivity implements View.OnClickListener {
     Button bt_start;
     Button bt_stop;
     Button bt_bind_service; //绑定服务
     Button bt_unbind_service; //解除绑定服务
     Intent intent ;
     MyConn conn;
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_main);
         bt_start = (Button) this.findViewById(R.id.button);
         bt_stop = (Button) this.findViewById(R.id.button2);
         bt_bind_service = (Button) this.findViewById(R.id.button3);
         bt_unbind_service = (Button) this.findViewById(R.id.button4);
         bt_start.setOnClickListener(this);
         bt_stop.setOnClickListener(this);
         bt_bind_service.setOnClickListener(this);
         bt_unbind_service.setOnClickListener(this);
         //自定义MyService实现服务意图
         intent = new Intent(this,MyService.class);
         conn = new MyConn();
     }
     @Override
     public void onClick(View v) {
         switch (v.getId()) {
             case R.id.button: // 开启服务
                 startService(intent);
                 break;
             case R.id.button2: //停止服务
                 stopService(intent);
                 System.out.println("服务 click button2");
                 break;
             case R.id.button3: // 绑定服务
                 System.out.println("服务 click button3");
                 //Context.BIND_AUTO_CREATE：当被绑定的服务不存在时候则自动创建对应服务
                 //conn ServiceConnection的实例化对象，用于服务连接成功与连接中断的处理接口
                 bindService(intent, conn, Context.BIND_AUTO_CREATE);
                 break;
             case R.id.button4: //解除绑定服务
                 unbindService(conn);
                 break;
         }
     }
     private class MyConn implements ServiceConnection {
         //绑定一个服务成功的时候 调用 onServiceConnected
         @Override
         public void onServiceConnected(ComponentName name, IBinder service) {}
         @Override
         public void onServiceDisconnected(ComponentName name) {}
     }
     @Override
     protected void onDestroy() {
         unbindService(conn);
         super.onDestroy();
     }
 }

不过经过我的测试，这家伙可有可无，我发现无论有没有最后都执行了服务的onDestory方法，且没有出现上面类似错误。可能与sdk版本有关的，我用的安卓9的sdk，应该是相比较高的版本，没有这个问题吧。

另外还有最后一个明显的区别就是以startService形式实现的服务则无法调用服务类里面的方法。而以绑定形式实现的服务则可以调用服务类里面的方法。

调用服务类里面的方法

上面已经了解了，以绑定服务的方式，则可以调用服务类里面的方法，那么具体实现则
 观察onBind方法返回值类型是Ibinder，也就是返回Ibinder的实例

那么这个Ibinder的实例中提供一个方法可以被外部能够访问即可。

然而这个Ibinder类需要我们继承Binder类，并实现一个接口，该接口中提供上面我们说的这个可以被外部访问的方法。

那么假如这个要实现的接口我们建立为Iservice.java:

package com.example.servicelifecycle;
 public interface IService {
    public void callMethodInService();
 }

所以在MyService.java中onbind可以这样实现：

package com.example.servicelifecycle;
 import android.app.Service;
 import android.content.Intent;
 import android.os.Binder;
 import android.os.IBinder;
 public class MyService extends Service {
    /**
     * 服务里面的一个方法
     */
    public void sayHelloInService(){
       System.out.println("hello in service");
    }
    public class MyBinder extends Binder implements IService{
       @Override
       public void callMethodInService() {
          System.out.println("服务 调用了callMethodInService");
          sayHelloInService();
       }
    }
    @Override
    public IBinder onBind(Intent intent) {
       System.out.println("服务 on bind");
       return new MyBinder();
    }
    @Override
    public boolean onUnbind(Intent intent) {
       System.out.println("服务 on  unbind");
       return super.onUnbind(intent);
    }
    @Override
    public void onCreate() {
       System.out.println("服务 oncreate");
       super.onCreate();
    }
    @Override
    public void onStart(Intent intent, int startId) {
       System.out.println("服务 onstart");
       super.onStart(intent, startId);
    }
    //
    @Override
    public void onDestroy() {
       System.out.println("服务 ondestroy");
       super.onDestroy();
    }
 }

那么接下来再来一个按钮来调用服务里面的方法activity_main.xml:

<?xml version="1.0" encoding="utf-8"?>
 <androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:app="http://schemas.android.com/apk/res-auto"
     xmlns:tools="http://schemas.android.com/tools"
     android:layout_width="match_parent"
     android:layout_height="match_parent"
     tools:context=".MainActivity">
     <LinearLayout
         android:layout_width="match_parent"
         android:layout_height="match_parent"
         android:orientation="vertical">
         <Button
             android:id="@+id/button"
             android:layout_width="match_parent"
             android:layout_height="wrap_content"
             android:text="开启服务" />
         <Button
             android:id="@+id/button2"
             android:layout_width="match_parent"
             android:layout_height="wrap_content"
             android:text="关闭服务" />
         <Button
             android:id="@+id/button3"
             android:layout_width="match_parent"
             android:layout_height="wrap_content"
             android:text="绑定服务" />
         <Button
             android:id="@+id/button4"
             android:layout_width="match_parent"
             android:layout_height="wrap_content"
             android:text="解除绑定服务" />
         <Button
             android:id="@+id/button5"
             android:layout_width="match_parent"
             android:layout_height="wrap_content"
             android:text="调用服务里面的方法" />
     </LinearLayout>
 </androidx.constraintlayout.widget.ConstraintLayout>

然后是调用服务里面的方法的具体事件实现MainActivity.java:

package com.example.servicelifecycle;
 import androidx.appcompat.app.AppCompatActivity;
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
 import android.content.ServiceConnection;
 import android.os.Bundle;
 import android.os.IBinder;
 import android.view.View;
 import android.widget.Button;
 public class MainActivity extends AppCompatActivity implements View.OnClickListener {
     Button bt_start;
     Button bt_stop;
     Button bt_bind_service; //绑定服务
     Button bt_unbind_service; //解除绑定服务
     Intent intent ;
     MyConn conn;
     Button bt_call_service;
     IService iService;
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_main);
         bt_start = (Button) this.findViewById(R.id.button);
         bt_stop = (Button) this.findViewById(R.id.button2);
         bt_bind_service = (Button) this.findViewById(R.id.button3);
         bt_unbind_service = (Button) this.findViewById(R.id.button4);
         bt_call_service = (Button)this.findViewById(R.id.button5);
         bt_call_service.setOnClickListener(this);
         bt_start.setOnClickListener(this);
         bt_stop.setOnClickListener(this);
         bt_bind_service.setOnClickListener(this);
         bt_unbind_service.setOnClickListener(this);
         //自定义MyService实现服务意图
         intent = new Intent(this,MyService.class);
         conn = new MyConn();
     }
     @Override
     public void onClick(View v) {
         switch (v.getId()) {
             case R.id.button: // 开启服务
                 startService(intent);
                 break;
             case R.id.button2: //停止服务
                 stopService(intent);
                 System.out.println("服务 click button2");
                 break;
             case R.id.button3: // 绑定服务
                 System.out.println("服务 click button3");
                 //Context.BIND_AUTO_CREATE：当被绑定的服务不存在时候则自动创建对应服务
                 //conn ServiceConnection的实例化对象，用于服务连接成功与连接中断的处理接口
                 bindService(intent, conn, Context.BIND_AUTO_CREATE);
                 break;
             case R.id.button4: //解除绑定服务
                 unbindService(conn);
                 break;
             case R.id.button5: //调用服务里面的方法
                 iService.callMethodInService();
                 break;
         }
     }
     private class MyConn implements ServiceConnection {
         //绑定一个服务成功的时候 调用 onServiceConnected
         @Override
         public void onServiceConnected(ComponentName name, IBinder service) {
             iService = (IService) service;
         }
         @Override
         public void onServiceDisconnected(ComponentName name) {}
     }
 }

最后部署到设备中测试是ok的

关键字词：bindservice,服务

上一篇：63_通过startservice开启服务的生命周期

下一篇：65_采用aidl访问远程服务里面的方法

您当前的位置： 首页 > 学无止境 > 心得笔记 网站首页心得笔记

64_利用bindservice调用服务里面的方法

相关文章

您当前的位置：首页 > 学无止境 > 心得笔记网站首页心得笔记