1/* libs/android_runtime/android/graphics/Path.cpp
2**
3** Copyright 2006, The Android Open Source Project
4**
5** Licensed under the Apache License, Version 2.0 (the "License");
6** you may not use this file except in compliance with the License.
7** You may obtain a copy of the License at
8**
9**     http://www.apache.org/licenses/LICENSE-2.0
10**
11** Unless required by applicable law or agreed to in writing, software
12** distributed under the License is distributed on an "AS IS" BASIS,
13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14** See the License for the specific language governing permissions and
15** limitations under the License.
16*/
17
18// This file was generated from the C++ include file: SkPath.h
19// Any changes made to this file will be discarded by the build.
20// To change this file, either edit the include, or device/tools/gluemaker/main.cpp,
21// or one of the auxilary file specifications in device/tools/gluemaker.
22
23#include "jni.h"
24#include "GraphicsJNI.h"
25#include "core_jni_helpers.h"
26
27#include "SkPath.h"
28#include "SkPathOps.h"
29#include "SkGeometry.h" // WARNING: Internal Skia Header
30
31#include <Caches.h>
32#include <vector>
33#include <map>
34
35namespace android {
36
37class SkPathGlue {
38public:
39
40    // ---------------- Regular JNI -----------------------------
41
42    static jlong init(JNIEnv* env, jclass clazz) {
43        return reinterpret_cast<jlong>(new SkPath());
44    }
45
46    static jlong init_Path(JNIEnv* env, jclass clazz, jlong valHandle) {
47        SkPath* val = reinterpret_cast<SkPath*>(valHandle);
48        return reinterpret_cast<jlong>(new SkPath(*val));
49    }
50
51    static void finalize(JNIEnv* env, jclass clazz, jlong objHandle) {
52        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
53        // Purge entries from the HWUI path cache if this path's data is unique
54        if (obj->unique() && android::uirenderer::Caches::hasInstance()) {
55            android::uirenderer::Caches::getInstance().pathCache.removeDeferred(obj);
56        }
57        delete obj;
58    }
59
60    static void set(JNIEnv* env, jclass clazz, jlong dstHandle, jlong srcHandle) {
61        SkPath* dst = reinterpret_cast<SkPath*>(dstHandle);
62        const SkPath* src = reinterpret_cast<SkPath*>(srcHandle);
63        *dst = *src;
64    }
65
66    static void computeBounds(JNIEnv* env, jclass clazz, jlong objHandle, jobject jbounds) {
67        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
68        const SkRect& bounds = obj->getBounds();
69        GraphicsJNI::rect_to_jrectf(bounds, env, jbounds);
70    }
71
72    static void incReserve(JNIEnv* env, jclass clazz, jlong objHandle, jint extraPtCount) {
73        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
74        obj->incReserve(extraPtCount);
75    }
76
77    static void moveTo__FF(JNIEnv* env, jclass clazz, jlong objHandle, jfloat x, jfloat y) {
78        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
79        obj->moveTo(x, y);
80    }
81
82    static void rMoveTo(JNIEnv* env, jclass clazz, jlong objHandle, jfloat dx, jfloat dy) {
83        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
84        obj->rMoveTo(dx, dy);
85    }
86
87    static void lineTo__FF(JNIEnv* env, jclass clazz, jlong objHandle, jfloat x, jfloat y) {
88        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
89        obj->lineTo(x, y);
90    }
91
92    static void rLineTo(JNIEnv* env, jclass clazz, jlong objHandle, jfloat dx, jfloat dy) {
93        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
94        obj->rLineTo(dx, dy);
95    }
96
97    static void quadTo__FFFF(JNIEnv* env, jclass clazz, jlong objHandle, jfloat x1, jfloat y1,
98            jfloat x2, jfloat y2) {
99        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
100        obj->quadTo(x1, y1, x2, y2);
101    }
102
103    static void rQuadTo(JNIEnv* env, jclass clazz, jlong objHandle, jfloat dx1, jfloat dy1,
104            jfloat dx2, jfloat dy2) {
105        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
106        obj->rQuadTo(dx1, dy1, dx2, dy2);
107    }
108
109    static void cubicTo__FFFFFF(JNIEnv* env, jclass clazz, jlong objHandle, jfloat x1, jfloat y1,
110            jfloat x2, jfloat y2, jfloat x3, jfloat y3) {
111        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
112        obj->cubicTo(x1, y1, x2, y2, x3, y3);
113    }
114
115    static void rCubicTo(JNIEnv* env, jclass clazz, jlong objHandle, jfloat x1, jfloat y1,
116            jfloat x2, jfloat y2, jfloat x3, jfloat y3) {
117        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
118        obj->rCubicTo(x1, y1, x2, y2, x3, y3);
119    }
120
121    static void arcTo(JNIEnv* env, jclass clazz, jlong objHandle, jfloat left, jfloat top,
122            jfloat right, jfloat bottom, jfloat startAngle, jfloat sweepAngle,
123            jboolean forceMoveTo) {
124        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
125        SkRect oval = SkRect::MakeLTRB(left, top, right, bottom);
126        obj->arcTo(oval, startAngle, sweepAngle, forceMoveTo);
127    }
128
129    static void close(JNIEnv* env, jclass clazz, jlong objHandle) {
130        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
131        obj->close();
132    }
133
134    static void addRect(JNIEnv* env, jclass clazz, jlong objHandle,
135            jfloat left, jfloat top, jfloat right, jfloat bottom, jint dirHandle) {
136        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
137        SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle);
138        obj->addRect(left, top, right, bottom, dir);
139    }
140
141    static void addOval(JNIEnv* env, jclass clazz, jlong objHandle,
142            jfloat left, jfloat top, jfloat right, jfloat bottom, jint dirHandle) {
143        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
144        SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle);
145        SkRect oval = SkRect::MakeLTRB(left, top, right, bottom);
146        obj->addOval(oval, dir);
147    }
148
149    static void addCircle(JNIEnv* env, jclass clazz, jlong objHandle, jfloat x, jfloat y,
150            jfloat radius, jint dirHandle) {
151        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
152        SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle);
153        obj->addCircle(x, y, radius, dir);
154    }
155
156    static void addArc(JNIEnv* env, jclass clazz, jlong objHandle, jfloat left, jfloat top,
157            jfloat right, jfloat bottom, jfloat startAngle, jfloat sweepAngle) {
158        SkRect oval = SkRect::MakeLTRB(left, top, right, bottom);
159        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
160        obj->addArc(oval, startAngle, sweepAngle);
161    }
162
163    static void addRoundRectXY(JNIEnv* env, jclass clazz, jlong objHandle, jfloat left, jfloat top,
164            jfloat right, jfloat bottom, jfloat rx, jfloat ry, jint dirHandle) {
165        SkRect rect = SkRect::MakeLTRB(left, top, right, bottom);
166        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
167        SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle);
168        obj->addRoundRect(rect, rx, ry, dir);
169    }
170
171    static void addRoundRect8(JNIEnv* env, jclass clazz, jlong objHandle, jfloat left, jfloat top,
172                jfloat right, jfloat bottom, jfloatArray array, jint dirHandle) {
173        SkRect rect = SkRect::MakeLTRB(left, top, right, bottom);
174        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
175        SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle);
176        AutoJavaFloatArray  afa(env, array, 8);
177#ifdef SK_SCALAR_IS_FLOAT
178        const float* src = afa.ptr();
179#else
180        #error Need to convert float array to SkScalar array before calling the following function.
181#endif
182        obj->addRoundRect(rect, src, dir);
183    }
184
185    static void addPath__PathFF(JNIEnv* env, jclass clazz, jlong objHandle, jlong srcHandle,
186            jfloat dx, jfloat dy) {
187        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
188        SkPath* src = reinterpret_cast<SkPath*>(srcHandle);
189        obj->addPath(*src, dx, dy);
190    }
191
192    static void addPath__Path(JNIEnv* env, jclass clazz, jlong objHandle, jlong srcHandle) {
193        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
194        SkPath* src = reinterpret_cast<SkPath*>(srcHandle);
195        obj->addPath(*src);
196    }
197
198    static void addPath__PathMatrix(JNIEnv* env, jclass clazz, jlong objHandle, jlong srcHandle,
199            jlong matrixHandle) {
200        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
201        SkPath* src = reinterpret_cast<SkPath*>(srcHandle);
202        SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
203        obj->addPath(*src, *matrix);
204    }
205
206    static void offset__FF(JNIEnv* env, jclass clazz, jlong objHandle, jfloat dx, jfloat dy) {
207        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
208        obj->offset(dx, dy);
209    }
210
211    static void setLastPoint(JNIEnv* env, jclass clazz, jlong objHandle, jfloat dx, jfloat dy) {
212        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
213        obj->setLastPt(dx, dy);
214    }
215
216    static void transform__MatrixPath(JNIEnv* env, jclass clazz, jlong objHandle, jlong matrixHandle,
217            jlong dstHandle) {
218        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
219        SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
220        SkPath* dst = reinterpret_cast<SkPath*>(dstHandle);
221        obj->transform(*matrix, dst);
222    }
223
224    static void transform__Matrix(JNIEnv* env, jclass clazz, jlong objHandle, jlong matrixHandle) {
225        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
226        SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
227        obj->transform(*matrix);
228    }
229
230    static jboolean op(JNIEnv* env, jclass clazz, jlong p1Handle, jlong p2Handle, jint opHandle,
231            jlong rHandle) {
232        SkPath* p1  = reinterpret_cast<SkPath*>(p1Handle);
233        SkPath* p2  = reinterpret_cast<SkPath*>(p2Handle);
234        SkPathOp op = static_cast<SkPathOp>(opHandle);
235        SkPath* r   = reinterpret_cast<SkPath*>(rHandle);
236        return Op(*p1, *p2, op, r);
237     }
238
239    typedef SkPoint (*bezierCalculation)(float t, const SkPoint* points);
240
241    static void addMove(std::vector<SkPoint>& segmentPoints, std::vector<float>& lengths,
242            const SkPoint& point) {
243        float length = 0;
244        if (!lengths.empty()) {
245            length = lengths.back();
246        }
247        segmentPoints.push_back(point);
248        lengths.push_back(length);
249    }
250
251    static void addLine(std::vector<SkPoint>& segmentPoints, std::vector<float>& lengths,
252            const SkPoint& toPoint) {
253        if (segmentPoints.empty()) {
254            segmentPoints.push_back(SkPoint::Make(0, 0));
255            lengths.push_back(0);
256        } else if (segmentPoints.back() == toPoint) {
257            return; // Empty line
258        }
259        float length = lengths.back() + SkPoint::Distance(segmentPoints.back(), toPoint);
260        segmentPoints.push_back(toPoint);
261        lengths.push_back(length);
262    }
263
264    static float cubicCoordinateCalculation(float t, float p0, float p1, float p2, float p3) {
265        float oneMinusT = 1 - t;
266        float oneMinusTSquared = oneMinusT * oneMinusT;
267        float oneMinusTCubed = oneMinusTSquared * oneMinusT;
268        float tSquared = t * t;
269        float tCubed = tSquared * t;
270        return (oneMinusTCubed * p0) + (3 * oneMinusTSquared * t * p1)
271                + (3 * oneMinusT * tSquared * p2) + (tCubed * p3);
272    }
273
274    static SkPoint cubicBezierCalculation(float t, const SkPoint* points) {
275        float x = cubicCoordinateCalculation(t, points[0].x(), points[1].x(),
276            points[2].x(), points[3].x());
277        float y = cubicCoordinateCalculation(t, points[0].y(), points[1].y(),
278            points[2].y(), points[3].y());
279        return SkPoint::Make(x, y);
280    }
281
282    static float quadraticCoordinateCalculation(float t, float p0, float p1, float p2) {
283        float oneMinusT = 1 - t;
284        return oneMinusT * ((oneMinusT * p0) + (t * p1)) + t * ((oneMinusT * p1) + (t * p2));
285    }
286
287    static SkPoint quadraticBezierCalculation(float t, const SkPoint* points) {
288        float x = quadraticCoordinateCalculation(t, points[0].x(), points[1].x(), points[2].x());
289        float y = quadraticCoordinateCalculation(t, points[0].y(), points[1].y(), points[2].y());
290        return SkPoint::Make(x, y);
291    }
292
293    // Subdivide a section of the Bezier curve, set the mid-point and the mid-t value.
294    // Returns true if further subdivision is necessary as defined by errorSquared.
295    static bool subdividePoints(const SkPoint* points, bezierCalculation bezierFunction,
296            float t0, const SkPoint &p0, float t1, const SkPoint &p1,
297            float& midT, SkPoint &midPoint, float errorSquared) {
298        midT = (t1 + t0) / 2;
299        float midX = (p1.x() + p0.x()) / 2;
300        float midY = (p1.y() + p0.y()) / 2;
301
302        midPoint = (*bezierFunction)(midT, points);
303        float xError = midPoint.x() - midX;
304        float yError = midPoint.y() - midY;
305        float midErrorSquared = (xError * xError) + (yError * yError);
306        return midErrorSquared > errorSquared;
307    }
308
309    // Divides Bezier curves until linear interpolation is very close to accurate, using
310    // errorSquared as a metric. Cubic Bezier curves can have an inflection point that improperly
311    // short-circuit subdivision. If you imagine an S shape, the top and bottom points being the
312    // starting and end points, linear interpolation would mark the center where the curve places
313    // the point. It is clearly not the case that we can linearly interpolate at that point.
314    // doubleCheckDivision forces a second examination between subdivisions to ensure that linear
315    // interpolation works.
316    static void addBezier(const SkPoint* points,
317            bezierCalculation bezierFunction, std::vector<SkPoint>& segmentPoints,
318            std::vector<float>& lengths, float errorSquared, bool doubleCheckDivision) {
319        typedef std::map<float, SkPoint> PointMap;
320        PointMap tToPoint;
321
322        tToPoint[0] = (*bezierFunction)(0, points);
323        tToPoint[1] = (*bezierFunction)(1, points);
324
325        PointMap::iterator iter = tToPoint.begin();
326        PointMap::iterator next = iter;
327        ++next;
328        while (next != tToPoint.end()) {
329            bool needsSubdivision = true;
330            SkPoint midPoint;
331            do {
332                float midT;
333                needsSubdivision = subdividePoints(points, bezierFunction, iter->first,
334                    iter->second, next->first, next->second, midT, midPoint, errorSquared);
335                if (!needsSubdivision && doubleCheckDivision) {
336                    SkPoint quarterPoint;
337                    float quarterT;
338                    needsSubdivision = subdividePoints(points, bezierFunction, iter->first,
339                        iter->second, midT, midPoint, quarterT, quarterPoint, errorSquared);
340                    if (needsSubdivision) {
341                        // Found an inflection point. No need to double-check.
342                        doubleCheckDivision = false;
343                    }
344                }
345                if (needsSubdivision) {
346                    next = tToPoint.insert(iter, PointMap::value_type(midT, midPoint));
347                }
348            } while (needsSubdivision);
349            iter = next;
350            next++;
351        }
352
353        // Now that each division can use linear interpolation with less than the allowed error
354        for (iter = tToPoint.begin(); iter != tToPoint.end(); ++iter) {
355            addLine(segmentPoints, lengths, iter->second);
356        }
357    }
358
359    static void createVerbSegments(const SkPath::Iter& pathIter, SkPath::Verb verb,
360            const SkPoint* points, std::vector<SkPoint>& segmentPoints,
361            std::vector<float>& lengths, float errorSquared, float errorConic) {
362        switch (verb) {
363            case SkPath::kMove_Verb:
364                addMove(segmentPoints, lengths, points[0]);
365                break;
366            case SkPath::kClose_Verb:
367                addLine(segmentPoints, lengths, points[0]);
368                break;
369            case SkPath::kLine_Verb:
370                addLine(segmentPoints, lengths, points[1]);
371                break;
372            case SkPath::kQuad_Verb:
373                addBezier(points, quadraticBezierCalculation, segmentPoints, lengths,
374                    errorSquared, false);
375                break;
376            case SkPath::kCubic_Verb:
377                addBezier(points, cubicBezierCalculation, segmentPoints, lengths,
378                    errorSquared, true);
379                break;
380            case SkPath::kConic_Verb: {
381                SkAutoConicToQuads converter;
382                const SkPoint* quads = converter.computeQuads(
383                        points, pathIter.conicWeight(), errorConic);
384                for (int i = 0; i < converter.countQuads(); i++) {
385                    // Note: offset each subsequent quad by 2, since end points are shared
386                    const SkPoint* quad = quads + i * 2;
387                    addBezier(quad, quadraticBezierCalculation, segmentPoints, lengths,
388                        errorConic, false);
389                }
390                break;
391            }
392            default:
393                static_assert(SkPath::kMove_Verb == 0
394                                && SkPath::kLine_Verb == 1
395                                && SkPath::kQuad_Verb == 2
396                                && SkPath::kConic_Verb == 3
397                                && SkPath::kCubic_Verb == 4
398                                && SkPath::kClose_Verb == 5
399                                && SkPath::kDone_Verb == 6,
400                        "Path enum changed, new types may have been added.");
401                break;
402        }
403    }
404
405    // Returns a float[] with each point along the path represented by 3 floats
406    // * fractional length along the path that the point resides
407    // * x coordinate
408    // * y coordinate
409    // Note that more than one point may have the same length along the path in
410    // the case of a move.
411    // NULL can be returned if the Path is empty.
412    static jfloatArray approximate(JNIEnv* env, jclass clazz, jlong pathHandle,
413            float acceptableError) {
414        SkPath* path = reinterpret_cast<SkPath*>(pathHandle);
415        SkASSERT(path);
416        SkPath::Iter pathIter(*path, false);
417        SkPath::Verb verb;
418        SkPoint points[4];
419        std::vector<SkPoint> segmentPoints;
420        std::vector<float> lengths;
421        float errorSquared = acceptableError * acceptableError;
422        float errorConic = acceptableError / 2; // somewhat arbitrary
423
424        while ((verb = pathIter.next(points, false)) != SkPath::kDone_Verb) {
425            createVerbSegments(pathIter, verb, points, segmentPoints, lengths,
426                    errorSquared, errorConic);
427        }
428
429        if (segmentPoints.empty()) {
430            int numVerbs = path->countVerbs();
431            if (numVerbs == 1) {
432                addMove(segmentPoints, lengths, path->getPoint(0));
433            } else {
434                // Invalid or empty path. Fall back to point(0,0)
435                addMove(segmentPoints, lengths, SkPoint());
436            }
437        }
438
439        float totalLength = lengths.back();
440        if (totalLength == 0) {
441            // Lone Move instructions should still be able to animate at the same value.
442            segmentPoints.push_back(segmentPoints.back());
443            lengths.push_back(1);
444            totalLength = 1;
445        }
446
447        size_t numPoints = segmentPoints.size();
448        size_t approximationArraySize = numPoints * 3;
449
450        float* approximation = new float[approximationArraySize];
451
452        int approximationIndex = 0;
453        for (size_t i = 0; i < numPoints; i++) {
454            const SkPoint& point = segmentPoints[i];
455            approximation[approximationIndex++] = lengths[i] / totalLength;
456            approximation[approximationIndex++] = point.x();
457            approximation[approximationIndex++] = point.y();
458        }
459
460        jfloatArray result = env->NewFloatArray(approximationArraySize);
461        env->SetFloatArrayRegion(result, 0, approximationArraySize, approximation);
462        delete[] approximation;
463        return result;
464    }
465
466    // ---------------- @FastNative -----------------------------
467
468    static jboolean isRect(JNIEnv* env, jclass clazz, jlong objHandle, jobject jrect) {
469        SkRect rect;
470        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
471        jboolean result = obj->isRect(&rect);
472        GraphicsJNI::rect_to_jrectf(rect, env, jrect);
473        return result;
474    }
475
476    // ---------------- @CriticalNative -------------------------
477
478    static void reset(jlong objHandle) {
479        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
480        obj->reset();
481    }
482
483    static void rewind(jlong objHandle) {
484        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
485        obj->rewind();
486    }
487
488    static jboolean isEmpty(jlong objHandle) {
489        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
490        return obj->isEmpty();
491    }
492
493    static jboolean isConvex(jlong objHandle) {
494        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
495        return obj->isConvex();
496    }
497
498    static jint getFillType(jlong objHandle) {
499        SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
500        return obj->getFillType();
501    }
502
503    static void setFillType(jlong pathHandle, jint ftHandle) {;
504        SkPath* path = reinterpret_cast<SkPath*>(pathHandle);
505        SkPath::FillType ft = static_cast<SkPath::FillType>(ftHandle);
506        path->setFillType(ft);
507    }
508};
509
510static const JNINativeMethod methods[] = {
511    {"nInit","()J", (void*) SkPathGlue::init},
512    {"nInit","(J)J", (void*) SkPathGlue::init_Path},
513    {"nFinalize", "(J)V", (void*) SkPathGlue::finalize},
514    {"nSet","(JJ)V", (void*) SkPathGlue::set},
515    {"nComputeBounds","(JLandroid/graphics/RectF;)V", (void*) SkPathGlue::computeBounds},
516    {"nIncReserve","(JI)V", (void*) SkPathGlue::incReserve},
517    {"nMoveTo","(JFF)V", (void*) SkPathGlue::moveTo__FF},
518    {"nRMoveTo","(JFF)V", (void*) SkPathGlue::rMoveTo},
519    {"nLineTo","(JFF)V", (void*) SkPathGlue::lineTo__FF},
520    {"nRLineTo","(JFF)V", (void*) SkPathGlue::rLineTo},
521    {"nQuadTo","(JFFFF)V", (void*) SkPathGlue::quadTo__FFFF},
522    {"nRQuadTo","(JFFFF)V", (void*) SkPathGlue::rQuadTo},
523    {"nCubicTo","(JFFFFFF)V", (void*) SkPathGlue::cubicTo__FFFFFF},
524    {"nRCubicTo","(JFFFFFF)V", (void*) SkPathGlue::rCubicTo},
525    {"nArcTo","(JFFFFFFZ)V", (void*) SkPathGlue::arcTo},
526    {"nClose","(J)V", (void*) SkPathGlue::close},
527    {"nAddRect","(JFFFFI)V", (void*) SkPathGlue::addRect},
528    {"nAddOval","(JFFFFI)V", (void*) SkPathGlue::addOval},
529    {"nAddCircle","(JFFFI)V", (void*) SkPathGlue::addCircle},
530    {"nAddArc","(JFFFFFF)V", (void*) SkPathGlue::addArc},
531    {"nAddRoundRect","(JFFFFFFI)V", (void*) SkPathGlue::addRoundRectXY},
532    {"nAddRoundRect","(JFFFF[FI)V", (void*) SkPathGlue::addRoundRect8},
533    {"nAddPath","(JJFF)V", (void*) SkPathGlue::addPath__PathFF},
534    {"nAddPath","(JJ)V", (void*) SkPathGlue::addPath__Path},
535    {"nAddPath","(JJJ)V", (void*) SkPathGlue::addPath__PathMatrix},
536    {"nOffset","(JFF)V", (void*) SkPathGlue::offset__FF},
537    {"nSetLastPoint","(JFF)V", (void*) SkPathGlue::setLastPoint},
538    {"nTransform","(JJJ)V", (void*) SkPathGlue::transform__MatrixPath},
539    {"nTransform","(JJ)V", (void*) SkPathGlue::transform__Matrix},
540    {"nOp","(JJIJ)Z", (void*) SkPathGlue::op},
541    {"nApproximate", "(JF)[F", (void*) SkPathGlue::approximate},
542
543    // ------- @FastNative below here ----------------------
544    {"nIsRect","(JLandroid/graphics/RectF;)Z", (void*) SkPathGlue::isRect},
545
546    // ------- @CriticalNative below here ------------------
547    {"nReset","(J)V", (void*) SkPathGlue::reset},
548    {"nRewind","(J)V", (void*) SkPathGlue::rewind},
549    {"nIsEmpty","(J)Z", (void*) SkPathGlue::isEmpty},
550    {"nIsConvex","(J)Z", (void*) SkPathGlue::isConvex},
551    {"nGetFillType","(J)I", (void*) SkPathGlue::getFillType},
552    {"nSetFillType","(JI)V", (void*) SkPathGlue::setFillType},
553};
554
555int register_android_graphics_Path(JNIEnv* env) {
556    return RegisterMethodsOrDie(env, "android/graphics/Path", methods, NELEM(methods));
557
558    static_assert(0  == SkPath::kCW_Direction,  "direction_mismatch");
559    static_assert(1  == SkPath::kCCW_Direction, "direction_mismatch");
560}
561
562}
563