Service源码解读

发表于 | 分类于
字数统计: 2,382字 | 阅读时长 ≈ 14分钟

StartService

时序图

Service_Start

核心代码

startServiceLocked

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
ComponentName startServiceLocked(IApplicationThread caller, Intent service, String resolvedType,
         int callingPid, int callingUid, String callingPackage, int userId)
         throws TransactionTooLargeException {
     if (DEBUG_DELAYED_STARTS) Slog.v(TAG_SERVICE, "startService: " + service
             + " type=" + resolvedType + " args=" + service.getExtras());

     final boolean callerFg;
     if (caller != null) {
         final ProcessRecord callerApp = mAm.getRecordForAppLocked(caller);
         if (callerApp == null) {
             throw new SecurityException(
                     "Unable to find app for caller " + caller
                     + " (pid=" + Binder.getCallingPid()
                     + ") when starting service " + service);
         }
         callerFg = callerApp.setSchedGroup != Process.THREAD_GROUP_BG_NONINTERACTIVE;
     } else {
         callerFg = true;
     }

    /**
         private final class ServiceLookupResult {
             final ServiceRecord record;
             final String permission;

             ServiceLookupResult(ServiceRecord _record, String _permission) {
                 record = _record;
                 permission = _permission;
             }
         }
     **/
  
     ServiceLookupResult res =
         retrieveServiceLocked(service, resolvedType, callingPackage,
                 callingPid, callingUid, userId, true, callerFg);
     if (res == null) {
         return null;
     }
     if (res.record == null) {
         return new ComponentName("!", res.permission != null
                 ? res.permission : "private to package");
     }

     ServiceRecord r = res.record;

     if (!mAm.getUserManagerLocked().exists(r.userId)) {
         Slog.d(TAG, "Trying to start service with non-existent user! " + r.userId);
         return null;
     }
    // check permission 
     NeededUriGrants neededGrants = mAm.checkGrantUriPermissionFromIntentLocked(
             callingUid, r.packageName, service, service.getFlags(), null, r.userId);
     if (unscheduleServiceRestartLocked(r, callingUid, false)) {
         if (DEBUG_SERVICE) Slog.v(TAG_SERVICE, "START SERVICE WHILE RESTART PENDING: " + r);
     }
     r.lastActivity = SystemClock.uptimeMillis();
     r.startRequested = true;
     r.delayedStop = false;
     r.pendingStarts.add(new ServiceRecord.StartItem(r, false, r.makeNextStartId(),
             service, neededGrants));

     final ServiceMap smap = getServiceMap(r.userId);
     boolean addToStarting = false;
     if (!callerFg && r.app == null && mAm.mStartedUsers.get(r.userId) != null) {
         ProcessRecord proc = mAm.getProcessRecordLocked(r.processName, r.appInfo.uid, false);
         if (proc == null || proc.curProcState > ActivityManager.PROCESS_STATE_RECEIVER) {
             // If this is not coming from a foreground caller, then we may want
             // to delay the start if there are already other background services
             // that are starting.  This is to avoid process start spam when lots
             // of applications are all handling things like connectivity broadcasts.
             // We only do this for cached processes, because otherwise an application
             // can have assumptions about calling startService() for a service to run
             // in its own process, and for that process to not be killed before the
             // service is started.  This is especially the case for receivers, which
             // may start a service in onReceive() to do some additional work and have
             // initialized some global state as part of that.
             if (DEBUG_DELAYED_SERVICE) Slog.v(TAG_SERVICE, "Potential start delay of "
                     + r + " in " + proc);
             if (r.delayed) {
                 // This service is already scheduled for a delayed start; just leave
                 // it still waiting.
                 if (DEBUG_DELAYED_STARTS) Slog.v(TAG_SERVICE, "Continuing to delay: " + r);
                 return r.name;
             }
             if (smap.mStartingBackground.size() >= mMaxStartingBackground) {
                 // Something else is starting, delay!
                 Slog.i(TAG_SERVICE, "Delaying start of: " + r);
                 smap.mDelayedStartList.add(r);
                 r.delayed = true;
                 return r.name;
             }
             if (DEBUG_DELAYED_STARTS) Slog.v(TAG_SERVICE, "Not delaying: " + r);
             addToStarting = true;
         } else if (proc.curProcState >= ActivityManager.PROCESS_STATE_SERVICE) {
             // We slightly loosen when we will enqueue this new service as a background
             // starting service we are waiting for, to also include processes that are
             // currently running other services or receivers.
             addToStarting = true;
             if (DEBUG_DELAYED_STARTS) Slog.v(TAG_SERVICE,
                     "Not delaying, but counting as bg: " + r);
         } else if (DEBUG_DELAYED_STARTS) {
             StringBuilder sb = new StringBuilder(128);
             sb.append("Not potential delay (state=").append(proc.curProcState)
                     .append(' ').append(proc.adjType);
             String reason = proc.makeAdjReason();
             if (reason != null) {
                 sb.append(' ');
                 sb.append(reason);
             }
             sb.append("): ");
             sb.append(r.toString());
             Slog.v(TAG_SERVICE, sb.toString());
         }
     } else if (DEBUG_DELAYED_STARTS) {
         if (callerFg) {
             Slog.v(TAG_SERVICE, "Not potential delay (callerFg=" + callerFg + " uid="
                     + callingUid + " pid=" + callingPid + "): " + r);
         } else if (r.app != null) {
             Slog.v(TAG_SERVICE, "Not potential delay (cur app=" + r.app + "): " + r);
         } else {
             Slog.v(TAG_SERVICE,
                     "Not potential delay (user " + r.userId + " not started): " + r);
         }
     }

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

bringUpServiceLocked

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
  
private final String bringUpServiceLocked(ServiceRecord r, int intentFlags, boolean execInFg,
            boolean whileRestarting) throws TransactionTooLargeException {
        //Slog.i(TAG, "Bring up service:");
        //r.dump("  ");

        if (r.app != null && r.app.thread != null) {
            sendServiceArgsLocked(r, execInFg, false);
            return null;
        }

        if (!whileRestarting && r.restartDelay > 0) {
            // If waiting for a restart, then do nothing.
            return null;
        }

        if (DEBUG_SERVICE) Slog.v(TAG_SERVICE, "Bringing up " + r + " " + r.intent);

        // We are now bringing the service up, so no longer in the
        // restarting state.
        if (mRestartingServices.remove(r)) {
            r.resetRestartCounter();
            clearRestartingIfNeededLocked(r);
        }

        // Make sure this service is no longer considered delayed, we are starting it now.
        if (r.delayed) {
            if (DEBUG_DELAYED_STARTS) Slog.v(TAG_SERVICE, "REM FR DELAY LIST (bring up): " + r);
            getServiceMap(r.userId).mDelayedStartList.remove(r);
            r.delayed = false;
        }

        // Make sure that the user who owns this service is started.  If not,
        // we don't want to allow it to run.
        if (mAm.mStartedUsers.get(r.userId) == null) {
            String msg = "Unable to launch app "
                    + r.appInfo.packageName + "/"
                    + r.appInfo.uid + " for service "
                    + r.intent.getIntent() + ": user " + r.userId + " is stopped";
            Slog.w(TAG, msg);
            bringDownServiceLocked(r);
            return msg;
        }

        // Service is now being launched, its package can't be stopped.
        try {
            AppGlobals.getPackageManager().setPackageStoppedState(
                    r.packageName, false, r.userId);
        } catch (RemoteException e) {
        } catch (IllegalArgumentException e) {
            Slog.w(TAG, "Failed trying to unstop package "
                    + r.packageName + ": " + e);
        }
  
       //check wehther to make an isolated process
        final boolean isolated = (r.serviceInfo.flags&ServiceInfo.FLAG_ISOLATED_PROCESS) != 0;
        final String procName = r.processName;
        ProcessRecord app;

        if (!isolated) {
            app = mAm.getProcessRecordLocked(procName, r.appInfo.uid, false);
            if (DEBUG_MU) Slog.v(TAG_MU, "bringUpServiceLocked: appInfo.uid=" + r.appInfo.uid
                        + " app=" + app);
            if (app != null && app.thread != null) {
                try {
                    app.addPackage(r.appInfo.packageName, r.appInfo.versionCode, mAm.mProcessStats);
                    realStartServiceLocked(r, app, execInFg);
                    return null;
                } catch (TransactionTooLargeException e) {
                    throw e;
                } catch (RemoteException e) {
                    Slog.w(TAG, "Exception when starting service " + r.shortName, e);
                }

                // If a dead object exception was thrown -- fall through to
                // restart the application.
            }
        } else {
            // If this service runs in an isolated process, then each time
            // we call startProcessLocked() we will get a new isolated
            // process, starting another process if we are currently waiting
            // for a previous process to come up.  To deal with this, we store
            // in the service any current isolated process it is running in or
            // waiting to have come up.
            app = r.isolatedProc;
        }

        // Not running -- get it started, and enqueue this service record
        // to be executed when the app comes up.
        if (app == null) {
          /**
       final ProcessRecord newProcessRecordLocked(ApplicationInfo info, String customProcess,
            boolean isolated, int isolatedUid) {
        String proc = customProcess != null ? customProcess : info.processName;
        BatteryStatsImpl stats = mBatteryStatsService.getActiveStatistics();
        final int userId = UserHandle.getUserId(info.uid);
        int uid = info.uid;
        //here is the difference
        if (isolated) {
            if (isolatedUid == 0) {
                int stepsLeft = Process.LAST_ISOLATED_UID - Process.FIRST_ISOLATED_UID + 1;
                while (true) {
                    if (mNextIsolatedProcessUid < Process.FIRST_ISOLATED_UID
                            || mNextIsolatedProcessUid > Process.LAST_ISOLATED_UID) {
                        mNextIsolatedProcessUid = Process.FIRST_ISOLATED_UID;
                    }
                    uid = UserHandle.getUid(userId, mNextIsolatedProcessUid);
                    mNextIsolatedProcessUid++;
                    if (mIsolatedProcesses.indexOfKey(uid) < 0) {
                        // No process for this uid, use it.
                        break;
                    }
                    stepsLeft--;
                    if (stepsLeft <= 0) {
                        return null;
                    }
                }
            } else {
                // Special case for startIsolatedProcess (internal only), where
                // the uid of the isolated process is specified by the caller.
                uid = isolatedUid;
            }
            ......
            }
        }
          **/
            if ((app=mAm.startProcessLocked(procName, r.appInfo, true, intentFlags,
                    "service", r.name, false, isolated, false)) == null) {
                String msg = "Unable to launch app "
                        + r.appInfo.packageName + "/"
                        + r.appInfo.uid + " for service "
                        + r.intent.getIntent() + ": process is bad";
                Slog.w(TAG, msg);
                bringDownServiceLocked(r);
                return msg;
            }
            if (isolated) {
                r.isolatedProc = app;
            }
        }

        if (!mPendingServices.contains(r)) {
            mPendingServices.add(r);
        }

        if (r.delayedStop) {
            // Oh and hey we've already been asked to stop!
            r.delayedStop = false;
            if (r.startRequested) {
                if (DEBUG_DELAYED_STARTS) Slog.v(TAG_SERVICE,
                        "Applying delayed stop (in bring up): " + r);
                stopServiceLocked(r);
            }
        }

        return null;
    }

CreateService

时序图

Service_Create

核心代码

handleCreateService

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
private void handleCreateService(CreateServiceData data) {
    // If we are getting ready to gc after going to the background, well
    // we are back active so skip it.
    unscheduleGcIdler();

    LoadedApk packageInfo = getPackageInfoNoCheck(
            data.info.applicationInfo, data.compatInfo);
    Service service = null;
    try {
        java.lang.ClassLoader cl = packageInfo.getClassLoader();
        service = (Service) cl.loadClass(data.info.name).newInstance();
    } catch (Exception e) {
        if (!mInstrumentation.onException(service, e)) {
            throw new RuntimeException(
                "Unable to instantiate service " + data.info.name
                + ": " + e.toString(), e);
        }
    }

    try {
        if (localLOGV) Slog.v(TAG, "Creating service " + data.info.name);

        ContextImpl context = ContextImpl.createAppContext(this, packageInfo);
        context.setOuterContext(service);

        Application app = packageInfo.makeApplication(false, mInstrumentation);
        service.attach(context, this, data.info.name, data.token, app,
                ActivityManagerNative.getDefault());
        service.onCreate();
        mServices.put(data.token, service);
        try {
          // notify the ams service has been created.
            ActivityManagerNative.getDefault().serviceDoneExecuting(
                    data.token, SERVICE_DONE_EXECUTING_ANON, 0, 0);
        } catch (RemoteException e) {
            // nothing to do.
        }
    } catch (Exception e) {
        if (!mInstrumentation.onException(service, e)) {
            throw new RuntimeException(
                "Unable to create service " + data.info.name
                + ": " + e.toString(), e);
        }
    }
}

BindService

时序图

Service_Bind

核心代码

publishServiceLocked

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
void publishServiceLocked(ServiceRecord r, Intent intent, IBinder service) {
     final long origId = Binder.clearCallingIdentity();
     try {
         if (DEBUG_SERVICE) Slog.v(TAG_SERVICE, "PUBLISHING " + r
                 + " " + intent + ": " + service);
         if (r != null) {
             Intent.FilterComparison filter
                     = new Intent.FilterComparison(intent);
             IntentBindRecord b = r.bindings.get(filter);
             if (b != null && !b.received) {
                 b.binder = service;
                 b.requested = true;
                 b.received = true;
                 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)) {
                             if (DEBUG_SERVICE) Slog.v(
                                     TAG_SERVICE, "Not publishing to: " + c);
                             if (DEBUG_SERVICE) Slog.v(
                                     TAG_SERVICE, "Bound intent: " + c.binding.intent.intent);
                             if (DEBUG_SERVICE) Slog.v(
                                     TAG_SERVICE, "Published intent: " + intent);
                             continue;
                         }
                         if (DEBUG_SERVICE) Slog.v(TAG_SERVICE, "Publishing to: " + c);
                         try {
                           //c.conn -> LoadedApk.ServiceDispatcher.InnerConnection
                             c.conn.connected(r.name, service);
                         } catch (Exception e) {
                             Slog.w(TAG, "Failure sending service " + r.name +
                                   " to connection " + c.conn.asBinder() +
                                   " (in " + c.binding.client.processName + ")", e);
                         }
                     }
                 }
             }

             serviceDoneExecutingLocked(r, mDestroyingServices.contains(r), false);
         }
     } finally {
         Binder.restoreCallingIdentity(origId);
     }
 }

doConnected

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
      
public void doConnected(ComponentName name, IBinder service) {
            ServiceDispatcher.ConnectionInfo old;
            ServiceDispatcher.ConnectionInfo info;

            synchronized (this) {
                if (mForgotten) {
                    // We unbound before receiving the connection; ignore
                    // any connection received.
                    return;
                }
                old = mActiveConnections.get(name);
                if (old != null && old.binder == service) {
                    // Huh, already have this one.  Oh well!
                    return;
                }

                if (service != null) {
                    // A new service is being connected... set it all up.
                    mDied = false;
                    info = new ConnectionInfo();
                    info.binder = service;
                    info.deathMonitor = new DeathMonitor(name, service);
                    try {
                        service.linkToDeath(info.deathMonitor, 0);
                        mActiveConnections.put(name, info);
                    } catch (RemoteException e) {
                        // This service was dead before we got it...  just
                        // don't do anything with it.
                        mActiveConnections.remove(name);
                        return;
                    }

                } else {
                    // The named service is being disconnected... clean up.
                    mActiveConnections.remove(name);
                }

                if (old != null) {
                    old.binder.unlinkToDeath(old.deathMonitor, 0);
                }
            }

            // If there was an old service, it is not disconnected.
            if (old != null) {
                mConnection.onServiceDisconnected(name);
            }
            // If there is a new service, it is now connected.
            if (service != null) {
                mConnection.onServiceConnected(name, service);
            }
        }

Question

为什么不直接用线程？

  1. Service属于后台服务,独立与Activity,可以认为后者属于前台服务。在这样的界定下,不论Activity是被销毁或者被关闭,只要对应进程还在,Service就还在，这一点是Thread所达不到的。
  2. 可以通过process=”:remote”新建独立进程.
  3. 可以实现在多Activity之间共享服务数据.

多应用如何共享一个服务？

  1. 隐式的声明服务端的Intent。
  2. 将服务端的iadl文件,保留包路径的方式拷贝到自己的工程中。
  3. 在onServiceConnected的回调中生成远端Service实例,从而调用服务的接口。

如何提高服务的优先级，防止被杀？

​ 内存不足的时候,Android会回收一些后台应用;所以Service中提供了

startForeground(int id, Notification notification)类似的方法,使得将后台应用

关闭的权利交给用户.利用类似后台更新前台ui的方式，可以提高服务的优先级。