1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
|
/*
* Copyright (C) 2017 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.service.autofill;
import android.annotation.IntDef;
import android.annotation.NonNull;
import android.annotation.Nullable;
import android.os.Bundle;
import android.os.Parcel;
import android.os.Parcelable;
import android.view.View;
import com.android.internal.util.Preconditions;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.util.ArrayList;
import java.util.List;
/**
* This class represents a request to an autofill service
* to interpret the screen and provide information to the system which views are
* interesting for saving and what are the possible ways to fill the inputs on
* the screen if applicable.
*
* @see AutofillService#onFillRequest(FillRequest, android.os.CancellationSignal, FillCallback)
*/
public final class FillRequest implements Parcelable {
/**
* Indicates autofill was explicitly requested by the user.
*
* <p>Users typically make an explicit request to autofill a screen in two situations:
* <ul>
* <li>The app disabled autofill (using {@link View#setImportantForAutofill(int)}.
* <li>The service could not figure out how to autofill a screen (but the user knows the
* service has data for that app).
* </ul>
*
* <p>This flag is particularly useful for the second case. For example, the service could offer
* a complex UI where the user can map which screen views belong to each user data, or it could
* offer a simpler UI where the user picks the data for just the view used to trigger the
* request (that would be the view whose
* {@link android.app.assist.AssistStructure.ViewNode#isFocused()} method returns {@code true}).
*
* <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 show an
* {@code AUTOFILL} option in the overflow menu that triggers such request.
*/
public static final int FLAG_MANUAL_REQUEST = 0x1;
/**
* Indicates this request was made using
* <a href="AutofillService.html#CompatibilityMode">compatibility mode</a>.
*/
public static final int FLAG_COMPATIBILITY_MODE_REQUEST = 0x2;
/**
* Indicates the request came from a password field.
*
* (TODO: b/141703197) Temporary fix for augmented autofill showing passwords.
*
* @hide
*/
public static final @RequestFlags int FLAG_PASSWORD_INPUT_TYPE = 0x4;
/** @hide */
public static final int INVALID_REQUEST_ID = Integer.MIN_VALUE;
/** @hide */
@IntDef(flag = true, prefix = { "FLAG_" }, value = {
FLAG_MANUAL_REQUEST, FLAG_COMPATIBILITY_MODE_REQUEST, FLAG_PASSWORD_INPUT_TYPE
})
@Retention(RetentionPolicy.SOURCE)
@interface RequestFlags{}
private final int mId;
private final @RequestFlags int mFlags;
private final @NonNull ArrayList<FillContext> mContexts;
private final @Nullable Bundle mClientState;
private FillRequest(@NonNull Parcel parcel) {
mId = parcel.readInt();
mContexts = new ArrayList<>();
parcel.readParcelableList(mContexts, null);
mClientState = parcel.readBundle();
mFlags = parcel.readInt();
}
/** @hide */
public FillRequest(int id, @NonNull ArrayList<FillContext> contexts,
@Nullable Bundle clientState, @RequestFlags int flags) {
mId = id;
mFlags = Preconditions.checkFlagsArgument(flags,
FLAG_MANUAL_REQUEST | FLAG_COMPATIBILITY_MODE_REQUEST | FLAG_PASSWORD_INPUT_TYPE);
mContexts = Preconditions.checkCollectionElementsNotNull(contexts, "contexts");
mClientState = clientState;
}
/**
* Gets the unique id of this request.
*/
public int getId() {
return mId;
}
/**
* Gets the flags associated with this request.
*
* @return any combination of {@link #FLAG_MANUAL_REQUEST} and
* {@link #FLAG_COMPATIBILITY_MODE_REQUEST}.
*/
public @RequestFlags int getFlags() {
return mFlags;
}
/**
* Gets the contexts associated with each previous fill request.
*
* <p><b>Note:</b> Starting on Android {@link android.os.Build.VERSION_CODES#Q}, it could also
* include contexts from requests whose {@link SaveInfo} had the
* {@link SaveInfo#FLAG_DELAY_SAVE} flag.
*/
public @NonNull List<FillContext> getFillContexts() {
return mContexts;
}
@Override
public String toString() {
return "FillRequest: [id=" + mId + ", flags=" + mFlags + ", ctxts= " + mContexts + "]";
}
/**
* Gets the latest client state bundle set by the service in a
* {@link FillResponse.Builder#setClientState(Bundle) fill response}.
*
* <p><b>Note:</b> Prior to Android {@link android.os.Build.VERSION_CODES#P}, only client state
* bundles set by {@link FillResponse.Builder#setClientState(Bundle)} were considered. On
* Android {@link android.os.Build.VERSION_CODES#P} and higher, bundles set in the result of
* an authenticated request through the
* {@link android.view.autofill.AutofillManager#EXTRA_CLIENT_STATE} extra are
* also considered (and take precedence when set).
*
* @return The client state.
*/
public @Nullable Bundle getClientState() {
return mClientState;
}
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(Parcel parcel, int flags) {
parcel.writeInt(mId);
parcel.writeParcelableList(mContexts, flags);
parcel.writeBundle(mClientState);
parcel.writeInt(mFlags);
}
public static final @android.annotation.NonNull Parcelable.Creator<FillRequest> CREATOR =
new Parcelable.Creator<FillRequest>() {
@Override
public FillRequest createFromParcel(Parcel parcel) {
return new FillRequest(parcel);
}
@Override
public FillRequest[] newArray(int size) {
return new FillRequest[size];
}
};
}
|
