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
|
/*
* 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;
/** @hide */
public static final int INVALID_REQUEST_ID = Integer.MIN_VALUE;
/** @hide */
@IntDef(
flag = true,
value = {FLAG_MANUAL_REQUEST})
@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);
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.
*
* @see #FLAG_MANUAL_REQUEST
*/
public @RequestFlags int getFlags() {
return mFlags;
}
/**
* Gets the contexts associated with each previous fill request.
*/
public @NonNull List<FillContext> getFillContexts() {
return mContexts;
}
@Override
public String toString() {
return "FillRequest: [id=" + mId + ", flags=" + mFlags + ", ctxts= " + mContexts + "]";
}
/**
* Gets the extra client state returned from the last {@link
* AutofillService#onFillRequest(FillRequest, android.os.CancellationSignal, FillCallback)
* fill request}, so the service can use it for state management.
*
* <p>Once a {@link AutofillService#onSaveRequest(SaveRequest, SaveCallback)
* save request} is made, the client state is cleared.
*
* @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 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];
}
};
}
|
