1 /* 2 * Copyright (C) 2017 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package android.service.autofill; 18 19 import static android.service.autofill.Flags.FLAG_FILL_DIALOG_IMPROVEMENTS; 20 21 import android.annotation.FlaggedApi; 22 import android.annotation.IntDef; 23 import android.annotation.NonNull; 24 import android.annotation.Nullable; 25 import android.content.IntentSender; 26 import android.os.Bundle; 27 import android.os.Parcel; 28 import android.os.Parcelable; 29 import android.view.View; 30 import android.view.inputmethod.InlineSuggestionsRequest; 31 32 import com.android.internal.util.DataClass; 33 import com.android.internal.util.Preconditions; 34 35 import java.lang.annotation.Retention; 36 import java.lang.annotation.RetentionPolicy; 37 import java.util.ArrayList; 38 import java.util.List; 39 40 /** 41 * This class represents a request to an autofill service 42 * to interpret the screen and provide information to the system which views are 43 * interesting for saving and what are the possible ways to fill the inputs on 44 * the screen if applicable. 45 * 46 * @see AutofillService#onFillRequest(FillRequest, android.os.CancellationSignal, FillCallback) 47 */ 48 @DataClass( 49 genToString = true, 50 genHiddenConstructor = true, 51 genHiddenConstDefs = true) 52 public final class FillRequest implements Parcelable { 53 54 /** 55 * Indicates autofill was explicitly requested by the user. 56 * 57 * <p>Users typically make an explicit request to autofill a screen in two situations: 58 * <ul> 59 * <li>The app disabled autofill (using {@link View#setImportantForAutofill(int)}. 60 * <li>The service could not figure out how to autofill a screen (but the user knows the 61 * service has data for that app). 62 * </ul> 63 * 64 * <p>This flag is particularly useful for the second case. For example, the service could offer 65 * a complex UI where the user can map which screen views belong to each user data, or it could 66 * offer a simpler UI where the user picks the data for just the view used to trigger the 67 * request (that would be the view whose 68 * {@link android.app.assist.AssistStructure.ViewNode#isFocused()} method returns {@code true}). 69 * 70 * <p>An explicit autofill request is triggered when the 71 * {@link android.view.autofill.AutofillManager#requestAutofill(View)} or 72 * {@link android.view.autofill.AutofillManager#requestAutofill(View, int, android.graphics.Rect)} 73 * is called. For example, standard {@link android.widget.TextView} views show an 74 * {@code AUTOFILL} option in the overflow menu that triggers such request. 75 */ 76 public static final @RequestFlags int FLAG_MANUAL_REQUEST = 0x1; 77 78 /** 79 * Indicates this request was made using 80 * <a href="AutofillService.html#CompatibilityMode">compatibility mode</a>. 81 */ 82 public static final @RequestFlags int FLAG_COMPATIBILITY_MODE_REQUEST = 0x2; 83 84 /** 85 * Indicates the request came from a password field. 86 * 87 * (TODO: b/141703197) Temporary fix for augmented autofill showing passwords. 88 * 89 * @hide 90 */ 91 public static final @RequestFlags int FLAG_PASSWORD_INPUT_TYPE = 0x4; 92 93 /** 94 * Indicates the view was not focused. 95 * 96 * <p><b>Note:</b> Defines the flag value to 0x10, because the flag value 0x08 has been defined 97 * in {@link AutofillManager}.</p> 98 * 99 * @hide 100 */ 101 public static final @RequestFlags int FLAG_VIEW_NOT_FOCUSED = 0x10; 102 103 /** 104 * Indicates the request supports fill dialog presentation for the fields, the 105 * system will send the request when the activity just started. 106 * 107 * @deprecated All requests would support fill dialog by default. 108 * Presence of this flag isn't needed. 109 */ 110 @FlaggedApi(FLAG_FILL_DIALOG_IMPROVEMENTS) 111 @Deprecated 112 public static final @RequestFlags int FLAG_SUPPORTS_FILL_DIALOG = 0x40; 113 114 /** 115 * Indicates the ime is showing while request coming. 116 * @hide 117 */ 118 public static final @RequestFlags int FLAG_IME_SHOWING = 0x80; 119 120 /** 121 * Indicates whether autofill session should reset the fill dialog state. 122 * @hide 123 */ 124 public static final @RequestFlags int FLAG_RESET_FILL_DIALOG_STATE = 0x100; 125 126 /** 127 * Indicate the fill request is made for PCC detection 128 * @hide 129 */ 130 public static final @RequestFlags int FLAG_PCC_DETECTION = 0x200; 131 132 /** 133 * Indicate whether the screen has credman field 134 * @hide 135 */ 136 public static final @RequestFlags int FLAG_SCREEN_HAS_CREDMAN_FIELD = 0x400; 137 138 /** 139 * Indicate whether the user has focused on a credman field view. 140 * @hide 141 */ 142 public static final @RequestFlags int FLAG_VIEW_REQUESTS_CREDMAN_SERVICE = 0x800; 143 144 /** @hide */ 145 public static final int INVALID_REQUEST_ID = Integer.MIN_VALUE; 146 147 /** 148 * Gets the unique id of this request. 149 */ 150 private final int mId; 151 152 /** 153 * Gets the contexts associated with each previous fill request. 154 * 155 * <p><b>Note:</b> Starting on Android {@link android.os.Build.VERSION_CODES#Q}, it could also 156 * include contexts from requests whose {@link SaveInfo} had the 157 * {@link SaveInfo#FLAG_DELAY_SAVE} flag. 158 */ 159 private final @NonNull List<FillContext> mFillContexts; 160 161 /** 162 * Sends a list of datatypes for the Autofill Provider. 163 * 164 * If this is populated, Autofill Provider should return data 165 * for the autofill hints requested here, 166 * even though the Autofill Provider may not have detected these types. 167 * The hints would be part of HintConstants: 168 * https://developer.android.com/reference/androidx/autofill/HintConstants 169 * 170 * This is populated if the platform's field detection is enabled. 171 */ 172 private final @NonNull List<String> mHints; 173 174 /** 175 * Gets the latest client state bundle set by the service in a 176 * {@link FillResponse.Builder#setClientState(Bundle) fill response}. 177 * 178 * <p><b>Note:</b> Prior to Android {@link android.os.Build.VERSION_CODES#P}, only client state 179 * bundles set by {@link FillResponse.Builder#setClientState(Bundle)} were considered. On 180 * Android {@link android.os.Build.VERSION_CODES#P} and higher, bundles set in the result of 181 * an authenticated request through the 182 * {@link android.view.autofill.AutofillManager#EXTRA_CLIENT_STATE} extra are 183 * also considered (and take precedence when set). 184 * 185 * @return The client state. 186 */ 187 private final @Nullable Bundle mClientState; 188 189 /** 190 * Gets the flags associated with this request. 191 * 192 * @return any combination of {@link #FLAG_MANUAL_REQUEST}, 193 * {@link #FLAG_SUPPORTS_FILL_DIALOG} and 194 * {@link #FLAG_COMPATIBILITY_MODE_REQUEST}. 195 * 196 */ 197 private final @RequestFlags int mFlags; 198 199 /** 200 * Gets the {@link InlineSuggestionsRequest} associated 201 * with this request. 202 * 203 * <p>Autofill Framework will send a {@code @non-null} {@link InlineSuggestionsRequest} if 204 * currently inline suggestions are supported and can be displayed. If the Autofill service 205 * wants to show inline suggestions, they may return {@link Dataset} with valid 206 * {@link InlinePresentation}.</p> 207 * 208 * <p>The Autofill Service must set supportsInlineSuggestions in its XML to enable support 209 * for inline suggestions.</p> 210 * 211 * @return the suggestionspec 212 */ 213 private final @Nullable InlineSuggestionsRequest mInlineSuggestionsRequest; 214 215 /** 216 * Gets the {@link IntentSender} to send a delayed fill response. 217 * 218 * <p>The autofill service must first indicate that it wants to return a delayed 219 * {@link FillResponse} by setting {@link FillResponse#FLAG_DELAY_FILL} in a successful 220 * fill response. Then it can use this IntentSender to send an Intent with extra 221 * {@link AutofillService#EXTRA_FILL_RESPONSE} with the delayed response.</p> 222 * 223 * <p>Note that this may be null if a delayed fill response is not supported for 224 * this fill request.</p> 225 */ 226 private final @Nullable IntentSender mDelayedFillIntentSender; 227 onConstructed()228 private void onConstructed() { 229 Preconditions.checkCollectionElementsNotNull(mFillContexts, "contexts"); 230 Preconditions.checkCollectionElementsNotNull(mHints, "hints"); 231 } 232 233 234 235 // Code below generated by codegen v1.0.23. 236 // 237 // DO NOT MODIFY! 238 // CHECKSTYLE:OFF Generated code 239 // 240 // To regenerate run: 241 // $ codegen $ANDROID_BUILD_TOP/frameworks/base/core/java/android/service/autofill/FillRequest.java 242 // 243 // To exclude the generated code from IntelliJ auto-formatting enable (one-time): 244 // Settings > Editor > Code Style > Formatter Control 245 //@formatter:off 246 247 248 /** @hide */ 249 @IntDef(flag = true, prefix = "FLAG_", value = { 250 FLAG_MANUAL_REQUEST, 251 FLAG_COMPATIBILITY_MODE_REQUEST, 252 FLAG_PASSWORD_INPUT_TYPE, 253 FLAG_VIEW_NOT_FOCUSED, 254 FLAG_SUPPORTS_FILL_DIALOG, 255 FLAG_IME_SHOWING, 256 FLAG_RESET_FILL_DIALOG_STATE, 257 FLAG_PCC_DETECTION, 258 FLAG_SCREEN_HAS_CREDMAN_FIELD, 259 FLAG_VIEW_REQUESTS_CREDMAN_SERVICE 260 }) 261 @Retention(RetentionPolicy.SOURCE) 262 @DataClass.Generated.Member 263 public @interface RequestFlags {} 264 265 /** @hide */ 266 @DataClass.Generated.Member requestFlagsToString(@equestFlags int value)267 public static String requestFlagsToString(@RequestFlags int value) { 268 return com.android.internal.util.BitUtils.flagsToString( 269 value, FillRequest::singleRequestFlagsToString); 270 } 271 272 @DataClass.Generated.Member singleRequestFlagsToString(@equestFlags int value)273 static String singleRequestFlagsToString(@RequestFlags int value) { 274 switch (value) { 275 case FLAG_MANUAL_REQUEST: 276 return "FLAG_MANUAL_REQUEST"; 277 case FLAG_COMPATIBILITY_MODE_REQUEST: 278 return "FLAG_COMPATIBILITY_MODE_REQUEST"; 279 case FLAG_PASSWORD_INPUT_TYPE: 280 return "FLAG_PASSWORD_INPUT_TYPE"; 281 case FLAG_VIEW_NOT_FOCUSED: 282 return "FLAG_VIEW_NOT_FOCUSED"; 283 case FLAG_SUPPORTS_FILL_DIALOG: 284 return "FLAG_SUPPORTS_FILL_DIALOG"; 285 case FLAG_IME_SHOWING: 286 return "FLAG_IME_SHOWING"; 287 case FLAG_RESET_FILL_DIALOG_STATE: 288 return "FLAG_RESET_FILL_DIALOG_STATE"; 289 case FLAG_PCC_DETECTION: 290 return "FLAG_PCC_DETECTION"; 291 case FLAG_SCREEN_HAS_CREDMAN_FIELD: 292 return "FLAG_SCREEN_HAS_CREDMAN_FIELD"; 293 case FLAG_VIEW_REQUESTS_CREDMAN_SERVICE: 294 return "FLAG_VIEW_REQUESTS_CREDMAN_SERVICE"; 295 default: return Integer.toHexString(value); 296 } 297 } 298 299 /** 300 * Creates a new FillRequest. 301 * 302 * @param id 303 * Gets the unique id of this request. 304 * @param fillContexts 305 * Gets the contexts associated with each previous fill request. 306 * 307 * <p><b>Note:</b> Starting on Android {@link android.os.Build.VERSION_CODES#Q}, it could also 308 * include contexts from requests whose {@link SaveInfo} had the 309 * {@link SaveInfo#FLAG_DELAY_SAVE} flag. 310 * @param hints 311 * Sends a list of datatypes for the Autofill Provider. 312 * 313 * If this is populated, Autofill Provider should return data 314 * for the autofill hints requested here, 315 * even though the Autofill Provider may not have detected these types. 316 * The hints would be part of HintConstants: 317 * https://developer.android.com/reference/androidx/autofill/HintConstants 318 * 319 * This is populated if the platform's field detection is enabled. 320 * @param clientState 321 * Gets the latest client state bundle set by the service in a 322 * {@link FillResponse.Builder#setClientState(Bundle) fill response}. 323 * 324 * <p><b>Note:</b> Prior to Android {@link android.os.Build.VERSION_CODES#P}, only client state 325 * bundles set by {@link FillResponse.Builder#setClientState(Bundle)} were considered. On 326 * Android {@link android.os.Build.VERSION_CODES#P} and higher, bundles set in the result of 327 * an authenticated request through the 328 * {@link android.view.autofill.AutofillManager#EXTRA_CLIENT_STATE} extra are 329 * also considered (and take precedence when set). 330 * @param flags 331 * Gets the flags associated with this request. 332 * 333 * @return any combination of {@link #FLAG_MANUAL_REQUEST}, 334 * {@link #FLAG_SUPPORTS_FILL_DIALOG} and 335 * {@link #FLAG_COMPATIBILITY_MODE_REQUEST}. 336 * @param inlineSuggestionsRequest 337 * Gets the {@link InlineSuggestionsRequest} associated 338 * with this request. 339 * 340 * <p>Autofill Framework will send a {@code @non-null} {@link InlineSuggestionsRequest} if 341 * currently inline suggestions are supported and can be displayed. If the Autofill service 342 * wants to show inline suggestions, they may return {@link Dataset} with valid 343 * {@link InlinePresentation}.</p> 344 * 345 * <p>The Autofill Service must set supportsInlineSuggestions in its XML to enable support 346 * for inline suggestions.</p> 347 * @param delayedFillIntentSender 348 * Gets the {@link IntentSender} to send a delayed fill response. 349 * 350 * <p>The autofill service must first indicate that it wants to return a delayed 351 * {@link FillResponse} by setting {@link FillResponse#FLAG_DELAY_FILL} in a successful 352 * fill response. Then it can use this IntentSender to send an Intent with extra 353 * {@link AutofillService#EXTRA_FILL_RESPONSE} with the delayed response.</p> 354 * 355 * <p>Note that this may be null if a delayed fill response is not supported for 356 * this fill request.</p> 357 * @hide 358 */ 359 @DataClass.Generated.Member FillRequest( int id, @NonNull List<FillContext> fillContexts, @NonNull List<String> hints, @Nullable Bundle clientState, @RequestFlags int flags, @Nullable InlineSuggestionsRequest inlineSuggestionsRequest, @Nullable IntentSender delayedFillIntentSender)360 public FillRequest( 361 int id, 362 @NonNull List<FillContext> fillContexts, 363 @NonNull List<String> hints, 364 @Nullable Bundle clientState, 365 @RequestFlags int flags, 366 @Nullable InlineSuggestionsRequest inlineSuggestionsRequest, 367 @Nullable IntentSender delayedFillIntentSender) { 368 this.mId = id; 369 this.mFillContexts = fillContexts; 370 com.android.internal.util.AnnotationValidations.validate( 371 NonNull.class, null, mFillContexts); 372 this.mHints = hints; 373 com.android.internal.util.AnnotationValidations.validate( 374 NonNull.class, null, mHints); 375 this.mClientState = clientState; 376 this.mFlags = flags; 377 378 Preconditions.checkFlagsArgument( 379 mFlags, 380 FLAG_MANUAL_REQUEST 381 | FLAG_COMPATIBILITY_MODE_REQUEST 382 | FLAG_PASSWORD_INPUT_TYPE 383 | FLAG_VIEW_NOT_FOCUSED 384 | FLAG_SUPPORTS_FILL_DIALOG 385 | FLAG_IME_SHOWING 386 | FLAG_RESET_FILL_DIALOG_STATE 387 | FLAG_PCC_DETECTION 388 | FLAG_SCREEN_HAS_CREDMAN_FIELD 389 | FLAG_VIEW_REQUESTS_CREDMAN_SERVICE); 390 this.mInlineSuggestionsRequest = inlineSuggestionsRequest; 391 this.mDelayedFillIntentSender = delayedFillIntentSender; 392 393 onConstructed(); 394 } 395 396 /** 397 * Gets the unique id of this request. 398 */ 399 @DataClass.Generated.Member getId()400 public int getId() { 401 return mId; 402 } 403 404 /** 405 * Gets the contexts associated with each previous fill request. 406 * 407 * <p><b>Note:</b> Starting on Android {@link android.os.Build.VERSION_CODES#Q}, it could also 408 * include contexts from requests whose {@link SaveInfo} had the 409 * {@link SaveInfo#FLAG_DELAY_SAVE} flag. 410 */ 411 @DataClass.Generated.Member getFillContexts()412 public @NonNull List<FillContext> getFillContexts() { 413 return mFillContexts; 414 } 415 416 /** 417 * Sends a list of datatypes for the Autofill Provider. 418 * 419 * If this is populated, Autofill Provider should return data 420 * for the autofill hints requested here, 421 * even though the Autofill Provider may not have detected these types. 422 * The hints would be part of HintConstants: 423 * https://developer.android.com/reference/androidx/autofill/HintConstants 424 * 425 * This is populated if the platform's field detection is enabled. 426 */ 427 @DataClass.Generated.Member getHints()428 public @NonNull List<String> getHints() { 429 return mHints; 430 } 431 432 /** 433 * Gets the latest client state bundle set by the service in a 434 * {@link FillResponse.Builder#setClientState(Bundle) fill response}. 435 * 436 * <p><b>Note:</b> Prior to Android {@link android.os.Build.VERSION_CODES#P}, only client state 437 * bundles set by {@link FillResponse.Builder#setClientState(Bundle)} were considered. On 438 * Android {@link android.os.Build.VERSION_CODES#P} and higher, bundles set in the result of 439 * an authenticated request through the 440 * {@link android.view.autofill.AutofillManager#EXTRA_CLIENT_STATE} extra are 441 * also considered (and take precedence when set). 442 * 443 * @return The client state. 444 */ 445 @DataClass.Generated.Member getClientState()446 public @Nullable Bundle getClientState() { 447 return mClientState; 448 } 449 450 /** 451 * Gets the flags associated with this request. 452 * 453 * @return any combination of {@link #FLAG_MANUAL_REQUEST}, 454 * {@link #FLAG_SUPPORTS_FILL_DIALOG} and 455 * {@link #FLAG_COMPATIBILITY_MODE_REQUEST}. 456 */ 457 @DataClass.Generated.Member getFlags()458 public @RequestFlags int getFlags() { 459 return mFlags; 460 } 461 462 /** 463 * Gets the {@link InlineSuggestionsRequest} associated 464 * with this request. 465 * 466 * <p>Autofill Framework will send a {@code @non-null} {@link InlineSuggestionsRequest} if 467 * currently inline suggestions are supported and can be displayed. If the Autofill service 468 * wants to show inline suggestions, they may return {@link Dataset} with valid 469 * {@link InlinePresentation}.</p> 470 * 471 * <p>The Autofill Service must set supportsInlineSuggestions in its XML to enable support 472 * for inline suggestions.</p> 473 * 474 * @return the suggestionspec 475 */ 476 @DataClass.Generated.Member getInlineSuggestionsRequest()477 public @Nullable InlineSuggestionsRequest getInlineSuggestionsRequest() { 478 return mInlineSuggestionsRequest; 479 } 480 481 /** 482 * Gets the {@link IntentSender} to send a delayed fill response. 483 * 484 * <p>The autofill service must first indicate that it wants to return a delayed 485 * {@link FillResponse} by setting {@link FillResponse#FLAG_DELAY_FILL} in a successful 486 * fill response. Then it can use this IntentSender to send an Intent with extra 487 * {@link AutofillService#EXTRA_FILL_RESPONSE} with the delayed response.</p> 488 * 489 * <p>Note that this may be null if a delayed fill response is not supported for 490 * this fill request.</p> 491 */ 492 @DataClass.Generated.Member getDelayedFillIntentSender()493 public @Nullable IntentSender getDelayedFillIntentSender() { 494 return mDelayedFillIntentSender; 495 } 496 497 @Override 498 @DataClass.Generated.Member toString()499 public String toString() { 500 // You can override field toString logic by defining methods like: 501 // String fieldNameToString() { ... } 502 503 return "FillRequest { " + 504 "id = " + mId + ", " + 505 "fillContexts = " + mFillContexts + ", " + 506 "hints = " + mHints + ", " + 507 "clientState = " + mClientState + ", " + 508 "flags = " + requestFlagsToString(mFlags) + ", " + 509 "inlineSuggestionsRequest = " + mInlineSuggestionsRequest + ", " + 510 "delayedFillIntentSender = " + mDelayedFillIntentSender + 511 " }"; 512 } 513 514 @Override 515 @DataClass.Generated.Member writeToParcel(@onNull Parcel dest, int flags)516 public void writeToParcel(@NonNull Parcel dest, int flags) { 517 // You can override field parcelling by defining methods like: 518 // void parcelFieldName(Parcel dest, int flags) { ... } 519 520 byte flg = 0; 521 if (mClientState != null) flg |= 0x8; 522 if (mInlineSuggestionsRequest != null) flg |= 0x20; 523 if (mDelayedFillIntentSender != null) flg |= 0x40; 524 dest.writeByte(flg); 525 dest.writeInt(mId); 526 dest.writeParcelableList(mFillContexts, flags); 527 dest.writeStringList(mHints); 528 if (mClientState != null) dest.writeBundle(mClientState); 529 dest.writeInt(mFlags); 530 if (mInlineSuggestionsRequest != null) dest.writeTypedObject(mInlineSuggestionsRequest, flags); 531 if (mDelayedFillIntentSender != null) dest.writeTypedObject(mDelayedFillIntentSender, flags); 532 } 533 534 @Override 535 @DataClass.Generated.Member describeContents()536 public int describeContents() { return 0; } 537 538 /** @hide */ 539 @SuppressWarnings({"unchecked", "RedundantCast"}) 540 @DataClass.Generated.Member FillRequest(@onNull Parcel in)541 /* package-private */ FillRequest(@NonNull Parcel in) { 542 // You can override field unparcelling by defining methods like: 543 // static FieldType unparcelFieldName(Parcel in) { ... } 544 545 byte flg = in.readByte(); 546 int id = in.readInt(); 547 List<FillContext> fillContexts = new ArrayList<>(); 548 in.readParcelableList(fillContexts, FillContext.class.getClassLoader()); 549 List<String> hints = new ArrayList<>(); 550 in.readStringList(hints); 551 Bundle clientState = (flg & 0x8) == 0 ? null : in.readBundle(); 552 int flags = in.readInt(); 553 InlineSuggestionsRequest inlineSuggestionsRequest = (flg & 0x20) == 0 ? null : (InlineSuggestionsRequest) in.readTypedObject(InlineSuggestionsRequest.CREATOR); 554 IntentSender delayedFillIntentSender = (flg & 0x40) == 0 ? null : (IntentSender) in.readTypedObject(IntentSender.CREATOR); 555 556 this.mId = id; 557 this.mFillContexts = fillContexts; 558 com.android.internal.util.AnnotationValidations.validate( 559 NonNull.class, null, mFillContexts); 560 this.mHints = hints; 561 com.android.internal.util.AnnotationValidations.validate( 562 NonNull.class, null, mHints); 563 this.mClientState = clientState; 564 this.mFlags = flags; 565 566 Preconditions.checkFlagsArgument( 567 mFlags, 568 FLAG_MANUAL_REQUEST 569 | FLAG_COMPATIBILITY_MODE_REQUEST 570 | FLAG_PASSWORD_INPUT_TYPE 571 | FLAG_VIEW_NOT_FOCUSED 572 | FLAG_SUPPORTS_FILL_DIALOG 573 | FLAG_IME_SHOWING 574 | FLAG_RESET_FILL_DIALOG_STATE 575 | FLAG_PCC_DETECTION 576 | FLAG_SCREEN_HAS_CREDMAN_FIELD 577 | FLAG_VIEW_REQUESTS_CREDMAN_SERVICE); 578 this.mInlineSuggestionsRequest = inlineSuggestionsRequest; 579 this.mDelayedFillIntentSender = delayedFillIntentSender; 580 581 onConstructed(); 582 } 583 584 @DataClass.Generated.Member 585 public static final @NonNull Parcelable.Creator<FillRequest> CREATOR 586 = new Parcelable.Creator<FillRequest>() { 587 @Override 588 public FillRequest[] newArray(int size) { 589 return new FillRequest[size]; 590 } 591 592 @Override 593 public FillRequest createFromParcel(@NonNull Parcel in) { 594 return new FillRequest(in); 595 } 596 }; 597 598 @DataClass.Generated( 599 time = 1730991738865L, 600 codegenVersion = "1.0.23", 601 sourceFile = "frameworks/base/core/java/android/service/autofill/FillRequest.java", 602 inputSignatures = "public static final @android.service.autofill.FillRequest.RequestFlags int FLAG_MANUAL_REQUEST\npublic static final @android.service.autofill.FillRequest.RequestFlags int FLAG_COMPATIBILITY_MODE_REQUEST\npublic static final @android.service.autofill.FillRequest.RequestFlags int FLAG_PASSWORD_INPUT_TYPE\npublic static final @android.service.autofill.FillRequest.RequestFlags int FLAG_VIEW_NOT_FOCUSED\npublic static final @android.annotation.FlaggedApi @java.lang.Deprecated @android.service.autofill.FillRequest.RequestFlags int FLAG_SUPPORTS_FILL_DIALOG\npublic static final @android.service.autofill.FillRequest.RequestFlags int FLAG_IME_SHOWING\npublic static final @android.service.autofill.FillRequest.RequestFlags int FLAG_RESET_FILL_DIALOG_STATE\npublic static final @android.service.autofill.FillRequest.RequestFlags int FLAG_PCC_DETECTION\npublic static final @android.service.autofill.FillRequest.RequestFlags int FLAG_SCREEN_HAS_CREDMAN_FIELD\npublic static final @android.service.autofill.FillRequest.RequestFlags int FLAG_VIEW_REQUESTS_CREDMAN_SERVICE\npublic static final int INVALID_REQUEST_ID\nprivate final int mId\nprivate final @android.annotation.NonNull java.util.List<android.service.autofill.FillContext> mFillContexts\nprivate final @android.annotation.NonNull java.util.List<java.lang.String> mHints\nprivate final @android.annotation.Nullable android.os.Bundle mClientState\nprivate final @android.service.autofill.FillRequest.RequestFlags int mFlags\nprivate final @android.annotation.Nullable android.view.inputmethod.InlineSuggestionsRequest mInlineSuggestionsRequest\nprivate final @android.annotation.Nullable android.content.IntentSender mDelayedFillIntentSender\nprivate void onConstructed()\nclass FillRequest extends java.lang.Object implements [android.os.Parcelable]\n@com.android.internal.util.DataClass(genToString=true, genHiddenConstructor=true, genHiddenConstDefs=true)") 603 @Deprecated __metadata()604 private void __metadata() {} 605 606 607 //@formatter:on 608 // End of generated code 609 610 } 611