/**
* Start a set of activities as a synthesized task stack, if able.
*
* <p>In API level 11 (Android 3.0/Honeycomb) the recommended conventions for
* app navigation using the back key changed. The back key's behavior is local
* to the current task and does not capture navigation across different tasks.
* Navigating across tasks and easily reaching the previous task is accomplished
* through the "recents" UI, accessible through the software-provided Recents key
* on the navigation or system bar. On devices with the older hardware button configuration
* the recents UI can be accessed with a long press on the Home key.</p>
*
* <p>When crossing from one task stack to another post-Android 3.0,
* the application should synthesize a back stack/history for the new task so that
* the user may navigate out of the new task and back to the Launcher by repeated
* presses of the back key. Back key presses should not navigate across task stacks.</p>
*
* <p>startActivities provides a mechanism for constructing a synthetic task stack of
* multiple activities. If the underlying API is not available on the system this method
* will return false.</p>
*
* @param context Start activities using this activity as the starting context
* @param intents Array of intents defining the activities that will be started. The element
* length-1 will correspond to the top activity on the resulting task stack.
* @param options Additional options for how the Activity should be started.
* See {@link android.content.Context#startActivity(Intent, Bundle)
* @return true if the underlying API was available and the call was successful, false otherwise
*/
public static boolean startActivities(Context context, Intent[] intents, Bundle options) {
final int version = Build.VERSION.SDK_INT;
if (version >= 16) {
ContextCompatJellybean.startActivities(context, intents, options);
return true;
} else if (version >= 11) {
ContextCompatHoneycomb.startActivities(context, intents);
return true;
}
return false;
}
/**
* Returns absolute paths to application-specific directories on all external storage devices
* where the application's OBB files (if there are any) can be found. Note if the application does
* not have any OBB files, these directories may not exist.
*
* <p>This is like {@link Context#getFilesDir()} in that these files will be deleted when the
* application is uninstalled, however there are some important differences:
*
* <ul>
* <li>External files are not always available: they will disappear if the user mounts the
* external storage on a computer or removes it.
* <li>There is no security enforced with these files.
* </ul>
*
* <p>External storage devices returned here are considered a permanent part of the device,
* including both emulated external storage and physical media slots, such as SD cards in a
* battery compartment. The returned paths do not include transient devices, such as USB flash
* drives.
*
* <p>An application may store data on any or all of the returned devices. For example, an app may
* choose to store large files on the device with the most available space, as measured by {@link
* StatFs}.
*
* <p>Starting in {@link android.os.Build.VERSION_CODES#KITKAT}, no permissions are required to
* write to the returned paths; they're always accessible to the calling app. Before then, {@link
* android.Manifest.permission#WRITE_EXTERNAL_STORAGE} is required to write. Write access outside
* of these paths on secondary external storage devices is not available. To request external
* storage access in a backwards compatible way, consider using {@code android:maxSdkVersion} like
* this:
*
* <pre class="prettyprint"><uses-permission
* android:name="android.permission.WRITE_EXTERNAL_STORAGE"
* android:maxSdkVersion="18" /></pre>
*
* <p>The first path returned is the same as {@link Context#getObbDir()}. Returned paths may be
* {@code null} if a storage device is unavailable.
*
* @see Context#getObbDir()
* @see EnvironmentCompat#getStorageState(File)
*/
public static File[] getObbDirs(Context context) {
final int version = Build.VERSION.SDK_INT;
if (version >= 19) {
return ContextCompatKitKat.getObbDirs(context);
} else {
final File single;
if (version >= 11) {
single = ContextCompatHoneycomb.getObbDir(context);
} else {
single =
buildPath(
Environment.getExternalStorageDirectory(),
DIR_ANDROID,
DIR_OBB,
context.getPackageName());
}
return new File[] {single};
}
}