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