Presentation

public class Presentation
extends Dialog

演示文稿的基础类。

演示文稿是一种特殊类型的对话框，其目的是在辅助显示器上呈现内容。 A Presentation在创建时与目标Display相关联，并根据显示的度量配置其上下文和资源配置。

值得注意的是，演示文稿的Context不同于其包含Activity的上下文。 使用演示文稿自己的上下文来扩充演示文稿的布局并加载其他资源以确保加载目标显示的正确大小和密度的资源是非常重要的。

当与其相连的显示器被移除时，演示文稿会自动取消（请参阅cancel() ）。 每当活动本身暂停或恢复时，活动应负责暂停和恢复演示文稿中正在播放的任何内容。

Choosing a presentation display

呈现出前Presentation它选择是很重要的Display ，并会出现。 选择演示文稿显示有时很困难，因为可能会连接多个显示。 应用程序应该让系统选择合适的演示文稿显示，而不是试图猜测哪种显示效果最佳。

有两种主要方法可以选择 Display 。

Using the media router to choose a presentation display

选择演示文稿显示的最简单方法是使用MediaRouter API。 媒体路由器服务会跟踪系统上哪些音频和视频路由可用。 媒体路由器在选择或未选择路由或路由的首选演示显示更改时发送通知。 因此，应用程序可以简单地观看这些通知，并自动在首选演示文稿显示中显示或取消演示。

首选的演示文稿显示是媒体路由器建议应用程序在要显示辅助显示内容时应使用的显示。 有时可能没有首选的演示文稿显示，在这种情况下，应用程序应该在本地显示其内容而不使用演示文稿。

以下是如何使用媒体路由器在首选演示文稿显示中使用 getPresentationDisplay()创建和显示演示文稿。

 MediaRouter mediaRouter = (MediaRouter) context.getSystemService(Context.MEDIA_ROUTER_SERVICE);
 MediaRouter.RouteInfo route = mediaRouter.getSelectedRoute();
 if (route != null) {
     Display presentationDisplay = route.getPresentationDisplay();
     if (presentationDisplay != null) {
         Presentation presentation = new MyPresentation(context, presentationDisplay);
         presentation.show();
     }
 }

以下来自 ApiDemos示例代码演示了如何使用媒体路由器自动切换显示主要活动中的内容，并在演示文稿显示可用时显示演示文稿中的内容。

/**
 * <h3>Presentation Activity</h3>
 *
 * <p>
 * This demonstrates how to create an activity that shows some content
 * on a secondary display using a {@link Presentation}.
 * </p><p>
 * The activity uses the {@link MediaRouter} API to automatically detect when
 * a presentation display is available and to allow the user to control the
 * media routes using a menu item.  When a presentation display is available,
 * we stop showing content in the main activity and instead open up a
 * {@link Presentation} on the preferred presentation display.  When a presentation
 * display is removed, we revert to showing content in the main activity.
 * We also write information about displays and display-related events to
 * the Android log which you can read using <code>adb logcat</code>.
 * </p><p>
 * You can try this out using an HDMI or Wifi display or by using the
 * "Simulate secondary displays" feature in Development Settings to create a few
 * simulated secondary displays.  Each display will appear in the list along with a
 * checkbox to show a presentation on that display.
 * </p><p>
 * See also the {@link PresentationActivity} sample which
 * uses the low-level display manager to enumerate displays and to show multiple
 * simultaneous presentations on different displays.
 * </p>
 */
public class PresentationWithMediaRouterActivity extends Activity {
    private final String TAG = "PresentationWithMediaRouterActivity";

    private MediaRouter mMediaRouter;
    private DemoPresentation mPresentation;
    private GLSurfaceView mSurfaceView;
    private TextView mInfoTextView;
    private boolean mPaused;

    /**
     * Initialization of the Activity after it is first created.  Must at least
     * call {@link android.app.Activity#setContentView setContentView()} to
     * describe what is to be displayed in the screen.
     */
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        // Be sure to call the super class.
        super.onCreate(savedInstanceState);

        // Get the media router service.
        mMediaRouter = (MediaRouter)getSystemService(Context.MEDIA_ROUTER_SERVICE);

        // See assets/res/any/layout/presentation_with_media_router_activity.xml for this
        // view layout definition, which is being set here as
        // the content of our screen.
        setContentView(R.layout.presentation_with_media_router_activity);

        // Set up the surface view for visual interest.
        mSurfaceView = (GLSurfaceView)findViewById(R.id.surface_view);
        mSurfaceView.setRenderer(new CubeRenderer(false));

        // Get a text view where we will show information about what's happening.
        mInfoTextView = (TextView)findViewById(R.id.info);
    }

    @Override
    protected void onResume() {
        // Be sure to call the super class.
        super.onResume();

        // Listen for changes to media routes.
        mMediaRouter.addCallback(MediaRouter.ROUTE_TYPE_LIVE_VIDEO, mMediaRouterCallback);

        // Update the presentation based on the currently selected route.
        mPaused = false;
        updatePresentation();
    }

    @Override
    protected void onPause() {
        // Be sure to call the super class.
        super.onPause();

        // Stop listening for changes to media routes.
        mMediaRouter.removeCallback(mMediaRouterCallback);

        // Pause rendering.
        mPaused = true;
        updateContents();
    }

    @Override
    protected void onStop() {
        // Be sure to call the super class.
        super.onStop();

        // Dismiss the presentation when the activity is not visible.
        if (mPresentation != null) {
            Log.i(TAG, "Dismissing presentation because the activity is no longer visible.");
            mPresentation.dismiss();
            mPresentation = null;
        }
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Be sure to call the super class.
        super.onCreateOptionsMenu(menu);

        // Inflate the menu and configure the media router action provider.
        getMenuInflater().inflate(R.menu.presentation_with_media_router_menu, menu);

        MenuItem mediaRouteMenuItem = menu.findItem(R.id.menu_media_route);
        MediaRouteActionProvider mediaRouteActionProvider =
                (MediaRouteActionProvider)mediaRouteMenuItem.getActionProvider();
        mediaRouteActionProvider.setRouteTypes(MediaRouter.ROUTE_TYPE_LIVE_VIDEO);

        // Return true to show the menu.
        return true;
    }

    private void updatePresentation() {
        // Get the current route and its presentation display.
        MediaRouter.RouteInfo route = mMediaRouter.getSelectedRoute(
                MediaRouter.ROUTE_TYPE_LIVE_VIDEO);
        Display presentationDisplay = route != null ? route.getPresentationDisplay() : null;

        // Dismiss the current presentation if the display has changed.
        if (mPresentation != null && mPresentation.getDisplay() != presentationDisplay) {
            Log.i(TAG, "Dismissing presentation because the current route no longer "
                    + "has a presentation display.");
            mPresentation.dismiss();
            mPresentation = null;
        }

        // Show a new presentation if needed.
        if (mPresentation == null && presentationDisplay != null) {
            Log.i(TAG, "Showing presentation on display: " + presentationDisplay);
            mPresentation = new DemoPresentation(this, presentationDisplay);
            mPresentation.setOnDismissListener(mOnDismissListener);
            try {
                mPresentation.show();
            } catch (WindowManager.InvalidDisplayException ex) {
                Log.w(TAG, "Couldn't show presentation!  Display was removed in "
                        + "the meantime.", ex);
                mPresentation = null;
            }
        }

        // Update the contents playing in this activity.
        updateContents();
    }

    private void updateContents() {
        // Show either the content in the main activity or the content in the presentation
        // along with some descriptive text about what is happening.
        if (mPresentation != null) {
            mInfoTextView.setText(getResources().getString(
                    R.string.presentation_with_media_router_now_playing_remotely,
                    mPresentation.getDisplay().getName()));
            mSurfaceView.setVisibility(View.INVISIBLE);
            mSurfaceView.onPause();
            if (mPaused) {
                mPresentation.getSurfaceView().onPause();
            } else {
                mPresentation.getSurfaceView().onResume();
            }
        } else {
            mInfoTextView.setText(getResources().getString(
                    R.string.presentation_with_media_router_now_playing_locally,
                    getWindowManager().getDefaultDisplay().getName()));
            mSurfaceView.setVisibility(View.VISIBLE);
            if (mPaused) {
                mSurfaceView.onPause();
            } else {
                mSurfaceView.onResume();
            }
        }
    }

    private final MediaRouter.SimpleCallback mMediaRouterCallback =
            new MediaRouter.SimpleCallback() {
        @Override
        public void onRouteSelected(MediaRouter router, int type, RouteInfo info) {
            Log.d(TAG, "onRouteSelected: type=" + type + ", info=" + info);
            updatePresentation();
        }

        @Override
        public void onRouteUnselected(MediaRouter router, int type, RouteInfo info) {
            Log.d(TAG, "onRouteUnselected: type=" + type + ", info=" + info);
            updatePresentation();
        }

        @Override
        public void onRoutePresentationDisplayChanged(MediaRouter router, RouteInfo info) {
            Log.d(TAG, "onRoutePresentationDisplayChanged: info=" + info);
            updatePresentation();
        }
    };

    /**
     * Listens for when presentations are dismissed.
     */
    private final DialogInterface.OnDismissListener mOnDismissListener =
            new DialogInterface.OnDismissListener() {
        @Override
        public void onDismiss(DialogInterface dialog) {
            if (dialog == mPresentation) {
                Log.i(TAG, "Presentation was dismissed.");
                mPresentation = null;
                updateContents();
            }
        }
    };

    /**
     * The presentation to show on the secondary display.
     * <p>
     * Note that this display may have different metrics from the display on which
     * the main activity is showing so we must be careful to use the presentation's
     * own {@link Context} whenever we load resources.
     * </p>
     */
    private final static class DemoPresentation extends Presentation {
        private GLSurfaceView mSurfaceView;

        public DemoPresentation(Context context, Display display) {
            super(context, display);
        }

        @Override
        protected void onCreate(Bundle savedInstanceState) {
            // Be sure to call the super class.
            super.onCreate(savedInstanceState);

            // Get the resources for the context of the presentation.
            // Notice that we are getting the resources from the context of the presentation.
            Resources r = getContext().getResources();

            // Inflate the layout.
            setContentView(R.layout.presentation_with_media_router_content);

            // Set up the surface view for visual interest.
            mSurfaceView = (GLSurfaceView)findViewById(R.id.surface_view);
            mSurfaceView.setRenderer(new CubeRenderer(false));
        }

        public GLSurfaceView getSurfaceView() {
            return mSurfaceView;
        }
    }
}

Using the display manager to choose a presentation display

另一种选择演示文稿显示的方法是直接使用DisplayManager API。 显示管理器服务提供枚举和描述连接到系统的所有显示的功能，包括可用于演示的显示。

显示管理器跟踪系统中的所有显示。 但是，并非所有显示器都适合用于显示演示文稿。 例如，如果一个活动试图在主显示器上显示演示文稿，它可能会掩盖其自己的内容（就像在活动之上打开对话框一样）。

以下是如何确定使用 getDisplays(String)和 DISPLAY_CATEGORY_PRESENTATION类别显示演示文稿的合适显示方式。

 DisplayManager displayManager = (DisplayManager) context.getSystemService(Context.DISPLAY_SERVICE);
 Display[] presentationDisplays = displayManager.getDisplays(DisplayManager.DISPLAY_CATEGORY_PRESENTATION);
 if (presentationDisplays.length > 0) {
     // If there is more than one suitable presentation display, then we could consider
     // giving the user a choice.  For this example, we simply choose the first display
     // which is the one the system recommends as the preferred presentation display.
     Display display = presentationDisplays[0];
     Presentation presentation = new MyPresentation(context, presentationDisplay);
     presentation.show();
 }

以下来自 ApiDemos示例代码演示了如何使用显示管理器枚举显示并同时在多个演示显示中显示内容。

/**
 * <h3>Presentation Activity</h3>
 *
 * <p>
 * This demonstrates how to create an activity that shows some content
 * on a secondary display using a {@link Presentation}.
 * </p><p>
 * The activity uses the {@link DisplayManager} API to enumerate displays.
 * When the user selects a display, the activity opens a {@link Presentation}
 * on that display.  We show a different photograph in each presentation
 * on a unique background along with a label describing the display.
 * We also write information about displays and display-related events to
 * the Android log which you can read using <code>adb logcat</code>.
 * </p><p>
 * You can try this out using an HDMI or Wifi display or by using the
 * "Simulate secondary displays" feature in Development Settings to create a few
 * simulated secondary displays.  Each display will appear in the list along with a
 * checkbox to show a presentation on that display.
 * </p><p>
 * See also the {@link PresentationWithMediaRouterActivity} sample which
 * uses the media router to automatically select a secondary display
 * on which to show content based on the currently selected route.
 * </p>
 */
public class PresentationActivity extends Activity
        implements OnCheckedChangeListener, OnClickListener, OnItemSelectedListener {
    private final String TAG = "PresentationActivity";

    // Key for storing saved instance state.
    private static final String PRESENTATION_KEY = "presentation";

    // The content that we want to show on the presentation.
    private static final int[] PHOTOS = new int[] {
        R.drawable.frantic,
        R.drawable.photo1, R.drawable.photo2, R.drawable.photo3,
        R.drawable.photo4, R.drawable.photo5, R.drawable.photo6,
        R.drawable.sample_4,
    };

    private DisplayManager mDisplayManager;
    private DisplayListAdapter mDisplayListAdapter;
    private CheckBox mShowAllDisplaysCheckbox;
    private ListView mListView;
    private int mNextImageNumber;

    // List of presentation contents indexed by displayId.
    // This state persists so that we can restore the old presentation
    // contents when the activity is paused or resumed.
    private SparseArray<DemoPresentationContents> mSavedPresentationContents;

    // List of all currently visible presentations indexed by display id.
    private final SparseArray<DemoPresentation> mActivePresentations =
            new SparseArray<DemoPresentation>();

    /**
     * Initialization of the Activity after it is first created.  Must at least
     * call {@link android.app.Activity#setContentView setContentView()} to
     * describe what is to be displayed in the screen.
     */
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        // Be sure to call the super class.
        super.onCreate(savedInstanceState);

        // Restore saved instance state.
        if (savedInstanceState != null) {
            mSavedPresentationContents =
                    savedInstanceState.getSparseParcelableArray(PRESENTATION_KEY);
        } else {
            mSavedPresentationContents = new SparseArray<DemoPresentationContents>();
        }

        // Get the display manager service.
        mDisplayManager = (DisplayManager)getSystemService(Context.DISPLAY_SERVICE);

        // See assets/res/any/layout/presentation_activity.xml for this
        // view layout definition, which is being set here as
        // the content of our screen.
        setContentView(R.layout.presentation_activity);

        // Set up checkbox to toggle between showing all displays or only presentation displays.
        mShowAllDisplaysCheckbox = (CheckBox)findViewById(R.id.show_all_displays);
        mShowAllDisplaysCheckbox.setOnCheckedChangeListener(this);

        // Set up the list of displays.
        mDisplayListAdapter = new DisplayListAdapter(this);
        mListView = (ListView)findViewById(R.id.display_list);
        mListView.setAdapter(mDisplayListAdapter);
    }

    @Override
    protected void onResume() {
        // Be sure to call the super class.
        super.onResume();

        // Update our list of displays on resume.
        mDisplayListAdapter.updateContents();

        // Restore presentations from before the activity was paused.
        final int numDisplays = mDisplayListAdapter.getCount();
        for (int i = 0; i < numDisplays; i++) {
            final Display display = mDisplayListAdapter.getItem(i);
            final DemoPresentationContents contents =
                    mSavedPresentationContents.get(display.getDisplayId());
            if (contents != null) {
                showPresentation(display, contents);
            }
        }
        mSavedPresentationContents.clear();

        // Register to receive events from the display manager.
        mDisplayManager.registerDisplayListener(mDisplayListener, null);
    }

    @Override
    protected void onPause() {
        // Be sure to call the super class.
        super.onPause();

        // Unregister from the display manager.
        mDisplayManager.unregisterDisplayListener(mDisplayListener);

        // Dismiss all of our presentations but remember their contents.
        Log.d(TAG, "Activity is being paused.  Dismissing all active presentation.");
        for (int i = 0; i < mActivePresentations.size(); i++) {
            DemoPresentation presentation = mActivePresentations.valueAt(i);
            int displayId = mActivePresentations.keyAt(i);
            mSavedPresentationContents.put(displayId, presentation.mContents);
            presentation.dismiss();
        }
        mActivePresentations.clear();
    }

    @Override
    protected void onSaveInstanceState(Bundle outState) {
        // Be sure to call the super class.
        super.onSaveInstanceState(outState);
        outState.putSparseParcelableArray(PRESENTATION_KEY, mSavedPresentationContents);
    }

    /**
     * Shows a {@link Presentation} on the specified display.
     */
    private void showPresentation(Display display, DemoPresentationContents contents) {
        final int displayId = display.getDisplayId();
        if (mActivePresentations.get(displayId) != null) {
            return;
        }

        Log.d(TAG, "Showing presentation photo #" + contents.photo
                + " on display #" + displayId + ".");

        DemoPresentation presentation = new DemoPresentation(this, display, contents);
        presentation.show();
        presentation.setOnDismissListener(mOnDismissListener);
        mActivePresentations.put(displayId, presentation);
    }

    /**
     * Hides a {@link Presentation} on the specified display.
     */
    private void hidePresentation(Display display) {
        final int displayId = display.getDisplayId();
        DemoPresentation presentation = mActivePresentations.get(displayId);
        if (presentation == null) {
            return;
        }

        Log.d(TAG, "Dismissing presentation on display #" + displayId + ".");

        presentation.dismiss();
        mActivePresentations.delete(displayId);
    }

    /**
     * Sets the display mode of the {@link Presentation} on the specified display
     * if it is already shown.
     */
    private void setPresentationDisplayMode(Display display, int displayModeId) {
        final int displayId = display.getDisplayId();
        DemoPresentation presentation = mActivePresentations.get(displayId);
        if (presentation == null) {
            return;
        }

        presentation.setPreferredDisplayMode(displayModeId);
    }

    private int getNextPhoto() {
        final int photo = mNextImageNumber;
        mNextImageNumber = (mNextImageNumber + 1) % PHOTOS.length;
        return photo;
    }

    /**
     * Called when the show all displays checkbox is toggled or when
     * an item in the list of displays is checked or unchecked.
     */
    @Override
    public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
        if (buttonView == mShowAllDisplaysCheckbox) {
            // Show all displays checkbox was toggled.
            mDisplayListAdapter.updateContents();
        } else {
            // Display item checkbox was toggled.
            final Display display = (Display)buttonView.getTag();
            if (isChecked) {
                DemoPresentationContents contents = new DemoPresentationContents(getNextPhoto());
                showPresentation(display, contents);
            } else {
                hidePresentation(display);
            }
            mDisplayListAdapter.updateContents();
        }
    }

    /**
     * Called when the Info button next to a display is clicked to show information
     * about the display.
     */
    @Override
    public void onClick(View v) {
        Context context = v.getContext();
        AlertDialog.Builder builder = new AlertDialog.Builder(context);
        final Display display = (Display)v.getTag();
        Resources r = context.getResources();
        AlertDialog alert = builder
                .setTitle(r.getString(
                        R.string.presentation_alert_info_text, display.getDisplayId()))
                .setMessage(display.toString())
                .setNeutralButton(R.string.presentation_alert_dismiss_text,
                        new DialogInterface.OnClickListener() {
                            @Override
                            public void onClick(DialogInterface dialog, int which) {
                                dialog.dismiss();
                            }
                    })
                .create();
        alert.show();
    }

    /**
     * Called when a display mode has been selected.
     */
    @Override
    public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {
        final Display display = (Display)parent.getTag();
        final Display.Mode[] modes = display.getSupportedModes();
        setPresentationDisplayMode(display, position >= 1 && position <= modes.length ?
                modes[position - 1].getModeId() : 0);
    }

    /**
     * Called when a display mode has been unselected.
     */
    @Override
    public void onNothingSelected(AdapterView<?> parent) {
        final Display display = (Display)parent.getTag();
        setPresentationDisplayMode(display, 0);
    }

    /**
     * Listens for displays to be added, changed or removed.
     * We use it to update the list and show a new {@link Presentation} when a
     * display is connected.
     *
     * Note that we don't bother dismissing the {@link Presentation} when a
     * display is removed, although we could.  The presentation API takes care
     * of doing that automatically for us.
     */
    private final DisplayManager.DisplayListener mDisplayListener =
            new DisplayManager.DisplayListener() {
        @Override
        public void onDisplayAdded(int displayId) {
            Log.d(TAG, "Display #" + displayId + " added.");
            mDisplayListAdapter.updateContents();
        }

        @Override
        public void onDisplayChanged(int displayId) {
            Log.d(TAG, "Display #" + displayId + " changed.");
            mDisplayListAdapter.updateContents();
        }

        @Override
        public void onDisplayRemoved(int displayId) {
            Log.d(TAG, "Display #" + displayId + " removed.");
            mDisplayListAdapter.updateContents();
        }
    };

    /**
     * Listens for when presentations are dismissed.
     */
    private final DialogInterface.OnDismissListener mOnDismissListener =
            new DialogInterface.OnDismissListener() {
        @Override
        public void onDismiss(DialogInterface dialog) {
            DemoPresentation presentation = (DemoPresentation)dialog;
            int displayId = presentation.getDisplay().getDisplayId();
            Log.d(TAG, "Presentation on display #" + displayId + " was dismissed.");
            mActivePresentations.delete(displayId);
            mDisplayListAdapter.notifyDataSetChanged();
        }
    };

    /**
     * List adapter.
     * Shows information about all displays.
     */
    private final class DisplayListAdapter extends ArrayAdapter<Display> {
        final Context mContext;

        public DisplayListAdapter(Context context) {
            super(context, R.layout.presentation_list_item);
            mContext = context;
        }

        @Override
        public View getView(int position, View convertView, ViewGroup parent) {
            final View v;
            if (convertView == null) {
                v = ((Activity) mContext).getLayoutInflater().inflate(
                        R.layout.presentation_list_item, null);
            } else {
                v = convertView;
            }

            final Display display = getItem(position);
            final int displayId = display.getDisplayId();

            DemoPresentation presentation = mActivePresentations.get(displayId);
            DemoPresentationContents contents = presentation != null ?
                    presentation.mContents : null;
            if (contents == null) {
                contents = mSavedPresentationContents.get(displayId);
            }

            CheckBox cb = (CheckBox)v.findViewById(R.id.checkbox_presentation);
            cb.setTag(display);
            cb.setOnCheckedChangeListener(PresentationActivity.this);
            cb.setChecked(contents != null);

            TextView tv = (TextView)v.findViewById(R.id.display_id);
            tv.setText(v.getContext().getResources().getString(
                    R.string.presentation_display_id_text, displayId, display.getName()));

            Button b = (Button)v.findViewById(R.id.info);
            b.setTag(display);
            b.setOnClickListener(PresentationActivity.this);

            Spinner s = (Spinner)v.findViewById(R.id.modes);
            Display.Mode[] modes = display.getSupportedModes();
            if (contents == null || modes.length == 1) {
                s.setVisibility(View.GONE);
                s.setAdapter(null);
            } else {
                ArrayAdapter<String> modeAdapter = new ArrayAdapter<String>(mContext,
                        android.R.layout.simple_list_item_1);
                s.setVisibility(View.VISIBLE);
                s.setAdapter(modeAdapter);
                s.setTag(display);
                s.setOnItemSelectedListener(PresentationActivity.this);

                modeAdapter.add("<default mode>");

                for (Display.Mode mode : modes) {
                    modeAdapter.add(String.format("Mode %d: %dx%d/%.1ffps",
                            mode.getModeId(),
                            mode.getPhysicalWidth(), mode.getPhysicalHeight(),
                            mode.getRefreshRate()));
                    if (contents.displayModeId == mode.getModeId()) {
                        s.setSelection(modeAdapter.getCount() - 1);
                    }
                }
            }

            return v;
        }

        /**
         * Update the contents of the display list adapter to show
         * information about all current displays.
         */
        public void updateContents() {
            clear();

            String displayCategory = getDisplayCategory();
            Display[] displays = mDisplayManager.getDisplays(displayCategory);
            addAll(displays);

            Log.d(TAG, "There are currently " + displays.length + " displays connected.");
            for (Display display : displays) {
                Log.d(TAG, "  " + display);
            }
        }

        private String getDisplayCategory() {
            return mShowAllDisplaysCheckbox.isChecked() ? null :
                DisplayManager.DISPLAY_CATEGORY_PRESENTATION;
        }
    }

    /**
     * The presentation to show on the secondary display.
     *
     * Note that the presentation display may have different metrics from the display on which
     * the main activity is showing so we must be careful to use the presentation's
     * own {@link Context} whenever we load resources.
     */
    private final class DemoPresentation extends Presentation {

        final DemoPresentationContents mContents;

        public DemoPresentation(Context context, Display display,
                DemoPresentationContents contents) {
            super(context, display);
            mContents = contents;
        }

        /**
         * Sets the preferred display mode id for the presentation.
         */
        public void setPreferredDisplayMode(int modeId) {
            mContents.displayModeId = modeId;

            WindowManager.LayoutParams params = getWindow().getAttributes();
            params.preferredDisplayModeId = modeId;
            getWindow().setAttributes(params);
        }

        @Override
        protected void onCreate(Bundle savedInstanceState) {
            // Be sure to call the super class.
            super.onCreate(savedInstanceState);

            // Get the resources for the context of the presentation.
            // Notice that we are getting the resources from the context of the presentation.
            Resources r = getContext().getResources();

            // Inflate the layout.
            setContentView(R.layout.presentation_content);

            final Display display = getDisplay();
            final int displayId = display.getDisplayId();
            final int photo = mContents.photo;

            // Show a caption to describe what's going on.
            TextView text = (TextView)findViewById(R.id.text);
            text.setText(r.getString(R.string.presentation_photo_text,
                    photo, displayId, display.getName()));

            // Show a n image for visual interest.
            ImageView image = (ImageView)findViewById(R.id.image);
            image.setImageDrawable(r.getDrawable(PHOTOS[photo]));

            GradientDrawable drawable = new GradientDrawable();
            drawable.setShape(GradientDrawable.RECTANGLE);
            drawable.setGradientType(GradientDrawable.RADIAL_GRADIENT);

            // Set the background to a random gradient.
            Point p = new Point();
            getDisplay().getSize(p);
            drawable.setGradientRadius(Math.max(p.x, p.y) / 2);
            drawable.setColors(mContents.colors);
            findViewById(android.R.id.content).setBackground(drawable);
        }
    }

    /**
     * Information about the content we want to show in the presentation.
     */
    private final static class DemoPresentationContents implements Parcelable {
        final int photo;
        final int[] colors;
        int displayModeId;

        public static final Creator<DemoPresentationContents> CREATOR =
                new Creator<DemoPresentationContents>() {
            @Override
            public DemoPresentationContents createFromParcel(Parcel in) {
                return new DemoPresentationContents(in);
            }

            @Override
            public DemoPresentationContents[] newArray(int size) {
                return new DemoPresentationContents[size];
            }
        };

        public DemoPresentationContents(int photo) {
            this.photo = photo;
            colors = new int[] {
                    ((int) (Math.random() * Integer.MAX_VALUE)) | 0xFF000000,
                    ((int) (Math.random() * Integer.MAX_VALUE)) | 0xFF000000 };
        }

        private DemoPresentationContents(Parcel in) {
            photo = in.readInt();
            colors = new int[] { in.readInt(), in.readInt() };
            displayModeId = in.readInt();
        }

        @Override
        public int describeContents() {
            return 0;
        }

        @Override
        public void writeToParcel(Parcel dest, int flags) {
            dest.writeInt(photo);
            dest.writeInt(colors[0]);
            dest.writeInt(colors[1]);
            dest.writeInt(displayModeId);
        }
    }
}

Summary

Inherited constants
From interface android.content.DialogInterface int BUTTON1 此常数在API级别3中已弃用。请使用BUTTON_POSITIVE int BUTTON2 此常数在API级别3中已弃用。请使用BUTTON_NEGATIVE int BUTTON3 此常数在API级别3中已弃用。请使用BUTTON_NEUTRAL int BUTTON_NEGATIVE 负号按钮的标识符。 int BUTTON_NEUTRAL 中性按钮的标识符。 int BUTTON_POSITIVE 肯定按钮的标识符。

Inherited methods
From class android.app.Dialog void addContentView(View view, ViewGroup.LayoutParams params) 在屏幕上添加一个额外的内容视图。 void cancel() 取消对话框。 void closeOptionsMenu() void create() 强制立即创建对话框。 void dismiss() 关闭此对话框，将其从屏幕上移除。 boolean dispatchGenericMotionEvent(MotionEvent ev) 被调用来处理通用运动事件。 boolean dispatchKeyEvent(KeyEvent event) 被调用来处理关键事件。 boolean dispatchKeyShortcutEvent(KeyEvent event) 被调用来处理键快捷键事件。 boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event) 打电话来处理 AccessibilityEvent的人口。 boolean dispatchTouchEvent(MotionEvent ev) 被调用来处理触摸屏事件。 boolean dispatchTrackballEvent(MotionEvent ev) 被称为处理轨迹球事件。 View findViewById(int id) 使用给定的标识符查找子视图。 ActionBar getActionBar() 检索连接到此对话框的 ActionBar （如果存在）。 final Context getContext() 检索此对话框正在运行的上下文。 View getCurrentFocus() 如果此活动返回当前聚焦的视图，则在窗口上调用 getCurrentFocus() 。 LayoutInflater getLayoutInflater() final Activity getOwnerActivity() 返回拥有此对话框的活动。 final SearchEvent getSearchEvent() 在onSearchRequested（）回调期间，该函数将返回触发回调的 SearchEvent （如果存在）。 final int getVolumeControlStream() Window getWindow() 检索活动的当前窗口。 void hide() 隐藏对话框，但不要忽略它。 void invalidateOptionsMenu() boolean isShowing() void onActionModeFinished(ActionMode mode) 当动作模式完成时调用。 请注意，如果您重写此方法，则应始终通过调用super.onActionModeFinished（mode）调用超类实现。 void onActionModeStarted(ActionMode mode) 当动作模式已启动时调用。 请注意，如果您重写此方法，则应始终通过调用super.onActionModeStarted（mode）调用超类实现。 void onAttachedToWindow() 当窗口已连接到窗口管理器时调用。 void onBackPressed() 当对话框检测到用户按下后退键时调用。 void onContentChanged() 只要屏幕的内容视图发生变化（由于致电 Window.setContentView或 Window.addContentView ）， Window.setContentView调用此钩子。 boolean onContextItemSelected(MenuItem item) void onContextMenuClosed(Menu menu) void onCreate(Bundle savedInstanceState) 与 onCreate(Bundle)类似，您应该使用此方法初始化对话框，包括调用 setContentView(View) 。 void onCreateContextMenu(ContextMenu menu, View v, ContextMenu.ContextMenuInfo menuInfo) 在构建此视图的上下文菜单时调用。 boolean onCreateOptionsMenu(Menu menu) 如果客户需要此对话框的相同菜单，将此呼叫代理给所有者活动 onCreateOptionsMenu(Menu)通常是安全的。 boolean onCreatePanelMenu(int featureId, Menu menu) 初始化面板'featureId'的菜单内容。 View onCreatePanelView(int featureId) 实例化视图以显示在“featureId”的面板中。 void onDetachedFromWindow() 当窗口已连接到窗口管理器时调用。 boolean onGenericMotionEvent(MotionEvent event) 当通用运动事件未被对话框中的任何视图处理时调用。 boolean onKeyDown(int keyCode, KeyEvent event) 一键被按下。 boolean onKeyLongPress(int keyCode, KeyEvent event) KeyEvent.Callback.onKeyLongPress()默认实现：始终返回false（不处理事件）。 boolean onKeyMultiple(int keyCode, int repeatCount, KeyEvent event) KeyEvent.Callback.onKeyMultiple()默认实现：始终返回false（不处理事件）。 boolean onKeyShortcut(int keyCode, KeyEvent event) 当对话框中的任何视图未处理键快捷键事件时调用。 boolean onKeyUp(int keyCode, KeyEvent event) 一个关键被释放。 boolean onMenuItemSelected(int featureId, MenuItem item) 当用户选择了面板的菜单项时调用。 boolean onMenuOpened(int featureId, Menu menu) 用户打开面板菜单时调用。 boolean onOptionsItemSelected(MenuItem item) void onOptionsMenuClosed(Menu menu) void onPanelClosed(int featureId, Menu menu) 当面板关闭时调用。 boolean onPrepareOptionsMenu(Menu menu) 如果客户需要与此对话框相同的菜单，将此呼叫代理给所有者活动 onPrepareOptionsMenu(Menu)通常是安全的。 boolean onPreparePanel(int featureId, View view, Menu menu) 准备要显示的面板。 void onRestoreInstanceState(Bundle savedInstanceState) 从先前保存的包中恢复对话框的状态。 Bundle onSaveInstanceState() 将对话框的状态保存到一个包中。 boolean onSearchRequested(SearchEvent searchEvent) 当用户发出开始搜索的愿望时，这个钩子被调用。 boolean onSearchRequested() 当用户发出开始搜索的愿望时，这个钩子被调用。 void onStart() 当对话开始时调用。 void onStop() 打电话告诉你，你正在停止。 boolean onTouchEvent(MotionEvent event) 当触摸屏事件未被其下的任何视图处理时调用。 boolean onTrackballEvent(MotionEvent event) 当轨迹球被移动并且不被任何活动内部的视图处理时调用。 void onWindowAttributesChanged(WindowManager.LayoutParams params) 这在每当当前窗口属性改变时被调用。 void onWindowFocusChanged(boolean hasFocus) 这个钩子在窗口焦点改变时被调用。 ActionMode onWindowStartingActionMode(ActionMode.Callback callback) 当此窗口的动作模式正在启动时调用。 ActionMode onWindowStartingActionMode(ActionMode.Callback callback, int type) 当此窗口的动作模式正在启动时调用。 void openContextMenu(View view) void openOptionsMenu() void registerForContextMenu(View view) final boolean requestWindowFeature(int featureId) 启用扩展窗口功能。 void setCancelMessage(Message msg) 设置对话框取消时发送的消息。 void setCancelable(boolean flag) 使用 BACK键设置是否可以取消该对话框。 void setCanceledOnTouchOutside(boolean cancel) 设置在窗口边界之外触摸时是否取消该对话框。 void setContentView(int layoutResID) 从布局资源中设置屏幕内容。 void setContentView(View view, ViewGroup.LayoutParams params) 将屏幕内容设置为明确的视图。 void setContentView(View view) 将屏幕内容设置为明确的视图。 void setDismissMessage(Message msg) 设置消息在对话框关闭时发送。 final void setFeatureDrawable(int featureId, Drawable drawable) 方便拨打 setFeatureDrawable(int, Drawable) 。 final void setFeatureDrawableAlpha(int featureId, int alpha) 方便拨打 setFeatureDrawableAlpha(int, int) 。 final void setFeatureDrawableResource(int featureId, int resId) 方便拨打 setFeatureDrawableResource(int, int) 。 final void setFeatureDrawableUri(int featureId, Uri uri) 方便拨打 setFeatureDrawableUri(int, Uri) 。 void setOnCancelListener(DialogInterface.OnCancelListener listener) 设置一个侦听器，当对话框被取消时被调用。 void setOnDismissListener(DialogInterface.OnDismissListener listener) 设置一个侦听器，当对话框被解除时被调用。 void setOnKeyListener(DialogInterface.OnKeyListener onKeyListener) 设置将密钥分派到对话框时将要调用的回调。 void setOnShowListener(DialogInterface.OnShowListener listener) 设置显示对话框时要调用的侦听器。 final void setOwnerActivity(Activity activity) 设置拥有此对话框的活动。 void setTitle(CharSequence title) 为此对话框的窗口设置标题文本。 void setTitle(int titleId) 为此对话框的窗口设置标题文本。 final void setVolumeControlStream(int streamType) 默认情况下，这将使用所有者Activity的建议流类型。 void show() 启动对话框并将其显示在屏幕上。 void takeKeyEvents(boolean get) 请求重要事件进入该对话框。 void unregisterForContextMenu(View view)
From class java.lang.Object Object clone() 创建并返回此对象的副本。 boolean equals(Object obj) 指示其他某个对象是否“等于”这一个。 void finalize() 当垃圾收集确定没有更多对该对象的引用时，由对象上的垃圾回收器调用。 final Class<?> getClass() 返回此 Object的运行时类。 int hashCode() 返回对象的哈希码值。 final void notify() 唤醒正在等待该对象监视器的单个线程。 final void notifyAll() 唤醒在该对象监视器上等待的所有线程。 String toString() 返回对象的字符串表示形式。 final void wait(long millis, int nanos) 导致当前线程等待，直到其他线程调用 notify()方法或 notifyAll()方法此对象，或一些其它线程中断当前线程，或实时一定量已过去。 final void wait(long millis) 导致当前线程等待，直到另一个线程调用此对象的 notify()方法或 notifyAll()方法或经过了指定的时间量。 final void wait() 使当前线程等待，直到另一个线程调用此对象的 notify()方法或 notifyAll()方法。
From interface android.content.DialogInterface abstract void cancel() abstract void dismiss()
From interface android.view.Window.Callback abstract boolean dispatchGenericMotionEvent(MotionEvent event) 被调用来处理通用运动事件。 abstract boolean dispatchKeyEvent(KeyEvent event) 被调用来处理关键事件。 abstract boolean dispatchKeyShortcutEvent(KeyEvent event) 被调用来处理键快捷键事件。 abstract boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event) 打电话来处理 AccessibilityEvent的人口。 abstract boolean dispatchTouchEvent(MotionEvent event) 被调用来处理触摸屏事件。 abstract boolean dispatchTrackballEvent(MotionEvent event) 被称为处理轨迹球事件。 abstract void onActionModeFinished(ActionMode mode) 当动作模式完成时调用。 abstract void onActionModeStarted(ActionMode mode) 当动作模式已启动时调用。 abstract void onAttachedToWindow() 当窗口已连接到窗口管理器时调用。 abstract void onContentChanged() 只要屏幕的内容视图发生变化（由于调用 Window.setContentView或 Window.addContentView ）， Window.setContentView调用此钩子。 abstract boolean onCreatePanelMenu(int featureId, Menu menu) 初始化面板'featureId'的菜单内容。 abstract View onCreatePanelView(int featureId) 实例化视图以显示在“featureId”的面板中。 abstract void onDetachedFromWindow() 当窗口已连接到窗口管理器时调用。 abstract boolean onMenuItemSelected(int featureId, MenuItem item) 当用户选择了面板的菜单项时调用。 abstract boolean onMenuOpened(int featureId, Menu menu) 用户打开面板菜单时调用。 abstract void onPanelClosed(int featureId, Menu menu) 当面板关闭时调用。 abstract boolean onPreparePanel(int featureId, View view, Menu menu) 准备要显示的面板。 default void onProvideKeyboardShortcuts(List<KeyboardShortcutGroup> data, Menu menu, int deviceId) 在当前窗口请求键盘快捷键时调用。 abstract boolean onSearchRequested() 当用户指示开始搜索的愿望时调用。 abstract boolean onSearchRequested(SearchEvent searchEvent) 当用户指示开始搜索的愿望时调用。 abstract void onWindowAttributesChanged(WindowManager.LayoutParams attrs) 这在每当当前窗口属性改变时被调用。 abstract void onWindowFocusChanged(boolean hasFocus) 这个钩子在窗口焦点改变时被调用。 abstract ActionMode onWindowStartingActionMode(ActionMode.Callback callback) 当此窗口的动作模式正在启动时调用。 abstract ActionMode onWindowStartingActionMode(ActionMode.Callback callback, int type) 当此窗口的动作模式正在启动时调用。
From interface android.view.KeyEvent.Callback abstract boolean onKeyDown(int keyCode, KeyEvent event) 当关键事件发生时调用。 abstract boolean onKeyLongPress(int keyCode, KeyEvent event) 长时间按下时发生。 abstract boolean onKeyMultiple(int keyCode, int count, KeyEvent event) 当连续发生同一个键的多个向下/向上对时调用。 abstract boolean onKeyUp(int keyCode, KeyEvent event) 发生关键事件时调用。
From interface android.view.View.OnCreateContextMenuListener abstract void onCreateContextMenu(ContextMenu menu, View v, ContextMenu.ContextMenuInfo menuInfo) 在构建此视图的上下文菜单时调用。

Public constructors

Presentation (Context outerContext, 
                Display display)

Presentation (Context outerContext, 
                Display display, 
                int theme)

Public methods

Display getDisplay ()

Resources getResources ()

void onDisplayChanged ()

void onDisplayRemoved ()

void show ()

Protected methods

void onStart ()

void onStop ()