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