@akylas/nativescript-app-utils 2.1.6 → 2.2.1

package/CHANGELOG.md

@@ -3,6 +3,18 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [2.2.1](https://github.com/akylas/nativescript-app-utils/compare/v2.2.0...v2.2.1) (2024-12-18)
+
+### Bug Fixes
+
+* **ios:** handle urls starting with file:// ([cf78de2](https://github.com/akylas/nativescript-app-utils/commit/cf78de281977d11d2f16e59bfccfdd87bc81c543))
+
+## [2.2.0](https://github.com/akylas/nativescript-app-utils/compare/v2.1.6...v2.2.0) (2024-11-14)
+
+### Features
+
+* added share ([2e27a03](https://github.com/akylas/nativescript-app-utils/commit/2e27a03665b32ebb54b86e86beed2288f0bafe7a))
+
 ## [2.1.6](https://github.com/akylas/nativescript-app-utils/compare/v2.1.5...v2.1.6) (2024-11-08)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@akylas/nativescript-app-utils",
-    "version": "2.1.6",
+    "version": "2.2.1",
     "description": "Provides API for changing the styles of SystemUI (StatusBar, NavigationBar...) on iOS.",
     "main": "index",
     "sideEffects": false,
@@ -63,5 +63,8 @@
     "bugs": {
         "url": "https://github.com/akylas/nativescript-app-utils/issues"
     },
-    "gitHead": "f9d8fa107bd8ef7a0bba2b7cd091e8b53402368d"
+    "dependencies": {
+        "@nativescript-community/ui-share-file": "1.3.3"
+    },
+    "gitHead": "83d8799e538f6dae600c486a122b6bbafefd7e4a"
 }

package/platforms/android/java/com/nativescript/apputils/Utils.kt

@@ -110,5 +110,13 @@ class Utils {
 
             }
         }
+
+        fun guessMimeType(context: Context, uri: android.net.Uri): String? {
+            val type = android.webkit.MimeTypeMap.getSingleton().getExtensionFromMimeType(context.getContentResolver().getType(uri));
+            if (type != null) {
+                return android.webkit.MimeTypeMap.getSingleton().getMimeTypeFromExtension(type);
+            }
+            return null
+        }
     }
 }

package/platforms/ios/src/ImageUtils.swift

@@ -152,7 +152,7 @@ class ImageUtils : NSObject {
   }
   
   static func getImageSize(_ src: String) -> Dictionary<String, Any>? {
-    let url = NSURL.fileURL(withPath: src)
+    let url = NSURL.fileURL(withPath: src.replacingOccurrences(of: "file://", with: ""))
     let imageSource = CGImageSourceCreateWithURL(url as CFURL, nil);
     if (imageSource == nil) {
       // Error loading image
@@ -191,7 +191,7 @@ class ImageUtils : NSObject {
   
   
   static func readImageFromFileSync(_ src: String, options: NSDictionary?) -> UIImage? {
-    let image = UIImage(contentsOfFile: src)
+    let image = UIImage(contentsOfFile: src.replacingOccurrences(of: "file://", with: ""))
     if let image {
       let size = image.size
       let imageOrientation = image.imageOrientation

package/references.d.ts

@@ -0,0 +1 @@
+/// <reference path="../../node_modules/@nativescript/types-ios/lib/ios/objc-x86_64/objc!LinkPresentation.d.ts" />

package/share/index.android.d.ts

@@ -0,0 +1,3 @@
+import { Content, Options } from '.';
+export * from './index.common';
+export declare function share(content: Content, options?: Options): Promise<boolean>;

package/share/index.android.js

@@ -0,0 +1,101 @@
+import { Application, Device, Utils, knownFolders, path } from '@nativescript/core';
+export * from './index.common';
+let numberOfImagesCreated = 0;
+const sdkVersionInt = parseInt(Device.sdkVersion, 10);
+const EXTRA_STREAM = 'android.intent.extra.STREAM';
+const ACTION_SEND = 'android.intent.action.SEND';
+const ACTION_SEND_MULTIPLE = 'android.intent.action.SEND_MULTIPLE';
+export async function share(content, options = {}) {
+    if (content == null) {
+        throw new Error('missing_content');
+    }
+    const Intent = android.content.Intent;
+    let mimetype = options.mimetype;
+    const intent = new Intent(ACTION_SEND);
+    const currentActivity = Application.android.foregroundActivity || Application.android.startActivity;
+    const context = Utils.android.getApplicationContext();
+    const uris = [];
+    async function addImage(image) {
+        if (!mimetype) {
+            mimetype = 'image/jpeg';
+        }
+        const imageFileName = 'share_image_' + numberOfImagesCreated++ + '.jpg';
+        const filePath = path.join(knownFolders.temp().path, imageFileName);
+        await image.saveToFileAsync(filePath, 'jpg');
+        const newFile = new java.io.File(filePath);
+        let shareableFileUri;
+        if (sdkVersionInt >= 21) {
+            shareableFileUri = androidx.core.content.FileProvider.getUriForFile(currentActivity, Application.android.nativeApp.getPackageName() + '.provider', newFile);
+        }
+        else {
+            shareableFileUri = android.net.Uri.fromFile(newFile);
+        }
+        uris.push(shareableFileUri);
+    }
+    function addFile(file) {
+        const newFile = new java.io.File(file);
+        let shareableFileUri;
+        if (sdkVersionInt >= 21) {
+            shareableFileUri = androidx.core.content.FileProvider.getUriForFile(currentActivity, Application.android.nativeApp.getPackageName() + '.provider', newFile);
+        }
+        else {
+            shareableFileUri = android.net.Uri.fromFile(newFile);
+        }
+        if (!mimetype) {
+            // try to guess the file mimetype
+            const guessedMimetype = com.nativescript.apputils.Utils.Companion.guessMimeType(context, shareableFileUri);
+            if (guessedMimetype) {
+                mimetype = guessedMimetype;
+            }
+        }
+        uris.push(shareableFileUri);
+    }
+    if (content.image) {
+        await addImage(content.image);
+    }
+    if (content.images) {
+        for (let index = 0; index < content.images.length; index++) {
+            await addImage(content.images[index]);
+        }
+    }
+    if (content.file) {
+        addFile(content.file);
+    }
+    if (content.files) {
+        for (let index = 0; index < content.files.length; index++) {
+            addFile(content.files[index]);
+        }
+    }
+    if (content.title) {
+        if (!mimetype) {
+            mimetype = 'text/plain';
+        }
+        intent.putExtra(Intent.EXTRA_SUBJECT, content.title);
+    }
+    if (content.message) {
+        if (!mimetype) {
+            mimetype = 'text/plain';
+        }
+        intent.putExtra(Intent.EXTRA_TEXT, content.message);
+    }
+    if (uris.length === 1) {
+        intent.putExtra(EXTRA_STREAM, uris[0]);
+    }
+    else if (uris.length > 1) {
+        const arrayList = new java.util.ArrayList(uris.length);
+        uris.forEach((uri) => arrayList.add(uri));
+        intent.setAction(ACTION_SEND_MULTIPLE);
+        intent.putExtra(EXTRA_STREAM, arrayList);
+    }
+    intent.setTypeAndNormalize(mimetype || '*/*');
+    const chooser = Intent.createChooser(intent, options.dialogTitle);
+    chooser.addCategory(Intent.CATEGORY_DEFAULT);
+    if (currentActivity !== null) {
+        currentActivity.startActivity(chooser);
+    }
+    else {
+        Utils.android.getApplicationContext().startActivity(chooser);
+    }
+    return true;
+}
+//# sourceMappingURL=index.android.js.map

package/share/index.common.d.ts

@@ -0,0 +1,2 @@
+import { ShareOptions } from '@nativescript-community/ui-share-file';
+export declare function shareFile(content: string, fileName: string, shareOptions?: Partial<ShareOptions>): Promise<boolean>;

package/share/index.common.js

@@ -0,0 +1,18 @@
+import { knownFolders } from '@nativescript/core';
+import { ShareFile } from '@nativescript-community/ui-share-file';
+const shareFileObject = new ShareFile();
+export async function shareFile(content, fileName, shareOptions = {}) {
+    const file = knownFolders.temp().getFile(fileName);
+    // iOS: using writeText was not adding the file. Surely because it was too soon or something
+    // doing it sync works better but still needs a timeout
+    // showLoading('loading');
+    await file.writeText(content);
+    return shareFileObject.open({
+        path: file.path,
+        title: fileName,
+        options: true, // optional iOS
+        animated: true, // optional iOS,
+        ...shareOptions
+    });
+}
+//# sourceMappingURL=index.common.js.map

package/share/index.d.ts

@@ -0,0 +1,22 @@
+import { Color } from '@nativescript/core';
+export * from './index.common';
+
+export interface Content {
+    title?: string;
+    message?: string;
+    image?: ImageSource;
+    images?: ImageSource[];
+    file?: string;
+    files?: string[];
+    url?: string;
+}
+export interface Options {
+    mimetype?: string;
+    dialogTitle?: string;
+    excludedActivityTypes?: string[];
+    tintColor?: string | Color;
+    subject?: string;
+    anchor?: View; //ios only
+    appearance?: 'light' | 'dark';
+}
+export function share(content: Content, options?: Options): Promise<boolean>;

package/share/index.ios.d.ts

@@ -0,0 +1,3 @@
+import { Content, Options } from '.';
+export * from './index.common';
+export declare function share(content: Content, options?: Options): Promise<unknown>;

package/share/index.ios.js

@@ -0,0 +1,134 @@
+import { Application, Color } from '@nativescript/core';
+export * from './index.common';
+var ItemSource = /** @class */ (function (_super) {
+    __extends(ItemSource, _super);
+    function ItemSource() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    ItemSource.initWithData = function (data, placeholder, subject, metadata) {
+        var delegate = ItemSource.new();
+        delegate.data = data;
+        delegate.placeholder = placeholder;
+        delegate.subject = subject;
+        delegate.metadata = metadata;
+        return delegate;
+    };
+    // activityViewControllerDataTypeIdentifierForActivityType?(activityViewController: UIActivityViewController, activityType: string): string {
+    //     throw new Error('Method not implemented.');
+    // }
+    ItemSource.prototype.activityViewControllerItemForActivityType = function (activityViewController, activityType) {
+        return this.data;
+    };
+    ItemSource.prototype.activityViewControllerLinkMetadata = function (activityViewController) {
+        if (this.metadata) {
+            var metadata = LPLinkMetadata.new();
+            metadata.title = this.metadata.title;
+            if (this.metadata.image) {
+                metadata.imageProvider = NSItemProvider.alloc().initWithObject(this.metadata.image);
+                metadata.iconProvider = metadata.imageProvider;
+            }
+            if (this.metadata.icon) {
+                metadata.iconProvider = NSItemProvider.alloc().initWithObject(this.metadata.icon);
+            }
+            if (this.metadata.originalURL) {
+                metadata.originalURL = NSURL.alloc().initWithString(this.metadata.originalURL);
+            }
+            return metadata;
+        }
+        return null;
+    };
+    ItemSource.prototype.activityViewControllerPlaceholderItem = function (activityViewController) {
+        return this.placeholder;
+    };
+    ItemSource.prototype.activityViewControllerSubjectForActivityType = function (activityViewController, activityType) {
+        return this.subject;
+    };
+    ItemSource.ObjCProtocols = [UIActivityItemSource];
+    return ItemSource;
+}(NSObject));
+export async function share(content, options = {}) {
+    if (content == null) {
+        throw new Error('missing_content');
+    }
+    return new Promise((resolve, reject) => {
+        let metadata;
+        if (content.title) {
+            metadata = { title: content.title };
+        }
+        const items = [];
+        if (content.url) {
+            const url = NSURL.URLWithString(content.url);
+            if (url.scheme.toLowerCase() === 'data') {
+                const data = NSData.dataWithContentsOfURLOptionsError(url, 0);
+                if (!data) {
+                    throw new Error('cant_share_url');
+                }
+                items.push(data);
+            }
+            else {
+                items.push(url);
+            }
+        }
+        if (content.message) {
+            items.push(content.message);
+        }
+        if (content.image) {
+            items.push(content.image.ios);
+        }
+        if (content.images) {
+            content.images.forEach((image) => items.push(image.ios));
+        }
+        if (content.file) {
+            items.push(NSURL.fileURLWithPath(content.file));
+        }
+        if (content.files) {
+            content.files.forEach((file) => items.push(NSURL.fileURLWithPath(file)));
+        }
+        const shareController = UIActivityViewController.alloc().initWithActivityItemsApplicationActivities(items, null);
+        // should we use UIActivityItemSource?
+        // const shareController = UIActivityViewController.alloc().initWithActivityItemsApplicationActivities(
+        //     items.map((i) => ItemSource.initWithData(i, i, options.subject, metadata)),
+        //     null
+        // );
+        if (options.subject) {
+            shareController.setValueForKey(options.subject, 'subject');
+        }
+        if (options.excludedActivityTypes) {
+            shareController.excludedActivityTypes = NSArray.arrayWithArray(options.excludedActivityTypes);
+        }
+        const presentingController = Application.ios.rootController;
+        shareController.completionWithItemsHandler = (activityType, completed, error) => {
+            if (error) {
+                reject(error);
+            }
+            else if (completed || activityType == null) {
+                resolve(true);
+            }
+        };
+        shareController.modalPresentationStyle = 7 /* UIModalPresentationStyle.Popover */;
+        const appearance = options.appearance || Application.ios.systemAppearance;
+        if (appearance === 'dark') {
+            shareController.overrideUserInterfaceStyle = 2 /* UIUserInterfaceStyle.Dark */;
+        }
+        else if (appearance === 'light') {
+            shareController.overrideUserInterfaceStyle = 1 /* UIUserInterfaceStyle.Light */;
+        }
+        let sourceView = presentingController.view;
+        if (options.anchor) {
+            sourceView = options.anchor.nativeViewProtected;
+        }
+        else if (shareController.popoverPresentationController) {
+            shareController.popoverPresentationController.permittedArrowDirections = 0;
+        }
+        if (shareController.popoverPresentationController) {
+            shareController.popoverPresentationController.sourceView = sourceView;
+            shareController.popoverPresentationController.sourceRect = sourceView.bounds;
+        }
+        if (options.tintColor) {
+            const color = options.tintColor instanceof Color ? options.tintColor : new Color(options.tintColor);
+            shareController.view.tintColor = color.ios;
+        }
+        presentingController.presentViewControllerAnimatedCompletion(shareController, true, null);
+    });
+}
+//# sourceMappingURL=index.ios.js.map

package/typings/android.d.ts

@@ -30,6 +30,7 @@ declare namespace com {
                     static getSystemLocale(): java.util.Locale;
                     static getRootWindowInsets(view: android.view.View): number[];
                     static listenForWindowInsetsChange(view: android.view.View, callback: WindowInsetsCallback);
+                    static guessMimeType(context: android.content.Context, uri: android.net.Uri);
                 }
             }
             export class ImageUtils extends java.lang.Object {