Fire "dreaming started" and "dreaming stopped" broadcasts.
Dream manager now fires broadcast intents when entering + exiting
dreamland (except when testing).
Power manager can now listen for dreams ending, using polling only
as a backstop.
Also:
- Bullet-proof dream-manager/dream against known failure modes
- Add new read/write dream permissions
- Refactor dream-manager to delegate work + state management into
a new DreamController class, via a handler
Bug:6999949
Bug:7152024
Change-Id: I986bb7812209d8c95ae1d660a5eee5998a7b08b1
diff --git a/services/java/com/android/server/DreamManagerService.java b/services/java/com/android/server/DreamManagerService.java
new file mode 100644
index 0000000..b02ea7f
--- /dev/null
+++ b/services/java/com/android/server/DreamManagerService.java
@@ -0,0 +1,387 @@
+/*
+ * Copyright (C) 2012 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 static android.provider.Settings.Secure.SCREENSAVER_COMPONENTS;
+import static android.provider.Settings.Secure.SCREENSAVER_DEFAULT_COMPONENT;
+
+import android.app.ActivityManagerNative;
+import android.content.BroadcastReceiver;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.ServiceConnection;
+import android.content.pm.PackageManager;
+import android.os.Binder;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.IBinder;
+import android.os.Message;
+import android.os.RemoteException;
+import android.os.UserHandle;
+import android.provider.Settings;
+import android.service.dreams.Dream;
+import android.service.dreams.IDreamManager;
+import android.util.Slog;
+import android.util.SparseArray;
+
+import java.io.FileDescriptor;
+import java.io.PrintWriter;
+
+/**
+ * Service api for managing dreams.
+ *
+ * @hide
+ */
+public final class DreamManagerService
+ extends IDreamManager.Stub
+ implements ServiceConnection {
+ private static final boolean DEBUG = true;
+ private static final String TAG = DreamManagerService.class.getSimpleName();
+
+ private static final Intent mDreamingStartedIntent = new Intent(Dream.ACTION_DREAMING_STARTED)
+ .addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);
+ private static final Intent mDreamingStoppedIntent = new Intent(Dream.ACTION_DREAMING_STOPPED)
+ .addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);
+
+ private final Object mLock = new Object();
+ private final DreamController mController;
+ private final DreamControllerHandler mHandler;
+ private final Context mContext;
+
+ private final CurrentUserManager mCurrentUserManager = new CurrentUserManager();
+
+ private final DeathRecipient mAwakenOnBinderDeath = new DeathRecipient() {
+ @Override
+ public void binderDied() {
+ if (DEBUG) Slog.v(TAG, "binderDied()");
+ awaken();
+ }
+ };
+
+ private final DreamController.Listener mControllerListener = new DreamController.Listener() {
+ @Override
+ public void onDreamStopped(boolean wasTest) {
+ synchronized(mLock) {
+ setDreamingLocked(false, wasTest);
+ }
+ }};
+
+ private boolean mIsDreaming;
+
+ public DreamManagerService(Context context) {
+ if (DEBUG) Slog.v(TAG, "DreamManagerService startup");
+ mContext = context;
+ mController = new DreamController(context, mAwakenOnBinderDeath, this, mControllerListener);
+ mHandler = new DreamControllerHandler(mController);
+ mController.setHandler(mHandler);
+ }
+
+ public void systemReady() {
+ mCurrentUserManager.init(mContext);
+
+ if (DEBUG) Slog.v(TAG, "Ready to dream!");
+ }
+
+ @Override
+ protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
+ mContext.enforceCallingOrSelfPermission(android.Manifest.permission.DUMP, TAG);
+
+ pw.println("Dreamland:");
+ mController.dump(pw);
+ mCurrentUserManager.dump(pw);
+ }
+
+ // begin IDreamManager api
+ @Override
+ public ComponentName[] getDreamComponents() {
+ checkPermission(android.Manifest.permission.READ_DREAM_STATE);
+ int userId = UserHandle.getCallingUserId();
+
+ final long ident = Binder.clearCallingIdentity();
+ try {
+ return getDreamComponentsForUser(userId);
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+ }
+
+ @Override
+ public void setDreamComponents(ComponentName[] componentNames) {
+ checkPermission(android.Manifest.permission.WRITE_DREAM_STATE);
+ int userId = UserHandle.getCallingUserId();
+
+ final long ident = Binder.clearCallingIdentity();
+ try {
+ Settings.Secure.putStringForUser(mContext.getContentResolver(),
+ SCREENSAVER_COMPONENTS,
+ componentsToString(componentNames),
+ userId);
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+ }
+
+ @Override
+ public ComponentName getDefaultDreamComponent() {
+ checkPermission(android.Manifest.permission.READ_DREAM_STATE);
+ int userId = UserHandle.getCallingUserId();
+
+ final long ident = Binder.clearCallingIdentity();
+ try {
+ String name = Settings.Secure.getStringForUser(mContext.getContentResolver(),
+ SCREENSAVER_DEFAULT_COMPONENT,
+ userId);
+ return name == null ? null : ComponentName.unflattenFromString(name);
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+
+ }
+
+ @Override
+ public boolean isDreaming() {
+ checkPermission(android.Manifest.permission.READ_DREAM_STATE);
+
+ return mIsDreaming;
+ }
+
+ @Override
+ public void dream() {
+ checkPermission(android.Manifest.permission.WRITE_DREAM_STATE);
+
+ final long ident = Binder.clearCallingIdentity();
+ try {
+ if (DEBUG) Slog.v(TAG, "Dream now");
+ ComponentName[] dreams = getDreamComponentsForUser(mCurrentUserManager.getCurrentUserId());
+ ComponentName firstDream = dreams != null && dreams.length > 0 ? dreams[0] : null;
+ if (firstDream != null) {
+ mHandler.requestStart(firstDream, false /*isTest*/);
+ synchronized (mLock) {
+ setDreamingLocked(true, false /*isTest*/);
+ }
+ }
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+ }
+
+ @Override
+ public void testDream(ComponentName dream) {
+ checkPermission(android.Manifest.permission.WRITE_DREAM_STATE);
+
+ final long ident = Binder.clearCallingIdentity();
+ try {
+ if (DEBUG) Slog.v(TAG, "Test dream name=" + dream);
+ if (dream != null) {
+ mHandler.requestStart(dream, true /*isTest*/);
+ synchronized (mLock) {
+ setDreamingLocked(true, true /*isTest*/);
+ }
+ }
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+
+ }
+
+ @Override
+ public void awaken() {
+ checkPermission(android.Manifest.permission.WRITE_DREAM_STATE);
+
+ final long ident = Binder.clearCallingIdentity();
+ try {
+ if (DEBUG) Slog.v(TAG, "Wake up");
+ mHandler.requestStop();
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+ }
+
+ @Override
+ public void awakenSelf(IBinder token) {
+ // requires no permission, called by Dream from an arbitrary process
+
+ final long ident = Binder.clearCallingIdentity();
+ try {
+ if (DEBUG) Slog.v(TAG, "Wake up from dream: " + token);
+ if (token != null) {
+ mHandler.requestStopSelf(token);
+ }
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+ }
+ // end IDreamManager api
+
+ // begin ServiceConnection
+ @Override
+ public void onServiceConnected(ComponentName name, IBinder dream) {
+ if (DEBUG) Slog.v(TAG, "Service connected: " + name + " binder=" +
+ dream + " thread=" + Thread.currentThread().getId());
+ mHandler.requestAttach(name, dream);
+ }
+
+ @Override
+ public void onServiceDisconnected(ComponentName name) {
+ if (DEBUG) Slog.v(TAG, "Service disconnected: " + name);
+ // Only happens in exceptional circumstances, awaken just to be safe
+ awaken();
+ }
+ // end ServiceConnection
+
+ private void checkPermission(String permission) {
+ if (PackageManager.PERMISSION_GRANTED != mContext.checkCallingOrSelfPermission(permission)) {
+ throw new SecurityException("Access denied to process: " + Binder.getCallingPid()
+ + ", must have permission " + permission);
+ }
+ }
+
+ private void setDreamingLocked(boolean isDreaming, boolean isTest) {
+ boolean wasDreaming = mIsDreaming;
+ if (!isTest) {
+ if (!wasDreaming && isDreaming) {
+ if (DEBUG) Slog.v(TAG, "Firing ACTION_DREAMING_STARTED");
+ mContext.sendBroadcast(mDreamingStartedIntent);
+ } else if (wasDreaming && !isDreaming) {
+ if (DEBUG) Slog.v(TAG, "Firing ACTION_DREAMING_STOPPED");
+ mContext.sendBroadcast(mDreamingStoppedIntent);
+ }
+ }
+ mIsDreaming = isDreaming;
+ }
+
+ private ComponentName[] getDreamComponentsForUser(int userId) {
+ String names = Settings.Secure.getStringForUser(mContext.getContentResolver(),
+ SCREENSAVER_COMPONENTS,
+ userId);
+ return names == null ? null : componentsFromString(names);
+ }
+
+ private static String componentsToString(ComponentName[] componentNames) {
+ StringBuilder names = new StringBuilder();
+ if (componentNames != null) {
+ for (ComponentName componentName : componentNames) {
+ if (names.length() > 0) {
+ names.append(',');
+ }
+ names.append(componentName.flattenToString());
+ }
+ }
+ return names.toString();
+ }
+
+ private static ComponentName[] componentsFromString(String names) {
+ String[] namesArray = names.split(",");
+ ComponentName[] componentNames = new ComponentName[namesArray.length];
+ for (int i = 0; i < namesArray.length; i++) {
+ componentNames[i] = ComponentName.unflattenFromString(namesArray[i]);
+ }
+ return componentNames;
+ }
+
+ /**
+ * Keeps track of the current user, since dream() uses the current user's configuration.
+ */
+ private static class CurrentUserManager {
+ private final Object mLock = new Object();
+ private int mCurrentUserId;
+
+ public void init(Context context) {
+ IntentFilter filter = new IntentFilter();
+ filter.addAction(Intent.ACTION_USER_SWITCHED);
+ context.registerReceiver(new BroadcastReceiver() {
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ String action = intent.getAction();
+ if (Intent.ACTION_USER_SWITCHED.equals(action)) {
+ synchronized(mLock) {
+ mCurrentUserId = intent.getIntExtra(Intent.EXTRA_USER_HANDLE, 0);
+ if (DEBUG) Slog.v(TAG, "userId " + mCurrentUserId + " is in the house");
+ }
+ }
+ }}, filter);
+ try {
+ synchronized (mLock) {
+ mCurrentUserId = ActivityManagerNative.getDefault().getCurrentUser().id;
+ }
+ } catch (RemoteException e) {
+ Slog.w(TAG, "Couldn't get current user ID; guessing it's 0", e);
+ }
+ }
+
+ public void dump(PrintWriter pw) {
+ pw.print(" user="); pw.println(getCurrentUserId());
+ }
+
+ public int getCurrentUserId() {
+ synchronized(mLock) {
+ return mCurrentUserId;
+ }
+ }
+ }
+
+ /**
+ * Handler for asynchronous operations performed by the dream manager.
+ *
+ * Ensures operations to {@link DreamController} are single-threaded.
+ */
+ private static final class DreamControllerHandler extends Handler {
+ private final DreamController mController;
+ private final Runnable mStopRunnable = new Runnable() {
+ @Override
+ public void run() {
+ mController.stop();
+ }};
+
+ public DreamControllerHandler(DreamController controller) {
+ super(true /*async*/);
+ mController = controller;
+ }
+
+ public void requestStart(final ComponentName name, final boolean isTest) {
+ post(new Runnable(){
+ @Override
+ public void run() {
+ mController.start(name, isTest);
+ }});
+ }
+
+ public void requestAttach(final ComponentName name, final IBinder dream) {
+ post(new Runnable(){
+ @Override
+ public void run() {
+ mController.attach(name, dream);
+ }});
+ }
+
+ public void requestStopSelf(final IBinder token) {
+ post(new Runnable(){
+ @Override
+ public void run() {
+ mController.stopSelf(token);
+ }});
+ }
+
+ public void requestStop() {
+ post(mStopRunnable);
+ }
+
+ }
+
+}