行业资讯

如何实现CmProcess跨进程通信

发布时间：2021-06-28 14:22:47 作者：小新
来源：亿速云 阅读：195

这篇文章给大家分享的是有关如何实现CmProcess跨进程通信的内容。小编觉得挺实用的，因此分享给大家做个参考，一起跟随小编过来看看吧。

一、基础知识准备

1.1、多进程

Android多进程概念：一般一个 app 只有一个进程，所有的 components 都运行在同一个进程中，进程名称就是 app 包名。但是每一个进程都有内存的限制，如果一个进程的内存超过了这个限制的时候就会报 OOM 错误。为了解决内存限制的问题，Android 引入了多进程的概念，将占用内存的操作放在一个单独的进程中分担主进程的压力。

多进程的好处：

多进程的缺点：

1.2、Bundle类

bundle 定义 bundle 是一个 final 类，final 类通常功能是完整的，它们不能被继承。Java 中有许多类是 final 的，譬如 String, Interger 以及其他包装类。

public final class Bundle extends BaseBundle implements Cloneable, Parcelable

bundle 传递的数据可以是 boolean、byte、int、long、float、double、string 等基本类型或它们对应的数组，也可以是对象或对象数组。但是如果传递对象或对象数组，该对象必须实现 Serializable 或 Parcelable 接口。由 Bundle 定义我们也可以看到其实现了 Parcelable 接口，所以支持实现了Parcelable 接口的对象。
因此当我们在一个进程中启动了另外一个进程的 Activity、Service、Receiver，我们就可以在 Bundle 中附加我们需要传输给远程进程的信息（前提是能够被序列化）并通过 Intent 发送出去。

二、代码解析

2.1、AIDL接口

1、IEventReceiver：事件接收器

// 事件接受器
interface IEventReceiver {
　　 // 这里的 event 是 bundle 类型
    void onEventReceive(String key,in Bundle event);
}

2、IPCCallback：看名字也可以看出来是跨进程 callback

interface IPCCallback {
　　 // result 也是 bundle
    void onSuccess(in Bundle result);
    void onFail(String reason);
}

3、IServiceFetcher：获取服务的。可以再此进行注册。

interface IServiceFetcher {　　 // service 是 Ibinder 类型
    android.os.IBinder getService(java.lang.String name);　　 // 注册服务
    void addService(java.lang.String name, android.os.IBinder service);　　 // 添加回调
    void addEventListener(java.lang.String name, android.os.IBinder service);　　 // 移除 service 
    void removeService(java.lang.String name);　　 // 移除回调
    void removeEventListener(java.lang.String name);　　// 发送消息
    void post(String key,in Bundle result);
}

2.2、启动分析

根据代码可知，咱们有三个进程，分别是：

也就是每个进程在初始化的时候，都会走一遍Application 的初始化，因此如果需要对进程做啥操作，可以判断出具体的进程，然后做一些额外的操作。对于 CmProcess ，所有进程的初始化逻辑都是一样的。

public class App extends Application {
    private static final String TAG = "App";

    @Override
    protected void attachBaseContext(Context base) {
        super.attachBaseContext(base);
        // 先启动主进程，之后才启动其他进程
        VCore.init(base);
    }
}

启动过程中，会主动为每个进程注册回调，注意是每个进程。

该 init 方法最终会走入到下面的方法中：

public void startup(Context context) {
        if (!isStartUp) {
            // 在主线程启动，每个进程都有一个自己的主线程
            if (Looper.myLooper() != Looper.getMainLooper()) {
                throw new IllegalStateException("VirtualCore.startup() must called in main thread.");
            }

            ServiceManagerNative.SERVICE_CP_AUTH = context.getPackageName() + "." + ServiceManagerNative.SERVICE_DEF_AUTH;
            this.context = context;
            // 传入了一个 cache 实例，这个实例是只有主线程有的
            IPCBus.initialize(new IServerCache() {
                @Override
                public void join(String serverName, IBinder binder) {
                    ServiceManagerNative.addService(serverName, binder);
                }

                @Override
                public void joinLocal(String serverName, Object object) {
                    ServiceCache.addLocalService(serverName,object);
                }

                @Override
                public void removeService(String serverName) {
                    ServiceManagerNative.removeService(serverName);
                }

                @Override
                public void removeLocalService(String serverName) {
                     ServiceCache.removeLocalService(serverName);
                }

                @Override
                public IBinder query(String serverName) {
                    return ServiceManagerNative.getService(serverName);
                }

                @Override
                public Object queryLocal(String serverName) {
                    return ServiceCache.getLocalService(serverName);
                }

                @Override
                public void post(String key,Bundle bundle) {
                    ServiceManagerNative.post(key,bundle);
                }
            });　　　　　　　// 这里是根据进程名字添加注册的事件接收器
            ServiceManagerNative.addEventListener(AppUtil.getProcessName(context, Process.myPid()), EventReceiver.getInstance());
            isStartUp = true;
        }
    }

这里整个逻辑很简单，就是在主线程初始化了IPCBus，然后给该进程注册了一个事件分发的监听。

三、EventReceiver

public class EventReceiver extends IEventReceiver.Stub {

    private static final String TAG = "EventReceiver";

    private static final EventReceiver EVENT_RECEIVER = new EventReceiver();

    private EventReceiver(){}

    public static final EventReceiver getInstance(){
        return EVENT_RECEIVER;
    }

    @Override
    public void onEventReceive(String key,Bundle event) {
        EventCenter.onEventReceive(key,event);
    }
}

整个类的代码很简单。但是要注意的是，其继承了IEventReceiver.Stub，说明他具有跨进程传输的能力。主要就是通过EventCenter 来分发消息。

由于每个进程都会走一遍初始化逻辑，所以每个进程都注册了事件的接收。

四、ServiceManagerNative

从名字也可以看出来，这个跟我们平时看到的ServiceManager 很像。主要就是用来获取 service 和注册 listener 的。

public static void addEventListener(String name, IBinder service) {
    IServiceFetcher fetcher = getServiceFetcher();
    if (fetcher != null) {
        try {
            fetcher.addEventListener(name, service);
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }
}

首先是调用getServiceFetcher 来获取最终保存服务的 fetcher。

注册回调的时候，会先获取是否存在 （binder）ServiceFetcher ，在将其转化为本地 binder；这样 ServiceFetcher 的管理器就可以用了。

private static IServiceFetcher getServiceFetcher() {
    if (sFetcher == null || !sFetcher.asBinder().isBinderAlive()) {
        synchronized (ServiceManagerNative.class) {
            Context context = VirtualCore.get().getContext();
            Bundle response = new ProviderCall.Builder(context, SERVICE_CP_AUTH).methodName("@").call();
            if (response != null) {
                IBinder binder = BundleCompat.getBinder(response, "_VM_|_binder_");
                linkBinderDied(binder);
                sFetcher = IServiceFetcher.Stub.asInterface(binder);
            }
        }
    }
    return sFetcher;
}

首先是看ProviderCall.Builder(context, SERVICE_CP_AUTH).methodName("@").call()，他最终会调用下面的方法：

//ContentProviderCompat
public static Bundle call(Context context, Uri uri, String method, String arg, Bundle extras) {
    // 这里还区分了版本
    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN_MR1) {
        return context.getContentResolver().call(uri, method, arg, extras);
    }
    ContentProviderClient client = crazyAcquireContentProvider(context, uri);  // 这里会不断重试最终会获得对 BinderProvider 的引用
    Bundle res = null;
    try {
        // 通过约定好的方法名字获得bindle
        res = client.call(method, arg, extras);
    } catch (RemoteException e) {
        e.printStackTrace();
    } finally {
        releaseQuietly(client);
    }
    return res;
}

五、BinderProvider

下面看下 BinderProvider 的 call 方法。

新建了一个 bundle 对象，然后将 binder 保存在里面。注意这是通过跨进程调用，最终将 bundle 传回主进程，然后拿到了ServiceFetcher 的 binder，并将其转为本地 binder。

可以发现这里对于方法名是 "@" 时，就会返回 bundle ，否则就是返回 null 。

public Bundle call(String method,  String arg,  Bundle extras) {
    if ("@".equals(method)) {
        Bundle bundle = new Bundle();
        BundleCompat.putBinder(bundle, "_VM_|_binder_", mServiceFetcher);
    　　return bundle;
    }
    return null;
}

简单来说，就是大家都通过 binderProvider 这个进程来保存对于回调的注册，保存是基于进城名字来的，因此可以保证不会被覆盖。

此处的mServiceFetcher 是BinderProvider 内部内的实例，但是其继承了IServiceFetcher.Stub，因此也就有了跨进程的能力。

到这里，理一下前面的逻辑：

ServiceManagerNative.addEventListener(AppUtil.getProcessName(context, Process.myPid()), EventReceiver.getInstance());

某个进程的主线程调用这个方法，所做的具体事情如下：

1.通过 binder 拿到了binderProvider 中的 IServiceFetcher.Stub 的实例；

2.向IServiceFetcher.Stub 注册回调，该回调最终会被保存binderProvider 进程里面。

六、BinderProvider 启动分析

上面介绍了其是怎么将 listener 注册到 binderProvider 进程的，但是并没有讲到接下去我们看下 BinderProvider 的启动过程，

下图是ContentProvider 的启动流程。当我们在主进程想获取 server 的时候，这时候，会看看 provider 存不存在，没有的就会进行启动，同时会走 Application 的初始化逻辑，

如何实现CmProcess跨进程通信

具体我们可以看下面这个启动流程图：

如何实现CmProcess跨进程通信

这里主要是梳理了下 provider 的启动过程，并没有很细讲，但是有必要了解一下。

七、MainActivity

接下去，开始看MainActivity 里面的代码。

调用registerService 注册服务，传入IPayManager.class 和MainActivity；记得MainActivity 也实现了IPayManager 接口。

VCore.getCore().registerService(IPayManager.class, this);

看下，里面的具体代码逻辑

// Vcore
public VCore registerService(Class<?> interfaceClass, Object server){
    if (VirtualCore.get().getContext() == null){
        return this;
    }
    Object o = IPCBus.getLocalService(interfaceClass);
    // 如果是第一次调用就会返回空
    IBinder service = ServiceManagerNative.getService(interfaceClass.getName());  
    if (service != null && o != null){
        return this;
    }
    IPCBus.registerLocal(interfaceClass,server);
    // 这里的注册就是把 server 保存到 binder 中
    IPCBus.register(interfaceClass,server);
    return this;
}

这里使用了一个registerLocal和register 方法，但是本质上两个方法是有区别的。registerLocal 意思很明确，就是本地ServiceCache保存一份。但是register，确实做了一些额外的操作。

public static void register(Class<?> interfaceClass, Object server) {
    checkInitialized();
    // 这里主要是获取一个 binder,或者换句话来说，采用 binder 来保存相关数据
    ServerInterface serverInterface = new ServerInterface(interfaceClass);
    // 这里就是把 binder 保存到 binderProvider
    TransformBinder binder = new TransformBinder(serverInterface, server);
    sCache.join(serverInterface.getInterfaceName(), binder);
}

首先这里创建了一个ServerInterface 实例，该实例内部保存了传过了来的接口和接口的方法，并将方法和 code 联系在一起。

public ServerInterface(Class<?> interfaceClass) {
    this.interfaceClass = interfaceClass;
    Method[] methods = interfaceClass.getMethods();
    codeToInterfaceMethod = new SparseArray<>(methods.length);
    methodToIPCMethodMap = new HashMap<>(methods.length);
    for (int i = 0; i < methods.length; i++) {// 这里每一个方法都有一个 code 
        int code = Binder.FIRST_CALL_TRANSACTION + i;// 组成一个 ipcMenhod
        IPCMethod ipcMethod = new IPCMethod(code, methods[i], interfaceClass.getName());
        codeToInterfaceMethod.put(code, ipcMethod);// 保存他们的映射关系
        methodToIPCMethodMap.put(methods[i], ipcMethod);
    }
}

同时利用TransformBinder 将接口和 实例保存到 binder 中。再将 binder 和 接口名字 保存到ServiceCache 中。

注册完以后，下面是调用获取本地服务：

// 其实 service 本质还是这个 MainActivity
IPayManager service = VCore.getCore().getLocalService(IPayManager.class);

最后注册了一个回调：

VCore.getCore().subscribe("key", new EventCallback() {
    @Override
    public void onEventCallBack(Bundle event) {

    }
});

最终EventCenter 会保存相关信息；

八、TestActivity

最后启动 TestActivity ，这个是在另一个进程。在 onCreate 里面调用下面的方法：

IPayManager service = VCore.getCore().getService(IPayManager.class);

进程刚刚创建，我们看看是怎么获取服务的：

// Vcore 
public <T> T getService(Class<T> ipcClass){
    T localService = IPCBus.getLocalService(ipcClass);
    if (localService != null){
        return localService;
    }
    return VManager.get().getService(ipcClass);
}

这里很明确，本地肯定是没有的，因此，最后会从 VManager 中获取：

// VManager
public <T> T getService(Class<T> ipcClass) {
    T t = IPCBus.get(ipcClass);
    if (t != null){
        return t;
    }
    IPCSingleton<T> tipcSingleton = mIPCSingletonArrayMap.get(ipcClass);
    if (tipcSingleton == null){
        tipcSingleton = new IPCSingleton<>(ipcClass);
        mIPCSingletonArrayMap.put(ipcClass,tipcSingleton);
    }
    return tipcSingleton.get();
}

接下去我们看下IPCSingleton 相关逻辑

// IPCSingleton
public T get() {
    if (instance == null) {
        synchronized (this) {
            if (instance == null) {
                instance = IPCBus.get(ipcClass);
            }
        }
    }
    return instance;
}

这是一个单例，目的也很明确，就是只获取一次，可以看到后面又调到了 IPCBus 里面。

//   IPCBus
public static <T> T get(Class<?> interfaceClass) {
    checkInitialized();
    ServerInterface serverInterface = new ServerInterface(interfaceClass);
    // 这里获取的 binder 应该是 TransformBinder
    IBinder binder = sCache.query(serverInterface.getInterfaceName());
    if (binder == null) {
        return null;
    }
    // 这里使用了动态代理
    return (T) Proxy.newProxyInstance(interfaceClass.getClassLoader(), new Class[]{interfaceClass}, new IPCInvocationBridge(serverInterface, binder));
}

这里采用了动态代理创造了一个实例，最终返回的实例被保存在一个单例中。

可以看到，这里回去查找存不存在 binder。

// VirtualCore
public IBinder query(String serverName) {
      return ServiceManagerNative.getService(serverName);
}

还是通过ServiceManagerNative 来获取的 service；这里又回到我们之前分析过的逻辑。先从 binderProvider 获取fetcher， 也就是 ServiceFetcher。

IServiceFetcher fetcher = getServiceFetcher();

它也会从ServiceFetcher 中获取到 binder ,而这个 binder 就是之前我们保存的TransformBinder 。拿到这个之后，还是一样，将其转化为该进程的本地 binder .

 // BinderProvider
 private class ServiceFetcher extends IServiceFetcher.Stub {

最后，我们通过动态代理的形式，创建了一个 IPayManager 的实例。

return (T) Proxy.newProxyInstance(interfaceClass.getClassLoader(), new Class[]{interfaceClass}, new IPCInvocationBridge(serverInterface, binder));

这里需要注意的是IPCInvocationBridge 继承自InvocationHandler。

拿到后，开始调用对应的方法：

if (service != null){
    Log.d(TAG, "onCreate: shentest  before   vcore   " + AppUtil.getAppName(this));
    // 首先这个 service 是跨进程调用的，怎么才通知到其他组件？这里大家可以思考下
    service.pay(5000, new BaseCallback() {
        @Override
        public void onSucceed(Bundle result) {
            textview.setText(result.getString("pay"));
            Bundle bundle = new Bundle();
            bundle.putString("name", "DoDo");
            VCore.getCore().post("key",bundle);
        }

        @Override
        public void onFailed(String reason) {

        }
    });
}

调用 service.pay 的时候，就会调用动态代理中的 invoke 方法：

public Object invoke(Object o, Method method, Object[] args) throws Throwable {
    IPCMethod ipcMethod = serverInterface.getIPCMethod(method);
    if (ipcMethod == null) {
        throw new IllegalStateException("Can not found the ipc method : " + method.getDeclaringClass().getName() + "@" +  method.getName());
    }　　　　　// 这里很关键
    return ipcMethod.callRemote(binder, args);
}

首先根据方法名获得ipcMethod，里面保存了方法的 code，接口名字，参数，返回值。接着调用了 ipcMethod.callRemote， 该方法又会调用：

// IPCMethod 
// 这个方法很重要，需要理解其实现过程
public Object callRemote(IBinder server, Object[] args) throws RemoteException {
    Parcel data = Parcel.obtain(); // 获取一个新的 parcel 对象
    Parcel reply = Parcel.obtain();
    Object result;
    try {
        data.writeInterfaceToken(interfaceName);
        data.writeArray(args);　　　　　　　// 这里 server 就是 transformBinder
        server.transact(code, data, reply, 0);
        reply.readException();
        result = readValue(reply);
        if (resultConverter != null) {
            result = resultConverter.convert(result);
        }
    } finally {
        data.recycle();
        reply.recycle();
    }
    return result;
}

code 变量用于标识客户端期望调用服务端的哪个函数，因此，双方需要约定一组 int 值，不同的值代表不同的服务端函数，该值和客户端的 transact() 函数中第一个参数 code 的值是一致的。

enforceInterface() 是为了某种校验，它与客户端的 writeInterfaceToken() 对应，具体见下一小节。
readString() 用于从包裹中取出一个字符串。如果该 IPC 调用的客户端期望返回一些结果，则可以在返回包裹 reply 中调用 Parcel 提供的相关函数写入相应的结果。 Parcel.writeXXX();

现在要看的是怎么通过 binder 一步一步拿到参数。

使用 Parcel 一般是通过 Parcel.obtain() 从对象池中获取一个新的 Parcel 对象，如果对象池中没有则直接 new 的 Parcel 则直接创建新的一个 Parcel 对象，并且会自动创建一个Parcel-Native 对象。

writeInterfaceToken 用于写入 IBinder 接口标志，所带参数是 String 类型的，如 IServiceManager.descriptor = "android.os.IServiceManager"。

之前说的 code 在这里用上了，code 是一个私有变量，跟 method 绑定在一起的。

中间有个 server.transact(code, data, reply, 0); 该方法实现了跨进程调用，最终会走到 binderProvider 的下面onTransact方法：

// TransformBinder 运行在主进程
@Override
protected boolean onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {　　　　　// 回调进来后，就到了  MainActivity 的进程
    if (code == INTERFACE_TRANSACTION) {
        reply.writeString(serverInterface.getInterfaceName());
        return true;
    }
    IPCMethod method = serverInterface.getIPCMethod(code);
    if (method != null) {
        try {
            method.handleTransact(server, data, reply);
        } catch (Throwable e) {
            e.printStackTrace();
        }
        return true;
    }
    return super.onTransact(code, data, reply, flags);
}

这里主要是根据 code 来获取到是哪个方法被调用了，下面才是真正的处理。

// IPCMethod 
public void handleTransact(Object server, Parcel data, Parcel reply) {
    data.enforceInterface(interfaceName); // 确保是目标接口
    Object[] parameters = data.readArray(getClass().getClassLoader());
    if (parameters != null && parameters.length > 0) {
        for (int i = 0; i < parameters.length; i++) {
            if (converters[i] != null) {
                parameters[i] = converters[i].convert(parameters[i]);
            }　　　　　　　　　　// 如果参数里面包含有 binder 
            if (parameters[i] instanceof IBinder){
                parameters[i] = IPCCallback.Stub.asInterface(((IBinder)parameters[i]));
            }
        }
    }
    try {
        // 最终通过反射的形式实现了的调用
        // 其实最主要的是通过 binder 拿到参数,然后知道对方调用的是哪个方法。
        // 现在要分析的是，他怎么将数据传过来的
        Object res = method.invoke(server, parameters);
        reply.writeNoException();
        reply.writeValue(res);
    } catch (IllegalAccessException e) {
        e.printStackTrace();
        reply.writeException(e);
    } catch (InvocationTargetException e) {
        e.printStackTrace();
        reply.writeException(e);
    }
}

看看 convert 里面的操作：

public Object convert(Object param) {
    if (param != null) {
        if (asInterfaceMethod == null) {
            synchronized (this) {
                if (asInterfaceMethod == null) {　　　　　　　　　　　　　　　　　// 找到 asInterface 方法
                    asInterfaceMethod = findAsInterfaceMethod(type);
                }
            }
        }
        try {　　　　　　　　　　　　// 因为 asInterface 方法是静态方法，所以对象可以传入空，最终转变成所需要的参数类型
            return asInterfaceMethod.invoke(null, param);
        } catch (Throwable e) {
            throw new IllegalStateException(e);
        }
    }
    return null;
}

通过 convert 这个一调用，就转变成我们所需要的参数了。

private static Method findAsInterfaceMethod(Class<?> type) {
    for (Class<?> innerClass : type.getDeclaredClasses()) {
        // public static class Stub extends Binder implements IType
        if (Modifier.isStatic(innerClass.getModifiers())
                && Binder.class.isAssignableFrom(innerClass)
                && type.isAssignableFrom(innerClass)) {
            // public static IType asInterface(android.os.IBinder obj)
            for (Method method : innerClass.getDeclaredMethods()) {
                if (Modifier.isStatic(method.getModifiers())) {
                    Class<?>[] types = method.getParameterTypes();
                    if (types.length == 1 && types[0] == IBinder.class) {
                        return method;
                    }
                }
            }
        }
    }
    throw new IllegalStateException("Can not found the " + type.getName() + "$Stub.asInterface method.");
}

findAsInterfaceMethod 通过层层筛选，最终获得需要的那个方法：

public static com.cmprocess.ipc.server.IPCCallback com.cmprocess.ipc.server.IPCCallback$Stub.asInterface(android.os.IBinder)

通过 invoke 方法，终将获得了我们需要的类型。

这里 server 就是 mainActivity。在把对应的参数传进去即可。最终调到了mainActivity 里面的 pay 方法。

public void pay(final int count, final IPCCallback callBack) {

    new Thread(new Runnable() {
        @Override
        public void run() {
            SystemClock.sleep(2000);
            Bundle bundle = new Bundle();
            bundle.putString("pay", count + 100 + "");
            try {
                // callback 也是一个binder
                callBack.onSuccess(bundle);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
    }).start();
}

此处，callback 也是一个binder，调用成功后，发送了post。 其实最终也是调用了ServiceFetcher 。

// TestActivity
 VCore.getCore().post("key",bundle);

其实也是通过 binder 来进行发送消息的。由于每个进程都注册了消息回调，因此，每个进程都会收到。

// ServiceCache
public static synchronized void sendEvent(String key,Bundle event){
    if (sEventCache.isEmpty()){
        return;
    }
    for (IBinder binder:sEventCache.values()){
        IEventReceiver eventReceiver = IEventReceiver.Stub.asInterface(binder);
        try {
            eventReceiver.onEventReceive(key, event);
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }
}

EventReceiver 存在于每个进程，因此，对于 binderprovider 来说都是客户端，其他进程则是服务端。最终 EventCenter 会根据 KEY 值来做分发。

到这里整个流程就基本讲完了。

不过我们发现还有两个 service ,他们的作用是干嘛用的呢？感觉是用来保活的，防止 provider 死了。

感谢各位的阅读！关于“如何实现CmProcess跨进程通信”这篇文章就分享到这里了，希望以上内容可以对大家有一定的帮助，让大家可以学到更多知识，如果觉得文章不错，可以把它分享出去让更多的人看到吧！

推荐阅读：
  1. BitMap实现
  2. listview实现

免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。

android

上一篇：Node如何实现搜索框进行模糊查询

下一篇：javascript如何实现拖曳互换div的位置

相关阅读

您好，登录后才能下订单哦！

密码登录
登录注册
获取短信验证码
其他方式登录
点击 登录注册 即表示同意《亿速云用户服务条款》
产品服务
地区划分
帮助支持
关于我们
行业资讯-文章归档 问答-问答归档
广州亿速云计算有限公司

7*24小时在线电话：400-100-2938

7*24小时在线QQ：800811969

Copyright © Yisu Cloud Ltd. All Rights Reserved. 2018 版权所有
粤ICP备17096448号-1 粤公网安备 44010402001142号