diff options
Diffstat (limited to 'core/java/android')
| -rw-r--r-- | core/java/android/app/ApplicationContext.java | 8 | ||||
| -rw-r--r-- | core/java/android/app/IWallpaperManager.aidl | 6 | ||||
| -rw-r--r-- | core/java/android/app/WallpaperManager.java | 63 | ||||
| -rw-r--r-- | core/java/android/content/Context.java | 8 | ||||
| -rw-r--r-- | core/java/android/service/wallpaper/IWallpaperConnection.aidl | 28 | ||||
| -rw-r--r-- | core/java/android/service/wallpaper/IWallpaperEngine.aidl | 24 | ||||
| -rw-r--r-- | core/java/android/service/wallpaper/IWallpaperService.aidl | 5 | ||||
| -rw-r--r-- | core/java/android/service/wallpaper/WallpaperService.java | 336 | ||||
| -rw-r--r-- | core/java/android/view/ViewRoot.java | 31 | ||||
| -rw-r--r-- | core/java/android/view/WindowManager.java | 19 | ||||
| -rw-r--r-- | core/java/android/view/inputmethod/InputMethodManager.java | 11 |
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; } |