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
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
|
/*
* Copyright 2016 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.os;
import android.content.Context;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.opengl.EGL14;
import android.os.Build;
import android.os.SystemProperties;
import android.provider.Settings;
import android.util.Log;
import dalvik.system.VMRuntime;
import java.io.File;
/** @hide */
public class GraphicsEnvironment {
private static final GraphicsEnvironment sInstance = new GraphicsEnvironment();
/**
* Returns the shared {@link GraphicsEnvironment} instance.
*/
public static GraphicsEnvironment getInstance() {
return sInstance;
}
private static final boolean DEBUG = false;
private static final String TAG = "GraphicsEnvironment";
private static final String PROPERTY_GFX_DRIVER = "ro.gfx.driver.0";
private ClassLoader mClassLoader;
private String mLayerPath;
private String mDebugLayerPath;
/**
* Set up GraphicsEnvironment
*/
public void setup(Context context) {
setupGpuLayers(context);
chooseDriver(context);
}
/**
* Check whether application is debuggable
*/
private static boolean isDebuggable(Context context) {
return (context.getApplicationInfo().flags & ApplicationInfo.FLAG_DEBUGGABLE) > 0;
}
/**
* Store the layer paths available to the loader.
*/
public void setLayerPaths(ClassLoader classLoader,
String layerPath,
String debugLayerPath) {
// We have to store these in the class because they are set up before we
// have access to the Context to properly set up GraphicsEnvironment
mClassLoader = classLoader;
mLayerPath = layerPath;
mDebugLayerPath = debugLayerPath;
}
/**
* Set up layer search paths for all apps
* If debuggable, check for additional debug settings
*/
private void setupGpuLayers(Context context) {
String layerPaths = "";
// Only enable additional debug functionality if the following conditions are met:
// 1. App is debuggable
// 2. ENABLE_GPU_DEBUG_LAYERS is true
// 3. Package name is equal to GPU_DEBUG_APP
if (isDebuggable(context)) {
int enable = Settings.Global.getInt(context.getContentResolver(),
Settings.Global.ENABLE_GPU_DEBUG_LAYERS, 0);
if (enable != 0) {
String gpuDebugApp = Settings.Global.getString(context.getContentResolver(),
Settings.Global.GPU_DEBUG_APP);
String packageName = context.getPackageName();
if ((gpuDebugApp != null && packageName != null)
&& (!gpuDebugApp.isEmpty() && !packageName.isEmpty())
&& gpuDebugApp.equals(packageName)) {
Log.i(TAG, "GPU debug layers enabled for " + packageName);
// Prepend the debug layer path as a searchable path.
// This will ensure debug layers added will take precedence over
// the layers specified by the app.
layerPaths = mDebugLayerPath + ":";
String layers = Settings.Global.getString(context.getContentResolver(),
Settings.Global.GPU_DEBUG_LAYERS);
Log.i(TAG, "Debug layer list: " + layers);
if (layers != null && !layers.isEmpty()) {
setDebugLayers(layers);
}
}
}
}
// Include the app's lib directory in all cases
layerPaths += mLayerPath;
setLayerPaths(mClassLoader, layerPaths);
}
/**
* Choose whether the current process should use the builtin or an updated driver.
*/
private static void chooseDriver(Context context) {
String driverPackageName = SystemProperties.get(PROPERTY_GFX_DRIVER);
if (driverPackageName == null || driverPackageName.isEmpty()) {
return;
}
// To minimize risk of driver updates crippling the device beyond user repair, never use an
// updated driver for privileged or non-updated system apps. Presumably pre-installed apps
// were tested thoroughly with the pre-installed driver.
ApplicationInfo ai = context.getApplicationInfo();
if (ai.isPrivilegedApp() || (ai.isSystemApp() && !ai.isUpdatedSystemApp())) {
if (DEBUG) Log.v(TAG, "ignoring driver package for privileged/non-updated system app");
return;
}
ApplicationInfo driverInfo;
try {
driverInfo = context.getPackageManager().getApplicationInfo(driverPackageName,
PackageManager.MATCH_SYSTEM_ONLY);
} catch (PackageManager.NameNotFoundException e) {
Log.w(TAG, "driver package '" + driverPackageName + "' not installed");
return;
}
String abi = chooseAbi(driverInfo);
if (abi == null) {
if (DEBUG) {
// This is the normal case for the pre-installed empty driver package, don't spam
if (driverInfo.isUpdatedSystemApp()) {
Log.w(TAG, "updated driver package has no compatible native libraries");
}
}
return;
}
if (driverInfo.targetSdkVersion < Build.VERSION_CODES.O) {
// O drivers are restricted to the sphal linker namespace, so don't try to use
// packages unless they declare they're compatible with that restriction.
Log.w(TAG, "updated driver package is not known to be compatible with O");
return;
}
StringBuilder sb = new StringBuilder();
sb.append(driverInfo.nativeLibraryDir)
.append(File.pathSeparator);
sb.append(driverInfo.sourceDir)
.append("!/lib/")
.append(abi);
String paths = sb.toString();
if (DEBUG) Log.v(TAG, "gfx driver package libs: " + paths);
setDriverPath(paths);
}
/**
* Start a background thread to initialize EGL.
*
* Initializing EGL involves loading and initializing the graphics driver. Some drivers take
* several 10s of milliseconds to do this, so doing it on-demand when an app tries to render
* its first frame adds directly to user-visible app launch latency. By starting it earlier
* on a separate thread, it can usually be finished well before the UI is ready to be drawn.
*
* Should only be called after chooseDriver().
*/
public static void earlyInitEGL() {
Thread eglInitThread = new Thread(
() -> {
EGL14.eglGetDisplay(EGL14.EGL_DEFAULT_DISPLAY);
},
"EGL Init");
eglInitThread.start();
}
private static String chooseAbi(ApplicationInfo ai) {
String isa = VMRuntime.getCurrentInstructionSet();
if (ai.primaryCpuAbi != null &&
isa.equals(VMRuntime.getInstructionSet(ai.primaryCpuAbi))) {
return ai.primaryCpuAbi;
}
if (ai.secondaryCpuAbi != null &&
isa.equals(VMRuntime.getInstructionSet(ai.secondaryCpuAbi))) {
return ai.secondaryCpuAbi;
}
return null;
}
private static native void setLayerPaths(ClassLoader classLoader, String layerPaths);
private static native void setDebugLayers(String layers);
private static native void setDriverPath(String path);
}
|
