Very primitive wallpapers in a surface.

This is all of the basic pieces:

- The WallpaperService now creates a surface with the window manager for its
  contents.
- There is a simple service that displays a bitmap.
- The wallpaper manager takes care of starting and stopping the service.
- The window manager knows about wallpaper windows and how to layer them with
  the windows that want to be shown on top of wallpaper.

Lots and lots of issues remain, but at this point you can actually write a
wallpaper service, select it in the UI, and see it behind an activity.

11 files changed, 474 insertions, 65 deletions

diff --git a/core/java/android/app/ApplicationContext.java b/core/java/android/app/ApplicationContext.java
index 8ac9557..7e71088 100644
--- a/core/java/android/app/ApplicationContext.java
+++ b/core/java/android/app/ApplicationContext.java
@@ -514,12 +514,12 @@ class ApplicationContext extends Context {
     
     @Override
     public Drawable getWallpaper() {
-        return getWallpaperManager().get();
+        return getWallpaperManager().getDrawable();
     }
 
     @Override
     public Drawable peekWallpaper() {
-        return getWallpaperManager().peek();
+        return getWallpaperManager().peekDrawable();
     }
 
     @Override
@@ -534,12 +534,12 @@ class ApplicationContext extends Context {
 
     @Override
     public void setWallpaper(Bitmap bitmap) throws IOException  {
-        getWallpaperManager().set(bitmap);
+        getWallpaperManager().setBitmap(bitmap);
     }
 
     @Override
     public void setWallpaper(InputStream data) throws IOException {
-        getWallpaperManager().set(data);
+        getWallpaperManager().setStream(data);
     }
 
     @Override
diff --git a/core/java/android/app/IWallpaperManager.aidl b/core/java/android/app/IWallpaperManager.aidl
index 1ed9b9f..7741668 100644
--- a/core/java/android/app/IWallpaperManager.aidl
+++ b/core/java/android/app/IWallpaperManager.aidl
@@ -18,6 +18,7 @@ package android.app;
 
 import android.os.ParcelFileDescriptor;
 import android.app.IWallpaperManagerCallback;
+import android.content.ComponentName;
 
 /** @hide */
 interface IWallpaperManager {
@@ -28,6 +29,11 @@ interface IWallpaperManager {
     ParcelFileDescriptor setWallpaper(String name);
     
     /**
+     * Set the live wallpaper.
+     */
+    void setWallpaperComponent(in ComponentName name);
+    
+    /**
      * Get the wallpaper.
      */
     ParcelFileDescriptor getWallpaper(IWallpaperManagerCallback cb);
diff --git a/core/java/android/app/WallpaperManager.java b/core/java/android/app/WallpaperManager.java
index 405db83..9019b54 100644
--- a/core/java/android/app/WallpaperManager.java
+++ b/core/java/android/app/WallpaperManager.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright (C) 2009 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 android.app;
 
 import android.content.Context;
@@ -21,6 +37,14 @@ public class WallpaperManager {
     private static String TAG = "WallpaperManager";
     private static boolean DEBUG = false;
 
+    /**
+     * Launch an activity for the user to pick the current global live
+     * wallpaper.
+     * @hide
+     */
+    public static final String ACTION_LIVE_WALLPAPER_CHOOSER
+            = "android.service.wallpaper.LIVE_WALLPAPER_CHOOSER";
+    
     private final Context mContext;
     
     static class Globals extends IWallpaperManagerCallback.Stub {
@@ -88,13 +112,26 @@ public class WallpaperManager {
     }
 
     /**
-     * Like {@link #peek}, but always returns a valid Drawable.  If
+     * Retrieve a WallpaperManager associated with the given Context.
+     */
+    public static WallpaperManager getInstance(Context context) {
+        return (WallpaperManager)context.getSystemService(
+                Context.WALLPAPER_SERVICE);
+    }
+    
+    /** @hide */
+    public IWallpaperManager getIWallpaperManager() {
+        return getGlobals().mService;
+    }
+    
+    /**
+     * Like {@link #peekDrawable}, but always returns a valid Drawable.  If
      * no wallpaper is set, the system default wallpaper is returned.
      *
      * @return Returns a Drawable object that will draw the wallpaper.
      */
-    public Drawable get() {
-        Drawable dr = peek();
+    public Drawable getDrawable() {
+        Drawable dr = peekDrawable();
         return dr != null ? dr : Resources.getSystem().getDrawable(
                 com.android.internal.R.drawable.default_wallpaper);
     }
@@ -108,7 +145,7 @@ public class WallpaperManager {
      * @return Returns a Drawable object that will draw the wallpaper or a
      * null pointer if these is none.
      */
-    public Drawable peek() {
+    public Drawable peekDrawable() {
         return getGlobals().peekWallpaper(mContext);
     }
 
@@ -123,7 +160,7 @@ public class WallpaperManager {
      * @throws IOException If an error occurs reverting to the default
      * wallpaper.
      */
-    public void set(int resid) throws IOException {
+    public void setResource(int resid) throws IOException {
         try {
             Resources resources = mContext.getResources();
             /* Set the wallpaper to the default values */
@@ -154,7 +191,7 @@ public class WallpaperManager {
      * @throws IOException If an error occurs reverting to the default
      * wallpaper.
      */
-    public void set(Bitmap bitmap) throws IOException {
+    public void setBitmap(Bitmap bitmap) throws IOException {
         try {
             ParcelFileDescriptor fd = getGlobals().mService.setWallpaper(null);
             if (fd == null) {
@@ -185,7 +222,7 @@ public class WallpaperManager {
      * @throws IOException If an error occurs reverting to the default
      * wallpaper.
      */
-    public void set(InputStream data) throws IOException {
+    public void setStream(InputStream data) throws IOException {
         try {
             ParcelFileDescriptor fd = getGlobals().mService.setWallpaper(null);
             if (fd == null) {
@@ -215,8 +252,8 @@ public class WallpaperManager {
 
     /**
      * Returns the desired minimum width for the wallpaper. Callers of
-     * {@link #set(android.graphics.Bitmap)} or
-     * {@link #set(java.io.InputStream)} should check this value
+     * {@link #setBitmap(android.graphics.Bitmap)} or
+     * {@link #setStream(java.io.InputStream)} should check this value
      * beforehand to make sure the supplied wallpaper respects the desired
      * minimum width.
      *
@@ -238,8 +275,8 @@ public class WallpaperManager {
 
     /**
      * Returns the desired minimum height for the wallpaper. Callers of
-     * {@link #set(android.graphics.Bitmap)} or
-     * {@link #set(java.io.InputStream)} should check this value
+     * {@link #setBitmap(android.graphics.Bitmap)} or
+     * {@link #setStream(java.io.InputStream)} should check this value
      * beforehand to make sure the supplied wallpaper respects the desired
      * minimum height.
      *
@@ -267,7 +304,7 @@ public class WallpaperManager {
      * @param minimumWidth Desired minimum width
      * @param minimumHeight Desired minimum height
      */
-    public void setDimensionHints(int minimumWidth, int minimumHeight) {
+    public void suggestDesiredDimensions(int minimumWidth, int minimumHeight) {
         try {
             getGlobals().mService.setDimensionHints(minimumWidth, minimumHeight);
         } catch (RemoteException e) {
@@ -283,6 +320,6 @@ public class WallpaperManager {
      * wallpaper.
      */
     public void clear() throws IOException {
-        set(com.android.internal.R.drawable.default_wallpaper);
+        setResource(com.android.internal.R.drawable.default_wallpaper);
     }
 }
diff --git a/core/java/android/content/Context.java b/core/java/android/content/Context.java
index 1105899..dbe6fb0 100644
--- a/core/java/android/content/Context.java
+++ b/core/java/android/content/Context.java
@@ -488,13 +488,13 @@ public abstract class Context {
     public abstract String[] databaseList();
 
     /**
-     * @deprecated Use {@link android.app.WallpaperManager#get
+     * @deprecated Use {@link android.app.WallpaperManager#getDrawable
      * WallpaperManager.get()} instead.
      */
     public abstract Drawable getWallpaper();
 
     /**
-     * @deprecated Use {@link android.app.WallpaperManager#peek
+     * @deprecated Use {@link android.app.WallpaperManager#peekDrawable
      * WallpaperManager.peek()} instead.
      */
     public abstract Drawable peekWallpaper();
@@ -512,13 +512,13 @@ public abstract class Context {
     public abstract int getWallpaperDesiredMinimumHeight();
 
     /**
-     * @deprecated Use {@link android.app.WallpaperManager#set(Bitmap)
+     * @deprecated Use {@link android.app.WallpaperManager#setBitmap(Bitmap)
      * WallpaperManager.set()} instead.
      */
     public abstract void setWallpaper(Bitmap bitmap) throws IOException;
 
     /**
-     * @deprecated Use {@link android.app.WallpaperManager#set(InputStream)
+     * @deprecated Use {@link android.app.WallpaperManager#setStream(InputStream)
      * WallpaperManager.set()} instead.
      */
     public abstract void setWallpaper(InputStream data) throws IOException;
diff --git a/core/java/android/service/wallpaper/IWallpaperConnection.aidl b/core/java/android/service/wallpaper/IWallpaperConnection.aidl
new file mode 100644
index 0000000..b09ccab
--- /dev/null
+++ b/core/java/android/service/wallpaper/IWallpaperConnection.aidl
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2009 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 android.service.wallpaper;
+
+import android.os.ParcelFileDescriptor;
+import android.service.wallpaper.IWallpaperEngine;
+
+/**
+ * @hide
+ */
+interface IWallpaperConnection {
+	void attachEngine(IWallpaperEngine engine);
+    ParcelFileDescriptor setWallpaper(String name);
+}
diff --git a/core/java/android/service/wallpaper/IWallpaperEngine.aidl b/core/java/android/service/wallpaper/IWallpaperEngine.aidl
new file mode 100644
index 0000000..9586e34
--- /dev/null
+++ b/core/java/android/service/wallpaper/IWallpaperEngine.aidl
@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2009 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 android.service.wallpaper;
+
+/**
+ * @hide
+ */
+oneway interface IWallpaperEngine {
+	void destroy();
+}
diff --git a/core/java/android/service/wallpaper/IWallpaperService.aidl b/core/java/android/service/wallpaper/IWallpaperService.aidl
index 97e032b..eb58c3b 100644
--- a/core/java/android/service/wallpaper/IWallpaperService.aidl
+++ b/core/java/android/service/wallpaper/IWallpaperService.aidl
@@ -16,9 +16,12 @@
 
 package android.service.wallpaper;
 
+import android.service.wallpaper.IWallpaperConnection;
+
 /**
  * @hide
  */
 oneway interface IWallpaperService {
-    void onInterrupt();
+    void attach(IWallpaperConnection connection,
+    		IBinder windowToken, int reqWidth, int reqHeight);
 }
diff --git a/core/java/android/service/wallpaper/WallpaperService.java b/core/java/android/service/wallpaper/WallpaperService.java
index a729ed5..dbec1e6 100644
--- a/core/java/android/service/wallpaper/WallpaperService.java
+++ b/core/java/android/service/wallpaper/WallpaperService.java
@@ -17,17 +17,29 @@
 package android.service.wallpaper;
 
 import com.android.internal.os.HandlerCaller;
+import com.android.internal.view.BaseIWindow;
+import com.android.internal.view.BaseSurfaceHolder;
 
 import android.app.Service;
 import android.content.Intent;
+import android.graphics.Rect;
+import android.os.Handler;
 import android.os.IBinder;
 import android.os.Message;
 import android.os.RemoteException;
 import android.util.Log;
+import android.view.Gravity;
+import android.view.IWindowSession;
+import android.view.SurfaceHolder;
+import android.view.View;
+import android.view.ViewRoot;
+import android.view.WindowManager;
+import android.view.WindowManagerImpl;
 
 /**
  * A wallpaper service is responsible for showing a live wallpaper behind
  * applications that would like to sit on top of it.
+ * @hide Live Wallpaper
  */
 public abstract class WallpaperService extends Service {
     /**
@@ -36,48 +48,320 @@ public abstract class WallpaperService extends Service {
     public static final String SERVICE_INTERFACE =
         "android.service.wallpaper.WallpaperService";
 
-    private static final String LOG_TAG = "WallpaperService";
-
+    static final String TAG = "WallpaperService";
+    static final boolean DEBUG = true;
+    
+    private static final int DO_ATTACH = 10;
+    private static final int DO_DETACH = 20;
+    
+    private static final int MSG_UPDATE_SURFACE = 10000;
+    
     /**
-     * Implement to return the implementation of the internal accessibility
-     * service interface.  Subclasses should not override.
+     * The actual implementation of a wallpaper.  A wallpaper service may
+     * have multiple instances running (for example as a real wallpaper
+     * and as a preview), each of which is represented by its own Engine
+     * instance.
      */
-    @Override
-    public final IBinder onBind(Intent intent) {
-        return new IWallpaperServiceWrapper(this);
-    }
+    public class Engine {
+        IWallpaperEngineWrapper mIWallpaperEngine;
+        
+        // Copies from mIWallpaperEngine.
+        HandlerCaller mCaller;
+        IWallpaperConnection mConnection;
+        IBinder mWindowToken;
+        
+        boolean mInitializing = true;
+        
+        // Current window state.
+        boolean mCreated;
+        boolean mIsCreating;
+        boolean mDrawingAllowed;
+        int mWidth;
+        int mHeight;
+        int mFormat;
+        int mType;
+        boolean mDestroyReportNeeded;
+        final Rect mVisibleInsets = new Rect();
+        final Rect mWinFrame = new Rect();
+        final Rect mContentInsets = new Rect();
+        
+        final WindowManager.LayoutParams mLayout
+                = new WindowManager.LayoutParams();
+        IWindowSession mSession;
 
-    /**
-     * Implements the internal {@link IWallpaperService} interface to convert
-     * incoming calls to it back to calls on an {@link WallpaperService}.
-     */
-    class IWallpaperServiceWrapper extends IWallpaperService.Stub
-            implements HandlerCaller.Callback {
+        final BaseSurfaceHolder mSurfaceHolder = new BaseSurfaceHolder() {
+
+            @Override
+            public boolean onAllowLockCanvas() {
+                return mDrawingAllowed;
+            }
+
+            @Override
+            public void onRelayoutContainer() {
+                Message msg = mCaller.obtainMessage(MSG_UPDATE_SURFACE);
+                mCaller.sendMessage(msg);
+            }
+
+            @Override
+            public void onUpdateSurface() {
+                Message msg = mCaller.obtainMessage(MSG_UPDATE_SURFACE);
+                mCaller.sendMessage(msg);
+            }
 
-        private static final int DO_ON_INTERRUPT = 10;
+            public boolean isCreating() {
+                return mIsCreating;
+            }
+
+            public void setKeepScreenOn(boolean screenOn) {
+                // Ignore.
+            }
+            
+        };
         
-        private final HandlerCaller mCaller;
+        final BaseIWindow mWindow = new BaseIWindow() {
+            
+        };
+        
+        public void onAttach(SurfaceHolder surfaceHolder) {
+        }
+        
+        public void onDetach() {
+        }
+        
+        public void onSurfaceChanged(SurfaceHolder holder, int format, int width, int height) {
+        }
 
-        private WallpaperService mTarget;
+        public void onSurfaceCreated(SurfaceHolder holder) {
+        }
 
-        public IWallpaperServiceWrapper(WallpaperService context) {
-            mTarget = context;
-            mCaller = new HandlerCaller(context, this);
+        public void onSurfaceDestroyed(SurfaceHolder holder) {
         }
 
-        public void onInterrupt() {
-            Message message = mCaller.obtainMessage(DO_ON_INTERRUPT);
-            mCaller.sendMessage(message);
+        void updateSurface(boolean force) {
+            int myWidth = mSurfaceHolder.getRequestedWidth();
+            if (myWidth <= 0) myWidth = mIWallpaperEngine.mReqWidth;
+            int myHeight = mSurfaceHolder.getRequestedHeight();
+            if (myHeight <= 0) myHeight = mIWallpaperEngine.mReqHeight;
+            
+            final boolean creating = !mCreated;
+            final boolean formatChanged = mFormat != mSurfaceHolder.getRequestedFormat();
+            final boolean sizeChanged = mWidth != myWidth || mHeight != myHeight;
+            final boolean typeChanged = mType != mSurfaceHolder.getRequestedType();
+            if (force || creating || formatChanged || sizeChanged || typeChanged) {
+
+                if (DEBUG) Log.i(TAG, "Changes: creating=" + creating
+                        + " format=" + formatChanged + " size=" + sizeChanged);
+
+                try {
+                    mWidth = myWidth;
+                    mHeight = myHeight;
+                    mFormat = mSurfaceHolder.getRequestedFormat();
+                    mType = mSurfaceHolder.getRequestedType();
+
+                    // Scaling/Translate window's layout here because mLayout is not used elsewhere.
+                    
+                    // Places the window relative
+                    mLayout.x = 0;
+                    mLayout.y = 0;
+                    mLayout.width = myWidth;
+                    mLayout.height = myHeight;
+                    
+                    mLayout.format = mFormat;
+                    mLayout.flags |=WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS
+                                  | WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN
+                                  | WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
+                                  | WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE
+                                  ;
+
+                    mLayout.memoryType = mType;
+                    mLayout.token = mWindowToken;
+
+                    if (!mCreated) {
+                        mLayout.type = WindowManager.LayoutParams.TYPE_WALLPAPER;
+                        mLayout.gravity = Gravity.LEFT|Gravity.TOP;
+                        mSession.add(mWindow, mLayout, View.VISIBLE, mContentInsets);
+                    }
+                    
+                    mSurfaceHolder.mSurfaceLock.lock();
+                    mDrawingAllowed = true;
+
+                    final int relayoutResult = mSession.relayout(
+                        mWindow, mLayout, mWidth, mHeight,
+                            View.VISIBLE, false, mWinFrame, mContentInsets,
+                            mVisibleInsets, mSurfaceHolder.mSurface);
+
+                    if (DEBUG) Log.i(TAG, "New surface: " + mSurfaceHolder.mSurface
+                            + ", frame=" + mWinFrame);
+                    
+                    mSurfaceHolder.mSurfaceLock.unlock();
+
+                    try {
+                        mDestroyReportNeeded = true;
+
+                        SurfaceHolder.Callback callbacks[] = null;
+                        synchronized (mSurfaceHolder.mCallbacks) {
+                            final int N = mSurfaceHolder.mCallbacks.size();
+                            if (N > 0) {
+                                callbacks = new SurfaceHolder.Callback[N];
+                                mSurfaceHolder.mCallbacks.toArray(callbacks);
+                            }
+                        }
+
+                        if (!mCreated) {
+                            mIsCreating = true;
+                            onSurfaceCreated(mSurfaceHolder);
+                            if (callbacks != null) {
+                                for (SurfaceHolder.Callback c : callbacks) {
+                                    c.surfaceCreated(mSurfaceHolder);
+                                }
+                            }
+                        }
+                        if (creating || formatChanged || sizeChanged) {
+                            onSurfaceChanged(mSurfaceHolder, mFormat, mWidth, mHeight);
+                            if (callbacks != null) {
+                                for (SurfaceHolder.Callback c : callbacks) {
+                                    c.surfaceChanged(mSurfaceHolder, mFormat, mWidth, mHeight);
+                                }
+                            }
+                        }
+                    } finally {
+                        mIsCreating = false;
+                        mCreated = true;
+                        if (creating || (relayoutResult&WindowManagerImpl.RELAYOUT_FIRST_TIME) != 0) {
+                            mSession.finishDrawing(mWindow);
+                        }
+                    }
+                } catch (RemoteException ex) {
+                }
+                if (DEBUG) Log.v(
+                    TAG, "Layout: x=" + mLayout.x + " y=" + mLayout.y +
+                    " w=" + mLayout.width + " h=" + mLayout.height);
+            }
+        }
+        
+        void attach(IWallpaperEngineWrapper wrapper) {
+            mIWallpaperEngine = wrapper;
+            mCaller = wrapper.mCaller;
+            mConnection = wrapper.mConnection;
+            mWindowToken = wrapper.mWindowToken;
+            mSurfaceHolder.setSizeFromLayout();
+            mInitializing = true;
+            mSession = ViewRoot.getWindowSession(getMainLooper());
+            mWindow.setSession(mSession);
+            
+            onAttach(mSurfaceHolder);
+            
+            mInitializing = false;
+            updateSurface(false);
+        }
+        
+        void detach() {
+            onDetach();
+            if (mDestroyReportNeeded) {
+                mDestroyReportNeeded = false;
+                SurfaceHolder.Callback callbacks[];
+                synchronized (mSurfaceHolder.mCallbacks) {
+                    callbacks = new SurfaceHolder.Callback[
+                            mSurfaceHolder.mCallbacks.size()];
+                    mSurfaceHolder.mCallbacks.toArray(callbacks);
+                }
+                for (SurfaceHolder.Callback c : callbacks) {
+                    c.surfaceDestroyed(mSurfaceHolder);
+                }
+            }
+            if (mCreated) {
+                try {
+                    mSession.remove(mWindow);
+                } catch (RemoteException e) {
+                }
+                mSurfaceHolder.mSurface.clear();
+                mCreated = false;
+            }
+        }
+    }
+    
+    class IWallpaperEngineWrapper extends IWallpaperEngine.Stub
+            implements HandlerCaller.Callback {
+        private final HandlerCaller mCaller;
+
+        final IWallpaperConnection mConnection;
+        final IBinder mWindowToken;
+        int mReqWidth;
+        int mReqHeight;
+        
+        Engine mEngine;
+        
+        IWallpaperEngineWrapper(WallpaperService context,
+                IWallpaperConnection conn, IBinder windowToken,
+                int reqWidth, int reqHeight) {
+            mCaller = new HandlerCaller(context, this);
+            mConnection = conn;
+            mWindowToken = windowToken;
+            mReqWidth = reqWidth;
+            mReqHeight = reqHeight;
+            
+            try {
+                conn.attachEngine(this);
+            } catch (RemoteException e) {
+                destroy();
+            }
+            
+            Message msg = mCaller.obtainMessage(DO_ATTACH);
+            mCaller.sendMessage(msg);
+        }
+        
+        public void destroy() {
+            Message msg = mCaller.obtainMessage(DO_DETACH);
+            mCaller.sendMessage(msg);
         }
 
         public void executeMessage(Message message) {
             switch (message.what) {
-                case DO_ON_INTERRUPT :
-                    //mTarget.onInterrupt();
+                case DO_ATTACH: {
+                    Engine engine = onCreateEngine();
+                    mEngine = engine;
+                    engine.attach(this);
                     return;
+                }
+                case DO_DETACH: {
+                    mEngine.detach();
+                    return;
+                }
+                case MSG_UPDATE_SURFACE:
+                    mEngine.updateSurface(false);
+                    break;
                 default :
-                    Log.w(LOG_TAG, "Unknown message type " + message.what);
+                    Log.w(TAG, "Unknown message type " + message.what);
             }
         }
     }
+
+    /**
+     * Implements the internal {@link IWallpaperService} interface to convert
+     * incoming calls to it back to calls on an {@link WallpaperService}.
+     */
+    class IWallpaperServiceWrapper extends IWallpaperService.Stub {
+        private final WallpaperService mTarget;
+
+        public IWallpaperServiceWrapper(WallpaperService context) {
+            mTarget = context;
+        }
+
+        public void attach(IWallpaperConnection conn,
+                IBinder windowToken, int reqWidth, int reqHeight) {
+            new IWallpaperEngineWrapper(
+                    mTarget, conn, windowToken, reqWidth, reqHeight);
+        }
+    }
+    
+    /**
+     * Implement to return the implementation of the internal accessibility
+     * service interface.  Subclasses should not override.
+     */
+    @Override
+    public final IBinder onBind(Intent intent) {
+        return new IWallpaperServiceWrapper(this);
+    }
+    
+    public abstract Engine onCreateEngine();
 }
diff --git a/core/java/android/view/ViewRoot.java b/core/java/android/view/ViewRoot.java
index 0d44b4e..216fc5e 100644
--- a/core/java/android/view/ViewRoot.java
+++ b/core/java/android/view/ViewRoot.java
@@ -192,22 +192,11 @@ public final class ViewRoot extends Handler implements ViewParent,
 
     private final int mDensity;
 
-    public ViewRoot(Context context) {
-        super();
-
-        if (MEASURE_LATENCY && lt == null) {
-            lt = new LatencyTimer(100, 1000);
-        }
-
-        ++sInstanceCount;
-
-        // Initialize the statics when this class is first instantiated. This is
-        // done here instead of in the static block because Zygote does not
-        // allow the spawning of threads.
+    public static IWindowSession getWindowSession(Looper mainLooper) {
         synchronized (mStaticInit) {
             if (!mInitialized) {
                 try {
-                    InputMethodManager imm = InputMethodManager.getInstance(context);
+                    InputMethodManager imm = InputMethodManager.getInstance(mainLooper);
                     sWindowSession = IWindowManager.Stub.asInterface(
                             ServiceManager.getService("window"))
                             .openSession(imm.getClient(), imm.getInputContext());
@@ -215,8 +204,24 @@ public final class ViewRoot extends Handler implements ViewParent,
                 } catch (RemoteException e) {
                 }
             }
+            return sWindowSession;
+        }
+    }
+    
+    public ViewRoot(Context context) {
+        super();
+
+        if (MEASURE_LATENCY && lt == null) {
+            lt = new LatencyTimer(100, 1000);
         }
 
+        ++sInstanceCount;
+
+        // Initialize the statics when this class is first instantiated. This is
+        // done here instead of in the static block because Zygote does not
+        // allow the spawning of threads.
+        getWindowSession(context.getMainLooper());
+        
         mThread = Thread.currentThread();
         mLocation = new WindowLeaked(null);
         mLocation.fillInStackTrace();
diff --git a/core/java/android/view/WindowManager.java b/core/java/android/view/WindowManager.java
index c0be9e8..35d7cc9 100644
--- a/core/java/android/view/WindowManager.java
+++ b/core/java/android/view/WindowManager.java
@@ -314,6 +314,12 @@ public interface WindowManager extends ViewManager {
         public static final int TYPE_INPUT_METHOD_DIALOG= FIRST_SYSTEM_WINDOW+12;
 
         /**
+         * Window type: wallpaper window, placed behind any window that wants
+         * to sit on top of the wallpaper.
+         */
+        public static final int TYPE_WALLPAPER          = FIRST_SYSTEM_WINDOW+13;
+
+        /**
          * End of types of system windows.
          */
         public static final int LAST_SYSTEM_WINDOW      = 2999;
@@ -479,16 +485,23 @@ public interface WindowManager extends ViewManager {
          * key guard or any other lock screens. Can be used with
          * {@link #FLAG_KEEP_SCREEN_ON} to turn screen on and display windows
          * directly before showing the key guard window
-         *
-         * {@hide} */
+         */
         public static final int FLAG_SHOW_WHEN_LOCKED = 0x00080000;
 
+        /** Window flag: ask that the system wallpaper be shown behind
+         * your window.  The window surface must be translucent to be able
+         * to actually see the wallpaper behind it; this flag just ensures
+         * that the wallpaper surface will be there if this window actually
+         * has translucent regions.
+         */
+        public static final int FLAG_SHOW_WALLPAPER = 0x00100000;
+        
         /** Window flag: special flag to limit the size of the window to be
          * original size ([320x480] x density). Used to create window for applications
          * running under compatibility mode.
          *
          * {@hide} */
-        public static final int FLAG_COMPATIBLE_WINDOW = 0x00100000;
+        public static final int FLAG_COMPATIBLE_WINDOW = 0x20000000;
 
         /** Window flag: a special option intended for system dialogs.  When
          * this flag is set, the window will demand focus unconditionally when
diff --git a/core/java/android/view/inputmethod/InputMethodManager.java b/core/java/android/view/inputmethod/InputMethodManager.java
index d797890..e30687f 100644
--- a/core/java/android/view/inputmethod/InputMethodManager.java
+++ b/core/java/android/view/inputmethod/InputMethodManager.java
@@ -446,13 +446,22 @@ public final class InputMethodManager {
      * @hide
      */
     static public InputMethodManager getInstance(Context context) {
+        return getInstance(context.getMainLooper());
+    }
+    
+    /**
+     * Internally, the input method manager can't be context-dependent, so
+     * we have this here for the places that need it.
+     * @hide
+     */
+    static public InputMethodManager getInstance(Looper mainLooper) {
         synchronized (mInstanceSync) {
             if (mInstance != null) {
                 return mInstance;
             }
             IBinder b = ServiceManager.getService(Context.INPUT_METHOD_SERVICE);
             IInputMethodManager service = IInputMethodManager.Stub.asInterface(b);
-            mInstance = new InputMethodManager(service, context.getMainLooper());
+            mInstance = new InputMethodManager(service, mainLooper);
         }
         return mInstance;
     }