-since $(SRC_API_DIR)/24.txt 24 \
-since $(SRC_API_DIR)/25.txt 25 \
-since $(SRC_API_DIR)/26.txt 26 \
- -werror -hide 111 -hide 113 -hide 121 \
+ -werror -lerror -hide 111 -hide 113 -hide 121 -hide 125 -hide 126 -hide 127 -hide 128 \
-overview $(LOCAL_PATH)/core/java/overview.html \
framework_docs_LOCAL_API_CHECK_ADDITIONAL_JAVA_DIR:= \
field public static final int FINGERPRINT_ERROR_NO_SPACE = 4; // 0x4
field public static final int FINGERPRINT_ERROR_TIMEOUT = 3; // 0x3
field public static final int FINGERPRINT_ERROR_UNABLE_TO_PROCESS = 2; // 0x2
- field public static final int FINGERPRINT_ERROR_UNABLE_TO_REMOVE = 6; // 0x6
field public static final int FINGERPRINT_ERROR_VENDOR = 8; // 0x8
}
field public static final int FINGERPRINT_ERROR_NO_SPACE = 4; // 0x4
field public static final int FINGERPRINT_ERROR_TIMEOUT = 3; // 0x3
field public static final int FINGERPRINT_ERROR_UNABLE_TO_PROCESS = 2; // 0x2
- field public static final int FINGERPRINT_ERROR_UNABLE_TO_REMOVE = 6; // 0x6
field public static final int FINGERPRINT_ERROR_VENDOR = 8; // 0x8
}
field public static final int FINGERPRINT_ERROR_NO_SPACE = 4; // 0x4
field public static final int FINGERPRINT_ERROR_TIMEOUT = 3; // 0x3
field public static final int FINGERPRINT_ERROR_UNABLE_TO_PROCESS = 2; // 0x2
- field public static final int FINGERPRINT_ERROR_UNABLE_TO_REMOVE = 6; // 0x6
field public static final int FINGERPRINT_ERROR_VENDOR = 8; // 0x8
}
/**
* Get the controller for fingerprint gestures. This feature requires {@link
- * AccessibilityServiceInfo#CAPABILITY_CAN_CAPTURE_FINGERPRINT_GESTURES}.
+ * AccessibilityServiceInfo#CAPABILITY_CAN_REQUEST_FINGERPRINT_GESTURES}.
*
*<strong>Note: </strong> The service must be connected before this method is called.
*
* sensor, as long as the device has a sensor capable of detecting gestures.
* <p>
* This capability must be declared by the service as
- * {@link AccessibilityServiceInfo#CAPABILITY_CAN_CAPTURE_FINGERPRINT_GESTURES}. It also requires
+ * {@link AccessibilityServiceInfo#CAPABILITY_CAN_REQUEST_FINGERPRINT_GESTURES}. It also requires
* the permission {@link android.Manifest.permission#USE_FINGERPRINT}.
* <p>
* Because capturing fingerprint gestures may have side effects, services with the capability only
- * capture gestures when {@link AccessibilityServiceInfo#FLAG_CAPTURE_FINGERPRINT_GESTURES} is set.
+ * capture gestures when {@link AccessibilityServiceInfo#FLAG_REQUEST_FINGERPRINT_GESTURES} is set.
* <p>
* <strong>Note: </strong>The fingerprint sensor is used for authentication in critical use cases,
* so services must carefully design their user's experience when performing gestures on the sensor.
/**
* Key to set default visibility for applications which don't satisfy conditions in
- * {@link PACKAGE_NAME_KEY_LEGACY_VISIBLE}. If the value was not set by authenticator
+ * {@link #PACKAGE_NAME_KEY_LEGACY_VISIBLE}. If the value was not set by authenticator
* {@link #VISIBILITY_USER_MANAGED_NOT_VISIBLE} is used.
*/
public static final String PACKAGE_NAME_KEY_LEGACY_NOT_VISIBLE =
* not authorized to view all accounts. This method can only be called by system apps and
* authenticators managing the type.
* Beginning API level {@link android.os.Build.VERSION_CODES#O} it also return accounts
- * which user can make visible to the application (see {@link VISIBILITY_USER_MANAGED_VISIBLE}).
+ * which user can make visible to the application (see {@link #VISIBILITY_USER_MANAGED_VISIBLE}).
*
* @param type The type of accounts to return, null to retrieve all accounts
* @param packageName The package name of the app for which the accounts are to be returned
* of accounts made visible to it by user
* (see {@link #newChooseAccountIntent(Account, List, String[], String,
* String, String[], Bundle)}) or AbstractAcccountAuthenticator
- * using {@link setAccountVisibility}.
+ * using {@link #setAccountVisibility}.
* {@link android.Manifest.permission#GET_ACCOUNTS} permission is not used.
*
* <p>
* of accounts made visible to it by user
* (see {@link #newChooseAccountIntent(Account, List, String[], String,
* String, String[], Bundle)}) or AbstractAcccountAuthenticator
- * using {@link setAccountVisibility}.
+ * using {@link #setAccountVisibility}.
* {@link android.Manifest.permission#GET_ACCOUNTS} permission is not used.
*
* <p>
* On success the activity returns a Bundle with the account name and type specified using
* keys {@link #KEY_ACCOUNT_NAME} and {@link #KEY_ACCOUNT_TYPE}.
* Chosen account is marked as {@link #VISIBILITY_USER_MANAGED_VISIBLE} to the caller
- * (see {@link setAccountVisibility}) and will be returned to it in consequent
+ * (see {@link #setAccountVisibility}) and will be returned to it in consequent
* {@link #getAccountsByType}) calls.
* <p>
* The most common case is to call this with one account type, e.g.:
* On success the activity returns a Bundle with the account name and type specified using
* keys {@link #KEY_ACCOUNT_NAME} and {@link #KEY_ACCOUNT_TYPE}.
* Chosen account is marked as {@link #VISIBILITY_USER_MANAGED_VISIBLE} to the caller
- * (see {@link setAccountVisibility}) and will be returned to it in consequent
+ * (see {@link #setAccountVisibility}) and will be returned to it in consequent
* {@link #getAccountsByType}) calls.
* <p>
* The most common case is to call this with one account type, e.g.:
}
/**
- * Callback passed to {@link KeyguardManager#dismissKeyguard} to notify caller of result.
+ * Callback passed to
+ * {@link KeyguardManager#requestDismissKeyguard(Activity, KeyguardDismissCallback)}
+ * to notify caller of result.
*/
public static abstract class KeyguardDismissCallback {
* could be reclaimed by the system.
* <p>
* Apps making logical decisions about disk space should always use
- * {@link StorageManager#getAllocatableBytes(UUID, int)} instead of this
- * value.
+ * {@link StorageManager#getAllocatableBytes(UUID)} instead of this value.
*
* @param storageUuid the UUID of the storage volume you're interested in,
* such as {@link StorageManager#UUID_DEFAULT}.
*
* <p>If your app needs to be excluded from battery optimizations (run in the background)
* or to have unrestricted data access (use data in the background) you can declare that
- * you use the {@link android.Manifest.permission#RUN_IN_BACKGROUND} and {@link
- * android.Manifest.permission#USE_DATA_IN_BACKGROUND} respectively. Note that these
+ * you use the {@link android.Manifest.permission#REQUEST_COMPANION_RUN_IN_BACKGROUND} and {@link
+ * android.Manifest.permission#REQUEST_COMPANION_USE_DATA_IN_BACKGROUND} respectively. Note that these
* special capabilities have a negative effect on the device's battery and user's data
* usage, therefore you should requested them when absolutely necessary.</p>
*
* before they system will consider them non-responsive and ANR the app. Since these usually
* execute on the app's main thread, they are already bound by the ~5 second time limit
* of various operations that can happen there (not to mention just avoiding UI jank), so
- * the receive limit is generally not of concern. However, once you use {@goAsync}, though
+ * the receive limit is generally not of concern. However, once you use {@code goAsync}, though
* able to be off the main thread, the broadcast execution limit still applies, and that
* includes the time spent between calling this method and ultimately
* {@link PendingResult#finish() PendingResult.finish()}.</p>
import android.os.CancellationSignal;
import android.os.IBinder;
import android.os.ICancellationSignal;
-import android.os.OperationCanceledException;
import android.os.ParcelFileDescriptor;
import android.os.Process;
import android.os.RemoteException;
import android.os.storage.StorageManager;
import android.text.TextUtils;
import android.util.Log;
-import android.util.MathUtils;
import java.io.File;
import java.io.FileDescriptor;
* @param sortOrder How the rows in the cursor should be sorted.
* If {@code null} then the provider is free to define the sort order.
* @param cancellationSignal A signal to cancel the operation in progress, or {@code null} if none.
- * If the operation is canceled, then {@link OperationCanceledException} will be thrown
+ * If the operation is canceled, then {@link android.os.OperationCanceledException} will be thrown
* when the query is executed.
* @return a Cursor or {@code null}.
*/
/**
* The {@link FingerprintManager#remove} call failed. Typically this will happen when the
* provided fingerprint id was incorrect.
+ *
+ * @hide
*/
public static final int FINGERPRINT_ERROR_UNABLE_TO_REMOVE = 6;
Bitmap getImage(int id);
/**
- * @returns {@code true} if the scan was properly scheduled,
+ * @return {@code true} if the scan was properly scheduled,
* {@code false} if the scan feature is unavailable
*/
boolean startBackgroundScan();
/**
* @param vendorFilter Vendor-specific filter, must be Map<String, String>
- * @returns the list, or null if scan is in progress
+ * @return the list, or null if scan is in progress
* @throws IllegalArgumentException if invalid arguments are passed
* @throws IllegalStateException if the scan has not been started, client may
* call startBackgroundScan to fix this.
/**
* Type of a radio technology.
*
- * @returns program type.
+ * @return program type.
*/
public @ProgramType int getProgramType() {
return mProgramType;
* Primary program identifier uniquely identifies a station and is used to
* determine equality between two ProgramSelectors.
*
- * @returns primary identifier.
+ * @return primary identifier.
*/
public @NonNull Identifier getPrimaryId() {
return mPrimaryId;
* Secondary program identifier is not required for tuning, but may make it
* faster or more reliable.
*
- * @returns secondary identifier list, must not be modified.
+ * @return secondary identifier list, must not be modified.
*/
public @NonNull Identifier[] getSecondaryIds() {
return mSecondaryIds;
* The operation is asynchronous and {@link Callback} onProgramInfoChanged() will be called
* when tune completes or onError() when cancelled or on timeout.
*
- * @thows IllegalArgumentException if the provided selector is invalid
+ * @throws IllegalArgumentException if the provided selector is invalid
*/
public abstract void tune(@NonNull ProgramSelector selector);
* itself on the given storage volume. This value is typically larger than
* {@link File#getUsableSpace()}, since the system may be willing to delete
* cached files to satisfy an allocation request. You can then allocate
- * space for yourself using {@link #allocateBytes(UUID, long, int)} or
- * {@link #allocateBytes(FileDescriptor, long, int)}.
+ * space for yourself using {@link #allocateBytes(UUID, long)} or
+ * {@link #allocateBytes(FileDescriptor, long)}.
* <p>
* This method is best used as a pre-flight check, such as deciding if there
* is enough space to store an entire music album before you allocate space
* UUID for a specific path can be obtained using
* {@link #getUuidForPath(File)}.
* @return the maximum number of new bytes that the calling app can allocate
- * using {@link #allocateBytes(UUID, long, int)} or
- * {@link #allocateBytes(FileDescriptor, long, int)}.
+ * using {@link #allocateBytes(UUID, long)} or
+ * {@link #allocateBytes(FileDescriptor, long)}.
* @throws IOException when the storage device isn't present, or when it
* doesn't support allocating space.
*/
* files necessary to satisfy your request.
* <p>
* Attempts to allocate disk space beyond the value returned by
- * {@link #getAllocatableBytes(UUID, int)} will fail.
+ * {@link #getAllocatableBytes(UUID)} will fail.
* <p>
* Since multiple apps can be running simultaneously, this method may be
* subject to race conditions. If possible, consider using
- * {@link #allocateBytes(FileDescriptor, long, int)} which will guarantee
+ * {@link #allocateBytes(FileDescriptor, long)} which will guarantee
* that bytes are allocated to an opened file.
* <p>
* If you're progressively allocating an unbounded amount of storage space
* @throws IOException when the storage device isn't present, or when it
* doesn't support allocating space, or if the device had
* trouble allocating the requested space.
- * @see #getAllocatableBytes(UUID, int)
+ * @see #getAllocatableBytes(UUID)
*/
@WorkerThread
public void allocateBytes(@NonNull UUID storageUuid, @BytesLong long bytes)
* necessary to satisfy your request.
* <p>
* Attempts to allocate disk space beyond the value returned by
- * {@link #getAllocatableBytes(UUID, int)} will fail.
+ * {@link #getAllocatableBytes(UUID)} will fail.
* <p>
* This method guarantees that bytes have been allocated to the opened file,
* otherwise it will throw if fast allocation is not possible. Fast
import android.os.OperationCanceledException;
import android.os.Parcel;
import android.os.ParcelFileDescriptor;
+import android.os.ParcelFileDescriptor.OnCloseListener;
import android.os.Parcelable;
import android.os.ParcelableException;
import android.os.RemoteException;
public FontRequestCallback() {}
/**
- * Called then a Typeface request done via {@link #requestFont} is complete. Note that this
+ * Called then a Typeface request done via {@link #requestFonts} is complete. Note that this
* method will not be called if {@link #onTypefaceRequestFailed(int)} is called instead.
* @param typeface The Typeface object retrieved.
*/
public void onTypefaceRetrieved(Typeface typeface) {}
/**
- * Called when a Typeface request done via {@link #requestFont}} fails.
+ * Called when a Typeface request done via {@link #requestFonts}} fails.
* @param reason One of {@link #FAIL_REASON_PROVIDER_NOT_FOUND},
* {@link #FAIL_REASON_FONT_NOT_FOUND},
* {@link #FAIL_REASON_FONT_LOAD_ERROR},
* <p>An explicit autofill request is triggered when the
* {@link android.view.autofill.AutofillManager#requestAutofill(View)} or
* {@link android.view.autofill.AutofillManager#requestAutofill(View, int, android.graphics.Rect)}
- * is called. For example, standard {@link android.widget.TextView} views that use
- * an {@link android.widget.Editor} shows an {@code AUTOFILL} option in the overflow menu that
- * triggers such request.
+ * is called. For example, standard {@link android.widget.TextView} views show an
+ * {@code AUTOFILL} option in the overflow menu that triggers such request.
*/
public static final int FLAG_MANUAL_REQUEST = 0x1;
* @param ids id of Views that when focused will display the authentication UI affordance.
*
* @return This builder.
- * @throw {@link IllegalArgumentException} if {@code ids} is {@code null} or empty, or if
+ * @throws IllegalArgumentException if {@code ids} is {@code null} or empty, or if
* neither {@code authentication} nor {@code presentation} is non-{@code null}.
*
* @see android.app.PendingIntent#getIntentSender()
import android.app.NotificationChannelGroup;
import android.app.NotificationManager;
import android.app.Service;
+import android.companion.CompanionDeviceManager;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
* A service that receives calls from the system when new notifications are
* posted or removed, or their ranking changed.
* <p>To extend this class, you must declare the service in your manifest file with
- * the {@link Manifest.permission#BIND_NOTIFICATION_LISTENER_SERVICE} permission
+ * the {@link android.Manifest.permission#BIND_NOTIFICATION_LISTENER_SERVICE} permission
* and include an intent filter with the {@link #SERVICE_INTERFACE} action. For example:</p>
* <pre>
* <service android:name=".NotificationListener"
@Deprecated
public static final int FLAG_TURN_SCREEN_ON = 0x00200000;
- /** Window flag: when set the window will cause the keyguard to
- * be dismissed, only if it is not a secure lock keyguard. Because such
- * a keyguard is not needed for security, it will never re-appear if
- * the user navigates to another window (in contrast to
- * {@link #FLAG_SHOW_WHEN_LOCKED}, which will only temporarily
- * hide both secure and non-secure keyguards but ensure they reappear
- * when the user moves to another UI that doesn't hide them).
- * If the keyguard is currently active and is secure (requires an
- * unlock credential) than the user will still need to confirm it before
- * seeing this window, unless {@link #FLAG_SHOW_WHEN_LOCKED} has
- * also been set.
- * @deprecated Use {@link #FLAG_SHOW_WHEN_LOCKED} or {@link KeyguardManager#dismissKeyguard}
- * instead. Since keyguard was dismissed all the time as long as an activity with this flag
- * on its window was focused, keyguard couldn't guard against unintentional touches on the
- * screen, which isn't desired.
+ /**
+ * Window flag: when set the window will cause the keyguard to be
+ * dismissed, only if it is not a secure lock keyguard. Because such a
+ * keyguard is not needed for security, it will never re-appear if the
+ * user navigates to another window (in contrast to
+ * {@link #FLAG_SHOW_WHEN_LOCKED}, which will only temporarily hide both
+ * secure and non-secure keyguards but ensure they reappear when the
+ * user moves to another UI that doesn't hide them). If the keyguard is
+ * currently active and is secure (requires an unlock credential) than
+ * the user will still need to confirm it before seeing this window,
+ * unless {@link #FLAG_SHOW_WHEN_LOCKED} has also been set.
+ *
+ * @deprecated Use {@link #FLAG_SHOW_WHEN_LOCKED} or
+ * {@link KeyguardManager#requestDismissKeyguard} instead.
+ * Since keyguard was dismissed all the time as long as an
+ * activity with this flag on its window was focused,
+ * keyguard couldn't guard against unintentional touches on
+ * the screen, which isn't desired.
*/
@Deprecated
public static final int FLAG_DISMISS_KEYGUARD = 0x00400000;
/**
* Used to indicate an action to take when hitting a malicious URL. Instances of this class are
- * created by the WebView and passed to {@link WebViewClient#onSafebrowsingHit}. The host
+ * created by the WebView and passed to {@link WebViewClient#onSafeBrowsingHit}. The host
* application must call {@link #showInterstitial}, {@link #proceed}, or {@link #backToSafety} to
* set the WebView's response to the Safe Browsing hit.
*/
import android.content.Context;
import android.util.AttributeSet;
+import android.view.LayoutInflater;
import android.view.MotionEvent;
import android.view.PointerIcon;
import android.widget.RemoteViews.RemoteView;
* }
* }</pre>
*
- * <p>The above snippet creates an instance of {@link View.OnClickListener} and wires
+ * <p>The above snippet creates an instance of {@link android.view.View.OnClickListener} and wires
* the listener to the button using
* {@link #setOnClickListener setOnClickListener(View.OnClickListener)}.
* As a result, the system executes the code you write in {@code onClick(View)} after the
* {@link android.R.styleable#Button Button Attributes},
* {@link android.R.styleable#TextView TextView Attributes},
* {@link android.R.styleable#View View Attributes}. See the
- *
{@link <a href="{@docRoot}guide/topics/ui/themes.html#ApplyingStyles">Styles and Themes</a>
+ * <a href="{@docRoot}guide/topics/ui/themes.html#ApplyingStyles">Styles and Themes</a>
* guide to learn how to implement and organize overrides to style-related attributes.</p>
- *
- * @see
- * <a href="{@docRoot}guide/topics/ui/controls/button.html">Buttons Guide</a>
- * {@link android.R.styleable#Button Styleable Button Attributes},
- * {@link android.R.styleable#TextView Styleable TextView Attributes},
- * {@link android.R.styleable#View Styleable View Attributes},
- *
*/
@RemoteView
public class Button extends TextView {
* both horizontal and vertical alignment of all child views within the single row or column.</p>
*
* <p>You can set
- * {@link LinearLayout.LayoutParams.html#attr_android:layout_weight android:layout_weight}
+ * {@link android.R.styleable#LinearLayout_Layout_layout_weight android:layout_weight}
* on individual child views to specify how linear layout divides remaining space amongst
* the views it contains. See the
* <a href="https://developer.android.com/guide/topics/ui/layout/linear.html">Linear Layout</a>
import java.util.stream.Stream;
/**
- * Utility methods for dealing with (typically {@link Nullable}) {@link Collection}s
+ * Utility methods for dealing with (typically {@code Nullable}) {@link Collection}s
*
* Unless a method specifies otherwise, a null value for a collection is treated as an empty
* collection of that type.
import java.io.IOException;
/**
- * @deprecated Use {@link com.android.internal.os.AtomicFile} instead. It would
+ * @deprecated Use {@code AtomicFile} instead. It would
* be nice to update all existing uses of this to switch to AtomicFile, but since
* their on-file semantics are slightly different that would run the risk of losing
* data if at the point of the platform upgrade to the new code it would need to
* <p>
* When writing a {@link LayoutManager} you almost always want to use layout positions whereas when
* writing an {@link Adapter}, you probably want to use adapter positions.
- *
- * @attr ref android.support.v7.recyclerview.R.styleable#RecyclerView_layoutManager
*/
public class RecyclerView extends ViewGroup implements ScrollingView, NestedScrollingChild {
/**
* Parse the xml attributes to get the most common properties used by layout managers.
*
- * @attr ref android.support.v7.recyclerview.R.styleable#RecyclerView_android_orientation
- * @attr ref android.support.v7.recyclerview.R.styleable#RecyclerView_spanCount
- * @attr ref android.support.v7.recyclerview.R.styleable#RecyclerView_reverseLayout
- * @attr ref android.support.v7.recyclerview.R.styleable#RecyclerView_stackFromEnd
- *
* @return an object containing the properties as specified in the attrs.
*/
public static Properties getProperties(Context context, AttributeSet attrs,
<!-- Allows applications to get the installed and enabled print services.
@hide
@SystemApi
- @TestApi
<p>Protection level: signature|preinstalled
-->
<permission android:name="android.permission.READ_PRINT_SERVICES"
to be set for all windows of this activity -->
<attr name="showForAllUsers" format="boolean" />
- <!-- Specifies whether an {@link Activity} should be shown on top of the the lock screen
+ <!-- Specifies whether an {@link android.app.Activity} should be shown on top of the the lock screen
whenever the lockscreen is up and the activity is resumed. Normally an activity will be
transitioned to the stopped state if it is started while the lockscreen is up, but with
this flag set the activity will remain in the resumed state visible on-top of the lock
screen.
- <p>This should be used instead of {@link android.view.LayoutParams#FLAG_SHOW_WHEN_LOCKED}
+ <p>This should be used instead of {@link android.view.WindowManager.LayoutParams#FLAG_SHOW_WHEN_LOCKED}
flag set for Windows. When using the Window flag during activity startup, there may not be
time to add it before the system stops your activity for being behind the lock-screen.
This leads to a double life-cycle as it is then restarted.</p> -->
<attr name="showWhenLocked" format="boolean" />
- <!-- Specifies whether the screen should be turned on when the {@link Activity} is resumed.
+ <!-- Specifies whether the screen should be turned on when the {@link android.app.Activity} is resumed.
Normally an activity will be transitioned to the stopped state if it is started while the
screen if off, but with this flag set the activity will cause the screen to turn on if the
activity will be visible and resumed due to the screen coming on. The screen will not be
normally used in conjunction with the {@link android.R.attr#showWhenLocked} flag to make
sure the activity is visible after the screen is turned on when the lockscreen is up. In
addition, if this flag is set and the activity calls
- {@link KeyguardManager#requestDismissKeyguard(Activity, KeyguardManager.KeyguardDismissCallback)}
+ {@link android.app.KeyguardManager#requestDismissKeyguard}
the screen will turn on.
- <p>This should be used instead of {@link android.view.LayoutParams.FLAG_TURN_SCREEN_ON}
+ <p>This should be used instead of {@link android.view.WindowManager.LayoutParams#FLAG_TURN_SCREEN_ON}
flag set for Windows. When using the Window flag during activity startup, there may not be
time to add it before the system stops your activity because the screen has not yet turned
on. This leads to a double life-cycle as it is then restarted.</p> -->
OSDN Git Service
