/* * Copyright (C) 2013 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.android.server; import android.app.ActivityThread; import android.content.Context; import android.os.IBinder; import android.os.ServiceManager; import android.os.UserManager; /** * The base class for services running in the system process. Override and implement * the lifecycle event callback methods as needed. *

* The lifecycle of a SystemService: *

* NOTE: All lifecycle methods are called from the system server's main looper thread. *

* * {@hide} */ public abstract class SystemService { /* * Boot Phases */ public static final int PHASE_WAIT_FOR_DEFAULT_DISPLAY = 100; // maybe should be a dependency? /** * After receiving this boot phase, services can obtain lock settings data. */ public static final int PHASE_LOCK_SETTINGS_READY = 480; /** * After receiving this boot phase, services can safely call into core system services * such as the PowerManager or PackageManager. */ public static final int PHASE_SYSTEM_SERVICES_READY = 500; /** * After receiving this boot phase, services can broadcast Intents. */ public static final int PHASE_ACTIVITY_MANAGER_READY = 550; /** * After receiving this boot phase, services can start/bind to third party apps. * Apps will be able to make Binder calls into services at this point. */ public static final int PHASE_THIRD_PARTY_APPS_CAN_START = 600; /** * After receiving this boot phase, services can allow user interaction with the device. * This phase occurs when boot has completed and the home application has started. * System services may prefer to listen to this phase rather than registering a * broadcast receiver for ACTION_BOOT_COMPLETED to reduce overall latency. */ public static final int PHASE_BOOT_COMPLETED = 1000; private final Context mContext; /** * Initializes the system service. *

* Subclasses must define a single argument constructor that accepts the context * and passes it to super. *

* * @param context The system server context. */ public SystemService(Context context) { mContext = context; } /** * Gets the system context. */ public final Context getContext() { return mContext; } /** * Get the system UI context. This context is to be used for displaying UI. It is themable, * which means resources can be overridden at runtime. Do not use to retrieve properties that * configure the behavior of the device that is not UX related. */ public final Context getUiContext() { // This has already been set up by the time any SystemServices are created. return ActivityThread.currentActivityThread().getSystemUiContext(); } /** * Returns true if the system is running in safe mode. * TODO: we should define in which phase this becomes valid */ public final boolean isSafeMode() { return getManager().isSafeMode(); } /** * Called when the dependencies listed in the @Service class-annotation are available * and after the chosen start phase. * When this method returns, the service should be published. */ public abstract void onStart(); /** * Called on each phase of the boot process. Phases before the service's start phase * (as defined in the @Service annotation) are never received. * * @param phase The current boot phase. */ public void onBootPhase(int phase) {} /** * Called when a new user is starting, for system services to initialize any per-user * state they maintain for running users. * @param userHandle The identifier of the user. */ public void onStartUser(int userHandle) {} /** * Called when an existing user is in the process of being unlocked. This * means the credential-encrypted storage for that user is now available, * and encryption-aware component filtering is no longer in effect. *

* While dispatching this event to services, the user is in the * {@code STATE_RUNNING_UNLOCKING} state, and once dispatching is finished * the user will transition into the {@code STATE_RUNNING_UNLOCKED} state. * Code written inside system services should use * {@link UserManager#isUserUnlockingOrUnlocked(int)} to handle both of * these states. * * @param userHandle The identifier of the user. */ public void onUnlockUser(int userHandle) {} /** * Called when switching to a different foreground user, for system services that have * special behavior for whichever user is currently in the foreground. This is called * before any application processes are aware of the new user. * @param userHandle The identifier of the user. */ public void onSwitchUser(int userHandle) {} /** * Called when an existing user is stopping, for system services to finalize any per-user * state they maintain for running users. This is called prior to sending the SHUTDOWN * broadcast to the user; it is a good place to stop making use of any resources of that * user (such as binding to a service running in the user). * *

NOTE: This is the last callback where the callee may access the target user's CE storage. * * @param userHandle The identifier of the user. */ public void onStopUser(int userHandle) {} /** * Called when an existing user is stopping, for system services to finalize any per-user * state they maintain for running users. This is called after all application process * teardown of the user is complete. * *

NOTE: When this callback is called, the CE storage for the target user may not be * accessible already. Use {@link #onStopUser} instead if you need to access the CE storage. * * @param userHandle The identifier of the user. */ public void onCleanupUser(int userHandle) {} /** * Publish the service so it is accessible to other services and apps. */ protected final void publishBinderService(String name, IBinder service) { publishBinderService(name, service, false); } /** * Publish the service so it is accessible to other services and apps. */ protected final void publishBinderService(String name, IBinder service, boolean allowIsolated) { ServiceManager.addService(name, service, allowIsolated); } /** * Get a binder service by its name. */ protected final IBinder getBinderService(String name) { return ServiceManager.getService(name); } /** * Publish the service so it is only accessible to the system process. */ protected final void publishLocalService(Class type, T service) { LocalServices.addService(type, service); } /** * Get a local service by interface. */ protected final T getLocalService(Class type) { return LocalServices.getService(type); } private SystemServiceManager getManager() { return LocalServices.getService(SystemServiceManager.class); } }