android_view_RenderNode.cpp revision ff941dcd815021bb20d6504eb486acb1e50592c3 
1/*
2 * Copyright (C) 2012 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define LOG_TAG "OpenGLRenderer"
18
19#include <EGL/egl.h>
20
21#include "jni.h"
22#include "GraphicsJNI.h"
23#include <nativehelper/JNIHelp.h>
24#include <android_runtime/AndroidRuntime.h>
25
26#include <Animator.h>
27#include <DisplayListRenderer.h>
28#include <RenderNode.h>
29
30namespace android {
31
32using namespace uirenderer;
33
34/**
35 * Note: OpenGLRenderer JNI layer is generated and compiled only on supported
36 *       devices. This means all the logic must be compiled only when the
37 *       preprocessor variable USE_OPENGL_RENDERER is defined.
38 */
39#ifdef USE_OPENGL_RENDERER
40
41// ----------------------------------------------------------------------------
42// DisplayList view properties
43// ----------------------------------------------------------------------------
44
45static void android_view_RenderNode_output(JNIEnv* env,
46        jobject clazz, jlong renderNodePtr) {
47    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
48    renderNode->output();
49}
50
51static jlong android_view_RenderNode_create(JNIEnv* env, jobject clazz, jstring name) {
52    RenderNode* renderNode = new RenderNode();
53    renderNode->incStrong(0);
54    if (name != NULL) {
55        const char* textArray = env->GetStringUTFChars(name, NULL);
56        renderNode->setName(textArray);
57        env->ReleaseStringUTFChars(name, textArray);
58    }
59    return reinterpret_cast<jlong>(renderNode);
60}
61
62static void android_view_RenderNode_destroyRenderNode(JNIEnv* env,
63        jobject clazz, jlong renderNodePtr) {
64    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
65    renderNode->decStrong(0);
66}
67
68static void android_view_RenderNode_setDisplayListData(JNIEnv* env,
69        jobject clazz, jlong renderNodePtr, jlong newDataPtr) {
70    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
71    DisplayListData* newData = reinterpret_cast<DisplayListData*>(newDataPtr);
72    renderNode->setStagingDisplayList(newData);
73}
74
75// ----------------------------------------------------------------------------
76// RenderProperties - setters
77// ----------------------------------------------------------------------------
78
79static void android_view_RenderNode_setCaching(JNIEnv* env,
80        jobject clazz, jlong renderNodePtr, jboolean caching) {
81    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
82    renderNode->mutateStagingProperties().setCaching(caching);
83    renderNode->setPropertyFieldsDirty(RenderNode::GENERIC);
84}
85
86static void android_view_RenderNode_setStaticMatrix(JNIEnv* env,
87        jobject clazz, jlong renderNodePtr, jlong matrixPtr) {
88    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
89    SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixPtr);
90    renderNode->mutateStagingProperties().setStaticMatrix(matrix);
91    renderNode->setPropertyFieldsDirty(RenderNode::GENERIC);
92}
93
94static void android_view_RenderNode_setAnimationMatrix(JNIEnv* env,
95        jobject clazz, jlong renderNodePtr, jlong matrixPtr) {
96    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
97    SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixPtr);
98    renderNode->mutateStagingProperties().setAnimationMatrix(matrix);
99    renderNode->setPropertyFieldsDirty(RenderNode::GENERIC);
100}
101
102static void android_view_RenderNode_setClipToBounds(JNIEnv* env,
103        jobject clazz, jlong renderNodePtr, jboolean clipToBounds) {
104    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
105    renderNode->mutateStagingProperties().setClipToBounds(clipToBounds);
106    renderNode->setPropertyFieldsDirty(RenderNode::GENERIC);
107}
108
109static void android_view_RenderNode_setProjectBackwards(JNIEnv* env,
110        jobject clazz, jlong renderNodePtr, jboolean shouldProject) {
111    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
112    renderNode->mutateStagingProperties().setProjectBackwards(shouldProject);
113    renderNode->setPropertyFieldsDirty(RenderNode::GENERIC);
114}
115
116static void android_view_RenderNode_setProjectionReceiver(JNIEnv* env,
117        jobject clazz, jlong renderNodePtr, jboolean shouldRecieve) {
118    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
119    renderNode->mutateStagingProperties().setProjectionReceiver(shouldRecieve);
120    renderNode->setPropertyFieldsDirty(RenderNode::GENERIC);
121}
122
123static void android_view_RenderNode_setOutlineRoundRect(JNIEnv* env,
124        jobject clazz, jlong renderNodePtr, jint left, jint top,
125        jint right, jint bottom, jfloat radius) {
126    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
127    renderNode->mutateStagingProperties().mutableOutline().setRoundRect(left, top, right, bottom, radius);
128    renderNode->setPropertyFieldsDirty(RenderNode::GENERIC);
129}
130
131static void android_view_RenderNode_setOutlineConvexPath(JNIEnv* env,
132        jobject clazz, jlong renderNodePtr, jlong outlinePathPtr) {
133    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
134    SkPath* outlinePath = reinterpret_cast<SkPath*>(outlinePathPtr);
135    renderNode->mutateStagingProperties().mutableOutline().setConvexPath(outlinePath);
136    renderNode->setPropertyFieldsDirty(RenderNode::GENERIC);
137}
138
139static void android_view_RenderNode_setOutlineEmpty(JNIEnv* env,
140        jobject clazz, jlong renderNodePtr) {
141    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
142    renderNode->mutateStagingProperties().mutableOutline().setEmpty();
143    renderNode->setPropertyFieldsDirty(RenderNode::GENERIC);
144}
145
146static void android_view_RenderNode_setClipToOutline(JNIEnv* env,
147        jobject clazz, jlong renderNodePtr, jboolean clipToOutline) {
148    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
149    renderNode->mutateStagingProperties().mutableOutline().setShouldClip(clipToOutline);
150    renderNode->setPropertyFieldsDirty(RenderNode::GENERIC);
151}
152
153static void android_view_RenderNode_setRevealClip(JNIEnv* env,
154        jobject clazz, jlong renderNodePtr, jboolean shouldClip, jboolean inverseClip,
155        jfloat x, jfloat y, jfloat radius) {
156    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
157    renderNode->mutateStagingProperties().mutableRevealClip().set(
158            shouldClip, inverseClip, x, y, radius);
159    renderNode->setPropertyFieldsDirty(RenderNode::GENERIC);
160}
161
162static void android_view_RenderNode_setAlpha(JNIEnv* env,
163        jobject clazz, jlong renderNodePtr, float alpha) {
164    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
165    renderNode->mutateStagingProperties().setAlpha(alpha);
166    renderNode->setPropertyFieldsDirty(RenderNode::ALPHA);
167}
168
169static void android_view_RenderNode_setHasOverlappingRendering(JNIEnv* env,
170        jobject clazz, jlong renderNodePtr, bool hasOverlappingRendering) {
171    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
172    renderNode->mutateStagingProperties().setHasOverlappingRendering(hasOverlappingRendering);
173    renderNode->setPropertyFieldsDirty(RenderNode::GENERIC);
174}
175
176static void android_view_RenderNode_setElevation(JNIEnv* env,
177        jobject clazz, jlong renderNodePtr, float elevation) {
178    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
179    renderNode->mutateStagingProperties().setElevation(elevation);
180    renderNode->setPropertyFieldsDirty(RenderNode::Z);
181}
182
183static void android_view_RenderNode_setTranslationX(JNIEnv* env,
184        jobject clazz, jlong renderNodePtr, float tx) {
185    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
186    renderNode->mutateStagingProperties().setTranslationX(tx);
187    renderNode->setPropertyFieldsDirty(RenderNode::TRANSLATION_X | RenderNode::X);
188}
189
190static void android_view_RenderNode_setTranslationY(JNIEnv* env,
191        jobject clazz, jlong renderNodePtr, float ty) {
192    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
193    renderNode->mutateStagingProperties().setTranslationY(ty);
194    renderNode->setPropertyFieldsDirty(RenderNode::TRANSLATION_Y | RenderNode::Y);
195}
196
197static void android_view_RenderNode_setTranslationZ(JNIEnv* env,
198        jobject clazz, jlong renderNodePtr, float tz) {
199    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
200    renderNode->mutateStagingProperties().setTranslationZ(tz);
201    renderNode->setPropertyFieldsDirty(RenderNode::TRANSLATION_Z | RenderNode::Z);
202}
203
204static void android_view_RenderNode_setRotation(JNIEnv* env,
205        jobject clazz, jlong renderNodePtr, float rotation) {
206    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
207    renderNode->mutateStagingProperties().setRotation(rotation);
208    renderNode->setPropertyFieldsDirty(RenderNode::ROTATION);
209}
210
211static void android_view_RenderNode_setRotationX(JNIEnv* env,
212        jobject clazz, jlong renderNodePtr, float rx) {
213    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
214    renderNode->mutateStagingProperties().setRotationX(rx);
215    renderNode->setPropertyFieldsDirty(RenderNode::ROTATION_X);
216}
217
218static void android_view_RenderNode_setRotationY(JNIEnv* env,
219        jobject clazz, jlong renderNodePtr, float ry) {
220    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
221    renderNode->mutateStagingProperties().setRotationY(ry);
222    renderNode->setPropertyFieldsDirty(RenderNode::ROTATION_Y);
223}
224
225static void android_view_RenderNode_setScaleX(JNIEnv* env,
226        jobject clazz, jlong renderNodePtr, float sx) {
227    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
228    renderNode->mutateStagingProperties().setScaleX(sx);
229    renderNode->setPropertyFieldsDirty(RenderNode::SCALE_X);
230}
231
232static void android_view_RenderNode_setScaleY(JNIEnv* env,
233        jobject clazz, jlong renderNodePtr, float sy) {
234    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
235    renderNode->mutateStagingProperties().setScaleY(sy);
236    renderNode->setPropertyFieldsDirty(RenderNode::SCALE_Y);
237}
238
239static void android_view_RenderNode_setPivotX(JNIEnv* env,
240        jobject clazz, jlong renderNodePtr, float px) {
241    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
242    renderNode->mutateStagingProperties().setPivotX(px);
243    renderNode->setPropertyFieldsDirty(RenderNode::GENERIC);
244}
245
246static void android_view_RenderNode_setPivotY(JNIEnv* env,
247        jobject clazz, jlong renderNodePtr, float py) {
248    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
249    renderNode->mutateStagingProperties().setPivotY(py);
250    renderNode->setPropertyFieldsDirty(RenderNode::GENERIC);
251}
252
253static void android_view_RenderNode_setCameraDistance(JNIEnv* env,
254        jobject clazz, jlong renderNodePtr, float distance) {
255    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
256    renderNode->mutateStagingProperties().setCameraDistance(distance);
257    renderNode->setPropertyFieldsDirty(RenderNode::GENERIC);
258}
259
260static void android_view_RenderNode_setLeft(JNIEnv* env,
261        jobject clazz, jlong renderNodePtr, int left) {
262    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
263    renderNode->mutateStagingProperties().setLeft(left);
264    renderNode->setPropertyFieldsDirty(RenderNode::X);
265}
266
267static void android_view_RenderNode_setTop(JNIEnv* env,
268        jobject clazz, jlong renderNodePtr, int top) {
269    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
270    renderNode->mutateStagingProperties().setTop(top);
271    renderNode->setPropertyFieldsDirty(RenderNode::Y);
272}
273
274static void android_view_RenderNode_setRight(JNIEnv* env,
275        jobject clazz, jlong renderNodePtr, int right) {
276    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
277    renderNode->mutateStagingProperties().setRight(right);
278    renderNode->setPropertyFieldsDirty(RenderNode::X);
279}
280
281static void android_view_RenderNode_setBottom(JNIEnv* env,
282        jobject clazz, jlong renderNodePtr, int bottom) {
283    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
284    renderNode->mutateStagingProperties().setBottom(bottom);
285    renderNode->setPropertyFieldsDirty(RenderNode::Y);
286}
287
288static void android_view_RenderNode_setLeftTopRightBottom(JNIEnv* env,
289        jobject clazz, jlong renderNodePtr, int left, int top,
290        int right, int bottom) {
291    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
292    renderNode->mutateStagingProperties().setLeftTopRightBottom(left, top, right, bottom);
293    renderNode->setPropertyFieldsDirty(RenderNode::X | RenderNode::Y);
294}
295
296static void android_view_RenderNode_offsetLeftAndRight(JNIEnv* env,
297        jobject clazz, jlong renderNodePtr, float offset) {
298    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
299    renderNode->mutateStagingProperties().offsetLeftRight(offset);
300    renderNode->setPropertyFieldsDirty(RenderNode::X);
301}
302
303static void android_view_RenderNode_offsetTopAndBottom(JNIEnv* env,
304        jobject clazz, jlong renderNodePtr, float offset) {
305    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
306    renderNode->mutateStagingProperties().offsetTopBottom(offset);
307    renderNode->setPropertyFieldsDirty(RenderNode::Y);
308}
309
310// ----------------------------------------------------------------------------
311// RenderProperties - getters
312// ----------------------------------------------------------------------------
313
314static jboolean android_view_RenderNode_hasOverlappingRendering(JNIEnv* env,
315        jobject clazz, jlong renderNodePtr) {
316    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
317    return renderNode->stagingProperties().hasOverlappingRendering();
318}
319
320static jfloat android_view_RenderNode_getAlpha(JNIEnv* env,
321        jobject clazz, jlong renderNodePtr) {
322    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
323    return renderNode->stagingProperties().getAlpha();
324}
325
326static jfloat android_view_RenderNode_getLeft(JNIEnv* env,
327        jobject clazz, jlong renderNodePtr) {
328    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
329    return renderNode->stagingProperties().getLeft();
330}
331
332static jfloat android_view_RenderNode_getTop(JNIEnv* env,
333        jobject clazz, jlong renderNodePtr) {
334    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
335    return renderNode->stagingProperties().getTop();
336}
337
338static jfloat android_view_RenderNode_getRight(JNIEnv* env,
339        jobject clazz, jlong renderNodePtr) {
340    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
341    return renderNode->stagingProperties().getRight();
342}
343
344static jfloat android_view_RenderNode_getBottom(JNIEnv* env,
345        jobject clazz, jlong renderNodePtr) {
346    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
347    return renderNode->stagingProperties().getBottom();
348}
349
350static jfloat android_view_RenderNode_getCameraDistance(JNIEnv* env,
351        jobject clazz, jlong renderNodePtr) {
352    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
353    return renderNode->stagingProperties().getCameraDistance();
354}
355
356static jfloat android_view_RenderNode_getScaleX(JNIEnv* env,
357        jobject clazz, jlong renderNodePtr) {
358    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
359    return renderNode->stagingProperties().getScaleX();
360}
361
362static jfloat android_view_RenderNode_getScaleY(JNIEnv* env,
363        jobject clazz, jlong renderNodePtr) {
364    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
365    return renderNode->stagingProperties().getScaleY();
366}
367
368static jfloat android_view_RenderNode_getElevation(JNIEnv* env,
369        jobject clazz, jlong renderNodePtr) {
370    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
371    return renderNode->stagingProperties().getElevation();
372}
373
374static jfloat android_view_RenderNode_getTranslationX(JNIEnv* env,
375        jobject clazz, jlong renderNodePtr) {
376    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
377    return renderNode->stagingProperties().getTranslationX();
378}
379
380static jfloat android_view_RenderNode_getTranslationY(JNIEnv* env,
381        jobject clazz, jlong renderNodePtr) {
382    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
383    return renderNode->stagingProperties().getTranslationY();
384}
385
386static jfloat android_view_RenderNode_getTranslationZ(JNIEnv* env,
387        jobject clazz, jlong renderNodePtr) {
388    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
389    return renderNode->stagingProperties().getTranslationZ();
390}
391
392static jfloat android_view_RenderNode_getRotation(JNIEnv* env,
393        jobject clazz, jlong renderNodePtr) {
394    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
395    return renderNode->stagingProperties().getRotation();
396}
397
398static jfloat android_view_RenderNode_getRotationX(JNIEnv* env,
399        jobject clazz, jlong renderNodePtr) {
400    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
401    return renderNode->stagingProperties().getRotationX();
402}
403
404static jfloat android_view_RenderNode_getRotationY(JNIEnv* env,
405        jobject clazz, jlong renderNodePtr) {
406    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
407    return renderNode->stagingProperties().getRotationY();
408}
409
410static jboolean android_view_RenderNode_isPivotExplicitlySet(JNIEnv* env,
411        jobject clazz, jlong renderNodePtr) {
412    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
413    return renderNode->stagingProperties().isPivotExplicitlySet();
414}
415
416static jboolean android_view_RenderNode_hasIdentityMatrix(JNIEnv* env,
417        jobject clazz, jlong renderNodePtr) {
418    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
419    renderNode->mutateStagingProperties().updateMatrix();
420    return !renderNode->stagingProperties().hasTransformMatrix();
421}
422
423// ----------------------------------------------------------------------------
424// RenderProperties - computed getters
425// ----------------------------------------------------------------------------
426
427static void android_view_RenderNode_getTransformMatrix(JNIEnv* env,
428        jobject clazz, jlong renderNodePtr, jlong outMatrixPtr) {
429    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
430    SkMatrix* outMatrix = reinterpret_cast<SkMatrix*>(outMatrixPtr);
431
432    renderNode->mutateStagingProperties().updateMatrix();
433    const SkMatrix* transformMatrix = renderNode->stagingProperties().getTransformMatrix();
434
435    if (transformMatrix) {
436        *outMatrix = *transformMatrix;
437    } else {
438        outMatrix->setIdentity();
439    }
440}
441
442static void android_view_RenderNode_getInverseTransformMatrix(JNIEnv* env,
443        jobject clazz, jlong renderNodePtr, jlong outMatrixPtr) {
444    // load transform matrix
445    android_view_RenderNode_getTransformMatrix(env, clazz, renderNodePtr, outMatrixPtr);
446    SkMatrix* outMatrix = reinterpret_cast<SkMatrix*>(outMatrixPtr);
447
448    // return it inverted
449    if (!outMatrix->invert(outMatrix)) {
450        // failed to load inverse, pass back identity
451        outMatrix->setIdentity();
452    }
453}
454
455static jfloat android_view_RenderNode_getPivotX(JNIEnv* env,
456        jobject clazz, jlong renderNodePtr) {
457    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
458    renderNode->mutateStagingProperties().updateMatrix();
459    return renderNode->stagingProperties().getPivotX();
460}
461
462static jfloat android_view_RenderNode_getPivotY(JNIEnv* env,
463        jobject clazz, jlong renderNodePtr) {
464    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
465    renderNode->mutateStagingProperties().updateMatrix();
466    return renderNode->stagingProperties().getPivotY();
467}
468
469// ----------------------------------------------------------------------------
470// RenderProperties - Animations
471// ----------------------------------------------------------------------------
472
473static void android_view_RenderNode_addAnimator(JNIEnv* env, jobject clazz,
474        jlong renderNodePtr, jlong animatorPtr) {
475    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
476    RenderPropertyAnimator* animator = reinterpret_cast<RenderPropertyAnimator*>(animatorPtr);
477    renderNode->addAnimator(animator);
478}
479
480static void android_view_RenderNode_removeAnimator(JNIEnv* env, jobject clazz,
481        jlong renderNodePtr, jlong animatorPtr) {
482    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
483    RenderPropertyAnimator* animator = reinterpret_cast<RenderPropertyAnimator*>(animatorPtr);
484    renderNode->removeAnimator(animator);
485}
486
487
488#endif // USE_OPENGL_RENDERER
489
490// ----------------------------------------------------------------------------
491// JNI Glue
492// ----------------------------------------------------------------------------
493
494const char* const kClassPathName = "android/view/RenderNode";
495
496static JNINativeMethod gMethods[] = {
497#ifdef USE_OPENGL_RENDERER
498    { "nCreate",               "(Ljava/lang/String;)J",    (void*) android_view_RenderNode_create },
499    { "nDestroyRenderNode",   "(J)V",   (void*) android_view_RenderNode_destroyRenderNode },
500    { "nSetDisplayListData",   "(JJ)V", (void*) android_view_RenderNode_setDisplayListData },
501    { "nOutput",               "(J)V",  (void*) android_view_RenderNode_output },
502
503    { "nSetCaching",           "(JZ)V",  (void*) android_view_RenderNode_setCaching },
504    { "nSetStaticMatrix",      "(JJ)V",  (void*) android_view_RenderNode_setStaticMatrix },
505    { "nSetAnimationMatrix",   "(JJ)V",  (void*) android_view_RenderNode_setAnimationMatrix },
506    { "nSetClipToBounds",      "(JZ)V",  (void*) android_view_RenderNode_setClipToBounds },
507    { "nSetProjectBackwards",  "(JZ)V",  (void*) android_view_RenderNode_setProjectBackwards },
508    { "nSetProjectionReceiver","(JZ)V",  (void*) android_view_RenderNode_setProjectionReceiver },
509
510    { "nSetOutlineRoundRect",  "(JIIIIF)V", (void*) android_view_RenderNode_setOutlineRoundRect },
511    { "nSetOutlineConvexPath", "(JJ)V",  (void*) android_view_RenderNode_setOutlineConvexPath },
512    { "nSetOutlineEmpty",      "(J)V",   (void*) android_view_RenderNode_setOutlineEmpty },
513    { "nSetClipToOutline",     "(JZ)V",  (void*) android_view_RenderNode_setClipToOutline },
514    { "nSetRevealClip",        "(JZZFFF)V", (void*) android_view_RenderNode_setRevealClip },
515
516    { "nSetAlpha",             "(JF)V",  (void*) android_view_RenderNode_setAlpha },
517    { "nSetHasOverlappingRendering", "(JZ)V",
518            (void*) android_view_RenderNode_setHasOverlappingRendering },
519    { "nSetElevation",         "(JF)V",  (void*) android_view_RenderNode_setElevation },
520    { "nSetTranslationX",      "(JF)V",  (void*) android_view_RenderNode_setTranslationX },
521    { "nSetTranslationY",      "(JF)V",  (void*) android_view_RenderNode_setTranslationY },
522    { "nSetTranslationZ",      "(JF)V",  (void*) android_view_RenderNode_setTranslationZ },
523    { "nSetRotation",          "(JF)V",  (void*) android_view_RenderNode_setRotation },
524    { "nSetRotationX",         "(JF)V",  (void*) android_view_RenderNode_setRotationX },
525    { "nSetRotationY",         "(JF)V",  (void*) android_view_RenderNode_setRotationY },
526    { "nSetScaleX",            "(JF)V",  (void*) android_view_RenderNode_setScaleX },
527    { "nSetScaleY",            "(JF)V",  (void*) android_view_RenderNode_setScaleY },
528    { "nSetPivotX",            "(JF)V",  (void*) android_view_RenderNode_setPivotX },
529    { "nSetPivotY",            "(JF)V",  (void*) android_view_RenderNode_setPivotY },
530    { "nSetCameraDistance",    "(JF)V",  (void*) android_view_RenderNode_setCameraDistance },
531    { "nSetLeft",              "(JI)V",  (void*) android_view_RenderNode_setLeft },
532    { "nSetTop",               "(JI)V",  (void*) android_view_RenderNode_setTop },
533    { "nSetRight",             "(JI)V",  (void*) android_view_RenderNode_setRight },
534    { "nSetBottom",            "(JI)V",  (void*) android_view_RenderNode_setBottom },
535    { "nSetLeftTopRightBottom","(JIIII)V", (void*) android_view_RenderNode_setLeftTopRightBottom },
536    { "nOffsetLeftAndRight",   "(JF)V",  (void*) android_view_RenderNode_offsetLeftAndRight },
537    { "nOffsetTopAndBottom",   "(JF)V",  (void*) android_view_RenderNode_offsetTopAndBottom },
538
539    { "nHasOverlappingRendering", "(J)Z",  (void*) android_view_RenderNode_hasOverlappingRendering },
540    { "nGetAlpha",                "(J)F",  (void*) android_view_RenderNode_getAlpha },
541    { "nGetLeft",                 "(J)F",  (void*) android_view_RenderNode_getLeft },
542    { "nGetTop",                  "(J)F",  (void*) android_view_RenderNode_getTop },
543    { "nGetRight",                "(J)F",  (void*) android_view_RenderNode_getRight },
544    { "nGetBottom",               "(J)F",  (void*) android_view_RenderNode_getBottom },
545    { "nGetCameraDistance",       "(J)F",  (void*) android_view_RenderNode_getCameraDistance },
546    { "nGetScaleX",               "(J)F",  (void*) android_view_RenderNode_getScaleX },
547    { "nGetScaleY",               "(J)F",  (void*) android_view_RenderNode_getScaleY },
548    { "nGetElevation",            "(J)F",  (void*) android_view_RenderNode_getElevation },
549    { "nGetTranslationX",         "(J)F",  (void*) android_view_RenderNode_getTranslationX },
550    { "nGetTranslationY",         "(J)F",  (void*) android_view_RenderNode_getTranslationY },
551    { "nGetTranslationZ",         "(J)F",  (void*) android_view_RenderNode_getTranslationZ },
552    { "nGetRotation",             "(J)F",  (void*) android_view_RenderNode_getRotation },
553    { "nGetRotationX",            "(J)F",  (void*) android_view_RenderNode_getRotationX },
554    { "nGetRotationY",            "(J)F",  (void*) android_view_RenderNode_getRotationY },
555    { "nIsPivotExplicitlySet",    "(J)Z",  (void*) android_view_RenderNode_isPivotExplicitlySet },
556    { "nHasIdentityMatrix",       "(J)Z",  (void*) android_view_RenderNode_hasIdentityMatrix },
557
558    { "nGetTransformMatrix",       "(JJ)V", (void*) android_view_RenderNode_getTransformMatrix },
559    { "nGetInverseTransformMatrix","(JJ)V", (void*) android_view_RenderNode_getInverseTransformMatrix },
560
561    { "nGetPivotX",                "(J)F",  (void*) android_view_RenderNode_getPivotX },
562    { "nGetPivotY",                "(J)F",  (void*) android_view_RenderNode_getPivotY },
563
564    { "nAddAnimator",              "(JJ)V", (void*) android_view_RenderNode_addAnimator },
565    { "nRemoveAnimator",           "(JJ)V", (void*) android_view_RenderNode_removeAnimator },
566#endif
567};
568
569#ifdef USE_OPENGL_RENDERER
570    #define FIND_CLASS(var, className) \
571            var = env->FindClass(className); \
572            LOG_FATAL_IF(! var, "Unable to find class " className);
573
574    #define GET_METHOD_ID(var, clazz, methodName, methodDescriptor) \
575            var = env->GetMethodID(clazz, methodName, methodDescriptor); \
576            LOG_FATAL_IF(! var, "Unable to find method " methodName);
577#else
578    #define FIND_CLASS(var, className)
579    #define GET_METHOD_ID(var, clazz, methodName, methodDescriptor)
580#endif
581
582int register_android_view_RenderNode(JNIEnv* env) {
583    return AndroidRuntime::registerNativeMethods(env, kClassPathName, gMethods, NELEM(gMethods));
584}
585
586};
587
588