BindService详解

	@Override
	public boolean bindService(Intent service, ServiceConnection conn, int flags) {
		//这个方法仅仅是打印日志用于警告，忽略
		warnIfCallingFromSystemProcess();
		//调用了bindServiceCommon（）看下面
		return bindServiceCommon(service, conn, flags, Process.myUserHandle());
	}
	/**
	 *  启动远程Service
	 * @param service  Intent指定要启动的Service
	 * @param conn      ServiceConnection，用于Service连接后就通过这个对象来回调其方法返回远程的Binder对象
	 * @param flags
	 * @param user
	 * @return
	 */
	private boolean bindServiceCommon(Intent service, ServiceConnection conn,
			int flags, UserHandle user) {
		IServiceConnection sd;
		if (conn == null) {
			throw new IllegalArgumentException("connection is null");
		}
		if (mPackageInfo != null) {
			//mPackageInfo是一个LoadApk实例，此方法用于返回一个IServiceConnection实例也就是InnerConnection类型的对象
			sd = mPackageInfo.getServiceDispatcher(conn, getOuterContext(),
					mMainThread.getHandler(), flags);
		} else {
			throw new RuntimeException("Not supported in system context");
		}
		validateServiceIntent(service);
		try {
			//获取令牌，表示要bindService的身份，这里就是用来表明Activity的身份
			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();
			//AMS调用bindService（）
			int res = ActivityManagerNative.getDefault().bindService(
					mMainThread.getApplicationThread(), getActivityToken(),
					service, service.resolveTypeIfNeeded(getContentResolver()),
					sd, flags, getOpPackageName(), user.getIdentifier());
			if (res < 0) {
				throw new SecurityException("Not allowed to bind to service "
						+ service);
			}
			return res != 0;
		} catch (RemoteException e) {
			throw new RuntimeException("Failure from system", e);
		}
	}

    /**
     * 获取一个IServiceConnection实例，
     * @param c
     * @param context
     * @param handler
     * @param flags
     * @return
     */
    public final IServiceConnection getServiceDispatcher(ServiceConnection c,
            Context context, Handler handler, int flags) {
        synchronized (mServices) {
            LoadedApk.ServiceDispatcher sd = null;
            ArrayMap<ServiceConnection, LoadedApk.ServiceDispatcher> map = mServices.get(context);
            if (map != null) {
                sd = map.get(c);
            }
            if (sd == null) {
            	//ServiceDispatcher是LoadedApk的内部类，在此方法中就会创建一个InnerConnection实例
                sd = new ServiceDispatcher(c, context, handler, flags);
                //如果本地还没有此链接就创建新的连接并保存到数组
                if (map == null) {
                    map = new ArrayMap<ServiceConnection, LoadedApk.ServiceDispatcher>();
                    mServices.put(context, map);
                }
                map.put(c, sd);
            } else {
                sd.validate(context, handler);
            }
            //返回InnerConnection实例mIServiceConnection
            return sd.getIServiceConnection();
        }
    }

int res = ActivityManagerNative.getDefault().bindService(
					mMainThread.getApplicationThread(), getActivityToken(),
					service, service.resolveTypeIfNeeded(getContentResolver()),
					sd, flags, getOpPackageName(), user.getIdentifier());

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

        synchronized(this) {
        	//这个mServices是一个ActivityService实例
            return mServices.bindServiceLocked(caller, token, service,
                    resolvedType, connection, flags, callingPackage, userId);
        }
    }

  int bindServiceLocked(IApplicationThread caller, IBinder token, Intent service,
            String resolvedType, IServiceConnection connection, int flags,
            String callingPackage, int userId) throws TransactionTooLargeException {
        //根据调用者来获取正在运行的当前app的所有进程信息
        final ProcessRecord callerApp = mAm.getRecordForAppLocked(caller);
        //如果没有找到进程记录就说明进程跪了，抛出异常
        if (callerApp == null) {
            throw new SecurityException(
                    "Unable to find app for caller " + caller
                    + " (pid=" + Binder.getCallingPid()
                    + ") when binding service " + service);
        }

        ActivityRecord activity = null;
        if (token != null) {
        	//根据token获取ActivityRecord，也就是获取调用bindService（）的那个Activity
        	//这一步就是从任务栈中去查找Activity
            activity = ActivityRecord.isInStackLocked(token);
            //如果没有找到就会绑定失败
            if (activity == null) {
                return 0;
            }
        }

        int clientLabel = 0;
        PendingIntent clientIntent = null;
        final boolean callerFg = callerApp.setSchedGroup != Process.THREAD_GROUP_BG_NONINTERACTIVE;
        //这里根据Intent获取Service
        ServiceLookupResult res =
            retrieveServiceLocked(service, resolvedType, callingPackage,
                    Binder.getCallingPid(), Binder.getCallingUid(), userId, true, callerFg);
        ServiceRecord s = res.record;
        final long origId = Binder.clearCallingIdentity();
        try {
            if (unscheduleServiceRestartLocked(s, callerApp.info.uid, false)) {
            }

            if ((flags&Context.BIND_AUTO_CREATE) != 0) {
                s.lastActivity = SystemClock.uptimeMillis();
            }

            mAm.startAssociationLocked(callerApp.uid, callerApp.processName,
                    s.appInfo.uid, s.name, s.processName);

            AppBindRecord b = s.retrieveAppBindingLocked(service, callerApp);
            //创建一个Connection记录,Service的连接
            //ConnectionRecord的解释是：Description of a single binding to a service
            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>();
                }
                //把ConnectionRecord保存到ActivityRecord中也就是云行的Activity，
                activity.connections.add(c);
            }

            if (s.app != null && b.intent.received) {
                try {
                	//这里开始就是调用了InnerConnection的connected（）方法，这种调用是跨进程的，即它调用时会首先调用IServiceConnection.Stub.Proxy的connected（）方法
                	//这个流程在上一篇文章已经讲过了，不再赘述，总之，它最后就调用了我们的MainActivity中定义的MyServiceConnection的onServiceConnected（）方法，这个b.intent.binder就是远程的对象即IServiceConnection对象。
                    c.conn.connected(s.name, b.intent.binder);
                } catch (Exception e) {
                }
            } else if (!b.intent.requested) {
                requestServiceBindingLocked(s, b.intent, callerFg, false);
            }
        } finally {
            Binder.restoreCallingIdentity(origId);
        }
        return 1;
    }