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
|
/*
* Copyright (C) 2009 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.content.pm;
import android.os.Parcel;
import android.os.Parcelable;
import android.util.proto.ProtoOutputStream;
/**
* Definition of a single optional hardware or software feature of an Android
* device.
* <p>
* This object is used to represent both features supported by a device and
* features requested by an app. Apps can request that certain features be
* available as a prerequisite to being installed through the
* {@code uses-feature} tag in their manifests.
* <p>
* Starting in {@link android.os.Build.VERSION_CODES#N}, features can have a
* version, which must always be backwards compatible. That is, a device
* claiming to support version 3 of a specific feature must support apps
* requesting version 1 of that feature.
*/
public class FeatureInfo implements Parcelable {
/**
* The name of this feature, for example "android.hardware.camera". If
* this is null, then this is an OpenGL ES version feature as described
* in {@link #reqGlEsVersion}.
*/
public String name;
/**
* If this object represents a feature supported by a device, this is the
* maximum version of this feature supported by the device. The device
* implicitly supports all older versions of this feature.
* <p>
* If this object represents a feature requested by an app, this is the
* minimum version of the feature required by the app.
* <p>
* When a feature version is undefined by a device, it's assumed to be
* version 0.
*/
public int version;
/**
* Default value for {@link #reqGlEsVersion};
*/
public static final int GL_ES_VERSION_UNDEFINED = 0;
/**
* The GLES version used by an application. The upper order 16 bits represent the
* major version and the lower order 16 bits the minor version. Only valid
* if {@link #name} is null.
*/
public int reqGlEsVersion;
/**
* Set on {@link #flags} if this feature has been required by the application.
*/
public static final int FLAG_REQUIRED = 0x0001;
/**
* Additional flags. May be zero or more of {@link #FLAG_REQUIRED}.
*/
public int flags;
public FeatureInfo() {
}
public FeatureInfo(FeatureInfo orig) {
name = orig.name;
version = orig.version;
reqGlEsVersion = orig.reqGlEsVersion;
flags = orig.flags;
}
@Override
public String toString() {
if (name != null) {
return "FeatureInfo{"
+ Integer.toHexString(System.identityHashCode(this))
+ " " + name + " v=" + version + " fl=0x" + Integer.toHexString(flags) + "}";
} else {
return "FeatureInfo{"
+ Integer.toHexString(System.identityHashCode(this))
+ " glEsVers=" + getGlEsVersion()
+ " fl=0x" + Integer.toHexString(flags) + "}";
}
}
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(Parcel dest, int parcelableFlags) {
dest.writeString(name);
dest.writeInt(version);
dest.writeInt(reqGlEsVersion);
dest.writeInt(flags);
}
/** @hide */
public void writeToProto(ProtoOutputStream proto, long fieldId) {
long token = proto.start(fieldId);
if (name != null) {
proto.write(FeatureInfoProto.NAME, name);
}
proto.write(FeatureInfoProto.VERSION, version);
proto.write(FeatureInfoProto.GLES_VERSION, getGlEsVersion());
proto.write(FeatureInfoProto.FLAGS, flags);
proto.end(token);
}
public static final Creator<FeatureInfo> CREATOR = new Creator<FeatureInfo>() {
@Override
public FeatureInfo createFromParcel(Parcel source) {
return new FeatureInfo(source);
}
@Override
public FeatureInfo[] newArray(int size) {
return new FeatureInfo[size];
}
};
private FeatureInfo(Parcel source) {
name = source.readString();
version = source.readInt();
reqGlEsVersion = source.readInt();
flags = source.readInt();
}
/**
* This method extracts the major and minor version of reqGLEsVersion attribute
* and returns it as a string. Say reqGlEsVersion value of 0x00010002 is returned
* as 1.2
* @return String representation of the reqGlEsVersion attribute
*/
public String getGlEsVersion() {
int major = ((reqGlEsVersion & 0xffff0000) >> 16);
int minor = reqGlEsVersion & 0x0000ffff;
return String.valueOf(major)+"."+String.valueOf(minor);
}
}
|
