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
|
package com.mapbox.mapboxsdk.maps.renderer;
import android.content.Context;
import android.support.annotation.CallSuper;
import android.support.annotation.Keep;
import android.support.annotation.NonNull;
import com.mapbox.mapboxsdk.LibraryLoader;
import com.mapbox.mapboxsdk.log.Logger;
import com.mapbox.mapboxsdk.maps.MapboxMap;
import com.mapbox.mapboxsdk.storage.FileSource;
import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.opengles.GL10;
/**
* The {@link MapRenderer} encapsulates the GL thread.
* <p>
* Performs actions on the GL thread to manage the GL resources and
* render on the one end and acts as a scheduler to request work to
* be performed on the GL thread on the other.
*/
@Keep
public abstract class MapRenderer implements MapRendererScheduler {
static {
LibraryLoader.load();
}
private static final String TAG = "Mbgl-MapRenderer";
// Holds the pointer to the native peer after initialisation
private long nativePtr = 0;
private double expectedRenderTime = 0;
private MapboxMap.OnFpsChangedListener onFpsChangedListener;
public MapRenderer(@NonNull Context context, String localIdeographFontFamily) {
float pixelRatio = context.getResources().getDisplayMetrics().density;
String programCacheDir = FileSource.getInternalCachePath(context);
// Initialise native peer
nativeInitialize(this, pixelRatio, programCacheDir, localIdeographFontFamily);
}
public void onStart() {
// Implement if needed
}
public void onPause() {
// Implement if needed
}
public void onResume() {
// Implement if needed
}
public void onStop() {
// Implement if needed
}
public void onDestroy() {
// Implement if needed
}
public void setOnFpsChangedListener(MapboxMap.OnFpsChangedListener listener) {
onFpsChangedListener = listener;
}
@CallSuper
protected void onSurfaceCreated(GL10 gl, EGLConfig config) {
nativeOnSurfaceCreated();
}
@CallSuper
protected void onSurfaceChanged(@NonNull GL10 gl, int width, int height) {
gl.glViewport(0, 0, width, height);
nativeOnSurfaceChanged(width, height);
}
@CallSuper
protected void onSurfaceDestroyed() {
nativeOnSurfaceDestroyed();
}
@CallSuper
protected void onDrawFrame(GL10 gl) {
long startTime = System.nanoTime();
try {
nativeRender();
} catch (java.lang.Error error) {
Logger.e(TAG, error.getMessage());
}
long renderTime = System.nanoTime() - startTime;
if (renderTime < expectedRenderTime) {
try {
Thread.sleep((long) ((expectedRenderTime - renderTime) / 1E6));
} catch (InterruptedException ex) {
Logger.e(TAG, ex.getMessage());
}
}
if (onFpsChangedListener != null) {
updateFps();
}
}
/**
* May be called from any thread.
* <p>
* Called from the native peer to schedule work on the GL
* thread. Explicit override for easier to read jni code.
*
* @param runnable the runnable to execute
* @see MapRendererRunnable
*/
@CallSuper
void queueEvent(MapRendererRunnable runnable) {
this.queueEvent((Runnable) runnable);
}
private native void nativeInitialize(MapRenderer self,
float pixelRatio,
String programCacheDir,
String localIdeographFontFamily);
@CallSuper
@Override
protected native void finalize() throws Throwable;
private native void nativeOnSurfaceCreated();
private native void nativeOnSurfaceChanged(int width, int height);
private native void nativeOnSurfaceDestroyed();
protected native void nativeReset();
private native void nativeRender();
private long timeElapsed;
private void updateFps() {
long currentTime = System.nanoTime();
double fps = 1E9 / ((currentTime - timeElapsed));
onFpsChangedListener.onFpsChanged(fps);
timeElapsed = currentTime;
}
/**
* The max frame rate at which this render is rendered,
* but it can't excess the ability of device hardware.
*
* @param maximumFps Can be set to arbitrary integer values.
*/
public void setMaximumFps(int maximumFps) {
if (maximumFps <= 0) {
// Not valid, just return
return;
}
expectedRenderTime = 1E9 / maximumFps;
}
}
|
