public class ActivityCompat extends ContextCompat
Activity
introduced after API level 4 in a backwards compatible fashion.Modifier and Type | Class and Description |
---|---|
static interface |
ActivityCompat.OnRequestPermissionsResultCallback
This interface is the contract for receiving the results for permission requests.
|
Modifier | Constructor and Description |
---|---|
protected |
ActivityCompat()
This class should not be instantiated, but the constructor must be
visible for the class to be extended (ex. in support-v13).
|
Modifier and Type | Method and Description |
---|---|
static void |
finishAffinity(Activity activity)
Finish this activity, and tries to finish all activities immediately below it
in the current task that have the same affinity.
|
static void |
finishAfterTransition(Activity activity)
Reverses the Activity Scene entry Transition and triggers the calling Activity
to reverse its exit Transition.
|
static Uri |
getReferrer(Activity activity)
Return information about who launched this activity.
|
static boolean |
invalidateOptionsMenu(Activity activity)
Invalidate the activity's options menu, if able.
|
static void |
postponeEnterTransition(Activity activity) |
static void |
requestPermissions(Activity activity,
String[] permissions,
int requestCode)
Requests permissions to be granted to this application.
|
static void |
setEnterSharedElementCallback(Activity activity,
SharedElementCallback callback)
When
ActivityOptions.makeSceneTransitionAnimation(Activity,
android.view.View, String) was used to start an Activity, callback
will be called to handle shared elements on the launched Activity. |
static void |
setExitSharedElementCallback(Activity activity,
SharedElementCallback callback)
When
ActivityOptions.makeSceneTransitionAnimation(Activity,
android.view.View, String) was used to start an Activity, callback
will be called to handle shared elements on the launching Activity. |
static boolean |
shouldShowRequestPermissionRationale(Activity activity,
String permission)
Gets whether you should show UI with rationale for requesting a permission.
|
static void |
startActivityForResult(Activity activity,
Intent intent,
int requestCode,
Bundle options)
Start new activity with options, if able, for which you would like a
result when it finished.
|
static void |
startIntentSenderForResult(Activity activity,
IntentSender intent,
int requestCode,
Intent fillInIntent,
int flagsMask,
int flagsValues,
int extraFlags,
Bundle options)
Start new IntentSender with options, if able, for which you would like a
result when it finished.
|
static void |
startPostponedEnterTransition(Activity activity) |
checkSelfPermission, createDeviceProtectedStorageContext, getCodeCacheDir, getColor, getColorStateList, getDataDir, getDrawable, getExternalCacheDirs, getExternalFilesDirs, getNoBackupFilesDir, getObbDirs, isDeviceProtectedStorage, startActivities, startActivities, startActivity
protected ActivityCompat()
public static boolean invalidateOptionsMenu(Activity activity)
Before API level 11 (Android 3.0/Honeycomb) the lifecycle of the
options menu was controlled primarily by the user's operation of
the hardware menu key. When the user presses down on the menu key
for the first time the menu was created and prepared by calls
to Activity.onCreateOptionsMenu(android.view.Menu)
and
Activity.onPrepareOptionsMenu(android.view.Menu)
respectively.
Subsequent presses of the menu key kept the existing instance of the
Menu itself and called Activity.onPrepareOptionsMenu(android.view.Menu)
to give the activity an opportunity to contextually alter the menu
before the menu panel was shown.
In Android 3.0+ the Action Bar forces the options menu to be built early
so that items chosen to show as actions may be displayed when the activity
first becomes visible. The Activity method invalidateOptionsMenu forces
the entire menu to be destroyed and recreated from
Activity.onCreateOptionsMenu(android.view.Menu)
, offering a similar
though heavier-weight opportunity to change the menu's contents. Normally
this functionality is used to support a changing configuration of Fragments.
Applications may use this support helper to signal a significant change in
activity state that should cause the options menu to be rebuilt. If the app
is running on an older platform version that does not support menu invalidation
the app will still receive Activity.onPrepareOptionsMenu(android.view.Menu)
the next time the user presses the menu key and this method will return false.
If this method returns true the options menu was successfully invalidated.
activity
- Invalidate the options menu of this activitypublic static void startActivityForResult(Activity activity, Intent intent, int requestCode, @Nullable Bundle options)
In Android 4.1+ additional options were introduced to allow for more
control on activity launch animations. Applications can use this method
along with ActivityOptionsCompat
to use these animations when
available. When run on versions of the platform where this feature does
not exist the activity will be launched normally.
activity
- Origin activity to launch from.intent
- The description of the activity to start.requestCode
- If >= 0, this code will be returned in
onActivityResult() when the activity exits.options
- Additional options for how the Activity should be started.
May be null if there are no options. See
ActivityOptionsCompat
for how to build the Bundle
supplied here; there are no supported definitions for
building it manually.public static void startIntentSenderForResult(Activity activity, IntentSender intent, int requestCode, Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags, @Nullable Bundle options) throws IntentSender.SendIntentException
In Android 4.1+ additional options were introduced to allow for more
control on activity launch animations. Applications can use this method
along with ActivityOptionsCompat
to use these animations when
available. When run on versions of the platform where this feature does
not exist the activity will be launched normally.
activity
- Origin activity to launch from.intent
- The IntentSender to launch.requestCode
- If >= 0, this code will be returned in
onActivityResult() when the activity exits.fillInIntent
- If non-null, this will be provided as the
intent parameter to IntentSender.sendIntent(android.content.Context, int, android.content.Intent, android.content.IntentSender.OnFinished, android.os.Handler)
.flagsMask
- Intent flags in the original IntentSender that you
would like to change.flagsValues
- Desired values for any bits set in flagsMaskextraFlags
- Always set to 0.options
- Additional options for how the Activity should be started.
May be null if there are no options. See
ActivityOptionsCompat
for how to build the Bundle
supplied here; there are no supported definitions for
building it manually.IntentSender.SendIntentException
public static void finishAffinity(Activity activity)
On Android 4.1+ calling this method will call through to the native version of this
method. For other platforms Activity.finish()
will be called instead.
public static void finishAfterTransition(Activity activity)
Activity.finish()
is called. If no entry Transition was used, finish() is called
immediately and the Activity exit Transition is run.
On Android 4.4 or lower, this method only finishes the Activity with no special exit transition.
@Nullable public static Uri getReferrer(Activity activity)
Intent.EXTRA_REFERRER
,
that will be returned as-is; otherwise, if known, an
android-app:
referrer URI containing the
package name that started the Intent will be returned. This may return null if no
referrer can be identified -- it is neither explicitly specified, nor is it known which
application package was involved.
If called while inside the handling of Activity.onNewIntent(android.content.Intent)
, this function will
return the referrer that submitted that new intent to the activity. Otherwise, it
always returns the referrer of the original Intent.
Note that this is not a security feature -- you can not trust the referrer information, applications can spoof it.
public static void setEnterSharedElementCallback(Activity activity, SharedElementCallback callback)
ActivityOptions.makeSceneTransitionAnimation(Activity,
android.view.View, String)
was used to start an Activity, callback
will be called to handle shared elements on the launched Activity. This requires
Window.FEATURE_CONTENT_TRANSITIONS
.callback
- Used to manipulate shared element transitions on the launched Activity.public static void setExitSharedElementCallback(Activity activity, SharedElementCallback callback)
ActivityOptions.makeSceneTransitionAnimation(Activity,
android.view.View, String)
was used to start an Activity, callback
will be called to handle shared elements on the launching Activity. Most
calls will only come when returning from the started Activity.
This requires Window.FEATURE_CONTENT_TRANSITIONS
.callback
- Used to manipulate shared element transitions on the launching Activity.public static void postponeEnterTransition(Activity activity)
public static void startPostponedEnterTransition(Activity activity)
public static void requestPermissions(@NonNull Activity activity, @NonNull String[] permissions, int requestCode)
#PROTECTION_DANGEROUS dangerous
, regardless whether they are declared by
the platform or a third-party app.
Normal permissions PermissionInfo.PROTECTION_NORMAL
are granted at install time if requested in the manifest. Signature permissions
PermissionInfo.PROTECTION_SIGNATURE
are granted at
install time if requested in the manifest and the signature of your app matches
the signature of the app declaring the permissions.
If your app does not have the requested permissions the user will be presented
with UI for accepting them. After the user has accepted or rejected the
requested permissions you will receive a callback reporting whether the
permissions were granted or not. Your activity has to implement ActivityCompat.OnRequestPermissionsResultCallback
and the results of permission requests will be delivered to its ActivityCompat.OnRequestPermissionsResultCallback.onRequestPermissionsResult(
int, String[], int[])
method.
Note that requesting a permission does not guarantee it will be granted and your app should be able to run without having this permission.
This method may start an activity allowing the user to choose which permissions
to grant and which to reject. Hence, you should be prepared that your activity
may be paused and resumed. Further, granting some permissions may require
a restart of you application. In such a case, the system will recreate the
activity stack before delivering the result to your
ActivityCompat.OnRequestPermissionsResultCallback.onRequestPermissionsResult(int, String[], int[])
.
When checking whether you have a permission you should use ContextCompat.checkSelfPermission(android.content.Context, String)
.
Calling this API for permissions already granted to your app would show UI to the user to decided whether the app can still hold these permissions. This can be useful if the way your app uses the data guarded by the permissions changes significantly.
You cannot request a permission if your activity sets noHistory
to true
in the manifest
because in this case the activity would not receive result callbacks including
ActivityCompat.OnRequestPermissionsResultCallback.onRequestPermissionsResult(int, String[], int[])
.
The RuntimePermissions sample app demonstrates how to use this method to request permissions at run time.
activity
- The target activity.permissions
- The requested permissions. Must me non-null and not empty.requestCode
- Application specific request code to match with a result
reported to ActivityCompat.OnRequestPermissionsResultCallback.onRequestPermissionsResult(int, String[], int[])
.
Should be >= 0.ActivityCompat.OnRequestPermissionsResultCallback.onRequestPermissionsResult(int, String[], int[])
,
ContextCompat.checkSelfPermission(android.content.Context, String)
,
shouldShowRequestPermissionRationale(android.app.Activity, String)
public static boolean shouldShowRequestPermissionRationale(@NonNull Activity activity, @NonNull String permission)
For example, if you write a camera app, requesting the camera permission would be expected by the user and no rationale for why it is requested is needed. If however, the app needs location for tagging photos then a non-tech savvy user may wonder how location is related to taking photos. In this case you may choose to show UI with rationale of requesting this permission.
activity
- The target activity.permission
- A permission your app wants to request.ContextCompat.checkSelfPermission(android.content.Context, String)
,
requestPermissions(android.app.Activity, String[], int)