core/jni/android_graphics_Canvas.cpp

   1 /*
   2  * Copyright (C) 2014 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 #include "jni.h"
  18 #include "GraphicsJNI.h"
  19 #include "core_jni_helpers.h"
  20
  21 #include <androidfw/ResourceTypes.h>
  22 #include <hwui/Canvas.h>
  23 #include <hwui/Paint.h>
  24 #include <hwui/Typeface.h>
  25 #include <minikin/Layout.h>
  26
  27 #include "Bitmap.h"
  28 #include "SkDrawFilter.h"
  29 #include "SkGraphics.h"
  30
  31 namespace android {
  32
  33 namespace CanvasJNI {
  34
  35 static Canvas* get_canvas(jlong canvasHandle) {
  36     return reinterpret_cast<Canvas*>(canvasHandle);
  37 }
  38
  39 static void delete_canvas(Canvas* canvas) {
  40     delete canvas;
  41 }
  42
  43 static jlong getNativeFinalizer(JNIEnv* env, jobject clazz) {
  44     return static_cast<jlong>(reinterpret_cast<uintptr_t>(&delete_canvas));
  45 }
  46
  47 // Native wrapper constructor used by Canvas(Bitmap)
  48 static jlong initRaster(JNIEnv* env, jobject, jobject jbitmap) {
  49     SkBitmap bitmap;
  50     if (jbitmap != NULL) {
  51         GraphicsJNI::getSkBitmap(env, jbitmap, &bitmap);
  52     }
  53     return reinterpret_cast<jlong>(Canvas::create_canvas(bitmap));
  54 }
  55
  56 // Set the given bitmap as the new draw target (wrapped in a new SkCanvas),
  57 // optionally copying canvas matrix & clip state.
  58 static void setBitmap(JNIEnv* env, jobject, jlong canvasHandle, jobject jbitmap) {
  59     SkBitmap bitmap;
  60     if (jbitmap != NULL) {
  61         GraphicsJNI::getSkBitmap(env, jbitmap, &bitmap);
  62     }
  63     get_canvas(canvasHandle)->setBitmap(bitmap);
  64 }
  65
  66 static jboolean isOpaque(JNIEnv*, jobject, jlong canvasHandle) {
  67     return get_canvas(canvasHandle)->isOpaque() ? JNI_TRUE : JNI_FALSE;
  68 }
  69
  70 static jint getWidth(JNIEnv*, jobject, jlong canvasHandle) {
  71     return static_cast<jint>(get_canvas(canvasHandle)->width());
  72 }
  73
  74 static jint getHeight(JNIEnv*, jobject, jlong canvasHandle) {
  75     return static_cast<jint>(get_canvas(canvasHandle)->height());
  76 }
  77
  78 static void setHighContrastText(JNIEnv*, jobject, jlong canvasHandle, jboolean highContrastText) {
  79     Canvas* canvas = get_canvas(canvasHandle);
  80     canvas->setHighContrastText(highContrastText);
  81 }
  82
  83 static jint getSaveCount(JNIEnv*, jobject, jlong canvasHandle) {
  84     return static_cast<jint>(get_canvas(canvasHandle)->getSaveCount());
  85 }
  86
  87 static jint save(JNIEnv*, jobject, jlong canvasHandle, jint flagsHandle) {
  88     SaveFlags::Flags flags = static_cast<SaveFlags::Flags>(flagsHandle);
  89     return static_cast<jint>(get_canvas(canvasHandle)->save(flags));
  90 }
  91
  92 static jint saveLayer(JNIEnv* env, jobject, jlong canvasHandle, jfloat l, jfloat t,
  93                       jfloat r, jfloat b, jlong paintHandle, jint flagsHandle) {
  94     Paint* paint  = reinterpret_cast<Paint*>(paintHandle);
  95     SaveFlags::Flags flags = static_cast<SaveFlags::Flags>(flagsHandle);
  96     return static_cast<jint>(get_canvas(canvasHandle)->saveLayer(l, t, r, b, paint, flags));
  97 }
  98
  99 static jint saveLayerAlpha(JNIEnv* env, jobject, jlong canvasHandle, jfloat l, jfloat t,
 100                            jfloat r, jfloat b, jint alpha, jint flagsHandle) {
 101     SaveFlags::Flags flags = static_cast<SaveFlags::Flags>(flagsHandle);
 102     return static_cast<jint>(get_canvas(canvasHandle)->saveLayerAlpha(l, t, r, b, alpha, flags));
 103 }
 104
 105 static void restore(JNIEnv* env, jobject, jlong canvasHandle, jboolean throwOnUnderflow) {
 106     Canvas* canvas = get_canvas(canvasHandle);
 107     if (canvas->getSaveCount() <= 1) {  // cannot restore anymore
 108         if (throwOnUnderflow) {
 109             doThrowISE(env, "Underflow in restore - more restores than saves");
 110         }
 111         return; // compat behavior - return without throwing
 112     }
 113     canvas->restore();
 114 }
 115
 116 static void restoreToCount(JNIEnv* env, jobject, jlong canvasHandle, jint restoreCount,
 117         jboolean throwOnUnderflow) {
 118     Canvas* canvas = get_canvas(canvasHandle);
 119     if (restoreCount < 1 || restoreCount > canvas->getSaveCount()) {
 120         if (throwOnUnderflow) {
 121             doThrowIAE(env, "Underflow in restoreToCount - more restores than saves");
 122             return;
 123         }
 124         restoreCount = 1; // compat behavior - restore as far as possible
 125     }
 126     canvas->restoreToCount(restoreCount);
 127 }
 128
 129 static void getCTM(JNIEnv* env, jobject, jlong canvasHandle, jlong matrixHandle) {
 130     SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
 131     get_canvas(canvasHandle)->getMatrix(matrix);
 132 }
 133
 134 static void setMatrix(JNIEnv* env, jobject, jlong canvasHandle, jlong matrixHandle) {
 135     const SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
 136     get_canvas(canvasHandle)->setMatrix(matrix ? *matrix : SkMatrix::I());
 137 }
 138
 139 static void concat(JNIEnv* env, jobject, jlong canvasHandle, jlong matrixHandle) {
 140     const SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
 141     get_canvas(canvasHandle)->concat(*matrix);
 142 }
 143
 144 static void rotate(JNIEnv*, jobject, jlong canvasHandle, jfloat degrees) {
 145     get_canvas(canvasHandle)->rotate(degrees);
 146 }
 147
 148 static void scale(JNIEnv*, jobject, jlong canvasHandle, jfloat sx, jfloat sy) {
 149     get_canvas(canvasHandle)->scale(sx, sy);
 150 }
 151
 152 static void skew(JNIEnv*, jobject, jlong canvasHandle, jfloat sx, jfloat sy) {
 153     get_canvas(canvasHandle)->skew(sx, sy);
 154 }
 155
 156 static void translate(JNIEnv*, jobject, jlong canvasHandle, jfloat dx, jfloat dy) {
 157     get_canvas(canvasHandle)->translate(dx, dy);
 158 }
 159
 160 static jboolean getClipBounds(JNIEnv* env, jobject, jlong canvasHandle, jobject bounds) {
 161     SkRect   r;
 162     SkIRect ir;
 163     bool result = get_canvas(canvasHandle)->getClipBounds(&r);
 164
 165     if (!result) {
 166         r.setEmpty();
 167     }
 168     r.round(&ir);
 169
 170     (void)GraphicsJNI::irect_to_jrect(ir, env, bounds);
 171     return result ? JNI_TRUE : JNI_FALSE;
 172 }
 173
 174 static jboolean quickRejectRect(JNIEnv* env, jobject, jlong canvasHandle,
 175                                 jfloat left, jfloat top, jfloat right, jfloat bottom) {
 176     bool result = get_canvas(canvasHandle)->quickRejectRect(left, top, right, bottom);
 177     return result ? JNI_TRUE : JNI_FALSE;
 178 }
 179
 180 static jboolean quickRejectPath(JNIEnv* env, jobject, jlong canvasHandle, jlong pathHandle) {
 181     SkPath* path = reinterpret_cast<SkPath*>(pathHandle);
 182     bool result = get_canvas(canvasHandle)->quickRejectPath(*path);
 183     return result ? JNI_TRUE : JNI_FALSE;
 184 }
 185
 186 static jboolean clipRect(JNIEnv*, jobject, jlong canvasHandle, jfloat l, jfloat t,
 187                          jfloat r, jfloat b, jint opHandle) {
 188     SkRegion::Op op = static_cast<SkRegion::Op>(opHandle);
 189     bool nonEmptyClip = get_canvas(canvasHandle)->clipRect(l, t, r, b, op);
 190     return nonEmptyClip ? JNI_TRUE : JNI_FALSE;
 191 }
 192
 193 static jboolean clipPath(JNIEnv* env, jobject, jlong canvasHandle, jlong pathHandle,
 194                          jint opHandle) {
 195     SkPath* path = reinterpret_cast<SkPath*>(pathHandle);
 196     SkRegion::Op op = static_cast<SkRegion::Op>(opHandle);
 197     bool nonEmptyClip = get_canvas(canvasHandle)->clipPath(path, op);
 198     return nonEmptyClip ? JNI_TRUE : JNI_FALSE;
 199 }
 200
 201 static jboolean clipRegion(JNIEnv* env, jobject, jlong canvasHandle, jlong deviceRgnHandle,
 202                            jint opHandle) {
 203     SkRegion* deviceRgn = reinterpret_cast<SkRegion*>(deviceRgnHandle);
 204     SkRegion::Op op = static_cast<SkRegion::Op>(opHandle);
 205     bool nonEmptyClip = get_canvas(canvasHandle)->clipRegion(deviceRgn, op);
 206     return nonEmptyClip ? JNI_TRUE : JNI_FALSE;
 207 }
 208
 209 static void drawColor(JNIEnv* env, jobject, jlong canvasHandle, jint color, jint modeHandle) {
 210     SkXfermode::Mode mode = static_cast<SkXfermode::Mode>(modeHandle);
 211     get_canvas(canvasHandle)->drawColor(color, mode);
 212 }
 213
 214 static void drawPaint(JNIEnv* env, jobject, jlong canvasHandle, jlong paintHandle) {
 215     Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 216     get_canvas(canvasHandle)->drawPaint(*paint);
 217 }
 218
 219 static void drawPoint(JNIEnv*, jobject, jlong canvasHandle, jfloat x, jfloat y,
 220                       jlong paintHandle) {
 221     const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 222     get_canvas(canvasHandle)->drawPoint(x, y, *paint);
 223 }
 224
 225 static void drawPoints(JNIEnv* env, jobject, jlong canvasHandle, jfloatArray jptsArray,
 226                        jint offset, jint count, jlong paintHandle) {
 227     NPE_CHECK_RETURN_VOID(env, jptsArray);
 228     AutoJavaFloatArray autoPts(env, jptsArray);
 229     float* floats = autoPts.ptr();
 230     const int length = autoPts.length();
 231
 232     if ((offset | count) < 0 || offset + count > length) {
 233         doThrowAIOOBE(env);
 234         return;
 235     }
 236
 237     const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 238     get_canvas(canvasHandle)->drawPoints(floats + offset, count, *paint);
 239 }
 240
 241 static void drawLine(JNIEnv* env, jobject, jlong canvasHandle, jfloat startX, jfloat startY,
 242                      jfloat stopX, jfloat stopY, jlong paintHandle) {
 243     Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 244     get_canvas(canvasHandle)->drawLine(startX, startY, stopX, stopY, *paint);
 245 }
 246
 247 static void drawLines(JNIEnv* env, jobject, jlong canvasHandle, jfloatArray jptsArray,
 248                       jint offset, jint count, jlong paintHandle) {
 249     NPE_CHECK_RETURN_VOID(env, jptsArray);
 250     AutoJavaFloatArray autoPts(env, jptsArray);
 251     float* floats = autoPts.ptr();
 252     const int length = autoPts.length();
 253
 254     if ((offset | count) < 0 || offset + count > length) {
 255         doThrowAIOOBE(env);
 256         return;
 257     }
 258
 259     const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 260     get_canvas(canvasHandle)->drawLines(floats + offset, count, *paint);
 261 }
 262
 263 static void drawRect(JNIEnv* env, jobject, jlong canvasHandle, jfloat left, jfloat top,
 264                      jfloat right, jfloat bottom, jlong paintHandle) {
 265     const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 266     get_canvas(canvasHandle)->drawRect(left, top, right, bottom, *paint);
 267 }
 268
 269 static void drawRegion(JNIEnv* env, jobject, jlong canvasHandle, jlong regionHandle,
 270                        jlong paintHandle) {
 271     const SkRegion* region = reinterpret_cast<SkRegion*>(regionHandle);
 272     const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 273     get_canvas(canvasHandle)->drawRegion(*region, *paint);
 274 }
 275
 276 static void drawRoundRect(JNIEnv* env, jobject, jlong canvasHandle, jfloat left, jfloat top,
 277                           jfloat right, jfloat bottom, jfloat rx, jfloat ry, jlong paintHandle) {
 278     const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 279     get_canvas(canvasHandle)->drawRoundRect(left, top, right, bottom, rx, ry, *paint);
 280 }
 281
 282 static void drawCircle(JNIEnv* env, jobject, jlong canvasHandle, jfloat cx, jfloat cy,
 283                        jfloat radius, jlong paintHandle) {
 284     const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 285     get_canvas(canvasHandle)->drawCircle(cx, cy, radius, *paint);
 286 }
 287
 288 static void drawOval(JNIEnv* env, jobject, jlong canvasHandle, jfloat left, jfloat top,
 289                      jfloat right, jfloat bottom, jlong paintHandle) {
 290     const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 291     get_canvas(canvasHandle)->drawOval(left, top, right, bottom, *paint);
 292 }
 293
 294 static void drawArc(JNIEnv* env, jobject, jlong canvasHandle, jfloat left, jfloat top,
 295                     jfloat right, jfloat bottom, jfloat startAngle, jfloat sweepAngle,
 296                     jboolean useCenter, jlong paintHandle) {
 297     const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 298     get_canvas(canvasHandle)->drawArc(left, top, right, bottom, startAngle, sweepAngle,
 299                                        useCenter, *paint);
 300 }
 301
 302 static void drawPath(JNIEnv* env, jobject, jlong canvasHandle, jlong pathHandle,
 303                      jlong paintHandle) {
 304     const SkPath* path = reinterpret_cast<SkPath*>(pathHandle);
 305     const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 306     get_canvas(canvasHandle)->drawPath(*path, *paint);
 307 }
 308
 309 static void drawVertices(JNIEnv* env, jobject, jlong canvasHandle,
 310                          jint modeHandle, jint vertexCount,
 311                          jfloatArray jverts, jint vertIndex,
 312                          jfloatArray jtexs, jint texIndex,
 313                          jintArray jcolors, jint colorIndex,
 314                          jshortArray jindices, jint indexIndex,
 315                          jint indexCount, jlong paintHandle) {
 316     AutoJavaFloatArray  vertA(env, jverts, vertIndex + vertexCount);
 317     AutoJavaFloatArray  texA(env, jtexs, texIndex + vertexCount);
 318     AutoJavaIntArray    colorA(env, jcolors, colorIndex + vertexCount);
 319     AutoJavaShortArray  indexA(env, jindices, indexIndex + indexCount);
 320
 321     const float* verts = vertA.ptr() + vertIndex;
 322     const float* texs = texA.ptr() + vertIndex;
 323     const int* colors = NULL;
 324     const uint16_t* indices = NULL;
 325
 326     if (jcolors != NULL) {
 327         colors = colorA.ptr() + colorIndex;
 328     }
 329     if (jindices != NULL) {
 330         indices = (const uint16_t*)(indexA.ptr() + indexIndex);
 331     }
 332
 333     SkCanvas::VertexMode mode = static_cast<SkCanvas::VertexMode>(modeHandle);
 334     const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 335     get_canvas(canvasHandle)->drawVertices(mode, vertexCount, verts, texs, colors,
 336                                            indices, indexCount, *paint);
 337 }
 338
 339 static void drawNinePatch(JNIEnv* env, jobject, jlong canvasHandle, jlong bitmapHandle,
 340         jlong chunkHandle, jfloat left, jfloat top, jfloat right, jfloat bottom,
 341         jlong paintHandle, jint dstDensity, jint srcDensity) {
 342
 343     Canvas* canvas = get_canvas(canvasHandle);
 344     Bitmap* bitmap = reinterpret_cast<Bitmap*>(bitmapHandle);
 345     SkBitmap skiaBitmap;
 346     bitmap->getSkBitmap(&skiaBitmap);
 347     const android::Res_png_9patch* chunk = reinterpret_cast<android::Res_png_9patch*>(chunkHandle);
 348     const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 349
 350     if (CC_LIKELY(dstDensity == srcDensity || dstDensity == 0 || srcDensity == 0)) {
 351         canvas->drawNinePatch(skiaBitmap, *chunk, left, top, right, bottom, paint);
 352     } else {
 353         canvas->save(SaveFlags::MatrixClip);
 354
 355         SkScalar scale = dstDensity / (float)srcDensity;
 356         canvas->translate(left, top);
 357         canvas->scale(scale, scale);
 358
 359         Paint filteredPaint;
 360         if (paint) {
 361             filteredPaint = *paint;
 362         }
 363         filteredPaint.setFilterQuality(kLow_SkFilterQuality);
 364
 365         canvas->drawNinePatch(skiaBitmap, *chunk, 0, 0, (right-left)/scale, (bottom-top)/scale,
 366                 &filteredPaint);
 367
 368         canvas->restore();
 369     }
 370 }
 371
 372 static void drawBitmap(JNIEnv* env, jobject jcanvas, jlong canvasHandle, jobject jbitmap,
 373                        jfloat left, jfloat top, jlong paintHandle, jint canvasDensity,
 374                        jint screenDensity, jint bitmapDensity) {
 375     Canvas* canvas = get_canvas(canvasHandle);
 376     SkBitmap bitmap;
 377     GraphicsJNI::getSkBitmap(env, jbitmap, &bitmap);
 378     const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 379
 380     if (canvasDensity == bitmapDensity || canvasDensity == 0 || bitmapDensity == 0) {
 381         if (screenDensity != 0 && screenDensity != bitmapDensity) {
 382             Paint filteredPaint;
 383             if (paint) {
 384                 filteredPaint = *paint;
 385             }
 386             filteredPaint.setFilterQuality(kLow_SkFilterQuality);
 387             canvas->drawBitmap(bitmap, left, top, &filteredPaint);
 388         } else {
 389             canvas->drawBitmap(bitmap, left, top, paint);
 390         }
 391     } else {
 392         canvas->save(SaveFlags::MatrixClip);
 393         SkScalar scale = canvasDensity / (float)bitmapDensity;
 394         canvas->translate(left, top);
 395         canvas->scale(scale, scale);
 396
 397         Paint filteredPaint;
 398         if (paint) {
 399             filteredPaint = *paint;
 400         }
 401         filteredPaint.setFilterQuality(kLow_SkFilterQuality);
 402
 403         canvas->drawBitmap(bitmap, 0, 0, &filteredPaint);
 404         canvas->restore();
 405     }
 406 }
 407
 408 static void drawBitmapMatrix(JNIEnv* env, jobject, jlong canvasHandle, jobject jbitmap,
 409                              jlong matrixHandle, jlong paintHandle) {
 410     const SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
 411     const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 412     SkBitmap bitmap;
 413     GraphicsJNI::getSkBitmap(env, jbitmap, &bitmap);
 414     get_canvas(canvasHandle)->drawBitmap(bitmap, *matrix, paint);
 415 }
 416
 417 static void drawBitmapRect(JNIEnv* env, jobject, jlong canvasHandle, jobject jbitmap,
 418                            float srcLeft, float srcTop, float srcRight, float srcBottom,
 419                            float dstLeft, float dstTop, float dstRight, float dstBottom,
 420                            jlong paintHandle, jint screenDensity, jint bitmapDensity) {
 421     Canvas* canvas = get_canvas(canvasHandle);
 422     const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 423
 424     SkBitmap bitmap;
 425     GraphicsJNI::getSkBitmap(env, jbitmap, &bitmap);
 426     if (screenDensity != 0 && screenDensity != bitmapDensity) {
 427         Paint filteredPaint;
 428         if (paint) {
 429             filteredPaint = *paint;
 430         }
 431         filteredPaint.setFilterQuality(kLow_SkFilterQuality);
 432         canvas->drawBitmap(bitmap, srcLeft, srcTop, srcRight, srcBottom,
 433                            dstLeft, dstTop, dstRight, dstBottom, &filteredPaint);
 434     } else {
 435         canvas->drawBitmap(bitmap, srcLeft, srcTop, srcRight, srcBottom,
 436                            dstLeft, dstTop, dstRight, dstBottom, paint);
 437     }
 438 }
 439
 440 static void drawBitmapArray(JNIEnv* env, jobject, jlong canvasHandle,
 441                             jintArray jcolors, jint offset, jint stride,
 442                             jfloat x, jfloat y, jint width, jint height,
 443                             jboolean hasAlpha, jlong paintHandle) {
 444     // Note: If hasAlpha is false, kRGB_565_SkColorType will be used, which will
 445     // correct the alphaType to kOpaque_SkAlphaType.
 446     SkImageInfo info = SkImageInfo::Make(width, height,
 447                            hasAlpha ? kN32_SkColorType : kRGB_565_SkColorType,
 448                            kPremul_SkAlphaType);
 449     SkBitmap bitmap;
 450     bitmap.setInfo(info);
 451     if (!GraphicsJNI::allocatePixels(env, &bitmap, NULL)) {
 452         return;
 453     }
 454
 455     if (!GraphicsJNI::SetPixels(env, jcolors, offset, stride, 0, 0, width, height, bitmap)) {
 456         return;
 457     }
 458
 459     const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 460     get_canvas(canvasHandle)->drawBitmap(bitmap, x, y, paint);
 461 }
 462
 463 static void drawBitmapMesh(JNIEnv* env, jobject, jlong canvasHandle, jobject jbitmap,
 464                            jint meshWidth, jint meshHeight, jfloatArray jverts,
 465                            jint vertIndex, jintArray jcolors, jint colorIndex, jlong paintHandle) {
 466     const int ptCount = (meshWidth + 1) * (meshHeight + 1);
 467     AutoJavaFloatArray vertA(env, jverts, vertIndex + (ptCount << 1));
 468     AutoJavaIntArray colorA(env, jcolors, colorIndex + ptCount);
 469
 470     const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 471     SkBitmap bitmap;
 472     GraphicsJNI::getSkBitmap(env, jbitmap, &bitmap);
 473     get_canvas(canvasHandle)->drawBitmapMesh(bitmap, meshWidth, meshHeight,
 474                                              vertA.ptr(), colorA.ptr(), paint);
 475 }
 476
 477 static void drawTextChars(JNIEnv* env, jobject, jlong canvasHandle, jcharArray text,
 478                           jint index, jint count, jfloat x, jfloat y, jint bidiFlags,
 479                           jlong paintHandle, jlong typefaceHandle) {
 480     Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 481     Typeface* typeface = reinterpret_cast<Typeface*>(typefaceHandle);
 482     jchar* jchars = env->GetCharArrayElements(text, NULL);
 483     get_canvas(canvasHandle)->drawText(jchars + index, 0, count, count, x, y,
 484                                        bidiFlags, *paint, typeface);
 485     env->ReleaseCharArrayElements(text, jchars, JNI_ABORT);
 486 }
 487
 488 static void drawTextString(JNIEnv* env, jobject, jlong canvasHandle, jstring text,
 489                            jint start, jint end, jfloat x, jfloat y, jint bidiFlags,
 490                            jlong paintHandle, jlong typefaceHandle) {
 491     Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 492     Typeface* typeface = reinterpret_cast<Typeface*>(typefaceHandle);
 493     const int count = end - start;
 494     const jchar* jchars = env->GetStringChars(text, NULL);
 495     get_canvas(canvasHandle)->drawText(jchars + start, 0, count, count, x, y,
 496                                        bidiFlags, *paint, typeface);
 497     env->ReleaseStringChars(text, jchars);
 498 }
 499
 500 static void drawTextRunChars(JNIEnv* env, jobject, jlong canvasHandle, jcharArray text, jint index,
 501                              jint count, jint contextIndex, jint contextCount, jfloat x, jfloat y,
 502                              jboolean isRtl, jlong paintHandle, jlong typefaceHandle) {
 503     Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 504     Typeface* typeface = reinterpret_cast<Typeface*>(typefaceHandle);
 505
 506     const int bidiFlags = isRtl ? kBidi_Force_RTL : kBidi_Force_LTR;
 507     jchar* jchars = env->GetCharArrayElements(text, NULL);
 508     get_canvas(canvasHandle)->drawText(jchars + contextIndex, index - contextIndex, count,
 509                                        contextCount, x, y, bidiFlags, *paint, typeface);
 510     env->ReleaseCharArrayElements(text, jchars, JNI_ABORT);
 511 }
 512
 513 static void drawTextRunString(JNIEnv* env, jobject obj, jlong canvasHandle, jstring text,
 514                               jint start, jint end, jint contextStart, jint contextEnd,
 515                               jfloat x, jfloat y, jboolean isRtl, jlong paintHandle,
 516                               jlong typefaceHandle) {
 517     Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 518     Typeface* typeface = reinterpret_cast<Typeface*>(typefaceHandle);
 519
 520     int bidiFlags = isRtl ? kBidi_Force_RTL : kBidi_Force_LTR;
 521     jint count = end - start;
 522     jint contextCount = contextEnd - contextStart;
 523     const jchar* jchars = env->GetStringChars(text, NULL);
 524     get_canvas(canvasHandle)->drawText(jchars + contextStart, start - contextStart, count,
 525                                        contextCount, x, y, bidiFlags, *paint, typeface);
 526     env->ReleaseStringChars(text, jchars);
 527 }
 528
 529 static void drawTextOnPathChars(JNIEnv* env, jobject, jlong canvasHandle, jcharArray text,
 530                                 jint index, jint count, jlong pathHandle, jfloat hOffset,
 531                                 jfloat vOffset, jint bidiFlags, jlong paintHandle,
 532                                 jlong typefaceHandle) {
 533     SkPath* path = reinterpret_cast<SkPath*>(pathHandle);
 534     Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 535     Typeface* typeface = reinterpret_cast<Typeface*>(typefaceHandle);
 536
 537     jchar* jchars = env->GetCharArrayElements(text, NULL);
 538
 539     get_canvas(canvasHandle)->drawTextOnPath(jchars + index, count, bidiFlags, *path,
 540                    hOffset, vOffset, *paint, typeface);
 541
 542     env->ReleaseCharArrayElements(text, jchars, 0);
 543 }
 544
 545 static void drawTextOnPathString(JNIEnv* env, jobject, jlong canvasHandle, jstring text,
 546                                  jlong pathHandle, jfloat hOffset, jfloat vOffset,
 547                                  jint bidiFlags, jlong paintHandle, jlong typefaceHandle) {
 548     SkPath* path = reinterpret_cast<SkPath*>(pathHandle);
 549     Paint* paint = reinterpret_cast<Paint*>(paintHandle);
 550     Typeface* typeface = reinterpret_cast<Typeface*>(typefaceHandle);
 551
 552     const jchar* jchars = env->GetStringChars(text, NULL);
 553     int count = env->GetStringLength(text);
 554
 555     get_canvas(canvasHandle)->drawTextOnPath(jchars, count, bidiFlags, *path,
 556                    hOffset, vOffset, *paint, typeface);
 557
 558     env->ReleaseStringChars(text, jchars);
 559 }
 560
 561 static void setDrawFilter(JNIEnv* env, jobject, jlong canvasHandle, jlong filterHandle) {
 562     get_canvas(canvasHandle)->setDrawFilter(reinterpret_cast<SkDrawFilter*>(filterHandle));
 563 }
 564
 565 static void freeCaches(JNIEnv* env, jobject) {
 566     SkGraphics::PurgeFontCache();
 567 }
 568
 569 static void freeTextLayoutCaches(JNIEnv* env, jobject) {
 570     Layout::purgeCaches();
 571 }
 572
 573 }; // namespace CanvasJNI
 574
 575 static const JNINativeMethod gMethods[] = {
 576     {"getNativeFinalizer", "()J", (void*) CanvasJNI::getNativeFinalizer},
 577     {"initRaster", "(Landroid/graphics/Bitmap;)J", (void*) CanvasJNI::initRaster},
 578     {"native_setBitmap", "!(JLandroid/graphics/Bitmap;)V", (void*) CanvasJNI::setBitmap},
 579     {"native_isOpaque","!(J)Z", (void*) CanvasJNI::isOpaque},
 580     {"native_getWidth","!(J)I", (void*) CanvasJNI::getWidth},
 581     {"native_getHeight","!(J)I", (void*) CanvasJNI::getHeight},
 582     {"native_setHighContrastText","!(JZ)V", (void*) CanvasJNI::setHighContrastText},
 583     {"native_save","!(JI)I", (void*) CanvasJNI::save},
 584     {"native_saveLayer","!(JFFFFJI)I", (void*) CanvasJNI::saveLayer},
 585     {"native_saveLayerAlpha","!(JFFFFII)I", (void*) CanvasJNI::saveLayerAlpha},
 586     {"native_getSaveCount","!(J)I", (void*) CanvasJNI::getSaveCount},
 587     {"native_restore","!(JZ)V", (void*) CanvasJNI::restore},
 588     {"native_restoreToCount","!(JIZ)V", (void*) CanvasJNI::restoreToCount},
 589     {"native_getCTM", "!(JJ)V", (void*)CanvasJNI::getCTM},
 590     {"native_setMatrix","!(JJ)V", (void*) CanvasJNI::setMatrix},
 591     {"native_concat","!(JJ)V", (void*) CanvasJNI::concat},
 592     {"native_rotate","!(JF)V", (void*) CanvasJNI::rotate},
 593     {"native_scale","!(JFF)V", (void*) CanvasJNI::scale},
 594     {"native_skew","!(JFF)V", (void*) CanvasJNI::skew},
 595     {"native_translate","!(JFF)V", (void*) CanvasJNI::translate},
 596     {"native_getClipBounds","!(JLandroid/graphics/Rect;)Z", (void*) CanvasJNI::getClipBounds},
 597     {"native_quickReject","!(JJ)Z", (void*) CanvasJNI::quickRejectPath},
 598     {"native_quickReject","!(JFFFF)Z", (void*)CanvasJNI::quickRejectRect},
 599     {"native_clipRect","!(JFFFFI)Z", (void*) CanvasJNI::clipRect},
 600     {"native_clipPath","!(JJI)Z", (void*) CanvasJNI::clipPath},
 601     {"native_clipRegion","!(JJI)Z", (void*) CanvasJNI::clipRegion},
 602     {"native_drawColor","!(JII)V", (void*) CanvasJNI::drawColor},
 603     {"native_drawPaint","!(JJ)V", (void*) CanvasJNI::drawPaint},
 604     {"native_drawPoint", "!(JFFJ)V", (void*) CanvasJNI::drawPoint},
 605     {"native_drawPoints", "!(J[FIIJ)V", (void*) CanvasJNI::drawPoints},
 606     {"native_drawLine", "!(JFFFFJ)V", (void*) CanvasJNI::drawLine},
 607     {"native_drawLines", "!(J[FIIJ)V", (void*) CanvasJNI::drawLines},
 608     {"native_drawRect","!(JFFFFJ)V", (void*) CanvasJNI::drawRect},
 609     {"native_drawRegion", "!(JJJ)V", (void*) CanvasJNI::drawRegion },
 610     {"native_drawRoundRect","!(JFFFFFFJ)V", (void*) CanvasJNI::drawRoundRect},
 611     {"native_drawCircle","!(JFFFJ)V", (void*) CanvasJNI::drawCircle},
 612     {"native_drawOval","!(JFFFFJ)V", (void*) CanvasJNI::drawOval},
 613     {"native_drawArc","!(JFFFFFFZJ)V", (void*) CanvasJNI::drawArc},
 614     {"native_drawPath","!(JJJ)V", (void*) CanvasJNI::drawPath},
 615     {"nativeDrawVertices", "!(JII[FI[FI[II[SIIJ)V", (void*)CanvasJNI::drawVertices},
 616     {"native_drawNinePatch", "!(JJJFFFFJII)V", (void*)CanvasJNI::drawNinePatch},
 617     {"native_drawBitmap","!(JLandroid/graphics/Bitmap;FFJIII)V", (void*) CanvasJNI::drawBitmap},
 618     {"nativeDrawBitmapMatrix", "!(JLandroid/graphics/Bitmap;JJ)V", (void*)CanvasJNI::drawBitmapMatrix},
 619     {"native_drawBitmap","!(JLandroid/graphics/Bitmap;FFFFFFFFJII)V", (void*) CanvasJNI::drawBitmapRect},
 620     {"native_drawBitmap", "!(J[IIIFFIIZJ)V", (void*)CanvasJNI::drawBitmapArray},
 621     {"nativeDrawBitmapMesh", "!(JLandroid/graphics/Bitmap;II[FI[IIJ)V", (void*)CanvasJNI::drawBitmapMesh},
 622     {"native_drawText","!(J[CIIFFIJJ)V", (void*) CanvasJNI::drawTextChars},
 623     {"native_drawText","!(JLjava/lang/String;IIFFIJJ)V", (void*) CanvasJNI::drawTextString},
 624     {"native_drawTextRun","!(J[CIIIIFFZJJ)V", (void*) CanvasJNI::drawTextRunChars},
 625     {"native_drawTextRun","!(JLjava/lang/String;IIIIFFZJJ)V", (void*) CanvasJNI::drawTextRunString},
 626     {"native_drawTextOnPath","!(J[CIIJFFIJJ)V", (void*) CanvasJNI::drawTextOnPathChars},
 627     {"native_drawTextOnPath","!(JLjava/lang/String;JFFIJJ)V", (void*) CanvasJNI::drawTextOnPathString},
 628     {"nativeSetDrawFilter", "!(JJ)V", (void*) CanvasJNI::setDrawFilter},
 629     {"freeCaches", "()V", (void*) CanvasJNI::freeCaches},
 630     {"freeTextLayoutCaches", "()V", (void*) CanvasJNI::freeTextLayoutCaches}
 631 };
 632
 633 int register_android_graphics_Canvas(JNIEnv* env) {
 634     return RegisterMethodsOrDie(env, "android/graphics/Canvas", gMethods, NELEM(gMethods));
 635 }
 636
 637 }; // namespace android