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