public ComponentName startService(Intent service) {

warnIfCallingFromSystemProcess();

return startServiceCommon(service, mUser);

}

private ComponentName startServiceCommon(Intent service, UserHandle user) {

try {

validateServiceIntent(service);

service.prepareToLeaveProcess();

ComponentName cn = ActivityManagerNative.getDefault().startService(

mMainThread.getApplicationThread(), service,

service.resolveTypeIfNeeded(getContentResolver()), user.getIdentifier());

…

public ComponentName startService(IApplicationThread caller, Intent service,

String resolvedType, int userId) throws RemoteException

{

Parcel data = Parcel.obtain();

Parcel reply = Parcel.obtain();

data.writeInterfaceToken(IActivityManager.descriptor);

data.writeStrongBinder(caller != null ? caller.asBinder() : null);

service.writeToParcel(data, 0);

data.writeString(resolvedType);

data.writeInt(userId);

mRemote.transact(START_SERVICE_TRANSACTION, data, reply, 0);

reply.readException();

ComponentName res = ComponentName.readFromParcel(reply);

data.recycle();

reply.recycle();

return res;

}

public ComponentName startService(IApplicationThread caller, Intent service,

String resolvedType, int userId) {

enforceNotIsolatedCaller("startService");

…

synchronized(this) {

final int callingPid = Binder.getCallingPid();

final int callingUid = Binder.getCallingUid();

final long origId = Binder.clearCallingIdentity();

ComponentName res = mServices.startServiceLocked(caller, service,

resolvedType, callingPid, callingUid, userId);

Binder.restoreCallingIdentity(origId);

return res;

}

}

ComponentName startServiceLocked(IApplicationThread caller,

Intent service, String resolvedType,

int callingPid, int callingUid, int userId) {

…

//获取进程的运行状态

final ProcessRecord callerApp = mAm.getRecordForAppLocked(caller);

callerFg = callerApp.setSchedGroup != Process.THREAD_GROUP_BG_NONINTERACTIVE;

…

//新建一个ServiceLookupResult容器 ，并创建ServiceRecord

ServiceLookupResult res =

retrieveServiceLocked(service, resolvedType,

callingPid, callingUid, userId, true, callerFg);

// record为空会返回

if (res.record == null) {

return new ComponentName("!", res.permission != null

? res.permission : "private to package");

}

ServiceRecord r = res.record;

//填充ServiceRecord的初始状态

r.lastActivity = SystemClock.uptimeMillis();

r.startRequested = true;

r.delayedStop = false;

r.pendingStarts.add(new ServiceRecord.StartItem(r, false, r.makeNextStartId(),

service, neededGrants));

…

if (!callerFg && r.app == null && mAm.mStartedUsers.get(r.userId) != null) {

…

}

//继续进一步调用

return startServiceInnerLocked(smap, service, r, callerFg, addToStarting);

ComponentName startServiceInnerLocked(ServiceMap smap, Intent service,

ServiceRecord r, boolean callerFg, boolean addToStarting) {

…

String error = bringUpServiceLocked(r, service.getFlags(), callerFg, false);

…

smap.ensureNotStartingBackground(r);

}

private final String bringUpServiceLocked(ServiceRecord r,

int intentFlags, boolean execInFg, boolean whileRestarting) {

…

if (r.app != null && r.app.thread != null) {

sendServiceArgsLocked(r, execInFg, false);

return null;

}

…

// Service is now being launched, its package can't be stopped.

try {

AppGlobals.getPackageManager().setPackageStoppedState(

r.packageName, false, r.userId);

app = mAm.getProcessRecordLocked(procName, r.appInfo.uid, false);

if (app != null && app.thread != null) {

try {

app.addPackage(r.appInfo.packageName, mAm.mProcessStats);

realStartServiceLocked(r, app, execInFg);

return null;

}}

if (app == null) {

if ((app=mAm.startProcessLocked(procName, r.appInfo, true, intentFlags,

"service", r.name, false, isolated, false)) == null) {

…

}}

private final void realStartServiceLocked(ServiceRecord r,

ProcessRecord app, boolean execInFg) throws RemoteException {

…

app.services.add(r);

bumpServiceExecutingLocked(r, execInFg, "create");

mAm.updateLruProcessLocked(app, true, false);

…

app.forceProcessStateUpTo(ActivityManager.PROCESS_STATE_SERVICE);

app.thread.scheduleCreateService(r, r.serviceInfo,

mAm.compatibilityInfoForPackageLocked(r.serviceInfo.applicationInfo),

app.repProcState);

r.postNotification();

created = true;

requestServiceBindingsLocked(r, execInFg);

…

sendServiceArgsLocked(r, execInFg, true);

…

}

private void handleCreateService(CreateServiceData data) {

java.lang.ClassLoader cl = packageInfo.getClassLoader();

service = (Service) cl.loadClass(data.info.name).newInstance();

…

ContextImpl context = new ContextImpl();

context.init(packageInfo, null, this);

Application app = packageInfo.makeApplication(false, mInstrumentation);

context.setOuterContext(service);

service.attach(context, this, data.info.name, data.token, app,

ActivityManagerNative.getDefault());

service.onCreate();

mServices.put(data.token, service);

try {

ActivityManagerNative.getDefault().serviceDoneExecuting(

data.token, 0, 0, 0);

private static void registerService(String serviceName, ServiceFetcher fetcher) {

if (!(fetcher instanceof StaticServiceFetcher)) {

fetcher.mContextCacheIndex = sNextPerContextServiceCacheIndex++;

}

SYSTEM_SERVICE_MAP.put(serviceName, fetcher);

}

…

static {

registerService(ACCESSIBILITY_SERVICE, new ServiceFetcher() {

public Object getService(ContextImpl ctx) {

return AccessibilityManager.getInstance(ctx);

}});

registerService(CAPTIONING_SERVICE, new ServiceFetcher() {

public Object getService(ContextImpl ctx) {

return new CaptioningManager(ctx);

}});

…

registerService(ACTIVITY_SERVICE, new ServiceFetcher() {

public Object createService(ContextImpl ctx) {

return new ActivityManager(ctx.getOuterContext(), ctx.mMainThread.getHandler());

}});

ContextImpl() {

mOuterContext = this;

}

final void init(LoadedApk packageInfo, IBinder activityToken, ActivityThread mainThread,

Resources container, String basePackageName, UserHandle user) {

mPackageInfo = packageInfo;

…

mResources = mPackageInfo.getResources(mainThread);

mResourcesManager = ResourcesManager.getInstance();

…

mMainThread = mainThread;

mActivityToken = activityToken;

mContentResolver = new ApplicationContentResolver(this, mainThread, user);

mUser = user;

}

context.setOuterContext(service);

final void setOuterContext(Context context) {

mOuterContext = context;

}

public Application makeApplication(boolean forceDefaultAppClass,

Instrumentation instrumentation) {

if (mApplication != null) {

return mApplication;

}

…

java.lang.ClassLoader cl = getClassLoader();

ContextImpl appContext = new ContextImpl();

appContext.init(this, null, mActivityThread);

app = mActivityThread.mInstrumentation.newApplication(

cl, appClass, appContext);

appContext.setOuterContext(app);

…

mActivityThread.mAllApplications.add(app);

mApplication = app;

if (instrumentation != null) {

try {

instrumentation.callApplicationOnCreate(app);

…

public final void attach(

Context context,

ActivityThread thread, String className, IBinder token,

Application application, Object activityManager) {

attachBaseContext(context);

mThread = thread; // NOTE: unused - remove?

mClassName = className;

mToken = token;

mApplication = application;

mActivityManager = (IActivityManager)activityManager;

mStartCompatibility = getApplicationInfo().targetSdkVersion

< Build.VERSION_CODES.ECLAIR;

}

private void handleServiceArgs(ServiceArgsData data) {

Service s = mServices.get(data.token);

if (data.args != null) {

data.args.setExtrasClassLoader(s.getClassLoader());

}

int res;

if (!data.taskRemoved) {

res = s.onStartCommand(data.args, data.flags, data.startId);

} else {

s.onTaskRemoved(data.args);

res = Service.START_TASK_REMOVED_COMPLETE;

}

QueuedWork.waitToFinish();

try {

ActivityManagerNative.getDefault().serviceDoneExecuting(

data.token, 1, data.startId, res);

} catch (RemoteException e) {

// nothing to do.

}

ensureJitEnabled();

}