BindService ---扩展Binder类

比眉伴天荒 2023-06-20 10:47 28阅读 0赞

1，BindServcie -- 扩展Binder类开启服务

*  前面描述过，如果我们的服务仅供本地应用使用，不需要跨进程工作，则可以实现自有 Binder 类，让客户端通过该类直接访问服务中的公共方法。其使用开发步骤如下

【1】创建BindService服务端，继承自Service并在类中，创建一个实现IBinder 接口的实例对象并提供公共方法给客户端调用

【2】从 onBind() 回调方法返回此 Binder 实例。

【3】在客户端中，从 onServiceConnected() 回调方法接收 Binder，并使用提供的方法调用绑定服务。

【4】注意事项：

*  此方式只有在客户端和服务位于同一应用和进程内才有效，
 *  如对于需要将 Activity 绑定到在后台播放音乐的自有服务的音乐应用，此方式非常有效。
 *  另一点之所以要求服务和客户端必须在同一应用内，是为了便于客户端转换返回的对象和正确调用其 API。服务和客户端还必须在同一进程内，因为此方式不执行任何跨进程编组。

2， 扩展 Binder 类的实例

【1】 Service端的实现BindService.java

*  BindService类继承自Service
 *  在该类中创建了一个LocalBinder继承自Binder类，LocalBinder中声明了一个getService方法，客户端可访问该方法获取LocalService对象的实例
 *  只要客户端获取到LocalService对象的实例就可调用LocalService服务端的公共方法，如getCount方法，
 *  值得注意的是，我们在onBind方法中返回了binder对象，该对象便是LocalBinder的具体实例，而binder对象最终会返回给客户端，客户端通过返回的binder对象便可以与服务端实现交互。

package com.ipctest.service;
    import android.app.Service;
    import android.content.Intent;
    import android.os.Binder;
    import android.os.IBinder;
    import android.support.annotation.Nullable;
    import android.util.Log;
    /**
    * Description:绑定服务简单实例--服务端
    */
    public class LocalService extends Service{
        private final static String TAG = "wzj";
        private int count;
        private boolean quit;
        private Thread thread;
        private LocalBinder binder = new LocalBinder();
        /**
         * 创建Binder对象，返回给客户端即Activity使用，提供数据交换的接口
         */
        public class LocalBinder extends Binder {
            // 声明一个方法，getService。（提供给客户端调用）
            LocalService getService() {
                // 返回当前对象LocalService,这样我们就可在客户端端调用Service的公共方法了
                return LocalService.this;
            }
        }
    
        /**
         * 把Binder类返回给客户端
         */
        @Nullable
        @Override
        public IBinder onBind(Intent intent) {
            return binder;
        }
    
        @Override
        public void onCreate() {
            super.onCreate();
            Log.i(TAG, "Service is invoke Created");
            thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    // 每间隔一秒count加1 ，直到quit为true。
                    while (!quit) {
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        count++;
                    }
                }
            });
            thread.start();
        }
    
        /**
         * 公共方法
         * @return
         */
        public int getCount(){
            return count;
        }
        /**
         * 解除绑定时调用
         * @return
         */
         @Override
        public boolean onUnbind(Intent intent) {
            Log.i(TAG, "Service is invoke onUnbind");
            return super.onUnbind(intent);
        }
    
        @Override
        public void onDestroy() {
            Log.i(TAG, "Service is invoke Destroyed");
            this.quit = true;
            super.onDestroy();
        }
    }

【2】客户端BindActivity的实现：

package com.ipctest.service;
    
    
    import android.app.Activity;
    import android.app.Service;
    import android.content.ComponentName;
    import android.content.Intent;
    import android.content.ServiceConnection;
    import android.os.Bundle;
    import android.os.IBinder;
    import android.util.Log;
    import android.view.View;
    import android.widget.Button;
    
    import com.zejian.ipctest.R;
    
    /**
    * Description:绑定服务实例--客户端
    */
    public class BindActivity extends Activity {
        protected static final String TAG = "wzj";
        Button btnBind;
        Button btnUnBind;
        Button btnGetDatas;
        /**
         * ServiceConnection代表与服务的连接，它只有两个方法，
         * onServiceConnected和onServiceDisconnected，
         * 前者是在操作者在连接一个服务成功时被调用，而后者是在服务崩溃或被杀死导致的连接中断时被调用
         */
        private ServiceConnection conn;
        private LocalService mService;
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_bind);
            btnBind = (Button) findViewById(R.id.BindService);
            btnUnBind = (Button) findViewById(R.id.unBindService);
            btnGetDatas = (Button) findViewById(R.id.getServiceDatas);
            //创建绑定对象
            final Intent intent = new Intent(this, LocalService.class);
    
    
            // 开启绑定
            btnBind.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    Log.d(TAG, "绑定调用：bindService");
                    //调用绑定方法
                    bindService(intent, conn, Service.BIND_AUTO_CREATE);
                }
            });
            // 解除绑定
            btnUnBind.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    Log.d(TAG, "解除绑定调用：unbindService");
                    // 解除绑定
                    if(mService!=null) {
                        mService = null;
                        unbindService(conn);
                    }
                }
            });
    
    
            // 获取数据
            btnGetDatas.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    if (mService != null) {
                        // 通过绑定服务传递的Binder对象，获取Service暴露出来的数据
    
    
                        Log.d(TAG, "从服务端获取数据：" + mService.getCount());
                    } else {
    
    
                        Log.d(TAG, "还没绑定呢，先绑定,无法从服务端获取数据");
                    }
                }
            });
    
            conn = new ServiceConnection() {
                /**
                 * 与服务器端交互的接口方法 绑定服务的时候被回调，在这个方法获取绑定Service传递过来的IBinder对象，
                 * 通过这个IBinder对象，实现宿主和Service的交互。
                 */
                @Override
                public void onServiceConnected(ComponentName name, IBinder service) {
                    Log.d(TAG, "绑定成功调用：onServiceConnected");
                    // 获取Binder
                    LocalService.LocalBinder binder = (LocalService.LocalBinder) service;
                    mService = binder.getService();
                }
                /**
                 * 当取消绑定的时候被回调。但正常情况下是不被调用的，它的调用时机是当Service服务被意外销毁时，
                 * 例如内存的资源不足时这个方法才被自动调用。
                 */
                @Override
                public void onServiceDisconnected(ComponentName name) {
                    mService=null;
                }
            };
        }
    }

*  在客户端中我们创建了一个ServiceConnection对象，该代表与服务的连接，它只有两个方法， onServiceConnected和onServiceDisconnected

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      onServiceConnected(ComponentName name, IBinder service)&nbsp; 
    </div> </td> 
   <td> 
    <div>
      系统会调用该方法以传递服务的　onBind() 方法返回的 IBinder。其中service便是服务端返回的IBinder实现类对象，通过该对象我们便可以调用获取LocalService实例对象，进而调用服务端的公共方法。而ComponentName是一个封装了组件(Activity, Service, BroadcastReceiver, or ContentProvider)信息的类，如包名，组件描述等信息，较少使用该参数。 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div>
      onServiceDisconnected(ComponentName name)&nbsp; 
    </div> </td> 
   <td> 
    <div>
      Android 系统会在与服务的连接意外中断时（例如当服务崩溃或被终止时）调用该方法。注意:当客户端取消绑定时，系统“绝对不会”调用该方法。 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

conn = new ServiceConnection() {
                @Override
                public void onServiceConnected(ComponentName name, IBinder service) {
                    Log.d(TAG, "绑定成功调用：onServiceConnected");
                    // 获取Binder
                    LocalService.LocalBinder binder = (LocalService.LocalBinder) service;
                    mService = binder.getService();
                }
                @Override
                public void onServiceDisconnected(ComponentName name) {
                    mService=null;
                }
            };

*  在onServiceConnected()被回调前，我们还需先把当前Activity绑定到服务LocalService上，绑定服务是通过通过bindService()方法，解绑服务则使用unbindService()方法，这两个方法解析如下：

<table> 
 <tbody> 
  <tr> 
   <td> 
    <div>
      bindService(Intent service, ServiceConnection conn, int flags)&nbsp; 
    </div> </td> 
   <td> 
    <div>
      该方法执行绑定服务操作，其中Intent是我们要绑定的服务(也就是LocalService)的意图，而ServiceConnection代表与服务的连接，它只有两个方法，前面已分析过，flags则是指定绑定时是否自动创建Service。0代表不自动创建、BIND_AUTO_CREATE则代表自动创建。 
    </div> </td> 
  </tr> 
  <tr> 
   <td> 
    <div>
      unbindService(ServiceConnection conn)&nbsp; 
    </div> </td> 
   <td> 
    <div>
      该方法执行解除绑定的操作，其中ServiceConnection代表与服务的连接，它只有两个方法，前面已分析过。 
    </div> </td> 
  </tr> 
 </tbody> 
</table>

*  Activity通过bindService()绑定到LocalService后，ServiceConnection\#onServiceConnected()便会被回调并可以获取到LocalService实例对象mService，之后我们就可以调用LocalService服务端的公共方法了，最后还需要在清单文件中声明该Service。而客户端布局文件实现如下：

<?xml version="1.0" encoding="utf-8"?>
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:orientation="vertical" android:layout_width="match_parent"
        android:layout_height="match_parent">
        <Button
            android:id="@+id/BindService"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="绑定服务器"
            />
        <Button
            android:id="@+id/unBindService"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="解除绑定"
            />
        <Button
            android:id="@+id/getServiceDatas"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="获取服务方数据"
            />
    </LinearLayout>

3，运行结果：

【1】我们运行程序，点击绑定服务并多次点击绑定服务接着多次调用LocalService中的getCount()获取数据，最后调用解除绑定的方法移除服务，其结果如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NyaWNrZXRfNw_size_16_color_FFFFFF_t_70][]

【2】通过Log可知，

*  当我们第一次点击绑定服务时，LocalService服务端的onCreate()、onBind方法会依次被调用，
 *  此时客户端的ServiceConnection\#onServiceConnected()被调用并返回LocalBinder对象，
 *  接着调用LocalBinder\#getService方法返回LocalService实例对象，
 *  此时客户端便持有了LocalService的实例对象，也就可以任意调用LocalService类中的声明公共方法了。
 *  更值得注意的是，我们多次调用bindService方法绑定LocalService服务端，而LocalService得onBind方法只调用了一次，那就是在第一次调用bindService时才会回调onBind方法。接着我们点击获取服务端的数据，
 *  从Log中看出我们点击了3次通过getCount()获取了服务端的3个不同数据，
 *  最后点击解除绑定，此时LocalService的onUnBind、onDestroy方法依次被回调，并且多次绑定只需一次解绑即可。

【3】bindService 的生命周期

*  此情景也就说明了绑定状态下的Service生命周期方法的调用依次为onCreate()、onBind、onUnBind、onDestroy。

关于更多Service内容： [https://blog.csdn.net/cricket\_7/category\_9580061.html][https_blog.csdn.net_cricket_7_category_9580061.html]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NyaWNrZXRfNw_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191210085921433.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NyaWNrZXRfNw==,size_16,color_FFFFFF,t_70
[https_blog.csdn.net_cricket_7_category_9580061.html]: https://blog.csdn.net/cricket_7/category_9580061.html