美文网首页
bindService流程分析

bindService流程分析

作者: 风月寒 | 来源:发表于2021-01-20 16:20 被阅读0次

    继上一篇大概介绍了startService的流程之后,下面来看看bindService流程。

    public boolean bindService(Intent service, ServiceConnection conn, int flags) {
            warnIfCallingFromSystemProcess();
            return bindServiceCommon(service, conn, flags, null, mMainThread.getHandler(), null,
                    getUser());
        }
        
    private boolean bindServiceCommon(Intent service, ServiceConnection conn, int flags,
                String instanceName, Handler handler, Executor executor, UserHandle user) {
            // Keep this in sync with DevicePolicyManager.bindDeviceAdminServiceAsUser.
            IServiceConnection sd;
            //有上面可知,handler不为null,所以走else
            if (mPackageInfo != null) {
                if (executor != null) {
                    sd = mPackageInfo.getServiceDispatcher(conn, getOuterContext(), executor, flags);
                } else {
                // handler不为null,将 ServiceConnection 封装成 IServiceConnection
                // IServiceConnection 就是 LoadedApk.ServiceDispatcher.InnerConnection 类
                // 将 conn 保持到InnerConnection中,handler 为主线程Handler,也就是 ActivityThread的内部类 H 对象
                    sd = mPackageInfo.getServiceDispatcher(conn, getOuterContext(), handler, flags);
                }
            } else {
                throw new RuntimeException("Not supported in system context");
            }
            validateServiceIntent(service);
            try {
                IBinder token = getActivityToken();
                if (token == null && (flags&BIND_AUTO_CREATE) == 0 && mPackageInfo != null
                        && mPackageInfo.getApplicationInfo().targetSdkVersion
                        < android.os.Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
                    flags |= BIND_WAIVE_PRIORITY;
                }
                service.prepareToLeaveProcess(this);
                //跨进程调用bindIsolatedService()
                int res = ActivityManager.getService().bindIsolatedService(
                    mMainThread.getApplicationThread(), getActivityToken(), service,
                    service.resolveTypeIfNeeded(getContentResolver()),
                    sd, flags, instanceName, getOpPackageName(), user.getIdentifier());
                if (res < 0) {
                    throw new SecurityException(
                            "Not allowed to bind to service " + service);
                }
                return res != 0;
            } catch (RemoteException e) {
                throw e.rethrowFromSystemServer();
            }
        }
    
    public int bindService(IApplicationThread caller, IBinder token, Intent service,
                String resolvedType, IServiceConnection connection, int flags, String callingPackage,
                int userId) throws TransactionTooLargeException {
            enforceNotIsolatedCaller("bindService");
    
            // Refuse possible leaked file descriptors
            if (service != null && service.hasFileDescriptors() == true) {
                throw new IllegalArgumentException("File descriptors passed in Intent");
            }
    
            if (callingPackage == null) {
                throw new IllegalArgumentException("callingPackage cannot be null");
            }
            //AMS中同样直接交给了ActiveService处理。
            synchronized(this) {
                return mServices.bindServiceLocked(caller, token, service,
                        resolvedType, connection, flags, callingPackage, userId);
            }
        }
    
    
    int bindServiceLocked(IApplicationThread caller, IBinder token, Intent service,
                String resolvedType, final IServiceConnection connection, int flags,
                String callingPackage, final int userId) throws TransactionTooLargeException {
                .....
            // 从ServiceMap中查找ServiceRecord,在这里进行了exported属性、权限等校验。
            ServiceLookupResult res =
                retrieveServiceLocked(service, resolvedType, callingPackage, Binder.getCallingPid(),
                        Binder.getCallingUid(), userId, true, callerFg, isBindExternal, allowInstant);
            if (res == null) {
                return 0;
            }
            if (res.record == null) {
                return -1;
            }
            ServiceRecord s = res.record;
    
            boolean permissionsReviewRequired = false;
            }
    
            try {
               // 将Service调用方和被调用方的信息保存到AMS中
                mAm.startAssociationLocked(callerApp.uid, callerApp.processName, callerApp.curProcState,
                        s.appInfo.uid, s.name, s.processName);
                mAm.grantEphemeralAccessLocked(callerApp.userId, service,
                        s.appInfo.uid, UserHandle.getAppId(callerApp.uid));
                // 创建连接信息
                AppBindRecord b = s.retrieveAppBindingLocked(service, callerApp);
                ConnectionRecord c = new ConnectionRecord(b, activity,
                        connection, flags, clientLabel, clientIntent);
    
                IBinder binder = connection.asBinder();
                ArrayList<ConnectionRecord> clist = s.connections.get(binder);
                if (clist == null) {
                    clist = new ArrayList<ConnectionRecord>();
                    s.connections.put(binder, clist);
                }
                clist.add(c);
                b.connections.add(c);
                if (activity != null) {
                    if (activity.connections == null) {
                        activity.connections = new HashSet<ConnectionRecord>();
                    }
                    activity.connections.add(c);
                }
                b.client.connections.add(c);
                if ((c.flags&Context.BIND_ABOVE_CLIENT) != 0) {
                    b.client.hasAboveClient = true;
                }
                if ((c.flags&Context.BIND_ALLOW_WHITELIST_MANAGEMENT) != 0) {
                    s.whitelistManager = true;
                }
                if (s.app != null) {
                    updateServiceClientActivitiesLocked(s.app, c, true);
                }
                clist = mServiceConnections.get(binder);
                //将连接信息保存到mServiceConnections中
                if (clist == null) {
                    clist = new ArrayList<ConnectionRecord>();
                    mServiceConnections.put(binder, clist);
                }
                clist.add(c);
                //如flag包含BIND_AUTO_CREATE,先启动Service
                if ((flags&Context.BIND_AUTO_CREATE) != 0) {
                    s.lastActivity = SystemClock.uptimeMillis();
                    if (bringUpServiceLocked(s, service.getFlags(), callerFg, false,
                            permissionsReviewRequired) != null) {
                        return 0;
                    }
                }
    
                if (s.app != null) {
                    if ((flags&Context.BIND_TREAT_LIKE_ACTIVITY) != 0) {
                        s.app.treatLikeActivity = true;
                    }
                    if (s.whitelistManager) {
                        s.app.whitelistManager = true;
                    }
                    // This could have made the service more important.
                    mAm.updateLruProcessLocked(s.app, s.app.hasClientActivities
                            || s.app.treatLikeActivity, b.client);
                    mAm.updateOomAdjLocked(s.app, true);
                }
    
    
                if (s.app != null && b.intent.received) {
                    try {
                     // 6.如Service已启动或者此intent未被连接过,立即发布连接,回调onServiceConnected
                        c.conn.connected(s.name, b.intent.binder, false);
                    } catch (Exception e) {
                        
                    }
    
                    if (b.intent.apps.size() == 1 && b.intent.doRebind) {
                        requestServiceBindingLocked(s, b.intent, callerFg, true);
                    }
                } else if (!b.intent.requested) {
                    // 7.Service未被bind过,先调用onBind,再回调onServiceConnected
                    requestServiceBindingLocked(s, b.intent, callerFg, false);
                }
    
                getServiceMapLocked(s.userId).ensureNotStartingBackgroundLocked(s);
    
            } finally {
                Binder.restoreCallingIdentity(origId);
            }
    
            return 1;
        }
    

    然后调用requestServiceBindingLocked()进行绑定工作。

    private final boolean requestServiceBindingLocked(ServiceRecord r, IntentBindRecord i,
                boolean execInFg, boolean rebind) throws TransactionTooLargeException {
            if (r.app == null || r.app.thread == null) {
                // If service is not currently running, can't yet bind.
                return false;
            }
        
            if ((!i.requested || rebind) && i.apps.size() > 0) {
                try {
                    bumpServiceExecutingLocked(r, execInFg, "bind");
                    r.app.forceProcessStateUpTo(ActivityManager.PROCESS_STATE_SERVICE);
                    //跨进程调用scheduleBindService
                    r.app.thread.scheduleBindService(r, i.intent.getIntent(), rebind,
                            r.app.repProcState);
                    if (!rebind) {
                        i.requested = true;
                    }
                    i.hasBound = true;
                    i.doRebind = false;
                } catch (TransactionTooLargeException e) {
                    
                }
            }
            return true;
        }
    
    private void handleBindService(BindServiceData data) {
            Service s = mServices.get(data.token);
            if (DEBUG_SERVICE)
                Slog.v(TAG, "handleBindService s=" + s + " rebind=" + data.rebind);
            if (s != null) {
                try {
                    data.intent.setExtrasClassLoader(s.getClassLoader());
                    data.intent.prepareToEnterProcess();
                    try {
                        if (!data.rebind) {
                            // 调用 Service 的 onBind() 方法
                            IBinder binder = s.onBind(data.intent);
                            // 这里调用 ActivityManagerService 的 publishService() 方法
                            ActivityManager.getService().publishService(
                                    data.token, data.intent, binder);
                        } else {
                            // 如果是重新绑定,就调用 Service 的 onRebind() 方法
                            s.onRebind(data.intent);
                            ActivityManager.getService().serviceDoneExecuting(
                                    data.token, SERVICE_DONE_EXECUTING_ANON, 0, 0);
                        }
                    } catch (RemoteException ex) {
                        throw ex.rethrowFromSystemServer();
                    }
                } catch (Exception e) {
                    if (!mInstrumentation.onException(s, e)) {
                        throw new RuntimeException(
                                "Unable to bind to service " + s
                                + " with " + data.intent + ": " + e.toString(), e);
                    }
                }
            }
        }
    

    调用 ActivityManagerService 的 publishService()方法

    public void publishService(IBinder token, Intent intent, IBinder service) {
            // Refuse possible leaked file descriptors
            if (intent != null && intent.hasFileDescriptors() == true) {
                throw new IllegalArgumentException("File descriptors passed in Intent");
            }
    
            synchronized(this) {
                if (!(token instanceof ServiceRecord)) {
                    throw new IllegalArgumentException("Invalid service token");
                }
                mServices.publishServiceLocked((ServiceRecord)token, intent, service);
            }
        
    void publishServiceLocked(ServiceRecord r, Intent intent, IBinder service) {
            final long origId = Binder.clearCallingIdentity();
            try {
                if (r != null) {
                    Intent.FilterComparison filter
                            = new Intent.FilterComparison(intent);
                    IntentBindRecord b = r.bindings.get(filter);
                    if (b != null && !b.received) {
                       // 将IntentBindRecord.binder赋值为onBinder返回的Binder对象
                        b.binder = service;
                        b.requested = true;
                        //将IntentBindRecord.binder置为true,表示已调用onBind
                        b.received = true;
                        //遍历此Service的所有连接记录
                        for (int conni=r.connections.size()-1; conni>=0; conni--) {
                            ArrayList<ConnectionRecord> clist = r.connections.valueAt(conni);
                            for (int i=0; i<clist.size(); i++) {
                                ConnectionRecord c = clist.get(i);
                                if (!filter.equals(c.binding.intent.intent)) {
                                    continue;
                                }
                                try {
                                    // 找到匹配的intent进行连接
                                    c.conn.connected(r.name, service, false);
                                } catch (Exception e) {
                                    
                                }
                            }
                        }
                    }
    
                    serviceDoneExecutingLocked(r, mDestroyingServices.contains(r), false);
                }
            } finally {
                Binder.restoreCallingIdentity(origId);
            }
        }
    
    

    c.conn 为 IServiceConnection 对象,实际就是 LoadedApk.ServiceDispatcher.InnerConnection 类。

    private static class InnerConnection extends IServiceConnection.Stub {
                @UnsupportedAppUsage
                final WeakReference<LoadedApk.ServiceDispatcher> mDispatcher;
    
                InnerConnection(LoadedApk.ServiceDispatcher sd) {
                    mDispatcher = new WeakReference<LoadedApk.ServiceDispatcher>(sd);
                }
    
                public void connected(ComponentName name, IBinder service, boolean dead)
                        throws RemoteException {
                    LoadedApk.ServiceDispatcher sd = mDispatcher.get();
                    if (sd != null) {
                        sd.connected(name, service, dead);
                    }
                }
            }
    

    最后会调用ServiceDispatcher的connected();

    public void connected(ComponentName name, IBinder service, boolean dead) {
                if (mActivityExecutor != null) {
                    mActivityExecutor.execute(new RunConnection(name, service, 0, dead));
                } else if (mActivityThread != null) {
                // 由 ContextImpl#bindServiceCommon() 方法中可知,mActivityThread 就是 ActivityThread 的 H对象(主线程的Handler),不为null
                // RunConnection 的 run方法中调用 doConnected() 方法
                // 因为是通过主线程的Handler调用的方法,所以客户端的ServiceConnection#onServiceConnected()运行在主线程
                    mActivityThread.post(new RunConnection(name, service, 0, dead));
                } else {
                    doConnected(name, service, dead);
                }
            }
    
    private final class RunConnection implements Runnable {
                RunConnection(ComponentName name, IBinder service, int command, boolean dead) {
                    mName = name;
                    mService = service;
                    mCommand = command;
                    mDead = dead;
                }
    
                public void run() {
                    if (mCommand == 0) {
                        //表示连接成功,在这里面会调用onServiceConnected回调
                        doConnected(mName, mService, mDead);
                    } else if (mCommand == 1) {
                        //表示失去连接,在这会调用onServiceDisconnected回调。
                        doDeath(mName, mService);
                    }
                }
            }
        }
        
    

    相关文章

      网友评论

          本文标题:bindService流程分析

          本文链接:https://www.haomeiwen.com/subject/pavkzktx.html