compat/java/android/support/v4/app/ActivityOptionsCompat.java - platform/frameworks/support - Git at Google

 /*
  * Copyright (C) 2012 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.support.v4.app;

 import android.app.Activity;
 import android.app.PendingIntent;
 import android.content.Context;
 import android.graphics.Bitmap;
 import android.graphics.Rect;
 import android.os.Build;
 import android.os.Bundle;
 import android.support.annotation.Nullable;
 import android.support.v4.util.Pair;
 import android.view.View;

 /**
  * Helper for accessing features in {@link android.app.ActivityOptions}
  * introduced in API level 16 in a backwards compatible fashion.
  */
 public class ActivityOptionsCompat {
     /**
      * A long in the extras delivered by {@link #requestUsageTimeReport} that contains
      * the total time (in ms) the user spent in the app flow.
      */
     public static final String EXTRA_USAGE_TIME_REPORT = "android.activity.usage_time";

     /**
      * A Bundle in the extras delivered by {@link #requestUsageTimeReport} that contains
      * detailed information about the time spent in each package associated with the app;
      * each key is a package name, whose value is a long containing the time (in ms).
      */
     public static final String EXTRA_USAGE_TIME_REPORT_PACKAGES = "android.usage_time_packages";

     /**
      * Create an ActivityOptions specifying a custom animation to run when the
      * activity is displayed.
      *
      * @param context Who is defining this. This is the application that the
      * animation resources will be loaded from.
      * @param enterResId A resource ID of the animation resource to use for the
      * incoming activity. Use 0 for no animation.
      * @param exitResId A resource ID of the animation resource to use for the
      * outgoing activity. Use 0 for no animation.
      * @return Returns a new ActivityOptions object that you can use to supply
      * these options as the options Bundle when starting an activity.
      */
     public static ActivityOptionsCompat makeCustomAnimation(Context context,
             int enterResId, int exitResId) {
         if (Build.VERSION.SDK_INT >= 24) {
             return new ActivityOptionsImpl24(
                 ActivityOptionsCompat24.makeCustomAnimation(context, enterResId, exitResId));
         } else if (Build.VERSION.SDK_INT >= 23) {
             return new ActivityOptionsImpl23(
                 ActivityOptionsCompat23.makeCustomAnimation(context, enterResId, exitResId));
         } else if (Build.VERSION.SDK_INT >= 21) {
             return new ActivityOptionsImpl21(
                 ActivityOptionsCompat21.makeCustomAnimation(context, enterResId, exitResId));
         } else if (Build.VERSION.SDK_INT >= 16) {
             return new ActivityOptionsImplJB(
                 ActivityOptionsCompatJB.makeCustomAnimation(context, enterResId, exitResId));
         }
         return new ActivityOptionsCompat();
     }

     /**
      * Create an ActivityOptions specifying an animation where the new activity is
      * scaled from a small originating area of the screen to its final full
      * representation.
      * <p/>
      * If the Intent this is being used with has not set its
      * {@link android.content.Intent#setSourceBounds(android.graphics.Rect)},
      * those bounds will be filled in for you based on the initial bounds passed
      * in here.
      *
      * @param source The View that the new activity is animating from. This
      * defines the coordinate space for startX and startY.
      * @param startX The x starting location of the new activity, relative to
      * source.
      * @param startY The y starting location of the activity, relative to source.
      * @param startWidth The initial width of the new activity.
      * @param startHeight The initial height of the new activity.
      * @return Returns a new ActivityOptions object that you can use to supply
      * these options as the options Bundle when starting an activity.
      */
     public static ActivityOptionsCompat makeScaleUpAnimation(View source,
             int startX, int startY, int startWidth, int startHeight) {
         if (Build.VERSION.SDK_INT >= 24) {
             return new ActivityOptionsImpl24(
                 ActivityOptionsCompat24.makeScaleUpAnimation(source, startX, startY,
                         startWidth, startHeight));
         } else if (Build.VERSION.SDK_INT >= 23) {
             return new ActivityOptionsImpl23(
                 ActivityOptionsCompat23.makeScaleUpAnimation(source, startX, startY,
                         startWidth, startHeight));
         } else if (Build.VERSION.SDK_INT >= 21) {
             return new ActivityOptionsImpl21(
                 ActivityOptionsCompat21.makeScaleUpAnimation(source, startX, startY,
                         startWidth, startHeight));
         } else if (Build.VERSION.SDK_INT >= 16) {
             return new ActivityOptionsImplJB(
                 ActivityOptionsCompatJB.makeScaleUpAnimation(source, startX, startY,
                         startWidth, startHeight));
         }
         return new ActivityOptionsCompat();
     }

     /**
      * Create an ActivityOptions specifying an animation where the new
      * activity is revealed from a small originating area of the screen to
      * its final full representation.
      *
      * @param source The View that the new activity is animating from.  This
      * defines the coordinate space for <var>startX</var> and <var>startY</var>.
      * @param startX The x starting location of the new activity, relative to <var>source</var>.
      * @param startY The y starting location of the activity, relative to <var>source</var>.
      * @param width The initial width of the new activity.
      * @param height The initial height of the new activity.
      * @return Returns a new ActivityOptions object that you can use to
      * supply these options as the options Bundle when starting an activity.
      */
     public static ActivityOptionsCompat makeClipRevealAnimation(View source,
             int startX, int startY, int width, int height) {
         if (Build.VERSION.SDK_INT >= 24) {
             return new ActivityOptionsImpl24(
                 ActivityOptionsCompat24.makeClipRevealAnimation(source, startX, startY,
                         width, height));
         } else if (Build.VERSION.SDK_INT >= 23) {
             return new ActivityOptionsImpl23(
                 ActivityOptionsCompat23.makeClipRevealAnimation(source, startX, startY,
                         width, height));
         }
         return new ActivityOptionsCompat();
     }

     /**
      * Create an ActivityOptions specifying an animation where a thumbnail is
      * scaled from a given position to the new activity window that is being
      * started.
      * <p/>
      * If the Intent this is being used with has not set its
      * {@link android.content.Intent#setSourceBounds(android.graphics.Rect)},
      * those bounds will be filled in for you based on the initial thumbnail
      * location and size provided here.
      *
      * @param source The View that this thumbnail is animating from. This
      * defines the coordinate space for startX and startY.
      * @param thumbnail The bitmap that will be shown as the initial thumbnail
      * of the animation.
      * @param startX The x starting location of the bitmap, relative to source.
      * @param startY The y starting location of the bitmap, relative to source.
      * @return Returns a new ActivityOptions object that you can use to supply
      * these options as the options Bundle when starting an activity.
      */
     public static ActivityOptionsCompat makeThumbnailScaleUpAnimation(View source,
             Bitmap thumbnail, int startX, int startY) {
         if (Build.VERSION.SDK_INT >= 24) {
             return new ActivityOptionsImpl24(
                 ActivityOptionsCompat24.makeThumbnailScaleUpAnimation(source, thumbnail,
                         startX, startY));
         } else if (Build.VERSION.SDK_INT >= 23) {
             return new ActivityOptionsImpl23(
                 ActivityOptionsCompat23.makeThumbnailScaleUpAnimation(source, thumbnail,
                         startX, startY));
         } else if (Build.VERSION.SDK_INT >= 21) {
             return new ActivityOptionsImpl21(
                 ActivityOptionsCompat21.makeThumbnailScaleUpAnimation(source, thumbnail,
                         startX, startY));
         } else if (Build.VERSION.SDK_INT >= 16) {
             return new ActivityOptionsImplJB(
                 ActivityOptionsCompatJB.makeThumbnailScaleUpAnimation(source, thumbnail,
                         startX, startY));
         }
         return new ActivityOptionsCompat();
     }

     /**
      * Create an ActivityOptions to transition between Activities using cross-Activity scene
      * animations. This method carries the position of one shared element to the started Activity.
      * The position of <code>sharedElement</code> will be used as the epicenter for the
      * exit Transition. The position of the shared element in the launched Activity will be the
      * epicenter of its entering Transition.
      *
      * <p>This requires {@link android.view.Window#FEATURE_CONTENT_TRANSITIONS} to be
      * enabled on the calling Activity to cause an exit transition. The same must be in
      * the called Activity to get an entering transition.</p>
      * @param activity The Activity whose window contains the shared elements.
      * @param sharedElement The View to transition to the started Activity. sharedElement must
      *                      have a non-null sharedElementName.
      * @param sharedElementName The shared element name as used in the target Activity. This may
      *                          be null if it has the same name as sharedElement.
      * @return Returns a new ActivityOptions object that you can use to
      *         supply these options as the options Bundle when starting an activity.
      */
     public static ActivityOptionsCompat makeSceneTransitionAnimation(Activity activity,
             View sharedElement, String sharedElementName) {
         if (Build.VERSION.SDK_INT >= 24) {
             return new ActivityOptionsCompat.ActivityOptionsImpl24(
                     ActivityOptionsCompat24.makeSceneTransitionAnimation(activity,
                             sharedElement, sharedElementName));
         } else if (Build.VERSION.SDK_INT >= 23) {
             return new ActivityOptionsCompat.ActivityOptionsImpl23(
                     ActivityOptionsCompat23.makeSceneTransitionAnimation(activity,
                             sharedElement, sharedElementName));
         } else if (Build.VERSION.SDK_INT >= 21) {
             return new ActivityOptionsCompat.ActivityOptionsImpl21(
                     ActivityOptionsCompat21.makeSceneTransitionAnimation(activity,
                             sharedElement, sharedElementName));
         }
         return new ActivityOptionsCompat();
     }

     /**
      * Create an ActivityOptions to transition between Activities using cross-Activity scene
      * animations. This method carries the position of multiple shared elements to the started
      * Activity. The position of the first element in sharedElements
      * will be used as the epicenter for the exit Transition. The position of the associated
      * shared element in the launched Activity will be the epicenter of its entering Transition.
      *
      * <p>This requires {@link android.view.Window#FEATURE_CONTENT_TRANSITIONS} to be
      * enabled on the calling Activity to cause an exit transition. The same must be in
      * the called Activity to get an entering transition.</p>
      * @param activity The Activity whose window contains the shared elements.
      * @param sharedElements The names of the shared elements to transfer to the called
      *                       Activity and their associated Views. The Views must each have
      *                       a unique shared element name.
      * @return Returns a new ActivityOptions object that you can use to
      *         supply these options as the options Bundle when starting an activity.
      */
     @SafeVarargs
     public static ActivityOptionsCompat makeSceneTransitionAnimation(Activity activity,
             Pair<View, String>... sharedElements) {
         if (Build.VERSION.SDK_INT >= 21) {
             View[] views = null;
             String[] names = null;
             if (sharedElements != null) {
                 views = new View[sharedElements.length];
                 names = new String[sharedElements.length];
                 for (int i = 0; i < sharedElements.length; i++) {
                     views[i] = sharedElements[i].first;
                     names[i] = sharedElements[i].second;
                 }
             }
             if (Build.VERSION.SDK_INT >= 24) {
                 return new ActivityOptionsCompat.ActivityOptionsImpl24(
                         ActivityOptionsCompat24.makeSceneTransitionAnimation(activity, views, names));
             } else if (Build.VERSION.SDK_INT >= 23) {
                 return new ActivityOptionsCompat.ActivityOptionsImpl23(
                         ActivityOptionsCompat23.makeSceneTransitionAnimation(activity, views, names));
             } else {
                 return new ActivityOptionsCompat.ActivityOptionsImpl21(
                         ActivityOptionsCompat21.makeSceneTransitionAnimation(activity, views, names));
             }
         }
         return new ActivityOptionsCompat();
     }

     /**
      * If set along with Intent.FLAG_ACTIVITY_NEW_DOCUMENT then the task being launched will not be
      * presented to the user but will instead be only available through the recents task list.
      * In addition, the new task wil be affiliated with the launching activity's task.
      * Affiliated tasks are grouped together in the recents task list.
      *
      * <p>This behavior is not supported for activities with
      * {@link android.R.attr#launchMode launchMode} values of
      * <code>singleInstance</code> or <code>singleTask</code>.
      */
     public static ActivityOptionsCompat makeTaskLaunchBehind() {
         if (Build.VERSION.SDK_INT >= 24) {
             return new ActivityOptionsCompat.ActivityOptionsImpl24(
                     ActivityOptionsCompat24.makeTaskLaunchBehind());
         } else if (Build.VERSION.SDK_INT >= 23) {
             return new ActivityOptionsCompat.ActivityOptionsImpl23(
                     ActivityOptionsCompat23.makeTaskLaunchBehind());
         } else if (Build.VERSION.SDK_INT >= 21) {
             return new ActivityOptionsCompat.ActivityOptionsImpl21(
                     ActivityOptionsCompat21.makeTaskLaunchBehind());
         }
         return new ActivityOptionsCompat();
     }

     /**
      * Create a basic ActivityOptions that has no special animation associated with it.
      * Other options can still be set.
      */
     public static ActivityOptionsCompat makeBasic() {
         if (Build.VERSION.SDK_INT >= 24) {
             return new ActivityOptionsCompat.ActivityOptionsImpl24(
                     ActivityOptionsCompat24.makeBasic());
         } else if (Build.VERSION.SDK_INT >= 23) {
             return new ActivityOptionsCompat.ActivityOptionsImpl23(
                     ActivityOptionsCompat23.makeBasic());
         }
         return new ActivityOptionsCompat();
     }

     private static class ActivityOptionsImplJB extends ActivityOptionsCompat {
         private final ActivityOptionsCompatJB mImpl;

         ActivityOptionsImplJB(ActivityOptionsCompatJB impl) {
             mImpl = impl;
         }

         @Override
         public Bundle toBundle() {
             return mImpl.toBundle();
         }

         @Override
         public void update(ActivityOptionsCompat otherOptions) {
             if (otherOptions instanceof ActivityOptionsImplJB) {
                 ActivityOptionsImplJB otherImpl = (ActivityOptionsImplJB)otherOptions;
                 mImpl.update(otherImpl.mImpl);
             }
         }
     }

     private static class ActivityOptionsImpl21 extends ActivityOptionsCompat {
         private final ActivityOptionsCompat21 mImpl;

         ActivityOptionsImpl21(ActivityOptionsCompat21 impl) {
             mImpl = impl;
         }

         @Override
         public Bundle toBundle() {
             return mImpl.toBundle();
         }

         @Override
         public void update(ActivityOptionsCompat otherOptions) {
             if (otherOptions instanceof ActivityOptionsCompat.ActivityOptionsImpl21) {
                 ActivityOptionsCompat.ActivityOptionsImpl21
                         otherImpl = (ActivityOptionsCompat.ActivityOptionsImpl21)otherOptions;
                 mImpl.update(otherImpl.mImpl);
             }
         }
     }

     private static class ActivityOptionsImpl23 extends ActivityOptionsCompat {
         private final ActivityOptionsCompat23 mImpl;

         ActivityOptionsImpl23(ActivityOptionsCompat23 impl) {
             mImpl = impl;
         }

         @Override
         public Bundle toBundle() {
             return mImpl.toBundle();
         }

         @Override
         public void update(ActivityOptionsCompat otherOptions) {
             if (otherOptions instanceof ActivityOptionsCompat.ActivityOptionsImpl23) {
                 ActivityOptionsCompat.ActivityOptionsImpl23
                         otherImpl = (ActivityOptionsCompat.ActivityOptionsImpl23)otherOptions;
                 mImpl.update(otherImpl.mImpl);
             }
         }

         @Override
         public void requestUsageTimeReport(PendingIntent receiver) {
             mImpl.requestUsageTimeReport(receiver);
         }
     }

     private static class ActivityOptionsImpl24 extends ActivityOptionsCompat {
         private final ActivityOptionsCompat24 mImpl;

         ActivityOptionsImpl24(ActivityOptionsCompat24 impl) {
             mImpl = impl;
         }

         @Override
         public Bundle toBundle() {
             return mImpl.toBundle();
         }

         @Override
         public void update(ActivityOptionsCompat otherOptions) {
             if (otherOptions instanceof ActivityOptionsCompat.ActivityOptionsImpl24) {
                 ActivityOptionsCompat.ActivityOptionsImpl24
                         otherImpl = (ActivityOptionsCompat.ActivityOptionsImpl24)otherOptions;
                 mImpl.update(otherImpl.mImpl);
             }
         }

         @Override
         public ActivityOptionsCompat setLaunchBounds(@Nullable Rect screenSpacePixelRect) {
             return new ActivityOptionsImpl24(mImpl.setLaunchBounds(screenSpacePixelRect));
         }

         @Override
         public Rect getLaunchBounds() {
             return mImpl.getLaunchBounds();
         }

         @Override
         public void requestUsageTimeReport(PendingIntent receiver) {
             mImpl.requestUsageTimeReport(receiver);
         }
     }

     protected ActivityOptionsCompat() {
     }

     /**
      * Sets the bounds (window size) that the activity should be launched in.
      * Rect position should be provided in pixels and in screen coordinates.
      * Set to null explicitly for fullscreen.
      * <p>
      * <strong>NOTE:<strong/> This value is ignored on devices that don't have
      * {@link android.content.pm.PackageManager#FEATURE_FREEFORM_WINDOW_MANAGEMENT} or
      * {@link android.content.pm.PackageManager#FEATURE_PICTURE_IN_PICTURE} enabled.
      * @param screenSpacePixelRect Launch bounds to use for the activity or null for fullscreen.
      */
     public ActivityOptionsCompat setLaunchBounds(@Nullable Rect screenSpacePixelRect) {
         return null;
     }

     /**
      * Returns the bounds that should be used to launch the activity.
      * @see #setLaunchBounds(Rect)
      * @return Bounds used to launch the activity.
      */
     @Nullable
     public Rect getLaunchBounds() {
         return null;
     }

     /**
      * Returns the created options as a Bundle, which can be passed to
      * {@link ActivityCompat#startActivity(android.app.Activity, android.content.Intent, android.os.Bundle)}.
      * Note that the returned Bundle is still owned by the ActivityOptions
      * object; you must not modify it, but can supply it to the startActivity
      * methods that take an options Bundle.
      */
     public Bundle toBundle() {
         return null;
     }

     /**
      * Update the current values in this ActivityOptions from those supplied in
      * otherOptions. Any values defined in otherOptions replace those in the
      * base options.
      */
     public void update(ActivityOptionsCompat otherOptions) {
         // Do nothing.
     }

     /**
      * Ask the the system track that time the user spends in the app being launched, and
      * report it back once done.  The report will be sent to the given receiver, with
      * the extras {@link #EXTRA_USAGE_TIME_REPORT} and {@link #EXTRA_USAGE_TIME_REPORT_PACKAGES}
      * filled in.
      *
      * <p>The time interval tracked is from launching this activity until the user leaves
      * that activity's flow.  They are considered to stay in the flow as long as
      * new activities are being launched or returned to from the original flow,
      * even if this crosses package or task boundaries.  For example, if the originator
      * starts an activity to view an image, and while there the user selects to share,
      * which launches their email app in a new task, and they complete the share, the
      * time during that entire operation will be included until they finally hit back from
      * the original image viewer activity.</p>
      *
      * <p>The user is considered to complete a flow once they switch to another
      * activity that is not part of the tracked flow.  This may happen, for example, by
      * using the notification shade, launcher, or recents to launch or switch to another
      * app.  Simply going in to these navigation elements does not break the flow (although
      * the launcher and recents stops time tracking of the session); it is the act of
      * going somewhere else that completes the tracking.</p>
      *
      * @param receiver A broadcast receiver that willl receive the report.
      */
     public void requestUsageTimeReport(PendingIntent receiver) {
         // Do nothing.
     }
 }
	/*
	* Copyright (C) 2012 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.support.v4.app;

	import android.app.Activity;
	import android.app.PendingIntent;
	import android.content.Context;
	import android.graphics.Bitmap;
	import android.graphics.Rect;
	import android.os.Build;
	import android.os.Bundle;
	import android.support.annotation.Nullable;
	import android.support.v4.util.Pair;
	import android.view.View;

	/**
	* Helper for accessing features in {@link android.app.ActivityOptions}
	* introduced in API level 16 in a backwards compatible fashion.
	*/
	public class ActivityOptionsCompat {
	/**
	* A long in the extras delivered by {@link #requestUsageTimeReport} that contains
	* the total time (in ms) the user spent in the app flow.
	*/
	public static final String EXTRA_USAGE_TIME_REPORT = "android.activity.usage_time";

	/**
	* A Bundle in the extras delivered by {@link #requestUsageTimeReport} that contains
	* detailed information about the time spent in each package associated with the app;
	* each key is a package name, whose value is a long containing the time (in ms).
	*/
	public static final String EXTRA_USAGE_TIME_REPORT_PACKAGES = "android.usage_time_packages";

	/**
	* Create an ActivityOptions specifying a custom animation to run when the
	* activity is displayed.
	*
	* @param context Who is defining this. This is the application that the
	* animation resources will be loaded from.
	* @param enterResId A resource ID of the animation resource to use for the
	* incoming activity. Use 0 for no animation.
	* @param exitResId A resource ID of the animation resource to use for the
	* outgoing activity. Use 0 for no animation.
	* @return Returns a new ActivityOptions object that you can use to supply
	* these options as the options Bundle when starting an activity.
	*/
	public static ActivityOptionsCompat makeCustomAnimation(Context context,
	int enterResId, int exitResId) {
	if (Build.VERSION.SDK_INT >= 24) {
	return new ActivityOptionsImpl24(
	ActivityOptionsCompat24.makeCustomAnimation(context, enterResId, exitResId));
	} else if (Build.VERSION.SDK_INT >= 23) {
	return new ActivityOptionsImpl23(
	ActivityOptionsCompat23.makeCustomAnimation(context, enterResId, exitResId));
	} else if (Build.VERSION.SDK_INT >= 21) {
	return new ActivityOptionsImpl21(
	ActivityOptionsCompat21.makeCustomAnimation(context, enterResId, exitResId));
	} else if (Build.VERSION.SDK_INT >= 16) {
	return new ActivityOptionsImplJB(
	ActivityOptionsCompatJB.makeCustomAnimation(context, enterResId, exitResId));
	}
	return new ActivityOptionsCompat();
	}

	/**
	* Create an ActivityOptions specifying an animation where the new activity is
	* scaled from a small originating area of the screen to its final full
	* representation.
	* <p/>
	* If the Intent this is being used with has not set its
	* {@link android.content.Intent#setSourceBounds(android.graphics.Rect)},
	* those bounds will be filled in for you based on the initial bounds passed
	* in here.
	*
	* @param source The View that the new activity is animating from. This
	* defines the coordinate space for startX and startY.
	* @param startX The x starting location of the new activity, relative to
	* source.
	* @param startY The y starting location of the activity, relative to source.
	* @param startWidth The initial width of the new activity.
	* @param startHeight The initial height of the new activity.
	* @return Returns a new ActivityOptions object that you can use to supply
	* these options as the options Bundle when starting an activity.
	*/
	public static ActivityOptionsCompat makeScaleUpAnimation(View source,
	int startX, int startY, int startWidth, int startHeight) {
	if (Build.VERSION.SDK_INT >= 24) {
	return new ActivityOptionsImpl24(
	ActivityOptionsCompat24.makeScaleUpAnimation(source, startX, startY,
	startWidth, startHeight));
	} else if (Build.VERSION.SDK_INT >= 23) {
	return new ActivityOptionsImpl23(
	ActivityOptionsCompat23.makeScaleUpAnimation(source, startX, startY,
	startWidth, startHeight));
	} else if (Build.VERSION.SDK_INT >= 21) {
	return new ActivityOptionsImpl21(
	ActivityOptionsCompat21.makeScaleUpAnimation(source, startX, startY,
	startWidth, startHeight));
	} else if (Build.VERSION.SDK_INT >= 16) {
	return new ActivityOptionsImplJB(
	ActivityOptionsCompatJB.makeScaleUpAnimation(source, startX, startY,
	startWidth, startHeight));
	}
	return new ActivityOptionsCompat();
	}

	/**
	* Create an ActivityOptions specifying an animation where the new
	* activity is revealed from a small originating area of the screen to
	* its final full representation.
	*
	* @param source The View that the new activity is animating from. This
	* defines the coordinate space for <var>startX</var> and <var>startY</var>.
	* @param startX The x starting location of the new activity, relative to <var>source</var>.
	* @param startY The y starting location of the activity, relative to <var>source</var>.
	* @param width The initial width of the new activity.
	* @param height The initial height of the new activity.
	* @return Returns a new ActivityOptions object that you can use to
	* supply these options as the options Bundle when starting an activity.
	*/
	public static ActivityOptionsCompat makeClipRevealAnimation(View source,
	int startX, int startY, int width, int height) {
	if (Build.VERSION.SDK_INT >= 24) {
	return new ActivityOptionsImpl24(
	ActivityOptionsCompat24.makeClipRevealAnimation(source, startX, startY,
	width, height));
	} else if (Build.VERSION.SDK_INT >= 23) {
	return new ActivityOptionsImpl23(
	ActivityOptionsCompat23.makeClipRevealAnimation(source, startX, startY,
	width, height));
	}
	return new ActivityOptionsCompat();
	}

	/**
	* Create an ActivityOptions specifying an animation where a thumbnail is
	* scaled from a given position to the new activity window that is being
	* started.
	* <p/>
	* If the Intent this is being used with has not set its
	* {@link android.content.Intent#setSourceBounds(android.graphics.Rect)},
	* those bounds will be filled in for you based on the initial thumbnail
	* location and size provided here.
	*
	* @param source The View that this thumbnail is animating from. This
	* defines the coordinate space for startX and startY.
	* @param thumbnail The bitmap that will be shown as the initial thumbnail
	* of the animation.
	* @param startX The x starting location of the bitmap, relative to source.
	* @param startY The y starting location of the bitmap, relative to source.
	* @return Returns a new ActivityOptions object that you can use to supply
	* these options as the options Bundle when starting an activity.
	*/
	public static ActivityOptionsCompat makeThumbnailScaleUpAnimation(View source,
	Bitmap thumbnail, int startX, int startY) {
	if (Build.VERSION.SDK_INT >= 24) {
	return new ActivityOptionsImpl24(
	ActivityOptionsCompat24.makeThumbnailScaleUpAnimation(source, thumbnail,
	startX, startY));
	} else if (Build.VERSION.SDK_INT >= 23) {
	return new ActivityOptionsImpl23(
	ActivityOptionsCompat23.makeThumbnailScaleUpAnimation(source, thumbnail,
	startX, startY));
	} else if (Build.VERSION.SDK_INT >= 21) {
	return new ActivityOptionsImpl21(
	ActivityOptionsCompat21.makeThumbnailScaleUpAnimation(source, thumbnail,
	startX, startY));
	} else if (Build.VERSION.SDK_INT >= 16) {
	return new ActivityOptionsImplJB(
	ActivityOptionsCompatJB.makeThumbnailScaleUpAnimation(source, thumbnail,
	startX, startY));
	}
	return new ActivityOptionsCompat();
	}

	/**
	* Create an ActivityOptions to transition between Activities using cross-Activity scene
	* animations. This method carries the position of one shared element to the started Activity.
	* The position of <code>sharedElement</code> will be used as the epicenter for the
	* exit Transition. The position of the shared element in the launched Activity will be the
	* epicenter of its entering Transition.
	*
	* <p>This requires {@link android.view.Window#FEATURE_CONTENT_TRANSITIONS} to be
	* enabled on the calling Activity to cause an exit transition. The same must be in
	* the called Activity to get an entering transition.</p>
	* @param activity The Activity whose window contains the shared elements.
	* @param sharedElement The View to transition to the started Activity. sharedElement must
	* have a non-null sharedElementName.
	* @param sharedElementName The shared element name as used in the target Activity. This may
	* be null if it has the same name as sharedElement.
	* @return Returns a new ActivityOptions object that you can use to
	* supply these options as the options Bundle when starting an activity.
	*/
	public static ActivityOptionsCompat makeSceneTransitionAnimation(Activity activity,
	View sharedElement, String sharedElementName) {
	if (Build.VERSION.SDK_INT >= 24) {
	return new ActivityOptionsCompat.ActivityOptionsImpl24(
	ActivityOptionsCompat24.makeSceneTransitionAnimation(activity,
	sharedElement, sharedElementName));
	} else if (Build.VERSION.SDK_INT >= 23) {
	return new ActivityOptionsCompat.ActivityOptionsImpl23(
	ActivityOptionsCompat23.makeSceneTransitionAnimation(activity,
	sharedElement, sharedElementName));
	} else if (Build.VERSION.SDK_INT >= 21) {
	return new ActivityOptionsCompat.ActivityOptionsImpl21(
	ActivityOptionsCompat21.makeSceneTransitionAnimation(activity,
	sharedElement, sharedElementName));
	}
	return new ActivityOptionsCompat();
	}

	/**
	* Create an ActivityOptions to transition between Activities using cross-Activity scene
	* animations. This method carries the position of multiple shared elements to the started
	* Activity. The position of the first element in sharedElements
	* will be used as the epicenter for the exit Transition. The position of the associated
	* shared element in the launched Activity will be the epicenter of its entering Transition.
	*
	* <p>This requires {@link android.view.Window#FEATURE_CONTENT_TRANSITIONS} to be
	* enabled on the calling Activity to cause an exit transition. The same must be in
	* the called Activity to get an entering transition.</p>
	* @param activity The Activity whose window contains the shared elements.
	* @param sharedElements The names of the shared elements to transfer to the called
	* Activity and their associated Views. The Views must each have
	* a unique shared element name.
	* @return Returns a new ActivityOptions object that you can use to
	* supply these options as the options Bundle when starting an activity.
	*/
	@SafeVarargs
	public static ActivityOptionsCompat makeSceneTransitionAnimation(Activity activity,
	Pair<View, String>... sharedElements) {
	if (Build.VERSION.SDK_INT >= 21) {
	View[] views = null;
	String[] names = null;
	if (sharedElements != null) {
	views = new View[sharedElements.length];
	names = new String[sharedElements.length];
	for (int i = 0; i < sharedElements.length; i++) {
	views[i] = sharedElements[i].first;
	names[i] = sharedElements[i].second;
	}
	}
	if (Build.VERSION.SDK_INT >= 24) {
	return new ActivityOptionsCompat.ActivityOptionsImpl24(
	ActivityOptionsCompat24.makeSceneTransitionAnimation(activity, views, names));
	} else if (Build.VERSION.SDK_INT >= 23) {
	return new ActivityOptionsCompat.ActivityOptionsImpl23(
	ActivityOptionsCompat23.makeSceneTransitionAnimation(activity, views, names));
	} else {
	return new ActivityOptionsCompat.ActivityOptionsImpl21(
	ActivityOptionsCompat21.makeSceneTransitionAnimation(activity, views, names));
	}
	}
	return new ActivityOptionsCompat();
	}

	/**
	* If set along with Intent.FLAG_ACTIVITY_NEW_DOCUMENT then the task being launched will not be
	* presented to the user but will instead be only available through the recents task list.
	* In addition, the new task wil be affiliated with the launching activity's task.
	* Affiliated tasks are grouped together in the recents task list.
	*
	* <p>This behavior is not supported for activities with
	* {@link android.R.attr#launchMode launchMode} values of
	* <code>singleInstance</code> or <code>singleTask</code>.
	*/
	public static ActivityOptionsCompat makeTaskLaunchBehind() {
	if (Build.VERSION.SDK_INT >= 24) {
	return new ActivityOptionsCompat.ActivityOptionsImpl24(
	ActivityOptionsCompat24.makeTaskLaunchBehind());
	} else if (Build.VERSION.SDK_INT >= 23) {
	return new ActivityOptionsCompat.ActivityOptionsImpl23(
	ActivityOptionsCompat23.makeTaskLaunchBehind());
	} else if (Build.VERSION.SDK_INT >= 21) {
	return new ActivityOptionsCompat.ActivityOptionsImpl21(
	ActivityOptionsCompat21.makeTaskLaunchBehind());
	}
	return new ActivityOptionsCompat();
	}

	/**
	* Create a basic ActivityOptions that has no special animation associated with it.
	* Other options can still be set.
	*/
	public static ActivityOptionsCompat makeBasic() {
	if (Build.VERSION.SDK_INT >= 24) {
	return new ActivityOptionsCompat.ActivityOptionsImpl24(
	ActivityOptionsCompat24.makeBasic());
	} else if (Build.VERSION.SDK_INT >= 23) {
	return new ActivityOptionsCompat.ActivityOptionsImpl23(
	ActivityOptionsCompat23.makeBasic());
	}
	return new ActivityOptionsCompat();
	}

	private static class ActivityOptionsImplJB extends ActivityOptionsCompat {
	private final ActivityOptionsCompatJB mImpl;

	ActivityOptionsImplJB(ActivityOptionsCompatJB impl) {
	mImpl = impl;
	}

	@Override
	public Bundle toBundle() {
	return mImpl.toBundle();
	}

	@Override
	public void update(ActivityOptionsCompat otherOptions) {
	if (otherOptions instanceof ActivityOptionsImplJB) {
	ActivityOptionsImplJB otherImpl = (ActivityOptionsImplJB)otherOptions;
	mImpl.update(otherImpl.mImpl);
	}
	}
	}

	private static class ActivityOptionsImpl21 extends ActivityOptionsCompat {
	private final ActivityOptionsCompat21 mImpl;

	ActivityOptionsImpl21(ActivityOptionsCompat21 impl) {
	mImpl = impl;
	}

	@Override
	public Bundle toBundle() {
	return mImpl.toBundle();
	}

	@Override
	public void update(ActivityOptionsCompat otherOptions) {
	if (otherOptions instanceof ActivityOptionsCompat.ActivityOptionsImpl21) {
	ActivityOptionsCompat.ActivityOptionsImpl21
	otherImpl = (ActivityOptionsCompat.ActivityOptionsImpl21)otherOptions;
	mImpl.update(otherImpl.mImpl);
	}
	}
	}

	private static class ActivityOptionsImpl23 extends ActivityOptionsCompat {
	private final ActivityOptionsCompat23 mImpl;

	ActivityOptionsImpl23(ActivityOptionsCompat23 impl) {
	mImpl = impl;
	}

	@Override
	public Bundle toBundle() {
	return mImpl.toBundle();
	}

	@Override
	public void update(ActivityOptionsCompat otherOptions) {
	if (otherOptions instanceof ActivityOptionsCompat.ActivityOptionsImpl23) {
	ActivityOptionsCompat.ActivityOptionsImpl23
	otherImpl = (ActivityOptionsCompat.ActivityOptionsImpl23)otherOptions;
	mImpl.update(otherImpl.mImpl);
	}
	}

	@Override
	public void requestUsageTimeReport(PendingIntent receiver) {
	mImpl.requestUsageTimeReport(receiver);
	}
	}

	private static class ActivityOptionsImpl24 extends ActivityOptionsCompat {
	private final ActivityOptionsCompat24 mImpl;

	ActivityOptionsImpl24(ActivityOptionsCompat24 impl) {
	mImpl = impl;
	}

	@Override
	public Bundle toBundle() {
	return mImpl.toBundle();
	}

	@Override
	public void update(ActivityOptionsCompat otherOptions) {
	if (otherOptions instanceof ActivityOptionsCompat.ActivityOptionsImpl24) {
	ActivityOptionsCompat.ActivityOptionsImpl24
	otherImpl = (ActivityOptionsCompat.ActivityOptionsImpl24)otherOptions;
	mImpl.update(otherImpl.mImpl);
	}
	}

	@Override
	public ActivityOptionsCompat setLaunchBounds(@Nullable Rect screenSpacePixelRect) {
	return new ActivityOptionsImpl24(mImpl.setLaunchBounds(screenSpacePixelRect));
	}

	@Override
	public Rect getLaunchBounds() {
	return mImpl.getLaunchBounds();
	}

	@Override
	public void requestUsageTimeReport(PendingIntent receiver) {
	mImpl.requestUsageTimeReport(receiver);
	}
	}

	protected ActivityOptionsCompat() {
	}

	/**
	* Sets the bounds (window size) that the activity should be launched in.
	* Rect position should be provided in pixels and in screen coordinates.
	* Set to null explicitly for fullscreen.
	* <p>
	* <strong>NOTE:<strong/> This value is ignored on devices that don't have
	* {@link android.content.pm.PackageManager#FEATURE_FREEFORM_WINDOW_MANAGEMENT} or
	* {@link android.content.pm.PackageManager#FEATURE_PICTURE_IN_PICTURE} enabled.
	* @param screenSpacePixelRect Launch bounds to use for the activity or null for fullscreen.
	*/
	public ActivityOptionsCompat setLaunchBounds(@Nullable Rect screenSpacePixelRect) {
	return null;
	}

	/**
	* Returns the bounds that should be used to launch the activity.
	* @see #setLaunchBounds(Rect)
	* @return Bounds used to launch the activity.
	*/
	@Nullable
	public Rect getLaunchBounds() {
	return null;
	}

	/**
	* Returns the created options as a Bundle, which can be passed to
	* {@link ActivityCompat#startActivity(android.app.Activity, android.content.Intent, android.os.Bundle)}.
	* Note that the returned Bundle is still owned by the ActivityOptions
	* object; you must not modify it, but can supply it to the startActivity
	* methods that take an options Bundle.
	*/
	public Bundle toBundle() {
	return null;
	}

	/**
	* Update the current values in this ActivityOptions from those supplied in
	* otherOptions. Any values defined in otherOptions replace those in the
	* base options.
	*/
	public void update(ActivityOptionsCompat otherOptions) {
	// Do nothing.
	}

	/**
	* Ask the the system track that time the user spends in the app being launched, and
	* report it back once done. The report will be sent to the given receiver, with
	* the extras {@link #EXTRA_USAGE_TIME_REPORT} and {@link #EXTRA_USAGE_TIME_REPORT_PACKAGES}
	* filled in.
	*
	* <p>The time interval tracked is from launching this activity until the user leaves
	* that activity's flow. They are considered to stay in the flow as long as
	* new activities are being launched or returned to from the original flow,
	* even if this crosses package or task boundaries. For example, if the originator
	* starts an activity to view an image, and while there the user selects to share,
	* which launches their email app in a new task, and they complete the share, the
	* time during that entire operation will be included until they finally hit back from
	* the original image viewer activity.</p>
	*
	* <p>The user is considered to complete a flow once they switch to another
	* activity that is not part of the tracked flow. This may happen, for example, by
	* using the notification shade, launcher, or recents to launch or switch to another
	* app. Simply going in to these navigation elements does not break the flow (although
	* the launcher and recents stops time tracking of the session); it is the act of
	* going somewhere else that completes the tracking.</p>
	*
	* @param receiver A broadcast receiver that willl receive the report.
	*/
	public void requestUsageTimeReport(PendingIntent receiver) {
	// Do nothing.
	}
	}