Window.java revision f013e1afd1e68af5e3b868c26a653bbfb39538f8
1/* 2 * Copyright (C) 2006 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17package android.view; 18 19import android.content.Context; 20import android.content.res.Configuration; 21import android.content.res.TypedArray; 22import android.graphics.PixelFormat; 23import android.graphics.drawable.Drawable; 24import android.net.Uri; 25import android.os.Bundle; 26import android.os.IBinder; 27import android.util.Log; 28 29/** 30 * Abstract base class for a top-level window look and behavior policy. An 31 * instance of this class should be used as the top-level view added to the 32 * window manager. It provides standard UI policies such as a background, title 33 * area, default key processing, etc. 34 * 35 * <p>The only existing implementation of this abstract class is 36 * android.policy.PhoneWindow, which you should instantiate when needing a 37 * Window. Eventually that class will be refactored and a factory method 38 * added for creating Window instances without knowing about a particular 39 * implementation. 40 */ 41public abstract class Window { 42 /** Flag for the "options panel" feature. This is enabled by default. */ 43 public static final int FEATURE_OPTIONS_PANEL = 0; 44 /** Flag for the "no title" feature, turning off the title at the top 45 * of the screen. */ 46 public static final int FEATURE_NO_TITLE = 1; 47 /** Flag for the progress indicator feature */ 48 public static final int FEATURE_PROGRESS = 2; 49 /** Flag for having an icon on the left side of the title bar */ 50 public static final int FEATURE_LEFT_ICON = 3; 51 /** Flag for having an icon on the right side of the title bar */ 52 public static final int FEATURE_RIGHT_ICON = 4; 53 /** Flag for indeterminate progress */ 54 public static final int FEATURE_INDETERMINATE_PROGRESS = 5; 55 /** Flag for the context menu. This is enabled by default. */ 56 public static final int FEATURE_CONTEXT_MENU = 6; 57 /** Flag for custom title. You cannot combine this feature with other title features. */ 58 public static final int FEATURE_CUSTOM_TITLE = 7; 59 /* Flag for asking for an OpenGL enabled window. 60 All 2D graphics will be handled by OpenGL ES. 61 Private for now, until it is better tested (not shipping in 1.0) 62 */ 63 private static final int FEATURE_OPENGL = 8; 64 /** Flag for setting the progress bar's visibility to VISIBLE */ 65 public static final int PROGRESS_VISIBILITY_ON = -1; 66 /** Flag for setting the progress bar's visibility to GONE */ 67 public static final int PROGRESS_VISIBILITY_OFF = -2; 68 /** Flag for setting the progress bar's indeterminate mode on */ 69 public static final int PROGRESS_INDETERMINATE_ON = -3; 70 /** Flag for setting the progress bar's indeterminate mode off */ 71 public static final int PROGRESS_INDETERMINATE_OFF = -4; 72 /** Starting value for the (primary) progress */ 73 public static final int PROGRESS_START = 0; 74 /** Ending value for the (primary) progress */ 75 public static final int PROGRESS_END = 10000; 76 /** Lowest possible value for the secondary progress */ 77 public static final int PROGRESS_SECONDARY_START = 20000; 78 /** Highest possible value for the secondary progress */ 79 public static final int PROGRESS_SECONDARY_END = 30000; 80 81 /** The default features enabled */ 82 @SuppressWarnings({"PointlessBitwiseExpression"}) 83 protected static final int DEFAULT_FEATURES = (1 << FEATURE_OPTIONS_PANEL) | 84 (1 << FEATURE_CONTEXT_MENU); 85 86 /** 87 * The ID that the main layout in the XML layout file should have. 88 */ 89 public static final int ID_ANDROID_CONTENT = com.android.internal.R.id.content; 90 91 private final Context mContext; 92 93 private TypedArray mWindowStyle; 94 private Callback mCallback; 95 private WindowManager mWindowManager; 96 private IBinder mAppToken; 97 private String mAppName; 98 private Window mContainer; 99 private Window mActiveChild; 100 private boolean mIsActive = false; 101 private boolean mHasChildren = false; 102 private int mForcedWindowFlags = 0; 103 104 private int mFeatures = DEFAULT_FEATURES; 105 private int mLocalFeatures = DEFAULT_FEATURES; 106 107 private boolean mHaveWindowFormat = false; 108 private int mDefaultWindowFormat = PixelFormat.OPAQUE; 109 110 private boolean mHasSoftInputMode = false; 111 112 // The current window attributes. 113 private final WindowManager.LayoutParams mWindowAttributes = 114 new WindowManager.LayoutParams(); 115 116 /** 117 * API from a Window back to its caller. This allows the client to 118 * intercept key dispatching, panels and menus, etc. 119 */ 120 public interface Callback { 121 /** 122 * Called to process key events. At the very least your 123 * implementation must call 124 * {@link android.view.Window#superDispatchKeyEvent} to do the 125 * standard key processing. 126 * 127 * @param event The key event. 128 * 129 * @return boolean Return true if this event was consumed. 130 */ 131 public boolean dispatchKeyEvent(KeyEvent event); 132 133 /** 134 * Called to process touch screen events. At the very least your 135 * implementation must call 136 * {@link android.view.Window#superDispatchTouchEvent} to do the 137 * standard touch screen processing. 138 * 139 * @param event The touch screen event. 140 * 141 * @return boolean Return true if this event was consumed. 142 */ 143 public boolean dispatchTouchEvent(MotionEvent event); 144 145 /** 146 * Called to process trackball events. At the very least your 147 * implementation must call 148 * {@link android.view.Window#superDispatchTrackballEvent} to do the 149 * standard trackball processing. 150 * 151 * @param event The trackball event. 152 * 153 * @return boolean Return true if this event was consumed. 154 */ 155 public boolean dispatchTrackballEvent(MotionEvent event); 156 157 /** 158 * Instantiate the view to display in the panel for 'featureId'. 159 * You can return null, in which case the default content (typically 160 * a menu) will be created for you. 161 * 162 * @param featureId Which panel is being created. 163 * 164 * @return view The top-level view to place in the panel. 165 * 166 * @see #onPreparePanel 167 */ 168 public View onCreatePanelView(int featureId); 169 170 /** 171 * Initialize the contents of the menu for panel 'featureId'. This is 172 * called if onCreatePanelView() returns null, giving you a standard 173 * menu in which you can place your items. It is only called once for 174 * the panel, the first time it is shown. 175 * 176 * <p>You can safely hold on to <var>menu</var> (and any items created 177 * from it), making modifications to it as desired, until the next 178 * time onCreatePanelMenu() is called for this feature. 179 * 180 * @param featureId The panel being created. 181 * @param menu The menu inside the panel. 182 * 183 * @return boolean You must return true for the panel to be displayed; 184 * if you return false it will not be shown. 185 */ 186 public boolean onCreatePanelMenu(int featureId, Menu menu); 187 188 /** 189 * Prepare a panel to be displayed. This is called right before the 190 * panel window is shown, every time it is shown. 191 * 192 * @param featureId The panel that is being displayed. 193 * @param view The View that was returned by onCreatePanelView(). 194 * @param menu If onCreatePanelView() returned null, this is the Menu 195 * being displayed in the panel. 196 * 197 * @return boolean You must return true for the panel to be displayed; 198 * if you return false it will not be shown. 199 * 200 * @see #onCreatePanelView 201 */ 202 public boolean onPreparePanel(int featureId, View view, Menu menu); 203 204 /** 205 * Called when a panel's menu is opened by the user. This may also be 206 * called when the menu is changing from one type to another (for 207 * example, from the icon menu to the expanded menu). 208 * 209 * @param featureId The panel that the menu is in. 210 * @param menu The menu that is opened. 211 * @return Return true to allow the menu to open, or false to prevent 212 * the menu from opening. 213 */ 214 public boolean onMenuOpened(int featureId, Menu menu); 215 216 /** 217 * Called when a panel's menu item has been selected by the user. 218 * 219 * @param featureId The panel that the menu is in. 220 * @param item The menu item that was selected. 221 * 222 * @return boolean Return true to finish processing of selection, or 223 * false to perform the normal menu handling (calling its 224 * Runnable or sending a Message to its target Handler). 225 */ 226 public boolean onMenuItemSelected(int featureId, MenuItem item); 227 228 /** 229 * This is called whenever the current window attributes change. 230 * 231 232 */ 233 public void onWindowAttributesChanged(WindowManager.LayoutParams attrs); 234 235 /** 236 * This hook is called whenever the content view of the screen changes 237 * (due to a call to 238 * {@link Window#setContentView(View, android.view.ViewGroup.LayoutParams) 239 * Window.setContentView} or 240 * {@link Window#addContentView(View, android.view.ViewGroup.LayoutParams) 241 * Window.addContentView}). 242 */ 243 public void onContentChanged(); 244 245 /** 246 * This hook is called whenever the window focus changes. 247 * 248 * @param hasFocus Whether the window now has focus. 249 */ 250 public void onWindowFocusChanged(boolean hasFocus); 251 252 /** 253 * Called when a panel is being closed. If another logical subsequent 254 * panel is being opened (and this panel is being closed to make room for the subsequent 255 * panel), this method will NOT be called. 256 * 257 * @param featureId The panel that is being displayed. 258 * @param menu If onCreatePanelView() returned null, this is the Menu 259 * being displayed in the panel. 260 */ 261 public void onPanelClosed(int featureId, Menu menu); 262 263 /** 264 * Called when the user signals the desire to start a search. 265 * 266 * @return true if search launched, false if activity refuses (blocks) 267 * 268 * @see android.app.Activity#onSearchRequested() 269 */ 270 public boolean onSearchRequested(); 271 } 272 273 public Window(Context context) { 274 mContext = context; 275 } 276 277 /** 278 * Return the Context this window policy is running in, for retrieving 279 * resources and other information. 280 * 281 * @return Context The Context that was supplied to the constructor. 282 */ 283 public final Context getContext() { 284 return mContext; 285 } 286 287 /** 288 * Return the {@link android.R.styleable#Window} attributes from this 289 * window's theme. 290 */ 291 public final TypedArray getWindowStyle() { 292 synchronized (this) { 293 if (mWindowStyle == null) { 294 mWindowStyle = mContext.obtainStyledAttributes( 295 com.android.internal.R.styleable.Window); 296 } 297 return mWindowStyle; 298 } 299 } 300 301 /** 302 * Set the container for this window. If not set, the DecorWindow 303 * operates as a top-level window; otherwise, it negotiates with the 304 * container to display itself appropriately. 305 * 306 * @param container The desired containing Window. 307 */ 308 public void setContainer(Window container) { 309 mContainer = container; 310 if (container != null) { 311 // Embedded screens never have a title. 312 mFeatures |= 1<<FEATURE_NO_TITLE; 313 mLocalFeatures |= 1<<FEATURE_NO_TITLE; 314 container.mHasChildren = true; 315 } 316 } 317 318 /** 319 * Return the container for this Window. 320 * 321 * @return Window The containing window, or null if this is a 322 * top-level window. 323 */ 324 public final Window getContainer() { 325 return mContainer; 326 } 327 328 public final boolean hasChildren() { 329 return mHasChildren; 330 } 331 332 /** 333 * Set the window manager for use by this Window to, for example, 334 * display panels. This is <em>not</em> used for displaying the 335 * Window itself -- that must be done by the client. 336 * 337 * @param wm The ViewManager for adding new windows. 338 */ 339 public void setWindowManager(WindowManager wm, 340 IBinder appToken, String appName) { 341 mAppToken = appToken; 342 mAppName = appName; 343 if (wm == null) { 344 wm = WindowManagerImpl.getDefault(); 345 } 346 mWindowManager = new LocalWindowManager(wm); 347 } 348 349 private class LocalWindowManager implements WindowManager { 350 LocalWindowManager(WindowManager wm) { 351 mWindowManager = wm; 352 } 353 354 public final void addView(View view, ViewGroup.LayoutParams params) { 355 // Let this throw an exception on a bad params. 356 WindowManager.LayoutParams wp = (WindowManager.LayoutParams)params; 357 CharSequence curTitle = wp.getTitle(); 358 if (wp.type >= WindowManager.LayoutParams.FIRST_SUB_WINDOW && 359 wp.type <= WindowManager.LayoutParams.LAST_SUB_WINDOW) { 360 if (wp.token == null) { 361 View decor = peekDecorView(); 362 if (decor != null) { 363 wp.token = decor.getWindowToken(); 364 } 365 } 366 if (curTitle == null || curTitle.length() == 0) { 367 String title; 368 if (wp.type == WindowManager.LayoutParams.TYPE_APPLICATION_MEDIA) { 369 title="Media"; 370 } else if (wp.type == WindowManager.LayoutParams.TYPE_APPLICATION_PANEL) { 371 title="Panel"; 372 } else { 373 title=Integer.toString(wp.type); 374 } 375 if (mAppName != null) { 376 title += ":" + mAppName; 377 } 378 wp.setTitle(title); 379 } 380 } else { 381 if (wp.token == null) { 382 wp.token = mContainer == null ? mAppToken : mContainer.mAppToken; 383 } 384 if ((curTitle == null || curTitle.length() == 0) 385 && mAppName != null) { 386 wp.setTitle(mAppName); 387 } 388 } 389 if (wp.packageName == null) { 390 wp.packageName = mContext.getPackageName(); 391 } 392 mWindowManager.addView(view, params); 393 } 394 395 public void updateViewLayout(View view, ViewGroup.LayoutParams params) { 396 mWindowManager.updateViewLayout(view, params); 397 } 398 399 public final void removeView(View view) { 400 mWindowManager.removeView(view); 401 } 402 403 public final void removeViewImmediate(View view) { 404 mWindowManager.removeViewImmediate(view); 405 } 406 407 public Display getDefaultDisplay() { 408 return mWindowManager.getDefaultDisplay(); 409 } 410 411 WindowManager mWindowManager; 412 } 413 414 /** 415 * Return the window manager allowing this Window to display its own 416 * windows. 417 * 418 * @return WindowManager The ViewManager. 419 */ 420 public WindowManager getWindowManager() { 421 return mWindowManager; 422 } 423 424 /** 425 * Set the Callback interface for this window, used to intercept key 426 * events and other dynamic operations in the window. 427 * 428 * @param callback The desired Callback interface. 429 */ 430 public void setCallback(Callback callback) { 431 mCallback = callback; 432 } 433 434 /** 435 * Return the current Callback interface for this window. 436 */ 437 public final Callback getCallback() { 438 return mCallback; 439 } 440 441 /** 442 * Return whether this window is being displayed with a floating style 443 * (based on the {@link android.R.attr#windowIsFloating} attribute in 444 * the style/theme). 445 * 446 * @return Returns true if the window is configured to be displayed floating 447 * on top of whatever is behind it. 448 */ 449 public abstract boolean isFloating(); 450 451 /** 452 * Set the width and height layout parameters of the window. The default 453 * for both of these is FILL_PARENT; you can change them to WRAP_CONTENT to 454 * make a window that is not full-screen. 455 * 456 * @param width The desired layout width of the window. 457 * @param height The desired layout height of the window. 458 */ 459 public void setLayout(int width, int height) 460 { 461 final WindowManager.LayoutParams attrs = getAttributes(); 462 attrs.width = width; 463 attrs.height = height; 464 if (mCallback != null) { 465 mCallback.onWindowAttributesChanged(attrs); 466 } 467 } 468 469 /** 470 * Set the gravity of the window, as per the Gravity constants. This 471 * controls how the window manager is positioned in the overall window; it 472 * is only useful when using WRAP_CONTENT for the layout width or height. 473 * 474 * @param gravity The desired gravity constant. 475 * 476 * @see Gravity 477 * @see #setLayout 478 */ 479 public void setGravity(int gravity) 480 { 481 final WindowManager.LayoutParams attrs = getAttributes(); 482 attrs.gravity = gravity; 483 if (mCallback != null) { 484 mCallback.onWindowAttributesChanged(attrs); 485 } 486 } 487 488 /** 489 * Set the type of the window, as per the WindowManager.LayoutParams 490 * types. 491 * 492 * @param type The new window type (see WindowManager.LayoutParams). 493 */ 494 public void setType(int type) { 495 final WindowManager.LayoutParams attrs = getAttributes(); 496 attrs.type = type; 497 if (mCallback != null) { 498 mCallback.onWindowAttributesChanged(attrs); 499 } 500 } 501 502 /** 503 * Set the format of window, as per the PixelFormat types. This overrides 504 * the default format that is selected by the Window based on its 505 * window decorations. 506 * 507 * @param format The new window format (see PixelFormat). Use 508 * PixelFormat.UNKNOWN to allow the Window to select 509 * the format. 510 * 511 * @see PixelFormat 512 */ 513 public void setFormat(int format) { 514 final WindowManager.LayoutParams attrs = getAttributes(); 515 if (format != PixelFormat.UNKNOWN) { 516 attrs.format = format; 517 mHaveWindowFormat = true; 518 } else { 519 attrs.format = mDefaultWindowFormat; 520 mHaveWindowFormat = false; 521 } 522 if (mCallback != null) { 523 mCallback.onWindowAttributesChanged(attrs); 524 } 525 } 526 527 /** 528 * Specify an explicit soft input mode to use for the window, as per 529 * {@link WindowManager.LayoutParams#softInputMode 530 * WindowManager.LayoutParams.softInputMode}. Providing anything besides 531 * "unspecified" here will override the input mode the window would 532 * normally retrieve from its theme. 533 */ 534 public void setSoftInputMode(int mode) { 535 final WindowManager.LayoutParams attrs = getAttributes(); 536 if (mode != WindowManager.LayoutParams.SOFT_INPUT_STATE_UNSPECIFIED) { 537 attrs.softInputMode = mode; 538 mHasSoftInputMode = true; 539 } else { 540 mHasSoftInputMode = false; 541 } 542 if (mCallback != null) { 543 mCallback.onWindowAttributesChanged(attrs); 544 } 545 } 546 547 /** 548 * Convenience function to set the flag bits as specified in flags, as 549 * per {@link #setFlags}. 550 * @param flags The flag bits to be set. 551 * @see #setFlags 552 */ 553 public void addFlags(int flags) { 554 setFlags(flags, flags); 555 } 556 557 /** 558 * Convenience function to clear the flag bits as specified in flags, as 559 * per {@link #setFlags}. 560 * @param flags The flag bits to be cleared. 561 * @see #setFlags 562 */ 563 public void clearFlags(int flags) { 564 setFlags(0, flags); 565 } 566 567 /** 568 * Set the flags of the window, as per the 569 * {@link WindowManager.LayoutParams WindowManager.LayoutParams} 570 * flags. 571 * 572 * <p>Note that some flags must be set before the window decoration is 573 * created (by the first call to 574 * {@link #setContentView(View, android.view.ViewGroup.LayoutParams)} or 575 * {@link #getDecorView()}: 576 * {@link WindowManager.LayoutParams#FLAG_LAYOUT_IN_SCREEN} and 577 * {@link WindowManager.LayoutParams#FLAG_LAYOUT_INSET_DECOR}. These 578 * will be set for you based on the {@link android.R.attr#windowIsFloating} 579 * attribute. 580 * 581 * @param flags The new window flags (see WindowManager.LayoutParams). 582 * @param mask Which of the window flag bits to modify. 583 */ 584 public void setFlags(int flags, int mask) { 585 final WindowManager.LayoutParams attrs = getAttributes(); 586 attrs.flags = (attrs.flags&~mask) | (flags&mask); 587 mForcedWindowFlags |= mask; 588 if (mCallback != null) { 589 mCallback.onWindowAttributesChanged(attrs); 590 } 591 } 592 593 /** 594 * Specify custom window attributes. <strong>PLEASE NOTE:</strong> the 595 * layout params you give here should generally be from values previously 596 * retrieved with {@link #getAttributes()}; you probably do not want to 597 * blindly create and apply your own, since this will blow away any values 598 * set by the framework that you are not interested in. 599 * 600 * @param a The new window attributes, which will completely override any 601 * current values. 602 */ 603 public void setAttributes(WindowManager.LayoutParams a) { 604 mWindowAttributes.copyFrom(a); 605 if (mCallback != null) { 606 mCallback.onWindowAttributesChanged(mWindowAttributes); 607 } 608 } 609 610 /** 611 * Retrieve the current window attributes associated with this panel. 612 * 613 * @return WindowManager.LayoutParams Either the existing window 614 * attributes object, or a freshly created one if there is none. 615 */ 616 public final WindowManager.LayoutParams getAttributes() { 617 return mWindowAttributes; 618 } 619 620 /** 621 * Return the window flags that have been explicitly set by the client, 622 * so will not be modified by {@link #getDecorView}. 623 */ 624 protected final int getForcedWindowFlags() { 625 return mForcedWindowFlags; 626 } 627 628 /** 629 * Has the app specified their own soft input mode? 630 */ 631 protected final boolean hasSoftInputMode() { 632 return mHasSoftInputMode; 633 } 634 635 /** 636 * Enable extended screen features. This must be called before 637 * setContentView(). May be called as many times as desired as long as it 638 * is before setContentView(). If not called, no extended features 639 * will be available. You can not turn off a feature once it is requested. 640 * You canot use other title features with {@link #FEATURE_CUSTOM_TITLE}. 641 * 642 * @param featureId The desired features, defined as constants by Window. 643 * @return The features that are now set. 644 */ 645 public boolean requestFeature(int featureId) { 646 final int flag = 1<<featureId; 647 mFeatures |= flag; 648 mLocalFeatures |= mContainer != null ? (flag&~mContainer.mFeatures) : flag; 649 return (mFeatures&flag) != 0; 650 } 651 652 public final void makeActive() { 653 if (mContainer != null) { 654 if (mContainer.mActiveChild != null) { 655 mContainer.mActiveChild.mIsActive = false; 656 } 657 mContainer.mActiveChild = this; 658 } 659 mIsActive = true; 660 onActive(); 661 } 662 663 public final boolean isActive() 664 { 665 return mIsActive; 666 } 667 668 /** 669 * Finds a view that was identified by the id attribute from the XML that 670 * was processed in {@link android.app.Activity#onCreate}. This will 671 * implicitly call {@link #getDecorView} for you, with all of the 672 * associated side-effects. 673 * 674 * @return The view if found or null otherwise. 675 */ 676 public View findViewById(int id) { 677 return getDecorView().findViewById(id); 678 } 679 680 /** 681 * Convenience for 682 * {@link #setContentView(View, android.view.ViewGroup.LayoutParams)} 683 * to set the screen content from a layout resource. The resource will be 684 * inflated, adding all top-level views to the screen. 685 * 686 * @param layoutResID Resource ID to be inflated. 687 * @see #setContentView(View, android.view.ViewGroup.LayoutParams) 688 */ 689 public abstract void setContentView(int layoutResID); 690 691 /** 692 * Convenience for 693 * {@link #setContentView(View, android.view.ViewGroup.LayoutParams)} 694 * set the screen content to an explicit view. This view is placed 695 * directly into the screen's view hierarchy. It can itself be a complex 696 * view hierarhcy. 697 * 698 * @param view The desired content to display. 699 * @see #setContentView(View, android.view.ViewGroup.LayoutParams) 700 */ 701 public abstract void setContentView(View view); 702 703 /** 704 * Set the screen content to an explicit view. This view is placed 705 * directly into the screen's view hierarchy. It can itself be a complex 706 * view hierarchy. 707 * 708 * <p>Note that calling this function "locks in" various characteristics 709 * of the window that can not, from this point forward, be changed: the 710 * features that have been requested with {@link #requestFeature(int)}, 711 * and certain window flags as described in {@link #setFlags(int, int)}. 712 * 713 * @param view The desired content to display. 714 * @param params Layout parameters for the view. 715 */ 716 public abstract void setContentView(View view, ViewGroup.LayoutParams params); 717 718 /** 719 * Variation on 720 * {@link #setContentView(View, android.view.ViewGroup.LayoutParams)} 721 * to add an additional content view to the screen. Added after any existing 722 * ones in the screen -- existing views are NOT removed. 723 * 724 * @param view The desired content to display. 725 * @param params Layout parameters for the view. 726 */ 727 public abstract void addContentView(View view, ViewGroup.LayoutParams params); 728 729 /** 730 * Return the view in this Window that currently has focus, or null if 731 * there are none. Note that this does not look in any containing 732 * Window. 733 * 734 * @return View The current View with focus or null. 735 */ 736 public abstract View getCurrentFocus(); 737 738 /** 739 * Quick access to the {@link LayoutInflater} instance that this Window 740 * retrieved from its Context. 741 * 742 * @return LayoutInflater The shared LayoutInflater. 743 */ 744 public abstract LayoutInflater getLayoutInflater(); 745 746 public abstract void setTitle(CharSequence title); 747 748 public abstract void setTitleColor(int textColor); 749 750 public abstract void openPanel(int featureId, KeyEvent event); 751 752 public abstract void closePanel(int featureId); 753 754 public abstract void togglePanel(int featureId, KeyEvent event); 755 756 public abstract boolean performPanelShortcut(int featureId, 757 int keyCode, 758 KeyEvent event, 759 int flags); 760 public abstract boolean performPanelIdentifierAction(int featureId, 761 int id, 762 int flags); 763 764 public abstract void closeAllPanels(); 765 766 public abstract boolean performContextMenuIdentifierAction(int id, int flags); 767 768 /** 769 * Should be called when the configuration is changed. 770 * 771 * @param newConfig The new configuration. 772 */ 773 public abstract void onConfigurationChanged(Configuration newConfig); 774 775 /** 776 * Change the background of this window to a Drawable resource. Setting the 777 * background to null will make the window be opaque. To make the window 778 * transparent, you can use an empty drawable (for instance a ColorDrawable 779 * with the color 0 or the system drawable android:drawable/empty.) 780 * 781 * @param resid The resource identifier of a drawable resource which will be 782 * installed as the new background. 783 */ 784 public void setBackgroundDrawableResource(int resid) 785 { 786 setBackgroundDrawable(mContext.getResources().getDrawable(resid)); 787 } 788 789 /** 790 * Change the background of this window to a custom Drawable. Setting the 791 * background to null will make the window be opaque. To make the window 792 * transparent, you can use an empty drawable (for instance a ColorDrawable 793 * with the color 0 or the system drawable android:drawable/empty.) 794 * 795 * @param drawable The new Drawable to use for this window's background. 796 */ 797 public abstract void setBackgroundDrawable(Drawable drawable); 798 799 /** 800 * Set the value for a drawable feature of this window, from a resource 801 * identifier. You must have called requestFeauture(featureId) before 802 * calling this function. 803 * 804 * @see android.content.res.Resources#getDrawable(int) 805 * 806 * @param featureId The desired drawable feature to change, defined as a 807 * constant by Window. 808 * @param resId Resource identifier of the desired image. 809 */ 810 public abstract void setFeatureDrawableResource(int featureId, int resId); 811 812 /** 813 * Set the value for a drawable feature of this window, from a URI. You 814 * must have called requestFeature(featureId) before calling this 815 * function. 816 * 817 * <p>The only URI currently supported is "content:", specifying an image 818 * in a content provider. 819 * 820 * @see android.widget.ImageView#setImageURI 821 * 822 * @param featureId The desired drawable feature to change. Features are 823 * constants defined by Window. 824 * @param uri The desired URI. 825 */ 826 public abstract void setFeatureDrawableUri(int featureId, Uri uri); 827 828 /** 829 * Set an explicit Drawable value for feature of this window. You must 830 * have called requestFeature(featureId) before calling this function. 831 * 832 * @param featureId The desired drawable feature to change. 833 * Features are constants defined by Window. 834 * @param drawable A Drawable object to display. 835 */ 836 public abstract void setFeatureDrawable(int featureId, Drawable drawable); 837 838 /** 839 * Set a custom alpha value for the given drawale feature, controlling how 840 * much the background is visible through it. 841 * 842 * @param featureId The desired drawable feature to change. 843 * Features are constants defined by Window. 844 * @param alpha The alpha amount, 0 is completely transparent and 255 is 845 * completely opaque. 846 */ 847 public abstract void setFeatureDrawableAlpha(int featureId, int alpha); 848 849 /** 850 * Set the integer value for a feature. The range of the value depends on 851 * the feature being set. For FEATURE_PROGRESSS, it should go from 0 to 852 * 10000. At 10000 the progress is complete and the indicator hidden. 853 * 854 * @param featureId The desired feature to change. 855 * Features are constants defined by Window. 856 * @param value The value for the feature. The interpretation of this 857 * value is feature-specific. 858 */ 859 public abstract void setFeatureInt(int featureId, int value); 860 861 /** 862 * Request that key events come to this activity. Use this if your 863 * activity has no views with focus, but the activity still wants 864 * a chance to process key events. 865 */ 866 public abstract void takeKeyEvents(boolean get); 867 868 /** 869 * Used by custom windows, such as Dialog, to pass the key press event 870 * further down the view hierarchy. Application developers should 871 * not need to implement or call this. 872 * 873 */ 874 public abstract boolean superDispatchKeyEvent(KeyEvent event); 875 876 /** 877 * Used by custom windows, such as Dialog, to pass the touch screen event 878 * further down the view hierarchy. Application developers should 879 * not need to implement or call this. 880 * 881 */ 882 public abstract boolean superDispatchTouchEvent(MotionEvent event); 883 884 /** 885 * Used by custom windows, such as Dialog, to pass the trackball event 886 * further down the view hierarchy. Application developers should 887 * not need to implement or call this. 888 * 889 */ 890 public abstract boolean superDispatchTrackballEvent(MotionEvent event); 891 892 /** 893 * Retrieve the top-level window decor view (containing the standard 894 * window frame/decorations and the client's content inside of that), which 895 * can be added as a window to the window manager. 896 * 897 * <p><em>Note that calling this function for the first time "locks in" 898 * various window characteristics as described in 899 * {@link #setContentView(View, android.view.ViewGroup.LayoutParams)}.</em></p> 900 * 901 * @return Returns the top-level window decor view. 902 */ 903 public abstract View getDecorView(); 904 905 /** 906 * Retrieve the current decor view, but only if it has already been created; 907 * otherwise returns null. 908 * 909 * @return Returns the top-level window decor or null. 910 * @see #getDecorView 911 */ 912 public abstract View peekDecorView(); 913 914 public abstract Bundle saveHierarchyState(); 915 916 public abstract void restoreHierarchyState(Bundle savedInstanceState); 917 918 protected abstract void onActive(); 919 920 /** 921 * Return the feature bits that are enabled. This is the set of features 922 * that were given to requestFeature(), and are being handled by this 923 * Window itself or its container. That is, it is the set of 924 * requested features that you can actually use. 925 * 926 * <p>To do: add a public version of this API that allows you to check for 927 * features by their feature ID. 928 * 929 * @return int The feature bits. 930 */ 931 protected final int getFeatures() 932 { 933 return mFeatures; 934 } 935 936 /** 937 * Return the feature bits that are being implemented by this Window. 938 * This is the set of features that were given to requestFeature(), and are 939 * being handled by only this Window itself, not by its containers. 940 * 941 * @return int The feature bits. 942 */ 943 protected final int getLocalFeatures() 944 { 945 return mLocalFeatures; 946 } 947 948 /** 949 * Set the default format of window, as per the PixelFormat types. This 950 * is the format that will be used unless the client specifies in explicit 951 * format with setFormat(); 952 * 953 * @param format The new window format (see PixelFormat). 954 * 955 * @see #setFormat 956 * @see PixelFormat 957 */ 958 protected void setDefaultWindowFormat(int format) { 959 mDefaultWindowFormat = format; 960 if (!mHaveWindowFormat) { 961 final WindowManager.LayoutParams attrs = getAttributes(); 962 attrs.format = format; 963 if (mCallback != null) { 964 mCallback.onWindowAttributesChanged(attrs); 965 } 966 } 967 } 968 969 public abstract void setChildDrawable(int featureId, Drawable drawable); 970 971 public abstract void setChildInt(int featureId, int value); 972 973 /** 974 * Is a keypress one of the defined shortcut keys for this window. 975 * @param keyCode the key code from {@link android.view.KeyEvent} to check. 976 * @param event the {@link android.view.KeyEvent} to use to help check. 977 */ 978 public abstract boolean isShortcutKey(int keyCode, KeyEvent event); 979 980 /** 981 * @see android.app.Activity#setVolumeControlStream(int) 982 */ 983 public abstract void setVolumeControlStream(int streamType); 984 985 /** 986 * @see android.app.Activity#getVolumeControlStream() 987 */ 988 public abstract int getVolumeControlStream(); 989 990} 991