FileDocCategorySizeDatePackage
DreamService.javaAPI DocAndroid 5.1 API39535Thu Mar 12 22:22:10 GMT 2015android.service.dreams

DreamService

public class DreamService extends android.app.Service implements Window.Callback
Extend this class to implement a custom dream (available to the user as a "Daydream").

Dreams are interactive screensavers launched when a charging device is idle, or docked in a desk dock. Dreams provide another modality for apps to express themselves, tailored for an exhibition/lean-back experience.

The {@code DreamService} lifecycle is as follows:

  1. {@link #onAttachedToWindow}

    Use this for initial setup, such as calling {@link #setContentView setContentView()}.

  2. {@link #onDreamingStarted}

    Your dream has started, so you should begin animations or other behaviors here.

  3. {@link #onDreamingStopped}

    Use this to stop the things you started in {@link #onDreamingStarted}.

  4. {@link #onDetachedFromWindow}

    Use this to dismantle resources (for example, detach from handlers and listeners).

In addition, onCreate and onDestroy (from the Service interface) will also be called, but initialization and teardown should be done by overriding the hooks above.

To be available to the system, your {@code DreamService} should be declared in the manifest as follows:

<service
android:name=".MyDream"
android:exported="true"
android:icon="@drawable/my_icon"
android:label="@string/my_dream_label" >

<intent-filter>
<action android:name="android.service.dreams.DreamService" />
<category android:name="android.intent.category.DEFAULT" />
</intent-filter>

<!-- Point to additional information for this dream (optional) -->
<meta-data
android:name="android.service.dream"
android:resource="@xml/my_dream" />
</service>

If specified with the {@code <meta-data>} element, additional information for the dream is defined using the {@link android.R.styleable#Dream <dream>} element in a separate XML file. Currently, the only addtional information you can provide is for a settings activity that allows the user to configure the dream behavior. For example:

res/xml/my_dream.xml

<dream xmlns:android="http://schemas.android.com/apk/res/android"
android:settingsActivity="com.example.app/.MyDreamSettingsActivity" />

This makes a Settings button available alongside your dream's listing in the system settings, which when pressed opens the specified activity.

To specify your dream layout, call {@link #setContentView}, typically during the {@link #onAttachedToWindow} callback. For example:

public class MyDream extends DreamService {

@Override
public void onAttachedToWindow() {
super.onAttachedToWindow();

// Exit dream upon user touch
setInteractive(false);
// Hide system UI
setFullscreen(true);
// Set the dream layout
setContentView(R.layout.dream);
}
}

When targeting api level 21 and above, you must declare the service in your manifest file with the {@link android.Manifest.permission#BIND_DREAM_SERVICE} permission. For example:

<service
android:name=".MyDream"
android:exported="true"
android:icon="@drawable/my_icon"
android:label="@string/my_dream_label"
android:permission="android.permission.BIND_DREAM_SERVICE">
<intent-filter>
<action android:name=‚¨żandroid.service.dreams.DreamService‚¨ż />
<category android:name=‚¨żandroid.intent.category.DEFAULT‚¨ż />
</intent-filter>
</service>

Fields Summary
private final String
TAG
public static final String
DREAM_SERVICE
The name of the dream manager service.
public static final String
SERVICE_INTERFACE
The {@link Intent} that must be declared as handled by the service.
public static final String
DREAM_META_DATA
Name under which a Dream publishes information about itself. This meta-data must reference an XML resource containing a <{@link android.R.styleable#Dream dream}> tag.
private final IDreamManager
mSandman
private final android.os.Handler
mHandler
private android.os.IBinder
mWindowToken
private android.view.Window
mWindow
private boolean
mInteractive
private boolean
mLowProfile
private boolean
mFullscreen
private boolean
mScreenBright
private boolean
mStarted
private boolean
mWaking
private boolean
mFinished
private boolean
mCanDoze
private boolean
mDozing
private boolean
mWindowless
private int
mDozeScreenState
private int
mDozeScreenBrightness
private boolean
mDebug
Constructors Summary
public DreamService()


      
        mSandman = IDreamManager.Stub.asInterface(ServiceManager.getService(DREAM_SERVICE));
    
Methods Summary
public voidaddContentView(android.view.View view, ViewGroup.LayoutParams params)
Adds a view to the Dream's window, leaving other content views in place.

Note: Requires a window, do not call before {@link #onAttachedToWindow()}

param
view The desired content to display.
param
params Layout parameters for the view.

        getWindow().addContentView(view, params);
    
private intapplyFlags(int oldFlags, int flags, int mask)

        return (oldFlags&~mask) | (flags&mask);
    
private voidapplySystemUiVisibilityFlags(int flags, int mask)

        View v = mWindow == null ? null : mWindow.getDecorView();
        if (v != null) {
            v.setSystemUiVisibility(applyFlags(v.getSystemUiVisibility(), flags, mask));
        }
    
private voidapplyWindowFlags(int flags, int mask)

        if (mWindow != null) {
            WindowManager.LayoutParams lp = mWindow.getAttributes();
            lp.flags = applyFlags(lp.flags, flags, mask);
            mWindow.setAttributes(lp);
            mWindow.getWindowManager().updateViewLayout(mWindow.getDecorView(), lp);
        }
    
private final voidattach(android.os.IBinder windowToken, boolean canDoze)
Called when the Dream is ready to be shown. Must run on mHandler.

param
windowToken A window token that will allow a window to be created in the correct layer.

        if (mWindowToken != null) {
            Slog.e(TAG, "attach() called when already attached with token=" + mWindowToken);
            return;
        }
        if (mFinished || mWaking) {
            Slog.w(TAG, "attach() called after dream already finished");
            try {
                mSandman.finishSelf(windowToken, true /*immediate*/);
            } catch (RemoteException ex) {
                // system server died
            }
            return;
        }

        mWindowToken = windowToken;
        mCanDoze = canDoze;
        if (mWindowless && !mCanDoze) {
            throw new IllegalStateException("Only doze dreams can be windowless");
        }
        if (!mWindowless) {
            mWindow = PolicyManager.makeNewWindow(this);
            mWindow.setCallback(this);
            mWindow.requestFeature(Window.FEATURE_NO_TITLE);
            mWindow.setBackgroundDrawable(new ColorDrawable(0xFF000000));
            mWindow.setFormat(PixelFormat.OPAQUE);

            if (mDebug) Slog.v(TAG, String.format("Attaching window token: %s to window of type %s",
                    windowToken, WindowManager.LayoutParams.TYPE_DREAM));

            WindowManager.LayoutParams lp = mWindow.getAttributes();
            lp.type = WindowManager.LayoutParams.TYPE_DREAM;
            lp.token = windowToken;
            lp.windowAnimations = com.android.internal.R.style.Animation_Dream;
            lp.flags |= ( WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN
                        | WindowManager.LayoutParams.FLAG_LAYOUT_INSET_DECOR
                        | WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED
                        | WindowManager.LayoutParams.FLAG_DISMISS_KEYGUARD
                        | WindowManager.LayoutParams.FLAG_ALLOW_LOCK_WHILE_SCREEN_ON
                        | (mFullscreen ? WindowManager.LayoutParams.FLAG_FULLSCREEN : 0)
                        | (mScreenBright ? WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON : 0)
                        );
            mWindow.setAttributes(lp);
            // Workaround: Currently low-profile and in-window system bar backgrounds don't go
            // along well. Dreams usually don't need such bars anyways, so disable them by default.
            mWindow.clearFlags(WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS);
            mWindow.setWindowManager(null, windowToken, "dream", true);

            applySystemUiVisibilityFlags(
                    (mLowProfile ? View.SYSTEM_UI_FLAG_LOW_PROFILE : 0),
                    View.SYSTEM_UI_FLAG_LOW_PROFILE);

            try {
                getWindowManager().addView(mWindow.getDecorView(), mWindow.getAttributes());
            } catch (WindowManager.BadTokenException ex) {
                // This can happen because the dream manager service will remove the token
                // immediately without necessarily waiting for the dream to start.
                // We should receive a finish message soon.
                Slog.i(TAG, "attach() called after window token already removed, dream will "
                        + "finish soon");
                mWindow = null;
                return;
            }
        }
        // We need to defer calling onDreamingStarted until after onWindowAttached,
        // which is posted to the handler by addView, so we post onDreamingStarted
        // to the handler also.  Need to watch out here in case detach occurs before
        // this callback is invoked.
        mHandler.post(new Runnable() {
            @Override
            public void run() {
                if (mWindow != null || mWindowless) {
                    if (mDebug) Slog.v(TAG, "Calling onDreamingStarted()");
                    mStarted = true;
                    onDreamingStarted();
                }
            }
        });
    
public booleancanDoze()
Returns true if this dream is allowed to doze.

The value returned by this method is only meaningful when the dream has started.

return
True if this dream can doze.
see
#startDozing
hide
For use by system UI components only.

        return mCanDoze;
    
private static intclampAbsoluteBrightness(int value)

        return MathUtils.constrain(value, PowerManager.BRIGHTNESS_OFF, PowerManager.BRIGHTNESS_ON);
    
private final voiddetach()
Called by DreamController.stopDream() when the Dream is about to be unbound and destroyed. Must run on mHandler.

        if (mStarted) {
            if (mDebug) Slog.v(TAG, "detach(): Calling onDreamingStopped()");
            mStarted = false;
            onDreamingStopped();
        }

        if (mWindow != null) {
            // force our window to be removed synchronously
            if (mDebug) Slog.v(TAG, "detach(): Removing window from window manager");
            mWindow.getWindowManager().removeViewImmediate(mWindow.getDecorView());
            mWindow = null;
        }

        if (mWindowToken != null) {
            // the following will print a log message if it finds any other leaked windows
            WindowManagerGlobal.getInstance().closeAll(mWindowToken,
                    this.getClass().getName(), "Dream");
            mWindowToken = null;
            mCanDoze = false;
        }
    
public booleandispatchGenericMotionEvent(android.view.MotionEvent event)
{@inheritDoc}

        if (!mInteractive) {
            if (mDebug) Slog.v(TAG, "Waking up on genericMotionEvent");
            wakeUp();
            return true;
        }
        return mWindow.superDispatchGenericMotionEvent(event);
    
public booleandispatchKeyEvent(android.view.KeyEvent event)
{@inheritDoc}

        // TODO: create more flexible version of mInteractive that allows use of KEYCODE_BACK
        if (!mInteractive) {
            if (mDebug) Slog.v(TAG, "Waking up on keyEvent");
            wakeUp();
            return true;
        } else if (event.getKeyCode() == KeyEvent.KEYCODE_BACK) {
            if (mDebug) Slog.v(TAG, "Waking up on back key");
            wakeUp();
            return true;
        }
        return mWindow.superDispatchKeyEvent(event);
    
public booleandispatchKeyShortcutEvent(android.view.KeyEvent event)
{@inheritDoc}

        if (!mInteractive) {
            if (mDebug) Slog.v(TAG, "Waking up on keyShortcutEvent");
            wakeUp();
            return true;
        }
        return mWindow.superDispatchKeyShortcutEvent(event);
    
public booleandispatchPopulateAccessibilityEvent(android.view.accessibility.AccessibilityEvent event)
{@inheritDoc}

        return false;
    
public booleandispatchTouchEvent(android.view.MotionEvent event)
{@inheritDoc}

        // TODO: create more flexible version of mInteractive that allows clicks
        // but finish()es on any other kind of activity
        if (!mInteractive) {
            if (mDebug) Slog.v(TAG, "Waking up on touchEvent");
            wakeUp();
            return true;
        }
        return mWindow.superDispatchTouchEvent(event);
    
public booleandispatchTrackballEvent(android.view.MotionEvent event)
{@inheritDoc}

        if (!mInteractive) {
            if (mDebug) Slog.v(TAG, "Waking up on trackballEvent");
            wakeUp();
            return true;
        }
        return mWindow.superDispatchTrackballEvent(event);
    
protected voiddump(java.io.FileDescriptor fd, java.io.PrintWriter pw, java.lang.String[] args)

        DumpUtils.dumpAsync(mHandler, new Dump() {
            @Override
            public void dump(PrintWriter pw) {
                dumpOnHandler(fd, pw, args);
            }
        }, pw, 1000);
    
protected voiddumpOnHandler(java.io.FileDescriptor fd, java.io.PrintWriter pw, java.lang.String[] args)

hide

        pw.print(TAG + ": ");
        if (mWindowToken == null) {
            pw.println("stopped");
        } else {
            pw.println("running (token=" + mWindowToken + ")");
        }
        pw.println("  window: " + mWindow);
        pw.print("  flags:");
        if (isInteractive()) pw.print(" interactive");
        if (isLowProfile()) pw.print(" lowprofile");
        if (isFullscreen()) pw.print(" fullscreen");
        if (isScreenBright()) pw.print(" bright");
        if (isWindowless()) pw.print(" windowless");
        if (isDozing()) pw.print(" dozing");
        else if (canDoze()) pw.print(" candoze");
        pw.println();
        if (canDoze()) {
            pw.println("  doze screen state: " + Display.stateToString(mDozeScreenState));
            pw.println("  doze screen brightness: " + mDozeScreenBrightness);
        }
    
public android.view.ViewfindViewById(int id)
Finds a view that was identified by the id attribute from the XML that was processed in {@link #onCreate}.

Note: Requires a window, do not call before {@link #onAttachedToWindow()}

return
The view if found or null otherwise.

        return getWindow().findViewById(id);
    
public final voidfinish()
Stops the dream and detaches from the window.

When the dream ends, the system will be allowed to go to sleep fully unless there is a reason for it to be awake such as recent user activity or wake locks being held.

        if (mDebug) Slog.v(TAG, "finish(): mFinished=" + mFinished);

        if (!mFinished) {
            mFinished = true;

            if (mWindowToken == null) {
                Slog.w(TAG, "Finish was called before the dream was attached.");
            } else {
                try {
                    mSandman.finishSelf(mWindowToken, true /*immediate*/);
                } catch (RemoteException ex) {
                    // system server died
                }
            }

            stopSelf(); // if launched via any other means
        }
    
public intgetDozeScreenBrightness()
Gets the screen brightness to use while dozing.

return
The screen brightness while dozing as a value between {@link PowerManager#BRIGHTNESS_OFF} (0) and {@link PowerManager#BRIGHTNESS_ON} (255), or {@link PowerManager#BRIGHTNESS_DEFAULT} (-1) to ask the system to apply its default policy based on the screen state.
see
#setDozeScreenBrightness
hide
For use by system UI components only.

        return mDozeScreenBrightness;
    
public intgetDozeScreenState()
Gets the screen state to use while dozing.

return
The screen state to use while dozing, such as {@link Display#STATE_ON}, {@link Display#STATE_DOZE}, {@link Display#STATE_DOZE_SUSPEND}, or {@link Display#STATE_OFF}, or {@link Display#STATE_UNKNOWN} for the default behavior.
see
#setDozeScreenState
hide
For use by system UI components only.

        return mDozeScreenState;
    
private booleangetSystemUiVisibilityFlagValue(int flag, boolean defaultValue)

        View v = mWindow == null ? null : mWindow.getDecorView();
        return v == null ? defaultValue : (v.getSystemUiVisibility() & flag) != 0;
    
public android.view.WindowgetWindow()
Retrieves the current {@link android.view.Window} for the dream. Behaves similarly to {@link android.app.Activity#getWindow()}.

return
The current window, or null if the dream is not started.

        return mWindow;
    
private booleangetWindowFlagValue(int flag, boolean defaultValue)

        return mWindow == null ? defaultValue : (mWindow.getAttributes().flags & flag) != 0;
    
public android.view.WindowManagergetWindowManager()
Retrieves the current {@link android.view.WindowManager} for the dream. Behaves similarly to {@link android.app.Activity#getWindowManager()}.

return
The current window manager, or null if the dream is not started.

        return mWindow != null ? mWindow.getWindowManager() : null;
    
public booleanisDozing()
Returns true if the dream will allow the system to enter a low-power state while it is running without actually turning off the screen. Defaults to false, keeping the application processor awake while the dream is running.

return
True if the dream is dozing.
see
#setDozing(boolean)
hide
For use by system UI components only.

        return mDozing;
    
public booleanisFullscreen()
Returns whether or not this dream is in fullscreen mode. Defaults to false.

see
#setFullscreen(boolean)

        return mFullscreen;
    
public booleanisInteractive()
Returns whether or not this dream is interactive. Defaults to false.

see
#setInteractive(boolean)

        return mInteractive;
    
public booleanisLowProfile()
Returns whether or not this dream is in low profile mode. Defaults to true.

see
#setLowProfile(boolean)
hide

        return getSystemUiVisibilityFlagValue(View.SYSTEM_UI_FLAG_LOW_PROFILE, mLowProfile);
    
public booleanisScreenBright()
Returns whether or not this dream keeps the screen bright while dreaming. Defaults to false, allowing the screen to dim if necessary.

see
#setScreenBright(boolean)

        return getWindowFlagValue(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON, mScreenBright);
    
public booleanisWindowless()
Returns whether or not this dream is windowless. Only available to doze dreams.

hide

        return mWindowless;
    
public voidonActionModeFinished(android.view.ActionMode mode)
{@inheritDoc}

    
public voidonActionModeStarted(android.view.ActionMode mode)
{@inheritDoc}

    
public voidonAttachedToWindow()
{@inheritDoc}

    
public final android.os.IBinderonBind(android.content.Intent intent)
{@inheritDoc}

        if (mDebug) Slog.v(TAG, "onBind() intent = " + intent);
        return new DreamServiceWrapper();
    
public voidonContentChanged()
{@inheritDoc}

    
public voidonCreate()
Called when this Dream is constructed.

        if (mDebug) Slog.v(TAG, "onCreate()");
        super.onCreate();
    
public booleanonCreatePanelMenu(int featureId, android.view.Menu menu)
{@inheritDoc}

        return false;
    
public android.view.ViewonCreatePanelView(int featureId)
{@inheritDoc}

        return null;
    
public voidonDestroy()
{@inheritDoc}

        if (mDebug) Slog.v(TAG, "onDestroy()");
        // hook for subclasses

        // Just in case destroy came in before detach, let's take care of that now
        detach();

        super.onDestroy();
    
public voidonDetachedFromWindow()
{@inheritDoc}

    
public voidonDreamingStarted()
Called when the dream's window has been created and is visible and animation may now begin.

        if (mDebug) Slog.v(TAG, "onDreamingStarted()");
        // hook for subclasses
    
public voidonDreamingStopped()
Called when this Dream is stopped, either by external request or by calling finish(), before the window has been removed.

        if (mDebug) Slog.v(TAG, "onDreamingStopped()");
        // hook for subclasses
    
public booleanonMenuItemSelected(int featureId, android.view.MenuItem item)
{@inheritDoc}

        return false;
    
public booleanonMenuOpened(int featureId, android.view.Menu menu)
{@inheritDoc}

        return false;
    
public voidonPanelClosed(int featureId, android.view.Menu menu)
{@inheritDoc}

    
public booleanonPreparePanel(int featureId, android.view.View view, android.view.Menu menu)
{@inheritDoc}

        return false;
    
public booleanonSearchRequested()
{@inheritDoc}

        return false;
    
public voidonWakeUp()
Called when the dream is being asked to stop itself and wake.

The default implementation simply calls {@link #finish} which ends the dream immediately. Subclasses may override this function to perform a smooth exit transition then call {@link #finish} afterwards.

Note that the dream will only be given a short period of time (currently about five seconds) to wake up. If the dream does not finish itself in a timely manner then the system will forcibly finish it once the time allowance is up.

        finish();
    
public voidonWindowAttributesChanged(android.view.WindowManager.LayoutParams attrs)
{@inheritDoc}

    
public voidonWindowFocusChanged(boolean hasFocus)
{@inheritDoc}

    
public android.view.ActionModeonWindowStartingActionMode(android.view.ActionMode.Callback callback)
{@inheritDoc}

        return null;
    
public voidsetContentView(int layoutResID)
Inflates a layout resource and set it to be the content view for this Dream. Behaves similarly to {@link android.app.Activity#setContentView(int)}.

Note: Requires a window, do not call before {@link #onAttachedToWindow()}

param
layoutResID Resource ID to be inflated.
see
#setContentView(android.view.View)
see
#setContentView(android.view.View, android.view.ViewGroup.LayoutParams)

        getWindow().setContentView(layoutResID);
    
public voidsetContentView(android.view.View view)
Sets a view to be the content view for this Dream. Behaves similarly to {@link android.app.Activity#setContentView(android.view.View)} in an activity, including using {@link ViewGroup.LayoutParams#MATCH_PARENT} as the layout height and width of the view.

Note: This requires a window, so you should usually call it during {@link #onAttachedToWindow()} and never earlier (you cannot call it during {@link #onCreate}).

see
#setContentView(int)
see
#setContentView(android.view.View, android.view.ViewGroup.LayoutParams)

        getWindow().setContentView(view);
    
public voidsetContentView(android.view.View view, ViewGroup.LayoutParams params)
Sets a view to be the content view for this Dream. Behaves similarly to {@link android.app.Activity#setContentView(android.view.View, android.view.ViewGroup.LayoutParams)} in an activity.

Note: This requires a window, so you should usually call it during {@link #onAttachedToWindow()} and never earlier (you cannot call it during {@link #onCreate}).

param
view The desired content to display.
param
params Layout parameters for the view.
see
#setContentView(android.view.View)
see
#setContentView(int)

        getWindow().setContentView(view, params);
    
public voidsetDebug(boolean dbg)

hide

        mDebug = dbg;
    
public voidsetDozeScreenBrightness(int brightness)
Sets the screen brightness to use while dozing.

The value of this property determines the power state of the primary display once {@link #startDozing} has been called. The default value is {@link PowerManager#BRIGHTNESS_DEFAULT} which lets the system decide. The dream may set a different brightness before starting to doze and may adjust the brightness while dozing to conserve power and achieve various effects.

Note that dream may specify any brightness in the full 0-255 range, including values that are less than the minimum value for manual screen brightness adjustments by the user. In particular, the value may be set to 0 which may turn off the backlight entirely while still leaving the screen on although this behavior is device dependent and not guaranteed.

The available range of display brightness values and their behavior while dozing is hardware dependent and may vary across devices. The dream may therefore need to be modified or configured to correctly support the hardware.

param
brightness The screen brightness while dozing as a value between {@link PowerManager#BRIGHTNESS_OFF} (0) and {@link PowerManager#BRIGHTNESS_ON} (255), or {@link PowerManager#BRIGHTNESS_DEFAULT} (-1) to ask the system to apply its default policy based on the screen state.
hide
For use by system UI components only.

        if (brightness != PowerManager.BRIGHTNESS_DEFAULT) {
            brightness = clampAbsoluteBrightness(brightness);
        }
        if (mDozeScreenBrightness != brightness) {
            mDozeScreenBrightness = brightness;
            updateDoze();
        }
    
public voidsetDozeScreenState(int state)
Sets the screen state to use while dozing.

The value of this property determines the power state of the primary display once {@link #startDozing} has been called. The default value is {@link Display#STATE_UNKNOWN} which lets the system decide. The dream may set a different state before starting to doze and may perform transitions between states while dozing to conserve power and achieve various effects.

It is recommended that the state be set to {@link Display#STATE_DOZE_SUSPEND} once the dream has completely finished drawing and before it releases its wakelock to allow the display hardware to be fully suspended. While suspended, the display will preserve its on-screen contents or hand off control to dedicated doze hardware if the devices supports it. If the doze suspend state is used, the dream must make sure to set the mode back to {@link Display#STATE_DOZE} or {@link Display#STATE_ON} before drawing again since the display updates may be ignored and not seen by the user otherwise.

The set of available display power states and their behavior while dozing is hardware dependent and may vary across devices. The dream may therefore need to be modified or configured to correctly support the hardware.

param
state The screen state to use while dozing, such as {@link Display#STATE_ON}, {@link Display#STATE_DOZE}, {@link Display#STATE_DOZE_SUSPEND}, or {@link Display#STATE_OFF}, or {@link Display#STATE_UNKNOWN} for the default behavior.
hide
For use by system UI components only.

        if (mDozeScreenState != state) {
            mDozeScreenState = state;
            updateDoze();
        }
    
public voidsetFullscreen(boolean fullscreen)
Controls {@link android.view.WindowManager.LayoutParams#FLAG_FULLSCREEN} on the dream's window.

param
fullscreen If true, the fullscreen flag will be set; else it will be cleared.

        if (mFullscreen != fullscreen) {
            mFullscreen = fullscreen;
            int flag = WindowManager.LayoutParams.FLAG_FULLSCREEN;
            applyWindowFlags(mFullscreen ? flag : 0, flag);
        }
    
public voidsetInteractive(boolean interactive)
Marks this dream as interactive to receive input events.

Non-interactive dreams (default) will dismiss on the first input event.

Interactive dreams should call {@link #finish()} to dismiss themselves.

param
interactive True if this dream will handle input events.

        mInteractive = interactive;
    
public voidsetLowProfile(boolean lowProfile)
Sets View.SYSTEM_UI_FLAG_LOW_PROFILE on the content view.

param
lowProfile True to set View.SYSTEM_UI_FLAG_LOW_PROFILE
hide
There is no reason to have this -- dreams can set this flag on their own content view, and from there can actually do the correct interactions with it (seeing when it is cleared etc).

        if (mLowProfile != lowProfile) {
            mLowProfile = lowProfile;
            int flag = View.SYSTEM_UI_FLAG_LOW_PROFILE;
            applySystemUiVisibilityFlags(mLowProfile ? flag : 0, flag);
        }
    
public voidsetScreenBright(boolean screenBright)
Marks this dream as keeping the screen bright while dreaming.

param
screenBright True to keep the screen bright while dreaming.

        if (mScreenBright != screenBright) {
            mScreenBright = screenBright;
            int flag = WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON;
            applyWindowFlags(mScreenBright ? flag : 0, flag);
        }
    
public voidsetWindowless(boolean windowless)
Marks this dream as windowless. Only available to doze dreams.

hide

        mWindowless = windowless;
    
public voidstartDozing()
Starts dozing, entering a deep dreamy sleep.

Dozing enables the system to conserve power while the user is not actively interacting with the device. While dozing, the display will remain on in a low-power state and will continue to show its previous contents but the application processor and other system components will be allowed to suspend when possible.

While the application processor is suspended, the dream may stop executing code for long periods of time. Prior to being suspended, the dream may schedule periodic wake-ups to render new content by scheduling an alarm with the {@link AlarmManager}. The dream may also keep the CPU awake by acquiring a {@link android.os.PowerManager#PARTIAL_WAKE_LOCK partial wake lock} when necessary. Note that since the purpose of doze mode is to conserve power (especially when running on battery), the dream should not wake the CPU very often or keep it awake for very long.

It is a good idea to call this method some time after the dream's entry animation has completed and the dream is ready to doze. It is important to completely finish all of the work needed before dozing since the application processor may be suspended at any moment once this method is called unless other wake locks are being held.

Call {@link #stopDozing} or {@link #finish} to stop dozing.

see
#stopDozing
hide
For use by system UI components only.

        if (mCanDoze && !mDozing) {
            mDozing = true;
            updateDoze();
        }
    
public voidstopDozing()
Stops dozing, returns to active dreaming.

This method reverses the effect of {@link #startDozing}. From this moment onward, the application processor will be kept awake as long as the dream is running or until the dream starts dozing again.

see
#startDozing
hide
For use by system UI components only.

        if (mDozing) {
            mDozing = false;
            try {
                mSandman.stopDozing(mWindowToken);
            } catch (RemoteException ex) {
                // system server died
            }
        }
    
private voidupdateDoze()

        if (mDozing) {
            try {
                mSandman.startDozing(mWindowToken, mDozeScreenState, mDozeScreenBrightness);
            } catch (RemoteException ex) {
                // system server died
            }
        }
    
public final voidwakeUp()
Wakes the dream up gently.

Calls {@link #onWakeUp} to give the dream a chance to perform an exit transition. When the transition is over, the dream should call {@link #finish}.

        wakeUp(false);
    
private voidwakeUp(boolean fromSystem)

        if (mDebug) Slog.v(TAG, "wakeUp(): fromSystem=" + fromSystem
                + ", mWaking=" + mWaking + ", mFinished=" + mFinished);

        if (!mWaking && !mFinished) {
            mWaking = true;

            // As a minor optimization, invoke the callback first in case it simply
            // calls finish() immediately so there wouldn't be much point in telling
            // the system that we are finishing the dream gently.
            onWakeUp();

            // Now tell the system we are waking gently, unless we already told
            // it we were finishing immediately.
            if (!fromSystem && !mFinished) {
                if (mWindowToken == null) {
                    Slog.w(TAG, "WakeUp was called before the dream was attached.");
                } else {
                    try {
                        mSandman.finishSelf(mWindowToken, false /*immediate*/);
                    } catch (RemoteException ex) {
                        // system server died
                    }
                }
            }
        }