@nativescript/canvas 2.0.0-alpha.2 → 2.0.0-alpha.21

package/Canvas2D/CanvasRenderingContext2D/{index.android.js → index.js}

@@ -1,4 +1,3 @@
-import { CanvasRenderingContext2DBase } from './common';
 import { CanvasGradient } from '../CanvasGradient';
 import { Path2D } from '../Path2D';
 import { ImageData } from '../ImageData';
@@ -9,10 +8,9 @@ import { CanvasPattern } from '../CanvasPattern';
 import { Canvas } from '../../Canvas';
 import { Helpers } from '../../helpers';
 let ctor;
-export class CanvasRenderingContext2D extends CanvasRenderingContext2DBase {
+export class CanvasRenderingContext2D {
     constructor(context, contextOptions) {
-        super();
-        this._methodCache = new Map();
+        this._type = 'none';
         /*const width = context.getDrawingBufferWidth(); // can use  getMeasuredWidth / getMeasuredHeight
         const height = context.getDrawingBufferHeight();
 
@@ -26,6 +24,9 @@ export class CanvasRenderingContext2D extends CanvasRenderingContext2DBase {
         const ctxPtr = BigInt(context.toString());
         this.context = ctor(ctxPtr);
     }
+    get type() {
+        return this._type;
+    }
     get native() {
         return this.context;
     }
@@ -33,161 +34,130 @@ export class CanvasRenderingContext2D extends CanvasRenderingContext2DBase {
         return this._canvas;
     }
     get shadowColor() {
-        this.log('shadowColor');
         return this.context.shadowColor;
     }
     set shadowColor(color) {
-        this.log('shadowColor value:', color);
-        this._ensureLayoutBeforeDraw();
         if (this.context) {
+            this._ensureLayoutBeforeDraw();
             this.context.shadowColor = color;
         }
     }
     get font() {
-        this.log('get font');
         return this.context.font;
     }
     set font(value) {
-        this.log('set font value:', value);
         if (this.context) {
+            this._ensureLayoutBeforeDraw();
             this.context.font = value;
         }
     }
     get direction() {
-        this.log('direction');
         return this.context.direction;
     }
     set direction(value) {
-        this.log('direction value:', value);
-        this._ensureLayoutBeforeDraw();
         if (this.context) {
+            this._ensureLayoutBeforeDraw();
             this.context.direction = value;
         }
     }
     get globalAlpha() {
-        this.log('globalAlpha');
         return this.context.globalAlpha;
     }
     set globalAlpha(alpha) {
-        this.log('globalAlpha value:', alpha);
-        this._ensureLayoutBeforeDraw();
         if (this.context) {
+            this._ensureLayoutBeforeDraw();
             this.context.globalAlpha = alpha;
         }
     }
     get imageSmoothingEnabled() {
-        this.log('imageSmoothingEnabled');
         return this.context.imageSmoothingEnabled;
     }
     set imageSmoothingEnabled(enabled) {
-        this.log('imageSmoothingEnabled value:', enabled);
-        this._ensureLayoutBeforeDraw();
         if (this.context) {
+            this._ensureLayoutBeforeDraw();
             this.context.imageSmoothingEnabled = enabled;
         }
     }
     get imageSmoothingQuality() {
-        this.log('imageSmoothingQuality');
         return this.context.imageSmoothingQuality;
     }
     set imageSmoothingQuality(quality) {
-        this.log('imageSmoothingQuality value:', quality);
         this._ensureLayoutBeforeDraw();
         this.context.imageSmoothingQuality = quality;
     }
     get lineDashOffset() {
-        this.log('lineDashOffset');
         return this.context.lineDashOffset;
     }
     set lineDashOffset(offset) {
-        this.log('lineDashOffset value:', offset);
-        this._ensureLayoutBeforeDraw();
         if (this.context) {
+            this._ensureLayoutBeforeDraw();
             this.context.lineDashOffset = offset;
         }
     }
     get lineJoin() {
-        this.log('lineJoin');
         return this.context.lineJoin;
     }
     set lineJoin(join) {
-        this.log('lineJoin value:', join);
         this._ensureLayoutBeforeDraw();
         this.context.lineJoin = join;
     }
     get lineCap() {
-        this.log('lineCap');
         return this.context.lineCap;
     }
     set lineCap(cap) {
-        this.log('lineCap value:', cap);
         this._ensureLayoutBeforeDraw();
         this.context.lineCap = cap;
     }
     get miterLimit() {
-        this.log('miterLimit value:');
         return this.context.miterLimit;
     }
     set miterLimit(limit) {
-        this.log('miterLimit value:', limit);
         this._ensureLayoutBeforeDraw();
         this.context.miterLimit = limit;
     }
     get shadowBlur() {
-        this.log('shadowBlur');
         return this.context.shadowBlur;
     }
     set shadowBlur(blur) {
-        this.log('shadowBlur value:', blur);
         this._ensureLayoutBeforeDraw();
         this.context.shadowBlur = blur;
     }
     get shadowOffsetX() {
-        this.log('shadowOffsetX');
         return this.context.shadowOffsetX;
     }
     set shadowOffsetX(x) {
-        this.log('shadowOffsetX value:', x);
-        this._ensureLayoutBeforeDraw();
         if (this.context) {
+            this._ensureLayoutBeforeDraw();
             this.context.shadowOffsetX = x;
         }
     }
     get shadowOffsetY() {
-        this.log('shadowOffsetY');
         return this.context.shadowOffsetY;
     }
     set shadowOffsetY(y) {
-        this.log('shadowOffsetY value:', y);
-        this._ensureLayoutBeforeDraw();
         if (this.context) {
+            this._ensureLayoutBeforeDraw();
             this.context.shadowOffsetY = y;
         }
     }
     get textAlign() {
-        this.log('textAlign');
         return this.context.textAlign;
     }
     set textAlign(alignment) {
-        this.log('textAlign value:', alignment);
         this._ensureLayoutBeforeDraw();
         this.context.setTextAlign = alignment;
     }
     get globalCompositeOperation() {
-        this.log('globalCompositeOperation');
         return this.context.globalCompositeOperation;
     }
     set globalCompositeOperation(composite) {
-        this.log('globalCompositeOperation value:', composite);
         this._ensureLayoutBeforeDraw();
         this.context.globalCompositeOperation = composite;
     }
     get fillStyle() {
-        this.log('fillStyle');
         return this.context.fillStyle;
     }
     set fillStyle(color) {
-        this.log('fillStyle:', color);
         if (color === undefined || color === null) {
             return;
         }
@@ -200,19 +170,16 @@ export class CanvasRenderingContext2D extends CanvasRenderingContext2DBase {
         }
     }
     get filter() {
-        this.log('get filter');
         return this.context.filter;
     }
     set filter(value) {
-        this.log('set filter', value);
+        this._ensureLayoutBeforeDraw();
         this.context.filter = value;
     }
     get strokeStyle() {
-        this.log('strokeStyle');
         return this.context.strokeStyle;
     }
     set strokeStyle(color) {
-        this.log('strokeStyle:', color);
         if (color === undefined || color === null) {
             return;
         }
@@ -225,84 +192,57 @@ export class CanvasRenderingContext2D extends CanvasRenderingContext2DBase {
         }
     }
     get lineWidth() {
-        this.log('lineWidth');
         return this.context.lineWidth;
     }
     set lineWidth(width) {
-        this.log('lineWidth value:', width);
         this._ensureLayoutBeforeDraw();
         this.context.lineWidth = width;
     }
-    _getMethod(name) {
-        const cached = this._methodCache.get(name);
-        if (cached === undefined) {
-            const ret = this.context[name];
-            this._methodCache.set(name, ret);
-            return ret;
-        }
-        return cached;
-    }
-    __toDataURL() {
-        const __toDataURL = this._getMethod('__toDataURL');
-        return __toDataURL(arguments[0], arguments[1]);
+    __toDataURL(type = 'image/jpg', quality = 92) {
+        return this.context.__toDataURL(type, quality);
     }
     addHitRegion(region) { }
     arc(x, y, radius, startAngle, endAngle, anticlockwise = false) {
-        this.log('arc value:', x, y, radius, startAngle, endAngle, anticlockwise);
         this._ensureLayoutBeforeDraw();
-        const arc = this._getMethod('arc');
-        arc(x, y, radius, startAngle, endAngle, anticlockwise);
+        this.context.arc(x, y, radius, startAngle, endAngle, anticlockwise);
     }
     arcTo(x1, y1, x2, y2, radius) {
-        this.log('arcTo value:', x1, y1, x2, y2, radius);
         this._ensureLayoutBeforeDraw();
-        const arcTo = this._getMethod('arcTo');
-        arcTo(x1, y1, x2, y2, radius);
+        this.context.arcTo(x1, y1, x2, y2, radius);
     }
     beginPath() {
-        this.log('beginPath');
         this._ensureLayoutBeforeDraw();
-        const beginPath = this._getMethod('beginPath');
-        beginPath();
+        this.context.beginPath();
     }
     bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y) {
-        this.log('bezierCurveTo value:', cp1x, cp1y, cp2x, cp2y, x, y);
         this._ensureLayoutBeforeDraw();
-        const bezierCurveTo = this._getMethod('bezierCurveTo');
-        bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y);
+        this.context.bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y);
     }
     clearHitRegions() { }
     clearRect(x, y, width, height) {
-        this.log('clearRect value:', x, y, width, height);
         this._ensureLayoutBeforeDraw();
-        const clearRect = this._getMethod('clearRect');
-        clearRect(x, y, width, height);
+        this.context.clearRect(x, y, width, height);
     }
     clip(...args) {
-        this.log('clip value:', ...args);
         this._ensureLayoutBeforeDraw();
-        const clip = this._getMethod('clip');
         if (typeof args[0] === 'string') {
-            clip(args[0]);
+            this.context.clip(args[0]);
         }
         else if (args[0] instanceof Path2D && typeof args[1] === 'string') {
-            clip(args[0].native, args[1]);
+            this.context.clip(args[0].native, args[1]);
         }
         else if (args[0] instanceof Path2D) {
-            clip(args[0].native);
+            this.context.clip(args[0].native);
         }
         else {
-            clip();
+            this.context.clip();
         }
     }
     closePath() {
-        this.log('closePath');
         this._ensureLayoutBeforeDraw();
-        const closePath = this._getMethod('closePath');
-        closePath();
+        this.context.closePath();
     }
     createImageData(width, height) {
-        this.log('createImageData value:', arguments);
         if (width instanceof ImageData) {
             return new ImageData(width.width, width.height);
         }
@@ -311,37 +251,49 @@ export class CanvasRenderingContext2D extends CanvasRenderingContext2DBase {
         }
     }
     createLinearGradient(x0, y0, x1, y1) {
-        this.log('createLinearGradient value:', x0, y0, x1, y1);
         this._ensureLayoutBeforeDraw();
-        const createLinearGradient = this._getMethod('createLinearGradient');
-        return CanvasGradient.fromNative(createLinearGradient(x0, y0, x1, y1));
+        return CanvasGradient.fromNative(this.context.createLinearGradient(x0, y0, x1, y1));
     }
     createPattern(image, repetition) {
-        var _a;
-        this.log('createPattern value:', image, repetition);
         this._ensureLayoutBeforeDraw();
         if (repetition === undefined || typeof repetition !== 'string') {
             const e = new Error('The string did not match the expected pattern.');
             e.name = 'SyntaxError';
             throw e;
         }
-        const createPattern = this._getMethod('createPattern');
+        //const createPattern = this._getMethod('createPattern');
+        //const createPattern = this.context.createPattern;
         let img;
-        if ((image === null || image === void 0 ? void 0 : image._type) === '2d' || ((_a = image === null || image === void 0 ? void 0 : image._type) === null || _a === void 0 ? void 0 : _a.indexOf('webgl')) > -1) {
+        if (image?._type === '2d' || image?._type?.indexOf('webgl') > -1) {
             img = image.native;
         }
         else if (image instanceof ImageSource) {
-            img = image.android;
-            const ptr = this._getMethod('__getPointer');
-            const createPattern = this._getMethod('__createPatternWithNative');
-            const pattern = org.nativescript.canvas.NSCCanvasRenderingContext2D.createPattern(long(ptr), img, repetition);
-            return new CanvasPattern(createPattern(pattern));
-        }
-        else if (image instanceof android.graphics.Bitmap) {
-            const ptr = this._getMethod('__getPointer');
-            const createPattern = this._getMethod('__createPatternWithNative');
-            const pattern = org.nativescript.canvas.NSCCanvasRenderingContext2D.createPattern(long(ptr), image, repetition);
-            return new CanvasPattern(createPattern(pattern));
+            //const ptr = this.context.__getPointer; //this._getMethod('__getPointer');
+            //const createPattern = this.context.__createPatternWithNative; //this._getMethod('__createPatternWithNative');
+            if (global.isAndroid) {
+                img = image.android;
+                const pattern = org.nativescript.canvas.NSCCanvasRenderingContext2D.createPattern(long(this.context.__getPointer()), img, repetition);
+                return new CanvasPattern(this.context.__createPatternWithNative(pattern));
+            }
+            if (global.isIOS) {
+                img = image.ios;
+                const pattern = NSCCanvasRenderingContext2D.createPattern(this.context.__getPointer(), img, repetition);
+                return new CanvasPattern(this.context.__createPatternWithNative(pattern));
+            }
+            return null;
+        }
+        else if (global.isAndroid && image instanceof android.graphics.Bitmap) {
+            //const ptr = this.context.__getPointer; //this._getMethod('__getPointer');
+            const createPattern = this.context.__createPatternWithNative; //this._getMethod('__createPatternWithNative');
+            if (global.isAndroid) {
+                const pattern = org.nativescript.canvas.NSCCanvasRenderingContext2D.createPattern(long(this.context.__getPointer()), image, repetition);
+                return new CanvasPattern(this.context.__createPatternWithNative(pattern));
+            }
+            if (global.isIOS) {
+                const pattern = NSCCanvasRenderingContext2D.createPattern(this.context.__getPointer(), image, repetition);
+                return new CanvasPattern(this.context.__createPatternWithNative(pattern));
+            }
+            return null;
         }
         else if (image instanceof ImageAsset) {
             img = image.native;
@@ -350,18 +302,27 @@ export class CanvasRenderingContext2D extends CanvasRenderingContext2DBase {
             img = image.native;
         }
         else if (image && typeof image.tagName === 'string' && (image.tagName === 'IMG' || image.tagName === 'IMAGE')) {
-            if (image._image instanceof android.graphics.Bitmap) {
+            if (global.isAndroid && image._image instanceof android.graphics.Bitmap) {
+                //todo ios
                 img = image._image;
             }
             else if (image._asset instanceof ImageAsset) {
                 img = image._asset.native;
             }
             else if (typeof image.src === 'string') {
-                img = ImageSource.fromFileSync(image.src).android;
-                const ptr = this._getMethod('__getPointer');
-                const createPattern = this._getMethod('__createPatternWithNative');
-                const pattern = org.nativescript.canvas.NSCCanvasRenderingContext2D.createPattern(long(ptr), img, repetition);
-                return new CanvasPattern(createPattern(pattern));
+                //const ptr = this.context.__getPointer; //this._getMethod('__getPointer');
+                //const createPattern = this.context.__createPatternWithNative; //this._getMethod('__createPatternWithNative');
+                if (global.isAndroid) {
+                    img = ImageSource.fromFileSync(image.src).android;
+                    const pattern = org.nativescript.canvas.NSCCanvasRenderingContext2D.createPattern(long(this.context.__getPointer()), img, repetition);
+                    return new CanvasPattern(this.context.__createPatternWithNative(pattern));
+                }
+                if (global.isiOS) {
+                    img = ImageSource.fromFileSync(image.src).android;
+                    const pattern = NSCCanvasRenderingContext2D.createPattern(this.context.__getPointer(), img, repetition);
+                    return new CanvasPattern(this.context.__createPatternWithNative(pattern));
+                }
+                return null;
             }
         }
         else if (image && typeof image.tagName === 'string' && image.tagName === 'CANVAS' && image._canvas instanceof Canvas) {
@@ -373,64 +334,121 @@ export class CanvasRenderingContext2D extends CanvasRenderingContext2DBase {
         if (!img) {
             return null;
         }
-        return new CanvasPattern(createPattern(img, repetition));
+        return new CanvasPattern(this.context.createPattern(img, repetition));
     }
     createRadialGradient(x0, y0, r0, x1, y1, r1) {
-        this.log('createRadialGradient value:', x0, y0, r0, x1, y1, r1);
         this._ensureLayoutBeforeDraw();
-        const createRadialGradient = this._getMethod('createRadialGradient');
-        return CanvasGradient.fromNative(createRadialGradient(x0, y0, r0, x1, y1, r1));
+        //const createRadialGradient = this._getMethod('createRadialGradient');
+        return CanvasGradient.fromNative(this.context.createRadialGradient(x0, y0, r0, x1, y1, r1));
+    }
+    drawPaint(color) {
+        this._ensureLayoutBeforeDraw();
+        //const drawPaint = this._getMethod('drawPaint');
+        this.context.drawPaint(color);
+    }
+    drawPoint(x, y) {
+        this._ensureLayoutBeforeDraw();
+        //const drawPoint = this._getMethod('drawPoint');
+        this.context.drawPoint(x, y);
+    }
+    drawPoints(mode, points) {
+        this._ensureLayoutBeforeDraw();
+        //const drawPoints = this._getMethod('drawPoints');
+        this.context.drawPoints(mode, points);
     }
     drawFocusIfNeeded(...args) { }
     drawImage(...args) {
-        var _a;
-        this.log('drawImage value:', ...args);
         this._ensureLayoutBeforeDraw();
-        const drawImage = this._getMethod('drawImage');
-        let image = args[0];
-        if ((image === null || image === void 0 ? void 0 : image._type) === '2d' || ((_a = image === null || image === void 0 ? void 0 : image._type) === null || _a === void 0 ? void 0 : _a.indexOf('webgl')) > -1) {
-            image = image.native;
-        }
-        else if (image instanceof ImageAsset) {
-            image = image.native;
-        }
-        else if (image instanceof ImageSource) {
-            image = image.android;
-            const ptr = this._getMethod('__getPointer');
-            const makeDirty = this._getMethod('__makeDirty');
+        //const drawImage = this.context.drawImage; //this._getMethod('drawImage');
+        const drawNativeImage = (args, image) => {
+            //const ptr = this.context.__getPointer; //this._getMethod('__getPointer');
+            //const makeDirty = this.context.__makeDirty; //this._getMethod('__makeDirty');
             let dirty = false;
             if (args.length === 3) {
-                dirty = org.nativescript.canvas.NSCCanvasRenderingContext2D.drawImage(long(ptr), image, args[1], args[2]);
+                if (global.isAndroid) {
+                    dirty = org.nativescript.canvas.NSCCanvasRenderingContext2D.drawImage(long(this.context.__getPointer()), image, args[1], args[2]);
+                }
+                if (global.isIOS) {
+                    dirty = NSCCanvasRenderingContext2D.drawImage(this.context.__getPointer(), image, args[1], args[2]);
+                }
             }
             else if (args.length === 5) {
-                dirty = org.nativescript.canvas.NSCCanvasRenderingContext2D.drawImage(long(ptr), image, args[1], args[2], args[3], args[4]);
+                if (global.isAndroid) {
+                    dirty = org.nativescript.canvas.NSCCanvasRenderingContext2D.drawImage(long(this.context.__getPointer()), image, args[1], args[2], args[3], args[4]);
+                }
+                if (global.isIOS) {
+                    dirty = NSCCanvasRenderingContext2D.drawImage(this.context.__getPointer(), image, args[1], args[2], args[3], args[4]);
+                }
             }
             else if (args.length === 9) {
-                dirty = org.nativescript.canvas.NSCCanvasRenderingContext2D.drawImage(long(ptr), image, args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8]);
+                if (global.Android) {
+                    dirty = org.nativescript.canvas.NSCCanvasRenderingContext2D.drawImage(long(this.context.__getPointer()), image, args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8]);
+                }
+                if (global.isIOS) {
+                    dirty = NSCCanvasRenderingContext2D.drawImage(this.context.__getPointer(), image, args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8]);
+                }
             }
             if (dirty) {
-                makeDirty();
+                this.context.__makeDirty();
+            }
+        };
+        let image = args[0];
+        if (image?._type === '2d' || image?._type?.indexOf('webgl') > -1) {
+            image = image.native;
+        }
+        else if (image instanceof ImageAsset) {
+            image = image.native;
+        }
+        else if (image instanceof ImageSource) {
+            if (global.isAndroid) {
+                drawNativeImage(args, image.android);
+            }
+            if (global.isIOS) {
+                drawNativeImage(args, image.ios);
             }
             return;
         }
-        else if (image instanceof android.graphics.Bitmap) {
-            image = image;
+        else if (global.isAndroid && image instanceof android.graphics.Bitmap) {
+            drawNativeImage(args, image);
+            return;
+        }
+        else if (global.isIOS && image instanceof UIImage) {
+            drawNativeImage(args, image);
+            return;
         }
         else if (image instanceof Canvas) {
             image = image.native;
         }
         else if (image && typeof image.tagName === 'string' && (image.tagName === 'IMG' || image.tagName === 'IMAGE')) {
             if (image._imageSource instanceof ImageSource) {
-                image = image._imageSource.android;
+                if (global.isAndroid) {
+                    drawNativeImage(args, image._imageSource.android);
+                }
+                if (global.isIOS) {
+                    drawNativeImage(args, image._imageSource.ios);
+                }
+                return;
             }
-            else if (image._image instanceof android.graphics.Bitmap) {
-                image = image._image;
+            else if (global.isAndroid && image._image instanceof android.graphics.Bitmap) {
+                drawNativeImage(args, image._image);
+                return;
+            }
+            else if (global.isIOS && image._image instanceof UIImage) {
+                drawNativeImage(args, image._image);
+                return;
             }
             else if (image._asset instanceof ImageAsset) {
                 image = image._asset.native;
             }
             else if (typeof image.src === 'string') {
                 image = ImageSource.fromFileSync(image.src).android;
+                if (global.isAndroid) {
+                    drawNativeImage(args, image.android);
+                }
+                if (global.isIOS) {
+                    drawNativeImage(args, image.ios);
+                }
+                return;
             }
         }
         else if (image && typeof image.tagName === 'string' && image.tagName === 'CANVAS' && image._canvas instanceof Canvas) {
@@ -440,239 +458,212 @@ export class CanvasRenderingContext2D extends CanvasRenderingContext2DBase {
             image = image.native;
         }
         if (args.length === 3) {
-            drawImage(image, args[1], args[2]);
+            this.context.drawImage(image, args[1], args[2]);
         }
         else if (args.length === 5) {
-            drawImage(image, args[1], args[2], args[3], args[4]);
+            this.context.drawImage(image, args[1], args[2], args[3], args[4]);
         }
         else if (args.length === 9) {
-            drawImage(image, args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8]);
+            this.context.drawImage(image, args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8]);
         }
     }
     ellipse(x, y, radiusX, radiusY, rotation, startAngle, endAngle, anticlockwise = false) {
-        this.log('ellipse value:', x, y, radiusX, radiusY, rotation, startAngle, endAngle, anticlockwise);
         this._ensureLayoutBeforeDraw();
-        const ellipse = this._getMethod('ellipse');
-        ellipse(x, y, radiusX, radiusY, rotation, startAngle, endAngle, anticlockwise);
+        //const ellipse = this._getMethod('ellipse');
+        this.context.ellipse(x, y, radiusX, radiusY, rotation, startAngle, endAngle, anticlockwise);
     }
     fill(...args) {
-        this.log('fill value:', ...args);
         this._ensureLayoutBeforeDraw();
-        const fill = this._getMethod('fill');
+        //const fill = this.context.fill; //this._getMethod('fill');
         if (typeof args[0] === 'string') {
-            fill(args[0]);
+            this.context.fill(args[0]);
         }
         else if (args[0] instanceof Path2D && typeof args[1] === 'string') {
-            fill(args[0].native, args[1]);
+            this.context.fill(args[0].native, args[1]);
         }
         else if (args[0] instanceof Path2D) {
-            fill(args[0].native);
+            this.context.fill(args[0].native);
         }
         else {
-            fill();
+            this.context.fill();
         }
     }
     fillRect(x, y, width, height) {
-        this.log('fillRect value:', x, y, width, height);
         this._ensureLayoutBeforeDraw();
-        const fillRect = this._getMethod('fillRect');
-        fillRect(x, y, width, height);
+        //const fillRect = this._getMethod('fillRect');
+        this.context.fillRect(x, y, width, height);
     }
     fillText(text, x, y, maxWidth) {
-        this.log('fillText value:', text, x, y, maxWidth);
         this._ensureLayoutBeforeDraw();
-        const fillText = this._getMethod('fillText');
+        //const fillText = this.context.fillText; //this._getMethod('fillText');
         if (typeof maxWidth === 'number') {
-            fillText(text + '', x, y, maxWidth);
+            this.context.fillText(text + '', x, y, maxWidth);
         }
         else {
-            fillText(text + '', x, y);
+            this.context.fillText(text + '', x, y);
         }
     }
     getImageData(sx, sy, sw, sh) {
-        this.log('getImageData value:', sx, sy, sw, sh);
         this._ensureLayoutBeforeDraw();
-        const getImageData = this._getMethod('getImageData');
-        return ImageData.fromNative(getImageData(sx, sy, sw, sh));
+        //const getImageData = this._getMethod('getImageData');
+        return ImageData.fromNative(this.context.getImageData(sx, sy, sw, sh));
     }
     getLineDash() {
-        this.log('getLineDash');
         this._ensureLayoutBeforeDraw();
-        const getLineDash = this._getMethod('getLineDash');
-        return getLineDash();
+        //const getLineDash = this._getMethod('getLineDash');
+        return this.context.getLineDash();
     }
     isPointInPath(...args) {
-        this.log('isPointInPath value:', ...args);
         this._ensureLayoutBeforeDraw();
-        const isPointInPath = this._getMethod('isPointInPath');
+        //const isPointInPath = this.context.isPointInPath; //this._getMethod('isPointInPath');
         if (args.length === 2) {
-            return isPointInPath(args[0], args[1]);
+            return this.context.isPointInPath(args[0], args[1]);
         }
         else if (args.length === 3) {
-            return isPointInPath(args[0], args[1], args[2]);
+            return this.context.isPointInPath(args[0], args[1], args[2]);
         }
         else if (args.length === 4 && args[0] instanceof Path2D) {
-            return isPointInPath(args[0].native, args[1], args[2], args[3]);
+            return this.context.isPointInPath(args[0].native, args[1], args[2], args[3]);
         }
         return false;
     }
     isPointInStroke(...args) {
-        this.log('isPointInStroke value:', ...args);
         this._ensureLayoutBeforeDraw();
-        const isPointInStroke = this._getMethod('isPointInStroke');
+        //const isPointInStroke = this.context.isPointInStroke; // this._getMethod('isPointInStroke');
         if (args.length === 2) {
-            return isPointInStroke(args[0], args[1]);
+            return this.context.isPointInStroke(args[0], args[1]);
         }
         else if (args.length === 3 && args[0] instanceof Path2D) {
-            return isPointInStroke(args[0].native, args[1], args[2]);
+            return this.context.isPointInStroke(args[0].native, args[1], args[2]);
         }
         return false;
     }
     lineTo(x, y) {
-        this.log('lineTo value:', x, y);
         this._ensureLayoutBeforeDraw();
-        const lineTo = this._getMethod('lineTo');
-        lineTo(x, y);
+        //const lineTo = this._getMethod('lineTo');
+        this.context.lineTo(x, y);
     }
     measureText(text) {
-        this.log('measureText value:', text);
         this._ensureLayoutBeforeDraw();
-        const measureText = this._getMethod('measureText');
-        return new TextMetrics(measureText(text));
+        //const measureText = this._getMethod('measureText');
+        return new TextMetrics(this.context.measureText(text));
     }
     moveTo(x, y) {
-        this.log('moveTo value:', x, y);
         this._ensureLayoutBeforeDraw();
-        const moveTo = this._getMethod('moveTo');
-        moveTo(x, y);
+        //const moveTo = this._getMethod('moveTo');
+        this.context.moveTo(x, y);
     }
     putImageData(...args) {
-        this.log('putImageData value:', ...args);
         this._ensureLayoutBeforeDraw();
         if (!args) {
             return;
         }
-        const putImageData = this._getMethod('putImageData');
+        //const putImageData = this.context.putImageData; //this._getMethod('putImageData');
         let data = args[0];
         if (args.length === 3) {
-            putImageData(data.native, args[1], args[2]);
+            this.context.putImageData(data.native, args[1], args[2]);
         }
         else if (args.length === 7) {
-            putImageData(data.native, args[1], args[2], args[3], args[4], args[5], args[6]);
+            this.context.putImageData(data.native, args[1], args[2], args[3], args[4], args[5], args[6]);
         }
     }
     quadraticCurveTo(cpx, cpy, x, y) {
-        this.log('quadraticCurveTo value:', cpx, cpy, x, y);
         this._ensureLayoutBeforeDraw();
-        const quadraticCurveTo = this._getMethod('quadraticCurveTo');
-        quadraticCurveTo(cpx, cpy, x, y);
+        //const quadraticCurveTo = this._getMethod('quadraticCurveTo');
+        this.context.quadraticCurveTo(cpx, cpy, x, y);
     }
     rect(x, y, width, height) {
-        this.log('rect value:', x, y, width, height);
         this._ensureLayoutBeforeDraw();
-        const rect = this._getMethod('rect');
-        rect(x, y, width, height);
+        //const rect = this._getMethod('rect');
+        this.context.rect(x, y, width, height);
+    }
+    roundRect(x, y, width, height, radii) {
+        this._ensureLayoutBeforeDraw();
+        //const roundRect = this._getMethod('roundRect');
+        this.context.roundRect(x, y, width, height, radii);
     }
     removeHitRegion(id) { }
     resetTransform() {
-        this.log('resetTransform value:');
         this._ensureLayoutBeforeDraw();
-        const resetTransform = this._getMethod('resetTransform');
-        resetTransform();
+        //const resetTransform = this._getMethod('resetTransform');
+        this.context.resetTransform();
     }
     restore() {
-        this.log('restore');
         this._ensureLayoutBeforeDraw();
-        const restore = this._getMethod('restore');
-        restore();
+        //const restore = this._getMethod('restore');
+        this.context.restore();
     }
     rotate(angle) {
-        this.log('rotate value:', angle);
         this._ensureLayoutBeforeDraw();
-        const rotate = this._getMethod('rotate');
-        rotate(angle);
+        //const rotate = this._getMethod('rotate');
+        this.context.rotate(angle);
     }
     save() {
-        this.log('save');
         this._ensureLayoutBeforeDraw();
-        const save = this._getMethod('save');
-        save();
+        //const save = this._getMethod('save');
+        this.context.save();
     }
     scale(x, y) {
-        this.log('scale value:', x, y);
         this._ensureLayoutBeforeDraw();
-        const scale = this._getMethod('scale');
-        scale(x, y);
+        //const scale = this._getMethod('scale');
+        this.context.scale(x, y);
     }
     scrollPathIntoView(path) { }
     setLineDash(segments) {
-        this.log('setLineDash value:', segments);
         this._ensureLayoutBeforeDraw();
-        const setLineDash = this._getMethod('setLineDash');
-        setLineDash(segments);
+        //const setLineDash = this._getMethod('setLineDash');
+        this.context.setLineDash(segments);
     }
     setTransform(a, b, c, d, e, f) {
-        this.log('setTransform value:', a, b, c, d, e, f);
         this._ensureLayoutBeforeDraw();
-        const setTransform = this._getMethod('setTransform');
-        setTransform(a, b, c, d, e, f);
+        //const setTransform = this._getMethod('setTransform');
+        this.context.setTransform(a, b, c, d, e, f);
     }
     stroke(path) {
-        this.log('stroke value:', path);
         this._ensureLayoutBeforeDraw();
-        const stroke = this._getMethod('stroke');
+        //const stroke = this.context.stroke; //this._getMethod('stroke');
         if (path) {
-            stroke(path.native);
+            this.context.stroke(path.native);
         }
         else {
-            stroke();
+            this.context.stroke();
         }
     }
     strokeRect(x, y, width, height) {
-        this.log('strokeRect value:', x, y, width, height);
         this._ensureLayoutBeforeDraw();
-        const strokeRect = this._getMethod('strokeRect');
-        strokeRect(x, y, width, height);
+        //const strokeRect = this._getMethod('strokeRect');
+        this.context.strokeRect(x, y, width, height);
     }
     strokeText(text, x, y, maxWidth) {
-        this.log('strokeText value:', text, x, y, maxWidth);
         this._ensureLayoutBeforeDraw();
-        const strokeText = this._getMethod('strokeText');
+        //const strokeText = this.context.strokeText; //this._getMethod('strokeText');
         if (typeof maxWidth === 'number') {
-            strokeText(text + '', x, y, maxWidth);
+            this.context.strokeText(text + '', x, y, maxWidth);
         }
         else {
-            strokeText(text + '', x, y);
+            this.context.strokeText(text + '', x, y);
         }
     }
     transform(a, b, c, d, e, f) {
-        this.log('transform value:', a, b, c, d, e, f);
         this._ensureLayoutBeforeDraw();
-        const transform = this._getMethod('transform');
-        transform(a, b, c, d, e, f);
+        //const transform = this._getMethod('transform');
+        this.context.transform(a, b, c, d, e, f);
     }
     translate(x, y) {
-        this.log('translate value:', x, y);
         this._ensureLayoutBeforeDraw();
-        const translate = this._getMethod('translate');
-        translate(x, y);
+        //const translate = this._getMethod('translate');
+        this.context.translate(x, y);
     }
     _ensureLayoutBeforeDraw() {
-        if (this.canvas) {
+        if (this.canvas !== undefined) {
             this.canvas._layoutNative();
         }
     }
-    log(message, ...args) {
-        if (!CanvasRenderingContext2D.isDebug) {
-            return;
-        }
-        console.log(message, args);
-    }
 }
-CanvasRenderingContext2D.isDebug = false;
+CanvasRenderingContext2D.isDebug = true;
 (() => {
     Helpers.initialize();
     //ctor = global.CanvasJSIModule.create2DContext;
-    ctor = global.CanvasJSIModule.create2DContextWithPointer;
+    ctor = global.CanvasModule.create2DContextWithPointer;
 })();
-//# sourceMappingURL=index.android.js.map
+//# sourceMappingURL=index.js.map