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
193
194
195
196
197
198
199
200
201
202
203
|
/*
* Copyright (C) 2014 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.net;
import android.annotation.Nullable;
import android.os.Parcel;
import android.os.Parcelable;
import android.os.UserHandle;
import android.util.ArraySet;
import android.util.Range;
import java.util.Collection;
import java.util.Set;
/**
* An inclusive range of UIDs.
*
* @hide
*/
public final class UidRange implements Parcelable {
public final int start;
public final int stop;
public UidRange(int startUid, int stopUid) {
if (startUid < 0) throw new IllegalArgumentException("Invalid start UID.");
if (stopUid < 0) throw new IllegalArgumentException("Invalid stop UID.");
if (startUid > stopUid) throw new IllegalArgumentException("Invalid UID range.");
start = startUid;
stop = stopUid;
}
/** Creates a UidRange for the specified user. */
public static UidRange createForUser(UserHandle user) {
final UserHandle nextUser = UserHandle.of(user.getIdentifier() + 1);
final int start = user.getUid(0 /* appId */);
final int end = nextUser.getUid(0 /* appId */) - 1;
return new UidRange(start, end);
}
/** Returns the smallest user Id which is contained in this UidRange */
public int getStartUser() {
return UserHandle.getUserHandleForUid(start).getIdentifier();
}
/** Returns the largest user Id which is contained in this UidRange */
public int getEndUser() {
return UserHandle.getUserHandleForUid(stop).getIdentifier();
}
/** Returns whether the UidRange contains the specified UID. */
public boolean contains(int uid) {
return start <= uid && uid <= stop;
}
/**
* Returns the count of UIDs in this range.
*/
public int count() {
return 1 + stop - start;
}
/**
* @return {@code true} if this range contains every UID contained by the {@code other} range.
*/
public boolean containsRange(UidRange other) {
return start <= other.start && other.stop <= stop;
}
@Override
public int hashCode() {
int result = 17;
result = 31 * result + start;
result = 31 * result + stop;
return result;
}
@Override
public boolean equals(@Nullable Object o) {
if (this == o) {
return true;
}
if (o instanceof UidRange) {
UidRange other = (UidRange) o;
return start == other.start && stop == other.stop;
}
return false;
}
@Override
public String toString() {
return start + "-" + stop;
}
// Implement the Parcelable interface
// TODO: Consider making this class no longer parcelable, since all users are likely in the
// system server.
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeInt(start);
dest.writeInt(stop);
}
public static final @android.annotation.NonNull Creator<UidRange> CREATOR =
new Creator<UidRange>() {
@Override
public UidRange createFromParcel(Parcel in) {
int start = in.readInt();
int stop = in.readInt();
return new UidRange(start, stop);
}
@Override
public UidRange[] newArray(int size) {
return new UidRange[size];
}
};
/**
* Returns whether any of the UidRange in the collection contains the specified uid
*
* @param ranges The collection of UidRange to check
* @param uid the uid in question
* @return {@code true} if the uid is contained within the ranges, {@code false} otherwise
*
* @see UidRange#contains(int)
*/
public static boolean containsUid(Collection<UidRange> ranges, int uid) {
if (ranges == null) return false;
for (UidRange range : ranges) {
if (range.contains(uid)) {
return true;
}
}
return false;
}
/**
* Convert a set of {@code Range<Integer>} to a set of {@link UidRange}.
*/
@Nullable
public static ArraySet<UidRange> fromIntRanges(@Nullable Set<Range<Integer>> ranges) {
if (null == ranges) return null;
final ArraySet<UidRange> uids = new ArraySet<>();
for (Range<Integer> range : ranges) {
uids.add(new UidRange(range.getLower(), range.getUpper()));
}
return uids;
}
/**
* Convert a set of {@link UidRange} to a set of {@code Range<Integer>}.
*/
@Nullable
public static ArraySet<Range<Integer>> toIntRanges(@Nullable Set<UidRange> ranges) {
if (null == ranges) return null;
final ArraySet<Range<Integer>> uids = new ArraySet<>();
for (UidRange range : ranges) {
uids.add(new Range<Integer>(range.start, range.stop));
}
return uids;
}
/**
* Compare if the given UID range sets have the same UIDs.
*
* @hide
*/
public static boolean hasSameUids(@Nullable Set<UidRange> uids1,
@Nullable Set<UidRange> uids2) {
if (null == uids1) return null == uids2;
if (null == uids2) return false;
// Make a copy so it can be mutated to check that all ranges in uids2 also are in uids.
final Set<UidRange> remainingUids = new ArraySet<>(uids2);
for (UidRange range : uids1) {
if (!remainingUids.contains(range)) {
return false;
}
remainingUids.remove(range);
}
return remainingUids.isEmpty();
}
}
|
