Merge "Create abstract base class for OpenGLRenderer"
diff --git a/core/java/android/hardware/camera2/CaptureRequest.java b/core/java/android/hardware/camera2/CaptureRequest.java
index 0c5ba67..28341d9 100644
--- a/core/java/android/hardware/camera2/CaptureRequest.java
+++ b/core/java/android/hardware/camera2/CaptureRequest.java
@@ -954,14 +954,14 @@
/**
* <p>Whether black-level compensation is locked
- * to its current values, or is free to vary</p>
+ * to its current values, or is free to vary.</p>
* <p>When set to ON, the values used for black-level
- * compensation must not change until the lock is set to
- * OFF</p>
+ * compensation will not change until the lock is set to
+ * OFF.</p>
* <p>Since changes to certain capture parameters (such as
* exposure time) may require resetting of black level
- * compensation, the HAL must report whether setting the
- * black level lock was successful in the output result
+ * compensation, the camera device must report whether setting
+ * the black level lock was successful in the output result
* metadata.</p>
* <p>For example, if a sequence of requests is as follows:</p>
* <ul>
@@ -972,8 +972,9 @@
* <li>Request 5: Exposure = 20ms, Black level lock = ON</li>
* <li>Request 6: Exposure = 20ms, Black level lock = ON</li>
* </ul>
- * <p>And the exposure change in Request 4 requires resetting the black
- * level offsets, then the output result metadata is expected to be:</p>
+ * <p>And the exposure change in Request 4 requires the camera
+ * device to reset the black level offsets, then the output
+ * result metadata is expected to be:</p>
* <ul>
* <li>Result 1: Exposure = 10ms, Black level lock = OFF</li>
* <li>Result 2: Exposure = 10ms, Black level lock = ON</li>
@@ -982,15 +983,13 @@
* <li>Result 5: Exposure = 20ms, Black level lock = ON</li>
* <li>Result 6: Exposure = 20ms, Black level lock = ON</li>
* </ul>
- * <p>This indicates to the application that on frame 4, black levels were
- * reset due to exposure value changes, and pixel values may not be
- * consistent across captures.</p>
- * <p>The black level locking must happen at the sensor, and not at the ISP.
- * If for some reason black level locking is no longer legal (for example,
- * the analog gain has changed, which forces black levels to be
- * recalculated), then the HAL is free to override this request (and it
- * must report 'OFF' when this does happen) until the next time locking
- * is legal again.</p>
+ * <p>This indicates to the application that on frame 4, black
+ * levels were reset due to exposure value changes, and pixel
+ * values may not be consistent across captures.</p>
+ * <p>The camera device will maintain the lock to the extent
+ * possible, only overriding the lock to OFF when changes to
+ * other request parameters require a black level recalculation
+ * or reset.</p>
*/
public static final Key<Boolean> BLACK_LEVEL_LOCK =
new Key<Boolean>("android.blackLevel.lock", boolean.class);
diff --git a/core/java/android/hardware/camera2/CaptureResult.java b/core/java/android/hardware/camera2/CaptureResult.java
index a892fbe..dab4bcf 100644
--- a/core/java/android/hardware/camera2/CaptureResult.java
+++ b/core/java/android/hardware/camera2/CaptureResult.java
@@ -853,10 +853,11 @@
/**
* <p>Whether black-level compensation is locked
- * to its current values, or is free to vary</p>
- * <p>Whether the black level offset was locked for this frame.
- * Should be ON if android.blackLevel.lock was ON in the capture request,
- * unless a change in capture settings forced a black level reset.</p>
+ * to its current values, or is free to vary.</p>
+ * <p>Whether the black level offset was locked for this frame. Should be
+ * ON if android.blackLevel.lock was ON in the capture request, unless
+ * a change in other capture settings forced the camera device to
+ * perform a black level reset.</p>
*/
public static final Key<Boolean> BLACK_LEVEL_LOCK =
new Key<Boolean>("android.blackLevel.lock", boolean.class);
diff --git a/core/jni/android_view_DisplayList.cpp b/core/jni/android_view_DisplayList.cpp
index a1f5ffc..1778a83 100644
--- a/core/jni/android_view_DisplayList.cpp
+++ b/core/jni/android_view_DisplayList.cpp
@@ -42,17 +42,20 @@
// ----------------------------------------------------------------------------
static void android_view_DisplayList_reset(JNIEnv* env,
- jobject clazz, DisplayList* displayList) {
+ jobject clazz, jint displayListPtr) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->reset();
}
static jint android_view_DisplayList_getDisplayListSize(JNIEnv* env,
- jobject clazz, DisplayList* displayList) {
+ jobject clazz, jint displayListPtr) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
return displayList->getSize();
}
static void android_view_DisplayList_setDisplayListName(JNIEnv* env,
- jobject clazz, DisplayList* displayList, jstring name) {
+ jobject clazz, jint displayListPtr, jstring name) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
if (name != NULL) {
const char* textArray = env->GetStringUTFChars(name, NULL);
displayList->setName(textArray);
@@ -61,12 +64,14 @@
}
static void android_view_DisplayList_output(JNIEnv* env,
- jobject clazz, DisplayList* displayList) {
+ jobject clazz, jint displayListPtr) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->output();
}
static void android_view_DisplayList_destroyDisplayList(JNIEnv* env,
- jobject clazz, DisplayList* displayList) {
+ jobject clazz, jint displayListPtr) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
DisplayList::destroyDisplayListDeferred(displayList);
}
@@ -75,84 +80,102 @@
// ----------------------------------------------------------------------------
static void android_view_DisplayList_setCaching(JNIEnv* env,
- jobject clazz, DisplayList* displayList, jboolean caching) {
+ jobject clazz, jint displayListPtr, jboolean caching) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setCaching(caching);
}
static void android_view_DisplayList_setStaticMatrix(JNIEnv* env,
- jobject clazz, DisplayList* displayList, SkMatrix* matrix) {
+ jobject clazz, jint displayListPtr, jint matrixPtr) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
+ SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixPtr);
displayList->setStaticMatrix(matrix);
}
static void android_view_DisplayList_setAnimationMatrix(JNIEnv* env,
- jobject clazz, DisplayList* displayList, SkMatrix* matrix) {
+ jobject clazz, jint displayListPtr, jint matrixPtr) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
+ SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixPtr);
displayList->setAnimationMatrix(matrix);
}
static void android_view_DisplayList_setClipToBounds(JNIEnv* env,
- jobject clazz, DisplayList* displayList, jboolean clipToBounds) {
+ jobject clazz, jint displayListPtr, jboolean clipToBounds) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setClipToBounds(clipToBounds);
}
static void android_view_DisplayList_setIsContainedVolume(JNIEnv* env,
- jobject clazz, DisplayList* displayList, jboolean isContainedVolume) {
+ jobject clazz, jint displayListPtr, jboolean isContainedVolume) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setIsContainedVolume(isContainedVolume);
}
static void android_view_DisplayList_setAlpha(JNIEnv* env,
- jobject clazz, DisplayList* displayList, float alpha) {
+ jobject clazz, jint displayListPtr, float alpha) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setAlpha(alpha);
}
static void android_view_DisplayList_setHasOverlappingRendering(JNIEnv* env,
- jobject clazz, DisplayList* displayList, bool hasOverlappingRendering) {
+ jobject clazz, jint displayListPtr, bool hasOverlappingRendering) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setHasOverlappingRendering(hasOverlappingRendering);
}
static void android_view_DisplayList_setTranslationX(JNIEnv* env,
- jobject clazz, DisplayList* displayList, float tx) {
+ jobject clazz, jint displayListPtr, float tx) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setTranslationX(tx);
}
static void android_view_DisplayList_setTranslationY(JNIEnv* env,
- jobject clazz, DisplayList* displayList, float ty) {
+ jobject clazz, jint displayListPtr, float ty) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setTranslationY(ty);
}
static void android_view_DisplayList_setTranslationZ(JNIEnv* env,
- jobject clazz, DisplayList* displayList, float tz) {
+ jobject clazz, jint displayListPtr, float tz) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setTranslationZ(tz);
}
static void android_view_DisplayList_setRotation(JNIEnv* env,
- jobject clazz, DisplayList* displayList, float rotation) {
+ jobject clazz, jint displayListPtr, float rotation) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setRotation(rotation);
}
static void android_view_DisplayList_setRotationX(JNIEnv* env,
- jobject clazz, DisplayList* displayList, float rx) {
+ jobject clazz, jint displayListPtr, float rx) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setRotationX(rx);
}
static void android_view_DisplayList_setRotationY(JNIEnv* env,
- jobject clazz, DisplayList* displayList, float ry) {
+ jobject clazz, jint displayListPtr, float ry) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setRotationY(ry);
}
static void android_view_DisplayList_setScaleX(JNIEnv* env,
- jobject clazz, DisplayList* displayList, float sx) {
+ jobject clazz, jint displayListPtr, float sx) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setScaleX(sx);
}
static void android_view_DisplayList_setScaleY(JNIEnv* env,
- jobject clazz, DisplayList* displayList, float sy) {
+ jobject clazz, jint displayListPtr, float sy) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setScaleY(sy);
}
static void android_view_DisplayList_setTransformationInfo(JNIEnv* env,
- jobject clazz, DisplayList* displayList, float alpha,
+ jobject clazz, jint displayListPtr, float alpha,
float translationX, float translationY, float translationZ,
float rotation, float rotationX, float rotationY, float scaleX, float scaleY) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setAlpha(alpha);
displayList->setTranslationX(translationX);
displayList->setTranslationY(translationY);
@@ -165,58 +188,70 @@
}
static void android_view_DisplayList_setPivotX(JNIEnv* env,
- jobject clazz, DisplayList* displayList, float px) {
+ jobject clazz, jint displayListPtr, float px) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setPivotX(px);
}
static void android_view_DisplayList_setPivotY(JNIEnv* env,
- jobject clazz, DisplayList* displayList, float py) {
+ jobject clazz, jint displayListPtr, float py) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setPivotY(py);
}
static void android_view_DisplayList_setCameraDistance(JNIEnv* env,
- jobject clazz, DisplayList* displayList, float distance) {
+ jobject clazz, jint displayListPtr, float distance) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setCameraDistance(distance);
}
static void android_view_DisplayList_setLeft(JNIEnv* env,
- jobject clazz, DisplayList* displayList, int left) {
+ jobject clazz, jint displayListPtr, int left) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setLeft(left);
}
static void android_view_DisplayList_setTop(JNIEnv* env,
- jobject clazz, DisplayList* displayList, int top) {
+ jobject clazz, jint displayListPtr, int top) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setTop(top);
}
static void android_view_DisplayList_setRight(JNIEnv* env,
- jobject clazz, DisplayList* displayList, int right) {
+ jobject clazz, jint displayListPtr, int right) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setRight(right);
}
static void android_view_DisplayList_setBottom(JNIEnv* env,
- jobject clazz, DisplayList* displayList, int bottom) {
+ jobject clazz, jint displayListPtr, int bottom) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setBottom(bottom);
}
static void android_view_DisplayList_setLeftTopRightBottom(JNIEnv* env,
- jobject clazz, DisplayList* displayList, int left, int top,
+ jobject clazz, jint displayListPtr, int left, int top,
int right, int bottom) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->setLeftTopRightBottom(left, top, right, bottom);
}
static void android_view_DisplayList_offsetLeftAndRight(JNIEnv* env,
- jobject clazz, DisplayList* displayList, float offset) {
+ jobject clazz, jint displayListPtr, float offset) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->offsetLeftRight(offset);
}
static void android_view_DisplayList_offsetTopAndBottom(JNIEnv* env,
- jobject clazz, DisplayList* displayList, float offset) {
+ jobject clazz, jint displayListPtr, float offset) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
displayList->offsetTopBottom(offset);
}
static void android_view_DisplayList_getMatrix(JNIEnv* env,
- jobject clazz, DisplayList* displayList, SkMatrix* matrix) {
+ jobject clazz, jint displayListPtr, jint matrixPtr) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
+ SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixPtr);
SkMatrix* source = displayList->getStaticMatrix();
if (source) {
matrix->setConcat(SkMatrix::I(), *source);
@@ -226,82 +261,98 @@
}
static jboolean android_view_DisplayList_hasOverlappingRendering(JNIEnv* env,
- jobject clazz, DisplayList* displayList) {
+ jobject clazz, jint displayListPtr) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
return displayList->hasOverlappingRendering();
}
static jfloat android_view_DisplayList_getAlpha(JNIEnv* env,
- jobject clazz, DisplayList* displayList) {
+ jobject clazz, jint displayListPtr) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
return displayList->getAlpha();
}
static jfloat android_view_DisplayList_getLeft(JNIEnv* env,
- jobject clazz, DisplayList* displayList) {
+ jobject clazz, jint displayListPtr) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
return displayList->getLeft();
}
static jfloat android_view_DisplayList_getTop(JNIEnv* env,
- jobject clazz, DisplayList* displayList) {
+ jobject clazz, jint displayListPtr) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
return displayList->getTop();
}
static jfloat android_view_DisplayList_getRight(JNIEnv* env,
- jobject clazz, DisplayList* displayList) {
+ jobject clazz, jint displayListPtr) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
return displayList->getRight();
}
static jfloat android_view_DisplayList_getBottom(JNIEnv* env,
- jobject clazz, DisplayList* displayList) {
+ jobject clazz, jint displayListPtr) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
return displayList->getBottom();
}
static jfloat android_view_DisplayList_getCameraDistance(JNIEnv* env,
- jobject clazz, DisplayList* displayList) {
+ jobject clazz, jint displayListPtr) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
return displayList->getCameraDistance();
}
static jfloat android_view_DisplayList_getScaleX(JNIEnv* env,
- jobject clazz, DisplayList* displayList) {
+ jobject clazz, jint displayListPtr) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
return displayList->getScaleX();
}
static jfloat android_view_DisplayList_getScaleY(JNIEnv* env,
- jobject clazz, DisplayList* displayList) {
+ jobject clazz, jint displayListPtr) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
return displayList->getScaleY();
}
static jfloat android_view_DisplayList_getTranslationX(JNIEnv* env,
- jobject clazz, DisplayList* displayList) {
+ jobject clazz, jint displayListPtr) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
return displayList->getTranslationX();
}
static jfloat android_view_DisplayList_getTranslationY(JNIEnv* env,
- jobject clazz, DisplayList* displayList) {
+ jobject clazz, jint displayListPtr) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
return displayList->getTranslationY();
}
static jfloat android_view_DisplayList_getRotation(JNIEnv* env,
- jobject clazz, DisplayList* displayList) {
+ jobject clazz, jint displayListPtr) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
return displayList->getRotation();
}
static jfloat android_view_DisplayList_getRotationX(JNIEnv* env,
- jobject clazz, DisplayList* displayList) {
+ jobject clazz, jint displayListPtr) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
return displayList->getRotationX();
}
static jfloat android_view_DisplayList_getRotationY(JNIEnv* env,
- jobject clazz, DisplayList* displayList) {
+ jobject clazz, jint displayListPtr) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
return displayList->getRotationY();
}
static jfloat android_view_DisplayList_getPivotX(JNIEnv* env,
- jobject clazz, DisplayList* displayList) {
+ jobject clazz, jint displayListPtr) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
return displayList->getPivotX();
}
static jfloat android_view_DisplayList_getPivotY(JNIEnv* env,
- jobject clazz, DisplayList* displayList) {
+ jobject clazz, jint displayListPtr) {
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
return displayList->getPivotY();
}
diff --git a/core/jni/android_view_GLES20Canvas.cpp b/core/jni/android_view_GLES20Canvas.cpp
index d02ab81..b0b5a5c 100644
--- a/core/jni/android_view_GLES20Canvas.cpp
+++ b/core/jni/android_view_GLES20Canvas.cpp
@@ -132,15 +132,16 @@
// Constructors
// ----------------------------------------------------------------------------
-static OpenGLRenderer* android_view_GLES20Canvas_createRenderer(JNIEnv* env, jobject clazz) {
+static jint android_view_GLES20Canvas_createRenderer(JNIEnv* env, jobject clazz) {
RENDERER_LOGD("Create OpenGLRenderer");
OpenGLRenderer* renderer = new OpenGLRenderer();
renderer->initProperties();
- return renderer;
+ return reinterpret_cast<jint>(renderer);
}
static void android_view_GLES20Canvas_destroyRenderer(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer) {
+ jint rendererPtr) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
RENDERER_LOGD("Destroy OpenGLRenderer");
delete renderer;
}
@@ -150,23 +151,27 @@
// ----------------------------------------------------------------------------
static void android_view_GLES20Canvas_setViewport(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, jint width, jint height) {
+ jint rendererPtr, jint width, jint height) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
renderer->setViewport(width, height);
}
static int android_view_GLES20Canvas_prepare(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, jboolean opaque) {
+ jint rendererPtr, jboolean opaque) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
return renderer->prepare(opaque);
}
static int android_view_GLES20Canvas_prepareDirty(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, jint left, jint top, jint right, jint bottom,
+ jint rendererPtr, jint left, jint top, jint right, jint bottom,
jboolean opaque) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
return renderer->prepareDirty(left, top, right, bottom, opaque);
}
static void android_view_GLES20Canvas_finish(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer) {
+ jint rendererPtr) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
renderer->finish();
}
@@ -175,7 +180,8 @@
}
static void android_view_GLES20Canvas_setName(JNIEnv* env,
- jobject clazz, OpenGLRenderer* renderer, jstring name) {
+ jobject clazz, jint rendererPtr, jstring name) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
if (name != NULL) {
const char* textArray = env->GetStringUTFChars(name, NULL);
renderer->setName(textArray);
@@ -204,12 +210,14 @@
}
static void android_view_GLES20Canvas_setCountOverdrawEnabled(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, jboolean enabled) {
+ jint rendererPtr, jboolean enabled) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
renderer->setCountOverdrawEnabled(enabled);
}
static jfloat android_view_GLES20Canvas_getOverdraw(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer) {
+ jint rendererPtr) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
return renderer->getOverdraw();
}
@@ -218,23 +226,30 @@
// ----------------------------------------------------------------------------
static jint android_view_GLES20Canvas_callDrawGLFunction(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, Functor* functor) {
+ jint rendererPtr, jint functorPtr) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
+ Functor* functor = reinterpret_cast<Functor*>(functorPtr);
android::uirenderer::Rect dirty;
return renderer->callDrawGLFunction(functor, dirty);
}
static void android_view_GLES20Canvas_detachFunctor(JNIEnv* env,
- jobject clazz, OpenGLRenderer* renderer, Functor* functor) {
+ jobject clazz, jint rendererPtr, jint functorPtr) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
+ Functor* functor = reinterpret_cast<Functor*>(functorPtr);
renderer->detachFunctor(functor);
}
static void android_view_GLES20Canvas_attachFunctor(JNIEnv* env,
- jobject clazz, OpenGLRenderer* renderer, Functor* functor) {
+ jobject clazz, jint rendererPtr, jint functorPtr) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
+ Functor* functor = reinterpret_cast<Functor*>(functorPtr);
renderer->attachFunctor(functor);
}
static jint android_view_GLES20Canvas_invokeFunctors(JNIEnv* env,
- jobject clazz, OpenGLRenderer* renderer, jobject dirty) {
+ jobject clazz, jint rendererPtr, jobject dirty) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
android::uirenderer::Rect bounds;
status_t status = renderer->invokeFunctors(bounds);
if (status != DrawGlInfo::kStatusDone && dirty != NULL) {
@@ -260,23 +275,27 @@
// State
// ----------------------------------------------------------------------------
-static jint android_view_GLES20Canvas_save(JNIEnv* env, jobject clazz, OpenGLRenderer* renderer,
+static jint android_view_GLES20Canvas_save(JNIEnv* env, jobject clazz, jint rendererPtr,
jint flags) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
return renderer->save(flags);
}
static jint android_view_GLES20Canvas_getSaveCount(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer) {
+ jint rendererPtr) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
return renderer->getSaveCount();
}
static void android_view_GLES20Canvas_restore(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer) {
+ jint rendererPtr) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
renderer->restore();
}
static void android_view_GLES20Canvas_restoreToCount(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, jint saveCount) {
+ jint rendererPtr, jint saveCount) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
renderer->restoreToCount(saveCount);
}
@@ -285,26 +304,32 @@
// ----------------------------------------------------------------------------
static jint android_view_GLES20Canvas_saveLayer(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, jfloat left, jfloat top, jfloat right, jfloat bottom,
- SkPaint* paint, jint saveFlags) {
+ jint rendererPtr, jfloat left, jfloat top, jfloat right, jfloat bottom,
+ jint paintPtr, jint saveFlags) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
+ SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
return renderer->saveLayer(left, top, right, bottom, paint, saveFlags);
}
static jint android_view_GLES20Canvas_saveLayerClip(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, SkPaint* paint, jint saveFlags) {
+ jint rendererPtr, jint paintPtr, jint saveFlags) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
+ SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
const android::uirenderer::Rect& bounds(renderer->getClipBounds());
return renderer->saveLayer(bounds.left, bounds.top, bounds.right, bounds.bottom,
paint, saveFlags);
}
static jint android_view_GLES20Canvas_saveLayerAlpha(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, jfloat left, jfloat top, jfloat right, jfloat bottom,
+ jint rendererPtr, jfloat left, jfloat top, jfloat right, jfloat bottom,
jint alpha, jint saveFlags) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
return renderer->saveLayerAlpha(left, top, right, bottom, alpha, saveFlags);
}
static jint android_view_GLES20Canvas_saveLayerAlphaClip(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, jint alpha, jint saveFlags) {
+ jint rendererPtr, jint alpha, jint saveFlags) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
const android::uirenderer::Rect& bounds(renderer->getClipBounds());
return renderer->saveLayerAlpha(bounds.left, bounds.top, bounds.right, bounds.bottom,
alpha, saveFlags);
@@ -315,34 +340,42 @@
// ----------------------------------------------------------------------------
static bool android_view_GLES20Canvas_quickReject(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, jfloat left, jfloat top, jfloat right, jfloat bottom) {
+ jint rendererPtr, jfloat left, jfloat top, jfloat right, jfloat bottom) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
return renderer->quickRejectConservative(left, top, right, bottom);
}
static bool android_view_GLES20Canvas_clipRectF(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, jfloat left, jfloat top, jfloat right, jfloat bottom,
+ jint rendererPtr, jfloat left, jfloat top, jfloat right, jfloat bottom,
SkRegion::Op op) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
return renderer->clipRect(left, top, right, bottom, op);
}
static bool android_view_GLES20Canvas_clipRect(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, jint left, jint top, jint right, jint bottom,
+ jint rendererPtr, jint left, jint top, jint right, jint bottom,
SkRegion::Op op) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
return renderer->clipRect(float(left), float(top), float(right), float(bottom), op);
}
static bool android_view_GLES20Canvas_clipPath(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, SkPath* path, SkRegion::Op op) {
+ jint rendererPtr, jint pathPtr, SkRegion::Op op) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
+ SkPath* path = reinterpret_cast<SkPath*>(pathPtr);
return renderer->clipPath(path, op);
}
static bool android_view_GLES20Canvas_clipRegion(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, SkRegion* region, SkRegion::Op op) {
+ jint rendererPtr, jint regionPtr, SkRegion::Op op) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
+ SkRegion* region = reinterpret_cast<SkRegion*>(regionPtr);
return renderer->clipRegion(region, op);
}
static bool android_view_GLES20Canvas_getClipBounds(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, jobject rect) {
+ jint rendererPtr, jobject rect) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
const android::uirenderer::Rect& bounds(renderer->getClipBounds());
env->CallVoidMethod(rect, gRectClassInfo.set,
@@ -356,37 +389,47 @@
// ----------------------------------------------------------------------------
static void android_view_GLES20Canvas_translate(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, jfloat dx, jfloat dy) {
+ jint rendererPtr, jfloat dx, jfloat dy) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
renderer->translate(dx, dy);
}
static void android_view_GLES20Canvas_rotate(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, jfloat degrees) {
+ jint rendererPtr, jfloat degrees) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
renderer->rotate(degrees);
}
static void android_view_GLES20Canvas_scale(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, jfloat sx, jfloat sy) {
+ jint rendererPtr, jfloat sx, jfloat sy) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
renderer->scale(sx, sy);
}
static void android_view_GLES20Canvas_skew(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, jfloat sx, jfloat sy) {
+ jint rendererPtr, jfloat sx, jfloat sy) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
renderer->skew(sx, sy);
}
static void android_view_GLES20Canvas_setMatrix(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, SkMatrix* matrix) {
+ jint rendererPtr, jint matrixPtr) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
+ SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixPtr);
renderer->setMatrix(matrix);
}
static void android_view_GLES20Canvas_getMatrix(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, SkMatrix* matrix) {
+ jint rendererPtr, jint matrixPtr) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
+ SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixPtr);
renderer->getMatrix(matrix);
}
static void android_view_GLES20Canvas_concatMatrix(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, SkMatrix* matrix) {
+ jint rendererPtr, jint matrixPtr) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
+ SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixPtr);
renderer->concatMatrix(matrix);
}
@@ -395,37 +438,47 @@
// ----------------------------------------------------------------------------
static void android_view_GLES20Canvas_drawBitmap(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, SkBitmap* bitmap, jbyteArray buffer,
- jfloat left, jfloat top, SkPaint* paint) {
+ jint rendererPtr, jint bitmapPtr, jbyteArray buffer,
+ jfloat left, jfloat top, jint paintPtr) {
+ SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapPtr);
// This object allows the renderer to allocate a global JNI ref to the buffer object.
JavaHeapBitmapRef bitmapRef(env, bitmap, buffer);
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
+ SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
renderer->drawBitmap(bitmap, left, top, paint);
}
static void android_view_GLES20Canvas_drawBitmapRect(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, SkBitmap* bitmap, jbyteArray buffer,
+ jint rendererPtr, jint bitmapPtr, jbyteArray buffer,
float srcLeft, float srcTop, float srcRight, float srcBottom,
- float dstLeft, float dstTop, float dstRight, float dstBottom, SkPaint* paint) {
+ float dstLeft, float dstTop, float dstRight, float dstBottom, jint paintPtr) {
+ SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapPtr);
// This object allows the renderer to allocate a global JNI ref to the buffer object.
JavaHeapBitmapRef bitmapRef(env, bitmap, buffer);
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
+ SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
renderer->drawBitmap(bitmap, srcLeft, srcTop, srcRight, srcBottom,
dstLeft, dstTop, dstRight, dstBottom, paint);
}
static void android_view_GLES20Canvas_drawBitmapMatrix(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, SkBitmap* bitmap, jbyteArray buffer,
- SkMatrix* matrix, SkPaint* paint) {
+ jint rendererPtr, jint bitmapPtr, jbyteArray buffer,
+ jint matrixPtr, jint paintPtr) {
+ SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapPtr);
// This object allows the renderer to allocate a global JNI ref to the buffer object.
JavaHeapBitmapRef bitmapRef(env, bitmap, buffer);
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
+ SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixPtr);
+ SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
renderer->drawBitmap(bitmap, matrix, paint);
}
static void android_view_GLES20Canvas_drawBitmapData(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, jintArray colors, jint offset, jint stride,
- jfloat left, jfloat top, jint width, jint height, jboolean hasAlpha, SkPaint* paint) {
+ jint rendererPtr, jintArray colors, jint offset, jint stride,
+ jfloat left, jfloat top, jint width, jint height, jboolean hasAlpha, jint paintPtr) {
SkBitmap* bitmap = new SkBitmap;
bitmap->setConfig(hasAlpha ? SkBitmap::kARGB_8888_Config : SkBitmap::kRGB_565_Config,
width, height);
@@ -440,6 +493,8 @@
return;
}
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
+ SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
renderer->drawBitmapData(bitmap, left, top, paint);
// If the renderer is a deferred renderer it will own the bitmap
@@ -449,15 +504,18 @@
}
static void android_view_GLES20Canvas_drawBitmapMesh(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, SkBitmap* bitmap, jbyteArray buffer,
+ jint rendererPtr, jint bitmapPtr, jbyteArray buffer,
jint meshWidth, jint meshHeight, jfloatArray vertices, jint offset, jintArray colors,
- jint colorOffset, SkPaint* paint) {
+ jint colorOffset, jint paintPtr) {
+ SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapPtr);
// This object allows the renderer to allocate a global JNI ref to the buffer object.
JavaHeapBitmapRef bitmapRef(env, bitmap, buffer);
jfloat* verticesArray = vertices ? env->GetFloatArrayElements(vertices, NULL) + offset : NULL;
jint* colorsArray = colors ? env->GetIntArrayElements(colors, NULL) + colorOffset : NULL;
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
+ SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
renderer->drawBitmapMesh(bitmap, meshWidth, meshHeight, verticesArray, colorsArray, paint);
if (vertices) env->ReleaseFloatArrayElements(vertices, verticesArray, 0);
@@ -465,50 +523,68 @@
}
static void android_view_GLES20Canvas_drawPatch(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, SkBitmap* bitmap, jbyteArray buffer, Res_png_9patch* patch,
- float left, float top, float right, float bottom, SkPaint* paint) {
+ jint rendererPtr, jint bitmapPtr, jbyteArray buffer, jint patchPtr,
+ float left, float top, float right, float bottom, jint paintPtr) {
+ SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapPtr);
// This object allows the renderer to allocate a global JNI ref to the buffer object.
JavaHeapBitmapRef bitmapRef(env, bitmap, buffer);
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
+ Res_png_9patch* patch = reinterpret_cast<Res_png_9patch*>(patchPtr);
+ SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
renderer->drawPatch(bitmap, patch, left, top, right, bottom, paint);
}
static void android_view_GLES20Canvas_drawColor(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, jint color, SkXfermode::Mode mode) {
+ jint rendererPtr, jint color, SkXfermode::Mode mode) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
renderer->drawColor(color, mode);
}
static void android_view_GLES20Canvas_drawRect(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, jfloat left, jfloat top, jfloat right, jfloat bottom,
- SkPaint* paint) {
+ jint rendererPtr, jfloat left, jfloat top, jfloat right, jfloat bottom,
+ jint paintPtr) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
+ SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
renderer->drawRect(left, top, right, bottom, paint);
}
static void android_view_GLES20Canvas_drawRoundRect(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, jfloat left, jfloat top, jfloat right, jfloat bottom,
- jfloat rx, jfloat ry, SkPaint* paint) {
+ jint rendererPtr, jfloat left, jfloat top, jfloat right, jfloat bottom,
+ jfloat rx, jfloat ry, jint paintPtr) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
+ SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
renderer->drawRoundRect(left, top, right, bottom, rx, ry, paint);
}
static void android_view_GLES20Canvas_drawCircle(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, jfloat x, jfloat y, jfloat radius, SkPaint* paint) {
+ jint rendererPtr, jfloat x, jfloat y, jfloat radius, jint paintPtr) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
+ SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
renderer->drawCircle(x, y, radius, paint);
}
static void android_view_GLES20Canvas_drawOval(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, jfloat left, jfloat top, jfloat right, jfloat bottom,
- SkPaint* paint) {
+ jint rendererPtr, jfloat left, jfloat top, jfloat right, jfloat bottom,
+ jint paintPtr) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
+ SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
renderer->drawOval(left, top, right, bottom, paint);
}
static void android_view_GLES20Canvas_drawArc(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, jfloat left, jfloat top, jfloat right, jfloat bottom,
- jfloat startAngle, jfloat sweepAngle, jboolean useCenter, SkPaint* paint) {
+ jint rendererPtr, jfloat left, jfloat top, jfloat right, jfloat bottom,
+ jfloat startAngle, jfloat sweepAngle, jboolean useCenter, jint paintPtr) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
+ SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
renderer->drawArc(left, top, right, bottom, startAngle, sweepAngle, useCenter, paint);
}
static void android_view_GLES20Canvas_drawRegionAsRects(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, SkRegion* region, SkPaint* paint) {
+ jint rendererPtr, jint regionPtr, jint paintPtr) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
+ SkRegion* region = reinterpret_cast<SkRegion*>(regionPtr);
+ SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
if (paint->getStyle() != SkPaint::kFill_Style ||
(paint->isAntiAlias() && !renderer->isCurrentTransformSimple())) {
SkRegion::Iterator it(*region);
@@ -535,27 +611,36 @@
}
static void android_view_GLES20Canvas_drawRects(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, jfloatArray rects, jint count, SkPaint* paint) {
+ jint rendererPtr, jfloatArray rects, jint count, jint paintPtr) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
jfloat* storage = env->GetFloatArrayElements(rects, NULL);
+ SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
renderer->drawRects(storage, count, paint);
env->ReleaseFloatArrayElements(rects, storage, 0);
}
static void android_view_GLES20Canvas_drawPoints(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, jfloatArray points, jint offset, jint count, SkPaint* paint) {
+ jint rendererPtr, jfloatArray points, jint offset, jint count, jint paintPtr) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
jfloat* storage = env->GetFloatArrayElements(points, NULL);
+ SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
renderer->drawPoints(storage + offset, count, paint);
env->ReleaseFloatArrayElements(points, storage, 0);
}
static void android_view_GLES20Canvas_drawPath(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, SkPath* path, SkPaint* paint) {
+ jint rendererPtr, jint pathPtr, jint paintPtr) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
+ SkPath* path = reinterpret_cast<SkPath*>(pathPtr);
+ SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
renderer->drawPath(path, paint);
}
static void android_view_GLES20Canvas_drawLines(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, jfloatArray points, jint offset, jint count, SkPaint* paint) {
+ jint rendererPtr, jfloatArray points, jint offset, jint count, jint paintPtr) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
jfloat* storage = env->GetFloatArrayElements(points, NULL);
+ SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
renderer->drawLines(storage + offset, count, paint);
env->ReleaseFloatArrayElements(points, storage, 0);
}
@@ -565,24 +650,30 @@
// ----------------------------------------------------------------------------
static void android_view_GLES20Canvas_resetModifiers(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, jint modifiers) {
+ jint rendererPtr, jint modifiers) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
if (modifiers & MODIFIER_SHADOW) renderer->resetShadow();
if (modifiers & MODIFIER_SHADER) renderer->resetShader();
if (modifiers & MODIFIER_COLOR_FILTER) renderer->resetColorFilter();
}
static void android_view_GLES20Canvas_setupShader(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, SkiaShader* shader) {
+ jint rendererPtr, jint shaderPtr) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
+ SkiaShader* shader = reinterpret_cast<SkiaShader*>(shaderPtr);
renderer->setupShader(shader);
}
static void android_view_GLES20Canvas_setupColorFilter(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, SkiaColorFilter* filter) {
- renderer->setupColorFilter(filter);
+ jint rendererPtr, jint colorFilterPtr) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
+ SkiaColorFilter* colorFilter = reinterpret_cast<SkiaColorFilter*>(colorFilterPtr);
+ renderer->setupColorFilter(colorFilter);
}
static void android_view_GLES20Canvas_setupShadow(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, jfloat radius, jfloat dx, jfloat dy, jint color) {
+ jint rendererPtr, jfloat radius, jfloat dx, jfloat dy, jint color) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
renderer->setupShadow(radius, dx, dy, color);
}
@@ -591,12 +682,14 @@
// ----------------------------------------------------------------------------
static void android_view_GLES20Canvas_setupPaintFilter(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, jint clearBits, jint setBits) {
+ jint rendererPtr, jint clearBits, jint setBits) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
renderer->setupPaintFilter(clearBits, setBits);
}
static void android_view_GLES20Canvas_resetPaintFilter(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer) {
+ jint rendererPtr) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
renderer->resetPaintFilter();
}
@@ -676,56 +769,76 @@
}
static void android_view_GLES20Canvas_drawTextArray(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, jcharArray text, jint index, jint count,
- jfloat x, jfloat y, jint flags, SkPaint* paint) {
+ jint rendererPtr, jcharArray text, jint index, jint count,
+ jfloat x, jfloat y, jint flags, jint paintPtr) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
jchar* textArray = env->GetCharArrayElements(text, NULL);
+ SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
+
renderText(renderer, textArray + index, count, x, y, flags, paint);
env->ReleaseCharArrayElements(text, textArray, JNI_ABORT);
}
static void android_view_GLES20Canvas_drawText(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, jstring text, jint start, jint end,
- jfloat x, jfloat y, jint flags, SkPaint* paint) {
+ jint rendererPtr, jstring text, jint start, jint end,
+ jfloat x, jfloat y, jint flags, jint paintPtr) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
const jchar* textArray = env->GetStringChars(text, NULL);
+ SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
+
renderText(renderer, textArray + start, end - start, x, y, flags, paint);
env->ReleaseStringChars(text, textArray);
}
static void android_view_GLES20Canvas_drawTextArrayOnPath(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, jcharArray text, jint index, jint count,
- SkPath* path, jfloat hOffset, jfloat vOffset, jint flags, SkPaint* paint) {
+ jint rendererPtr, jcharArray text, jint index, jint count,
+ jint pathPtr, jfloat hOffset, jfloat vOffset, jint flags, jint paintPtr) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
jchar* textArray = env->GetCharArrayElements(text, NULL);
+ SkPath* path = reinterpret_cast<SkPath*>(pathPtr);
+ SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
+
renderTextOnPath(renderer, textArray + index, count, path,
hOffset, vOffset, flags, paint);
env->ReleaseCharArrayElements(text, textArray, JNI_ABORT);
}
static void android_view_GLES20Canvas_drawTextOnPath(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, jstring text, jint start, jint end,
- SkPath* path, jfloat hOffset, jfloat vOffset, jint flags, SkPaint* paint) {
+ jint rendererPtr, jstring text, jint start, jint end,
+ jint pathPtr, jfloat hOffset, jfloat vOffset, jint flags, jint paintPtr) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
const jchar* textArray = env->GetStringChars(text, NULL);
+ SkPath* path = reinterpret_cast<SkPath*>(pathPtr);
+ SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
+
renderTextOnPath(renderer, textArray + start, end - start, path,
hOffset, vOffset, flags, paint);
env->ReleaseStringChars(text, textArray);
}
static void android_view_GLES20Canvas_drawTextRunArray(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, jcharArray text, jint index, jint count,
+ jint rendererPtr, jcharArray text, jint index, jint count,
jint contextIndex, jint contextCount, jfloat x, jfloat y, jint dirFlags,
- SkPaint* paint) {
+ jint paintPtr) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
jchar* textArray = env->GetCharArrayElements(text, NULL);
+ SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
+
renderTextRun(renderer, textArray + contextIndex, index - contextIndex,
count, contextCount, x, y, dirFlags, paint);
env->ReleaseCharArrayElements(text, textArray, JNI_ABORT);
}
static void android_view_GLES20Canvas_drawTextRun(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, jstring text, jint start, jint end,
+ jint rendererPtr, jstring text, jint start, jint end,
jint contextStart, int contextEnd, jfloat x, jfloat y, jint dirFlags,
- SkPaint* paint) {
+ jint paintPtr) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
const jchar* textArray = env->GetStringChars(text, NULL);
jint count = end - start;
jint contextCount = contextEnd - contextStart;
+ SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
+
renderTextRun(renderer, textArray + contextStart, start - contextStart,
count, contextCount, x, y, dirFlags, paint);
env->ReleaseStringChars(text, textArray);
@@ -747,10 +860,12 @@
}
static void android_view_GLES20Canvas_drawPosTextArray(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, jcharArray text, jint index, jint count,
- jfloatArray pos, SkPaint* paint) {
+ jint rendererPtr, jcharArray text, jint index, jint count,
+ jfloatArray pos, jint paintPtr) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
jchar* textArray = env->GetCharArrayElements(text, NULL);
jfloat* positions = env->GetFloatArrayElements(pos, NULL);
+ SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
renderPosText(renderer, textArray + index, count, positions, kBidi_LTR, paint);
@@ -759,10 +874,12 @@
}
static void android_view_GLES20Canvas_drawPosText(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, jstring text, jint start, jint end,
- jfloatArray pos, SkPaint* paint) {
+ jint rendererPtr, jstring text, jint start, jint end,
+ jfloatArray pos, jint paintPtr) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
const jchar* textArray = env->GetStringChars(text, NULL);
jfloat* positions = env->GetFloatArrayElements(pos, NULL);
+ SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
renderPosText(renderer, textArray + start, end - start, positions, kBidi_LTR, paint);
@@ -774,24 +891,29 @@
// Display lists
// ----------------------------------------------------------------------------
-static DisplayList* android_view_GLES20Canvas_getDisplayList(JNIEnv* env,
- jobject clazz, DisplayListRenderer* renderer, DisplayList* displayList) {
- return renderer->getDisplayList(displayList);
+static jint android_view_GLES20Canvas_getDisplayList(JNIEnv* env,
+ jobject clazz, jint rendererPtr, jint displayListPtr) {
+ DisplayListRenderer* renderer = reinterpret_cast<DisplayListRenderer*>(rendererPtr);
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
+ return reinterpret_cast<jint>(renderer->getDisplayList(displayList));
}
-static OpenGLRenderer* android_view_GLES20Canvas_createDisplayListRenderer(JNIEnv* env,
+static jint android_view_GLES20Canvas_createDisplayListRenderer(JNIEnv* env,
jobject clazz) {
- return new DisplayListRenderer;
+ return reinterpret_cast<jint>(new DisplayListRenderer);
}
static void android_view_GLES20Canvas_resetDisplayListRenderer(JNIEnv* env,
- jobject clazz, DisplayListRenderer* renderer) {
+ jobject clazz, jint rendererPtr) {
+ DisplayListRenderer* renderer = reinterpret_cast<DisplayListRenderer*>(rendererPtr);
renderer->reset();
}
static jint android_view_GLES20Canvas_drawDisplayList(JNIEnv* env,
- jobject clazz, OpenGLRenderer* renderer, DisplayList* displayList,
+ jobject clazz, jint rendererPtr, jint displayListPtr,
jobject dirty, jint flags) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
android::uirenderer::Rect bounds;
status_t status = renderer->drawDisplayList(displayList, bounds, flags);
if (status != DrawGlInfo::kStatusDone && dirty != NULL) {
@@ -806,26 +928,29 @@
// ----------------------------------------------------------------------------
static void android_view_GLES20Canvas_interrupt(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer) {
+ jint rendererPtr) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
renderer->interrupt();
}
static void android_view_GLES20Canvas_resume(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer) {
+ jint rendererPtr) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
renderer->resume();
}
-static OpenGLRenderer* android_view_GLES20Canvas_createLayerRenderer(JNIEnv* env,
- jobject clazz, Layer* layer) {
+static jint android_view_GLES20Canvas_createLayerRenderer(JNIEnv* env,
+ jobject clazz, jint layerPtr) {
+ Layer* layer = reinterpret_cast<Layer*>(layerPtr);
if (layer) {
OpenGLRenderer* renderer = new LayerRenderer(layer);
renderer->initProperties();
- return renderer;
+ return reinterpret_cast<jint>(renderer);
}
return NULL;
}
-static Layer* android_view_GLES20Canvas_createTextureLayer(JNIEnv* env, jobject clazz,
+static jint android_view_GLES20Canvas_createTextureLayer(JNIEnv* env, jobject clazz,
jboolean isOpaque, jintArray layerInfo) {
Layer* layer = LayerRenderer::createTextureLayer(isOpaque);
@@ -835,10 +960,10 @@
env->ReleaseIntArrayElements(layerInfo, storage, 0);
}
- return layer;
+ return reinterpret_cast<jint>(layer);
}
-static Layer* android_view_GLES20Canvas_createLayer(JNIEnv* env, jobject clazz,
+static jint android_view_GLES20Canvas_createLayer(JNIEnv* env, jobject clazz,
jint width, jint height, jboolean isOpaque, jintArray layerInfo) {
Layer* layer = LayerRenderer::createLayer(width, height, isOpaque);
@@ -849,11 +974,12 @@
env->ReleaseIntArrayElements(layerInfo, storage, 0);
}
- return layer;
+ return reinterpret_cast<jint>(layer);
}
static bool android_view_GLES20Canvas_resizeLayer(JNIEnv* env, jobject clazz,
- Layer* layer, jint width, jint height, jintArray layerInfo) {
+ jint layerPtr, jint width, jint height, jintArray layerInfo) {
+ Layer* layer = reinterpret_cast<Layer*>(layerPtr);
if (LayerRenderer::resizeLayer(layer, width, height)) {
jint* storage = env->GetIntArrayElements(layerInfo, NULL);
storage[0] = layer->getWidth();
@@ -865,28 +991,33 @@
}
static void android_view_GLES20Canvas_setLayerPaint(JNIEnv* env, jobject clazz,
- Layer* layer, SkPaint* paint) {
+ jint layerPtr, jint paintPtr) {
+ Layer* layer = reinterpret_cast<Layer*>(layerPtr);
if (layer) {
+ SkPaint* paint = reinterpret_cast<SkPaint*>(paintPtr);
layer->setPaint(paint);
}
}
static void android_view_GLES20Canvas_setLayerColorFilter(JNIEnv* env, jobject clazz,
- Layer* layer, SkiaColorFilter* colorFilter) {
+ jint layerPtr, jint colorFilterPtr) {
+ Layer* layer = reinterpret_cast<Layer*>(layerPtr);
if (layer) {
+ SkiaColorFilter* colorFilter = reinterpret_cast<SkiaColorFilter*>(colorFilterPtr);
layer->setColorFilter(colorFilter);
}
}
static void android_view_GLES20Canvas_setOpaqueLayer(JNIEnv* env, jobject clazz,
- Layer* layer, jboolean isOpaque) {
+ jint layerPtr, jboolean isOpaque) {
+ Layer* layer = reinterpret_cast<Layer*>(layerPtr);
if (layer) {
layer->setBlend(!isOpaque);
}
}
static void android_view_GLES20Canvas_updateTextureLayer(JNIEnv* env, jobject clazz,
- Layer* layer, jint width, jint height, jboolean isOpaque, jobject surface) {
+ jint layerPtr, jint width, jint height, jboolean isOpaque, jobject surface) {
float transform[16];
sp<GLConsumer> surfaceTexture(SurfaceTexture_getSurfaceTexture(env, surface));
@@ -911,62 +1042,81 @@
surfaceTexture->getTransformMatrix(transform);
GLenum renderTarget = surfaceTexture->getCurrentTextureTarget();
+ Layer* layer = reinterpret_cast<Layer*>(layerPtr);
LayerRenderer::updateTextureLayer(layer, width, height, isOpaque, renderTarget, transform);
}
}
static void android_view_GLES20Canvas_updateRenderLayer(JNIEnv* env, jobject clazz,
- Layer* layer, OpenGLRenderer* renderer, DisplayList* displayList,
+ jint layerPtr, jint rendererPtr, jint displayListPtr,
jint left, jint top, jint right, jint bottom) {
+ Layer* layer = reinterpret_cast<Layer*>(layerPtr);
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
+ DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
layer->updateDeferred(renderer, displayList, left, top, right, bottom);
}
static void android_view_GLES20Canvas_clearLayerTexture(JNIEnv* env, jobject clazz,
- Layer* layer) {
+ jint layerPtr) {
+ Layer* layer = reinterpret_cast<Layer*>(layerPtr);
layer->clearTexture();
}
static void android_view_GLES20Canvas_setTextureLayerTransform(JNIEnv* env, jobject clazz,
- Layer* layer, SkMatrix* matrix) {
+ jint layerPtr, jint matrixPtr) {
+ Layer* layer = reinterpret_cast<Layer*>(layerPtr);
+ SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixPtr);
layer->getTransform().load(*matrix);
}
-static void android_view_GLES20Canvas_destroyLayer(JNIEnv* env, jobject clazz, Layer* layer) {
+static void android_view_GLES20Canvas_destroyLayer(JNIEnv* env, jobject clazz, jint layerPtr) {
+ Layer* layer = reinterpret_cast<Layer*>(layerPtr);
LayerRenderer::destroyLayer(layer);
}
static void android_view_GLES20Canvas_destroyLayerDeferred(JNIEnv* env,
- jobject clazz, Layer* layer) {
+ jobject clazz, jint layerPtr) {
+ Layer* layer = reinterpret_cast<Layer*>(layerPtr);
LayerRenderer::destroyLayerDeferred(layer);
}
static void android_view_GLES20Canvas_drawLayer(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, Layer* layer, jfloat x, jfloat y) {
+ jint rendererPtr, jint layerPtr, jfloat x, jfloat y) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
+ Layer* layer = reinterpret_cast<Layer*>(layerPtr);
renderer->drawLayer(layer, x, y);
}
static jboolean android_view_GLES20Canvas_copyLayer(JNIEnv* env, jobject clazz,
- Layer* layer, SkBitmap* bitmap) {
+ jint layerPtr, jint bitmapPtr) {
+ Layer* layer = reinterpret_cast<Layer*>(layerPtr);
+ SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapPtr);
return LayerRenderer::copyLayer(layer, bitmap);
}
static void android_view_GLES20Canvas_pushLayerUpdate(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, Layer* layer) {
+ jint rendererPtr, jint layerPtr) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
+ Layer* layer = reinterpret_cast<Layer*>(layerPtr);
renderer->pushLayerUpdate(layer);
}
static void android_view_GLES20Canvas_cancelLayerUpdate(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer, Layer* layer) {
+ jint rendererPtr, jint layerPtr) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
+ Layer* layer = reinterpret_cast<Layer*>(layerPtr);
renderer->cancelLayerUpdate(layer);
}
static void android_view_GLES20Canvas_clearLayerUpdates(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer) {
+ jint rendererPtr) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
renderer->clearLayerUpdates();
}
static void android_view_GLES20Canvas_flushLayerUpdates(JNIEnv* env, jobject clazz,
- OpenGLRenderer* renderer) {
+ jint rendererPtr) {
+ OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
renderer->flushLayerUpdates();
}
diff --git a/core/res/res/values-ko/strings.xml b/core/res/res/values-ko/strings.xml
index 1cc177d..d3ba0ab 100644
--- a/core/res/res/values-ko/strings.xml
+++ b/core/res/res/values-ko/strings.xml
@@ -467,7 +467,7 @@
<string name="permlab_readCalendar" msgid="5972727560257612398">"캘린더 일정 및 기밀정보 읽기"</string>
<string name="permdesc_readCalendar" product="tablet" msgid="4216462049057658723">"앱이 친구나 동료의 일정을 포함하여 태블릿에 저장된 모든 캘린더 일정을 읽을 수 있도록 허용합니다. 이 경우 앱이 비밀유지 또는 기밀성을 무시하고 캘린더 데이터를 공유 또는 저장할 수도 있습니다."</string>
<string name="permdesc_readCalendar" product="default" msgid="7434548682470851583">"앱이 친구나 동료의 일정을 포함하여 휴대전화에 저장된 모든 캘린더 일정을 읽을 수 있도록 허용합니다. 이 경우 앱이 비밀유지 또는 기밀성과 관계 없이 캘린더 데이터를 공유 또는 저장할 수도 있습니다."</string>
- <string name="permlab_writeCalendar" msgid="8438874755193825647">"소유자 몰래 캘린더 일정을 추가 또는 수정하고 참석자에게 이메일 전송"</string>
+ <string name="permlab_writeCalendar" msgid="8438874755193825647">"소유자에게 알리지 않고 캘린더 일정을 추가 또는 수정하고 참석자에게 이메일 전송"</string>
<string name="permdesc_writeCalendar" product="tablet" msgid="6679035520113668528">"앱이 친구나 동료의 일정을 포함하여 태블릿에서 수정할 수 있는 일정을 추가, 삭제, 변경할 수 있도록 허용합니다. 이 경우 앱이 캘린더 소유자가 보내는 것처럼 메시지를 전송하거나 소유자 모르게 일정을 수정할 수도 있습니다."</string>
<string name="permdesc_writeCalendar" product="default" msgid="2324469496327249376">"앱이 친구나 동료의 일정을 포함하여 휴대전화에서 수정할 수 있는 일정을 추가, 삭제, 변경할 수 있도록 허용합니다. 이 경우 앱이 캘린더 소유자가 보내는 것처럼 메시지를 전송하거나 소유자 모르게 일정을 수정할 수도 있습니다."</string>
<string name="permlab_accessMockLocation" msgid="8688334974036823330">"테스트를 위해 위치 정보제공자로 가장"</string>