1/*
2 * Copyright (C) 2013 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.android.server;
18
19import android.app.ActivityThread;
20import android.content.Context;
21import android.os.IBinder;
22import android.os.ServiceManager;
23import android.os.UserManager;
24
25/**
26 * The base class for services running in the system process. Override and implement
27 * the lifecycle event callback methods as needed.
28 * <p>
29 * The lifecycle of a SystemService:
30 * </p><ul>
31 * <li>The constructor is called and provided with the system {@link Context}
32 * to initialize the system service.
33 * <li>{@link #onStart()} is called to get the service running.  The service should
34 * publish its binder interface at this point using
35 * {@link #publishBinderService(String, IBinder)}.  It may also publish additional
36 * local interfaces that other services within the system server may use to access
37 * privileged internal functions.
38 * <li>Then {@link #onBootPhase(int)} is called as many times as there are boot phases
39 * until {@link #PHASE_BOOT_COMPLETED} is sent, which is the last boot phase. Each phase
40 * is an opportunity to do special work, like acquiring optional service dependencies,
41 * waiting to see if SafeMode is enabled, or registering with a service that gets
42 * started after this one.
43 * </ul><p>
44 * NOTE: All lifecycle methods are called from the system server's main looper thread.
45 * </p>
46 *
47 * {@hide}
48 */
49public abstract class SystemService {
50    /*
51     * Boot Phases
52     */
53    public static final int PHASE_WAIT_FOR_DEFAULT_DISPLAY = 100; // maybe should be a dependency?
54
55    /**
56     * After receiving this boot phase, services can obtain lock settings data.
57     */
58    public static final int PHASE_LOCK_SETTINGS_READY = 480;
59
60    /**
61     * After receiving this boot phase, services can safely call into core system services
62     * such as the PowerManager or PackageManager.
63     */
64    public static final int PHASE_SYSTEM_SERVICES_READY = 500;
65
66    /**
67     * After receiving this boot phase, services can broadcast Intents.
68     */
69    public static final int PHASE_ACTIVITY_MANAGER_READY = 550;
70
71    /**
72     * After receiving this boot phase, services can start/bind to third party apps.
73     * Apps will be able to make Binder calls into services at this point.
74     */
75    public static final int PHASE_THIRD_PARTY_APPS_CAN_START = 600;
76
77    /**
78     * After receiving this boot phase, services can allow user interaction with the device.
79     * This phase occurs when boot has completed and the home application has started.
80     * System services may prefer to listen to this phase rather than registering a
81     * broadcast receiver for ACTION_BOOT_COMPLETED to reduce overall latency.
82     */
83    public static final int PHASE_BOOT_COMPLETED = 1000;
84
85    private final Context mContext;
86
87    /**
88     * Initializes the system service.
89     * <p>
90     * Subclasses must define a single argument constructor that accepts the context
91     * and passes it to super.
92     * </p>
93     *
94     * @param context The system server context.
95     */
96    public SystemService(Context context) {
97        mContext = context;
98    }
99
100    /**
101     * Gets the system context.
102     */
103    public final Context getContext() {
104        return mContext;
105    }
106
107    /**
108     * Get the system UI context. This context is to be used for displaying UI. It is themable,
109     * which means resources can be overridden at runtime. Do not use to retrieve properties that
110     * configure the behavior of the device that is not UX related.
111     */
112    public final Context getUiContext() {
113        // This has already been set up by the time any SystemServices are created.
114        return ActivityThread.currentActivityThread().getSystemUiContext();
115    }
116
117    /**
118     * Returns true if the system is running in safe mode.
119     * TODO: we should define in which phase this becomes valid
120     */
121    public final boolean isSafeMode() {
122        return getManager().isSafeMode();
123    }
124
125    /**
126     * Called when the dependencies listed in the @Service class-annotation are available
127     * and after the chosen start phase.
128     * When this method returns, the service should be published.
129     */
130    public abstract void onStart();
131
132    /**
133     * Called on each phase of the boot process. Phases before the service's start phase
134     * (as defined in the @Service annotation) are never received.
135     *
136     * @param phase The current boot phase.
137     */
138    public void onBootPhase(int phase) {}
139
140    /**
141     * Called when a new user is starting, for system services to initialize any per-user
142     * state they maintain for running users.
143     * @param userHandle The identifier of the user.
144     */
145    public void onStartUser(int userHandle) {}
146
147    /**
148     * Called when an existing user is in the process of being unlocked. This
149     * means the credential-encrypted storage for that user is now available,
150     * and encryption-aware component filtering is no longer in effect.
151     * <p>
152     * While dispatching this event to services, the user is in the
153     * {@code STATE_RUNNING_UNLOCKING} state, and once dispatching is finished
154     * the user will transition into the {@code STATE_RUNNING_UNLOCKED} state.
155     * Code written inside system services should use
156     * {@link UserManager#isUserUnlockingOrUnlocked(int)} to handle both of
157     * these states.
158     *
159     * @param userHandle The identifier of the user.
160     */
161    public void onUnlockUser(int userHandle) {}
162
163    /**
164     * Called when switching to a different foreground user, for system services that have
165     * special behavior for whichever user is currently in the foreground.  This is called
166     * before any application processes are aware of the new user.
167     * @param userHandle The identifier of the user.
168     */
169    public void onSwitchUser(int userHandle) {}
170
171    /**
172     * Called when an existing user is stopping, for system services to finalize any per-user
173     * state they maintain for running users.  This is called prior to sending the SHUTDOWN
174     * broadcast to the user; it is a good place to stop making use of any resources of that
175     * user (such as binding to a service running in the user).
176     *
177     * <p>NOTE: This is the last callback where the callee may access the target user's CE storage.
178     *
179     * @param userHandle The identifier of the user.
180     */
181    public void onStopUser(int userHandle) {}
182
183    /**
184     * Called when an existing user is stopping, for system services to finalize any per-user
185     * state they maintain for running users.  This is called after all application process
186     * teardown of the user is complete.
187     *
188     * <p>NOTE: When this callback is called, the CE storage for the target user may not be
189     * accessible already.  Use {@link #onStopUser} instead if you need to access the CE storage.
190     *
191     * @param userHandle The identifier of the user.
192     */
193    public void onCleanupUser(int userHandle) {}
194
195    /**
196     * Publish the service so it is accessible to other services and apps.
197     */
198    protected final void publishBinderService(String name, IBinder service) {
199        publishBinderService(name, service, false);
200    }
201
202    /**
203     * Publish the service so it is accessible to other services and apps.
204     */
205    protected final void publishBinderService(String name, IBinder service,
206            boolean allowIsolated) {
207        ServiceManager.addService(name, service, allowIsolated);
208    }
209
210    /**
211     * Get a binder service by its name.
212     */
213    protected final IBinder getBinderService(String name) {
214        return ServiceManager.getService(name);
215    }
216
217    /**
218     * Publish the service so it is only accessible to the system process.
219     */
220    protected final <T> void publishLocalService(Class<T> type, T service) {
221        LocalServices.addService(type, service);
222    }
223
224    /**
225     * Get a local service by interface.
226     */
227    protected final <T> T getLocalService(Class<T> type) {
228        return LocalServices.getService(type);
229    }
230
231    private SystemServiceManager getManager() {
232        return LocalServices.getService(SystemServiceManager.class);
233    }
234}
235