feat: Scoped Packages (#7911)

* chore: move tns-core-modules to nativescript-core * chore: preparing compat generate script * chore: add missing definitions * chore: no need for http-request to be private * chore: packages chore * test: generate tests for tns-core-modules * chore: add anroid module for consistency * chore: add .npmignore * chore: added privateModulesWhitelist * chore(webpack): added bundle-entry-points * chore: scripts * chore: tests changed to use @ns/core * test: add scoped-packages test project * test: fix types * test: update test project * chore: build scripts * chore: update build script * chore: npm scripts cleanup * chore: make the compat pgk work with old wp config * test: generate diff friendly tests * chore: create barrel exports * chore: move files after rebase * chore: typedoc config * chore: compat mode * chore: review of barrels * chore: remove tns-core-modules import after rebase * chore: dev workflow setup * chore: update developer-workflow * docs: experiment with API extractor * chore: api-extractor and barrel exports * chore: api-extractor configs * chore: generate d.ts rollup with api-extractor * refactor: move methods inside Frame * chore: fic tests to use Frame static methods * refactor: create Builder class * refactor: use Builder class in tests * refactor: include Style in ui barrel * chore: separate compat build script * chore: fix tslint errors * chore: update NATIVESCRIPT_CORE_ARGS * chore: fix compat pack * chore: fix ui-test-app build with linked modules * chore: Application, ApplicationSettings, Connectivity and Http * chore: export Trace, Profiling and Utils * refactor: Static create methods for ImageSource * chore: fix deprecated usages of ImageSource * chore: move Span and FormattedString to ui * chore: add events-args and ImageSource to index files * chore: check for CLI >= 6.2 when building for IOS * chore: update travis build * chore: copy Pod file to compat package * chore: update error msg ui-tests-app * refactor: Apply suggestions from code review Co-Authored-By: Martin Yankov <m.i.yankov@gmail.com> * chore: typings and refs * chore: add missing d.ts files for public API * chore: adress code review FB * chore: update api-report * chore: dev-workflow for other apps * chore: api update * chore: update api-report
2025-08-15 11:01:21 +08:00 · 2019-10-17 00:45:33 +03:00
parent 6c7139477e
commit cc97a16800
880 changed files with 9090 additions and 2104 deletions
--- a/nativescript-core/image-source/image-source.android.ts
+++ b/nativescript-core/image-source/image-source.android.ts
@ -0,0 +1,423 @@
+// Definitions.
+import { ImageSource as ImageSourceDefinition } from ".";
+import { ImageAsset } from "../image-asset";
+import * as httpModule from "../http";
+
+// Types.
+import { path as fsPath, knownFolders } from "../file-system";
+import { isFileOrResourcePath, RESOURCE_PREFIX, layout } from "../utils/utils";
+import { getNativeApplication } from "../application";
+import { Font } from "../ui/styling/font";
+import { Color } from "../color";
+
+export { isFileOrResourcePath };
+
+let http: typeof httpModule;
+function ensureHttp() {
+    if (!http) {
+        http = require("../http");
+    }
+}
+
+let application: android.app.Application;
+let resources: android.content.res.Resources;
+
+function getApplication() {
+    if (!application) {
+        application = (<android.app.Application>getNativeApplication());
+    }
+
+    return application;
+}
+
+function getResources() {
+    if (!resources) {
+        resources = getApplication().getResources();
+    }
+
+    return resources;
+}
+
+export class ImageSource implements ImageSourceDefinition {
+    public android: android.graphics.Bitmap;
+    public ios: UIImage;
+
+    public get height(): number {
+        if (this.android) {
+            return this.android.getHeight();
+        }
+
+        return NaN;
+    }
+
+    public get width(): number {
+        if (this.android) {
+            return this.android.getWidth();
+        }
+
+        return NaN;
+    }
+
+    private _rotationAngle: number;
+    public get rotationAngle(): number {
+        return this._rotationAngle;
+    }
+
+    public set rotationAngle(value: number) {
+        this._rotationAngle = value;
+    }
+
+    constructor(nativeSource?: any) {
+        if (nativeSource) {
+            this.setNativeSource(nativeSource);
+        }
+    }
+
+    static fromAsset(asset: ImageAsset): Promise<ImageSource> {
+        return new Promise<ImageSource>((resolve, reject) => {
+            asset.getImageAsync((image, err) => {
+                if (image) {
+                    resolve(new ImageSource(image));
+                } else {
+                    reject(err);
+                }
+            });
+        });
+    }
+
+    static fromUrl(url: string): Promise<ImageSourceDefinition> {
+        ensureHttp();
+
+        return http.getImage(url);
+    }
+
+    static fromResourceSync(name: string): ImageSource {
+        const res = getResources();
+        if (res) {
+            const identifier: number = res.getIdentifier(name, "drawable", getApplication().getPackageName());
+            if (0 < identifier) {
+                // Load BitmapDrawable with getDrawable to make use of Android internal caching
+                const bitmapDrawable = <android.graphics.drawable.BitmapDrawable>res.getDrawable(identifier);
+                if (bitmapDrawable && bitmapDrawable.getBitmap) {
+                    return new ImageSource(bitmapDrawable.getBitmap());
+                }
+            }
+        }
+
+        return null;
+    }
+    static fromResource(name: string): Promise<ImageSource> {
+        return new Promise<ImageSource>((resolve, reject) => {
+            resolve(ImageSource.fromResourceSync(name));
+        });
+    }
+
+    static fromFileSync(path: string): ImageSource {
+        let fileName = typeof path === "string" ? path.trim() : "";
+        if (fileName.indexOf("~/") === 0) {
+            fileName = fsPath.join(knownFolders.currentApp().path, fileName.replace("~/", ""));
+        }
+
+        const bitmap = android.graphics.BitmapFactory.decodeFile(fileName, null);
+        if (bitmap) {
+            const result = new ImageSource(bitmap);
+            result.rotationAngle = getRotationAngleFromFile(fileName);
+
+            return result;
+        } else {
+            return null;
+        }
+    }
+
+    static fromFile(path: string): Promise<ImageSource> {
+        return new Promise<ImageSource>((resolve, reject) => {
+            resolve(ImageSource.fromFileSync(path));
+        });
+    }
+
+    static fromFileOrResourceSync(path: string): ImageSource {
+        if (!isFileOrResourcePath(path)) {
+            throw new Error(`${path} is not a valid file or resource.`);
+        }
+
+        if (path.indexOf(RESOURCE_PREFIX) === 0) {
+            return ImageSource.fromResourceSync(path.substr(RESOURCE_PREFIX.length));
+        }
+
+        return ImageSource.fromFileSync(path);
+    }
+
+    static fromDataSync(data: any): ImageSource {
+        const bitmap = android.graphics.BitmapFactory.decodeStream(data);
+
+        return bitmap ? new ImageSource(bitmap) : null;
+    }
+
+    static fromData(data: any): Promise<ImageSource> {
+        return new Promise<ImageSource>((resolve, reject) => {
+            resolve(ImageSource.fromDataSync(data));
+        });
+    }
+
+    static fromBase64Sync(source: string): ImageSource {
+        let bitmap: android.graphics.Bitmap;
+
+        if (typeof source === "string") {
+            const bytes = android.util.Base64.decode(source, android.util.Base64.DEFAULT);
+            bitmap = android.graphics.BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
+        }
+
+        return bitmap ? new ImageSource(bitmap) : null;
+    }
+    static fromBase64(source: string): Promise<ImageSource> {
+        return new Promise<ImageSource>((resolve, reject) => {
+            resolve(ImageSource.fromBase64Sync(source));
+        });
+    }
+
+    static fromFontIconCodeSync(source: string, font: Font, color: Color): ImageSource {
+        const paint = new android.graphics.Paint();
+        paint.setTypeface(font.getAndroidTypeface());
+        paint.setAntiAlias(true);
+
+        if (color) {
+            paint.setColor(color.android);
+        }
+
+        let fontSize = layout.toDevicePixels(font.fontSize);
+        if (!fontSize) {
+            // TODO: Consider making 36 font size as default for optimal look on TabView and ActionBar
+            fontSize = paint.getTextSize();
+        }
+
+        const density = layout.getDisplayDensity();
+        const scaledFontSize = fontSize * density;
+        paint.setTextSize(scaledFontSize);
+
+        const textBounds = new android.graphics.Rect();
+        paint.getTextBounds(source, 0, source.length, textBounds);
+
+        const textWidth = textBounds.width();
+        const textHeight = textBounds.height();
+        if (textWidth > 0 && textHeight > 0) {
+            const bitmap = android.graphics.Bitmap
+                .createBitmap(
+                    textWidth,
+                    textHeight,
+                    android.graphics.Bitmap.Config.ARGB_8888
+                );
+
+            const canvas = new android.graphics.Canvas(bitmap);
+            canvas.drawText(source, -textBounds.left, -textBounds.top, paint);
+
+            return new ImageSource(bitmap);
+        }
+
+        return null;
+    }
+
+    public fromAsset(asset: ImageAsset): Promise<ImageSource> {
+        console.log("fromAsset() is deprecated. Use ImageSource.fromAsset() instead.");
+
+        return ImageSource.fromAsset(asset)
+            .then(imgSource => {
+                this.setNativeSource(imgSource.android);
+
+                return this;
+            });
+    }
+
+    public loadFromResource(name: string): boolean {
+        console.log("fromResource() and loadFromResource() are deprecated. Use ImageSource.fromResource[Sync]() instead.");
+
+        const imgSource = ImageSource.fromResourceSync(name);
+        this.android = imgSource ? imgSource.android : null;
+
+        return !!this.android;
+    }
+
+    public fromResource(name: string): Promise<boolean> {
+        return new Promise<boolean>((resolve, reject) => {
+            resolve(this.loadFromResource(name));
+        });
+    }
+
+    public loadFromFile(path: string): boolean {
+        console.log("fromFile() and loadFromFile() are deprecated. Use ImageSource.fromFile[Sync]() instead.");
+
+        const imgSource = ImageSource.fromFileSync(path);
+        this.android = imgSource ? imgSource.android : null;
+
+        return !!this.android;
+    }
+
+    public fromFile(path: string): Promise<boolean> {
+        return new Promise<boolean>((resolve, reject) => {
+            resolve(this.loadFromFile(path));
+        });
+    }
+
+    public loadFromData(data: any): boolean {
+        console.log("fromData() and loadFromData() are deprecated. Use ImageSource.fromData[Sync]() instead.");
+
+        const imgSource = ImageSource.fromDataSync(data);
+        this.android = imgSource ? imgSource.android : null;
+
+        return !!this.android;
+    }
+
+    public fromData(data: any): Promise<boolean> {
+        return new Promise<boolean>((resolve, reject) => {
+            resolve(this.loadFromData(data));
+        });
+    }
+
+    public loadFromBase64(source: string): boolean {
+        console.log("fromBase64() and loadFromBase64() are deprecated. Use ImageSource.fromBase64[Sync]() instead.");
+
+        const imgSource = ImageSource.fromBase64Sync(source);
+        this.android = imgSource ? imgSource.android : null;
+
+        return !!this.android;
+    }
+
+    public fromBase64(data: any): Promise<boolean> {
+        return new Promise<boolean>((resolve, reject) => {
+            resolve(this.loadFromBase64(data));
+        });
+    }
+
+    public loadFromFontIconCode(source: string, font: Font, color: Color): boolean {
+        console.log("loadFromFontIconCode() is deprecated. Use ImageSource.fromFontIconCodeSync() instead.");
+
+        const imgSource = ImageSource.fromFontIconCodeSync(source, font, color);
+        this.android = imgSource ? imgSource.android : null;
+
+        return !!this.android;
+    }
+
+    public setNativeSource(source: any): void {
+        if (source && !(source instanceof android.graphics.Bitmap)) {
+            throw new Error("The method setNativeSource() expects android.graphics.Bitmap instance.");
+        }
+        this.android = source;
+    }
+
+    public saveToFile(path: string, format: "png" | "jpeg" | "jpg", quality = 100): boolean {
+        if (!this.android) {
+            return false;
+        }
+
+        const targetFormat = getTargetFormat(format);
+
+        // TODO add exception handling
+        const outputStream = new java.io.BufferedOutputStream(new java.io.FileOutputStream(path));
+
+        const res = this.android.compress(targetFormat, quality, outputStream);
+        outputStream.close();
+
+        return res;
+    }
+
+    public toBase64String(format: "png" | "jpeg" | "jpg", quality = 100): string {
+        if (!this.android) {
+            return null;
+        }
+
+        const targetFormat = getTargetFormat(format);
+
+        const outputStream = new java.io.ByteArrayOutputStream();
+        const base64Stream = new android.util.Base64OutputStream(outputStream, android.util.Base64.NO_WRAP);
+
+        this.android.compress(targetFormat, quality, base64Stream);
+
+        base64Stream.close();
+        outputStream.close();
+
+        return outputStream.toString();
+    }
+}
+
+function getTargetFormat(format: "png" | "jpeg" | "jpg"): android.graphics.Bitmap.CompressFormat {
+    switch (format) {
+        case "jpeg":
+        case "jpg":
+            return android.graphics.Bitmap.CompressFormat.JPEG;
+        default:
+            return android.graphics.Bitmap.CompressFormat.PNG;
+    }
+}
+
+function getRotationAngleFromFile(filename: string): number {
+    let result = 0;
+    const ei = new android.media.ExifInterface(filename);
+    const orientation = ei.getAttributeInt(android.media.ExifInterface.TAG_ORIENTATION, android.media.ExifInterface.ORIENTATION_NORMAL);
+
+    switch (orientation) {
+        case android.media.ExifInterface.ORIENTATION_ROTATE_90:
+            result = 90;
+            break;
+        case android.media.ExifInterface.ORIENTATION_ROTATE_180:
+            result = 180;
+            break;
+        case android.media.ExifInterface.ORIENTATION_ROTATE_270:
+            result = 270;
+            break;
+    }
+
+    return result;
+}
+
+export function fromAsset(asset: ImageAsset): Promise<ImageSource> {
+    console.log("fromAsset() is deprecated. Use ImageSource.fromAsset() instead.");
+
+    return ImageSource.fromAsset(asset);
+}
+
+export function fromResource(name: string): ImageSource {
+    console.log("fromResource() is deprecated. Use ImageSource.fromResourceSync() instead.");
+
+    return ImageSource.fromResourceSync(name);
+}
+
+export function fromFile(path: string): ImageSource {
+    console.log("fromFile() is deprecated. Use ImageSource.fromFileSync() instead.");
+
+    return ImageSource.fromFileSync(path);
+}
+
+export function fromData(data: any): ImageSource {
+    console.log("fromData() is deprecated. Use ImageSource.fromDataSync() instead.");
+
+    return ImageSource.fromDataSync(data);
+}
+
+export function fromFontIconCode(source: string, font: Font, color: Color): ImageSource {
+    console.log("fromFontIconCode() is deprecated. Use ImageSource.fromFontIconCodeSync() instead.");
+
+    return ImageSource.fromFontIconCodeSync(source, font, color);
+}
+
+export function fromBase64(source: string): ImageSource {
+    console.log("fromBase64() is deprecated. Use ImageSource.fromBase64Sync() instead.");
+
+    return ImageSource.fromBase64Sync(source);
+}
+
+export function fromNativeSource(nativeSource: any): ImageSource {
+    console.log("fromNativeSource() is deprecated. Use ImageSource constructor instead.");
+
+    return new ImageSource(nativeSource);
+}
+
+export function fromUrl(url: string): Promise<ImageSourceDefinition> {
+    console.log("fromUrl() is deprecated. Use ImageSource.fromUrl() instead.");
+
+    return ImageSource.fromUrl(url);
+}
+
+export function fromFileOrResource(path: string): ImageSource {
+    console.log("fromFileOrResource() is deprecated. Use ImageSource.fromFileOrResourceSync() instead.");
+
+    return ImageSource.fromFileOrResourceSync(path);
+}