community-cordova-plugin-social-sharing 6.1.0

package/src/windows/SocialSharingProxy.js

@@ -0,0 +1,177 @@
+var cordova = require('cordova');
+
+module.exports = {
+    share: function (win, fail, args) {
+        //Text Message
+        var message = args[0];
+        //Title 
+        var subject = args[1];
+        //File(s) Path
+        var fileOrFileArray = args[2];
+        //Web link
+        var url = args[3];
+
+		var folder = Windows.Storage.ApplicationData.current.temporaryFolder;
+
+        var getExtension = function (strBase64) {
+            return strBase64.substring(strBase64.indexOf("/") + 1, strBase64.indexOf(";base64"));
+        };
+
+        var replaceAll = function (str, find, replace) {
+            return str.replace(new RegExp(find, 'g'), replace);
+        };
+
+        var sanitizeFilename = function (name) {
+            return replaceAll(name, "[:\\\\/*?|<> ]", "_");
+        };
+
+        var getFileName = function (position, fileExtension) {
+            var fileName = (subject ? sanitizeFilename(subject) : "file") + (position == 0 ? "" : "_" + position) + "." + fileExtension;
+            return fileName;
+        };
+
+        var createTemporalFile = function (fileName, buffer) {
+
+            var filePath = "";
+            return folder.createFileAsync(fileName, Windows.Storage.CreationCollisionOption.replaceExisting).then(function (file) {
+                filePath = file.path;
+                return Windows.Storage.FileIO.writeBufferAsync(file, buffer);
+            }).then(function(){
+                return Windows.Storage.StorageFile.getFileFromPathAsync(filePath);
+            });
+        };
+
+        var doShare = function (e) {
+            e.request.data.properties.title = subject?subject: "Sharing";
+            if (message) e.request.data.setText(message);
+            if (url) e.request.data.setWebLink(new Windows.Foundation.Uri(url));
+            if (fileOrFileArray.length > 0) {
+                var deferral = e.request.getDeferral();
+                var storageItems = [];
+                var filesCount = fileOrFileArray.length;
+
+                var completeFile = function () {
+                    if (!--filesCount) {
+                        storageItems.length && e.request.data.setStorageItems(storageItems);
+                        deferral.complete();
+                    }
+                };
+
+                for (var i = 0; i < fileOrFileArray.length; i++) {
+
+                    var file = fileOrFileArray[i];
+                    if (file.indexOf("data:") >= 0) {
+                        var fileName = getFileName(i, getExtension(file));
+                        var buffer = Windows.Security.Cryptography.CryptographicBuffer.decodeFromBase64String(file.split(',')[1]);
+                        if (buffer) {
+                            createTemporalFile(fileName, buffer).done(
+                                function (file) {
+                                    storageItems.push(file);
+                                    completeFile();
+                                },
+                                function () {
+                                    completeFile();
+                                }
+                            );
+                        }
+                        else {
+                            completeFile();
+                        }
+                    }
+                    else {
+                        Windows.Storage.StorageFile.getFileFromPathAsync(file).done(
+                            function (file) {
+                                storageItems.push(file);
+                                completeFile();
+                            },
+                            function () {
+                                completeFile();
+                            }
+                        );
+                    }
+                }
+            }
+        };
+
+
+        var dataTransferManager = Windows.ApplicationModel.DataTransfer.DataTransferManager.getForCurrentView();
+
+        dataTransferManager.addEventListener("datarequested", doShare);
+
+        try {
+            Windows.ApplicationModel.DataTransfer.DataTransferManager.showShareUI();
+            win(true);
+        } catch (err) {
+            fail(err);
+        }
+    },
+
+    canShareViaEmail: function (win, fail, args) {
+        win(true);
+    },
+
+    shareViaEmail: function (win, fail, args) {
+        //Text Message
+        var message = args[0];
+        //Title 
+        var subject = args[1];
+        //File(s) Path
+        var fileOrFileArray = args[5];
+
+        var doShare = function (e) {
+            e.request.data.properties.title = subject ? subject : "Sharing";
+            if (message) {
+                var htmlFormat = Windows.ApplicationModel.DataTransfer.HtmlFormatHelper.createHtmlFormat(message);
+                e.request.data.setHtmlFormat(htmlFormat);
+            }
+
+            if (fileOrFileArray.length > 0) {
+                var deferral = e.request.getDeferral();
+                var storageItems = [];
+                var filesCount = fileOrFileArray.length;
+                for (var i = 0; i < fileOrFileArray.length; i++) {
+                    Windows.Storage.StorageFile.getFileFromPathAsync(fileOrFileArray[i]).done(
+                        function (index, file) {
+                            var path = fileOrFileArray[index];
+                            var streamRef = Windows.Storage.Streams.RandomAccessStreamReference.createFromFile(file);
+                            e.request.data.resourceMap[path] = streamRef;
+                            storageItems.push(file);
+                            if (!--filesCount) {
+                                e.request.data.setStorageItems(storageItems);
+                                deferral.complete();
+                            }
+                        }.bind(this, i),
+                        function () {
+                            if (!--filesCount) {
+                                e.request.data.setStorageItems(storageItems);
+                                deferral.complete();
+                            }
+                        }
+                    );
+                }
+            }
+        };
+
+        var dataTransferManager = Windows.ApplicationModel.DataTransfer.DataTransferManager.getForCurrentView();
+
+        dataTransferManager.addEventListener("datarequested", doShare);
+
+        try {
+            Windows.ApplicationModel.DataTransfer.DataTransferManager.showShareUI();
+            win(true);
+        } catch (err) {
+            fail(err);
+        }
+    },
+
+    shareViaSMS: function (win, fail, args) {
+        var chatMessage = new Windows.ApplicationModel.Chat.ChatMessage();
+        chatMessage.body = args[0].message;
+        if (!!args[1]) {
+            chatMessage.recipients.push(args[1]);
+        }
+        Windows.ApplicationModel.Chat.ChatMessageManager.showComposeSmsMessageAsync(chatMessage).done(win, fail);
+    }
+};
+
+require("cordova/exec/proxy").add("SocialSharing", module.exports);

package/src/wp8/SocialSharing.cs

@@ -0,0 +1,103 @@
+using Microsoft.Phone.Tasks;
+
+using WPCordovaClassLib.Cordova;
+using WPCordovaClassLib.Cordova.Commands;
+using WPCordovaClassLib.Cordova.JSON;
+
+using Newtonsoft.Json;
+
+namespace Cordova.Extension.Commands
+{
+    public class SocialSharing : BaseCommand
+    {
+
+        public void available(string jsonArgs)
+        {
+            DispatchCommandResult(new PluginResult(PluginResult.Status.OK));
+        }
+
+        public void share(string jsonArgs)
+        {
+
+            var options = JsonHelper.Deserialize<string[]>(jsonArgs);
+
+            var message = options[0];
+            var title = options[1];
+            var files = JsonHelper.Deserialize<string[]>(options[2]);
+            var link = options[3];
+
+            if (link != null && !"null".Equals(link))
+            {
+                ShareLinkTask shareLinkTask = new ShareLinkTask();
+                shareLinkTask.Title = title;
+                shareLinkTask.LinkUri = new System.Uri(link, System.UriKind.Absolute);
+                shareLinkTask.Message = message;
+                shareLinkTask.Show();
+            }
+            else if (files != null && files.Length > 0)
+            {
+                ShareLinkTask shareLinkTask = new ShareLinkTask();
+                shareLinkTask.Title = title;
+                shareLinkTask.LinkUri = new System.Uri(files[0], System.UriKind.Absolute);
+                shareLinkTask.Message = message;
+                shareLinkTask.Show();
+            }
+            else
+            {
+                var shareStatusTask = new ShareStatusTask { Status = message };
+                shareStatusTask.Show();
+            }
+            // unfortunately, there is no way to tell if something was shared, so just invoke the successCallback
+            DispatchCommandResult(new PluginResult(PluginResult.Status.OK));
+        }
+
+        public void canShareViaEmail(string jsonArgs)
+        {
+            DispatchCommandResult(new PluginResult(PluginResult.Status.OK));
+        }
+
+        // HTML and attachments are currently not supported on WP8
+        public void shareViaEmail(string jsonArgs)
+        {
+            var options = JsonHelper.Deserialize<string[]>(jsonArgs);
+            EmailComposeTask draft = new EmailComposeTask();
+            draft.Body = options[0];
+            draft.Subject = options[1];
+            if (!"null".Equals(options[2]))
+            {
+                draft.To = string.Join(",", options[2]);
+            }
+            if (!"null".Equals(options[3]))
+            {
+                draft.Cc = string.Join(",", options[3]);
+            }
+            if (!"null".Equals(options[4]))
+            {
+                draft.Bcc = string.Join(",", options[4]);
+            }
+            draft.Show();
+            DispatchCommandResult(new PluginResult(PluginResult.Status.OK, true));
+        }
+		
+		 public void shareViaSMS(string jsonArgs)
+        {
+            var options = JsonHelper.Deserialize<string[]>(jsonArgs);
+
+            SmsComposeTask smsComposeTask = new SmsComposeTask();
+
+			smsComposeTask.To = options[1];
+            SMSMessageClass m = JsonConvert.DeserializeObject<SMSMessageClass>(options[0]);
+            smsComposeTask.Body = m.message;
+
+			smsComposeTask.Show();
+
+			DispatchCommandResult(new PluginResult(PluginResult.Status.OK, true));
+        }
+    }
+
+    public class SMSMessageClass
+    {
+        public string message { get; set; }
+    }
+
+}

package/types/index.d.ts

@@ -0,0 +1,62 @@
+// Type definitions for PhoneGap / Cordova Social Sharing plugin
+// Project: https://github.com/EddyVerbruggen/SocialSharing-PhoneGap-Plugin
+// Licensed under the MIT license.
+
+interface Window {
+	plugins: Plugins
+}
+
+interface Plugins {
+	socialsharing: SocialSharing
+}
+
+interface Navigator {
+	share: SocialSharingW3C
+}
+
+declare class SocialSharing {
+	iPadPopupCoordinates: () => string
+	setIPadPopupCoordinates: (coords: string) => void
+	available: (callback: (available: boolean) => void) => void
+	shareWithOptions: (options: SocialSharingOptions, successCallback?: SocialSharingSuccessCallback<SocialSharingResult>, errorCallback?: SocialSharingErrorCallback) => void
+	shareW3C: SocialSharingW3C
+	share: (message?: string, subject?: string, fileOrFileArray?: string | ArrayLike<string>, url?: string, successCallback?: SocialSharingSuccessCallback<boolean>, errorCallback?: SocialSharingErrorCallback) => void
+	shareViaTwitter: (message?: string, file?: string, url?: string, successCallback?: SocialSharingSuccessCallback<boolean>, errorCallback?: SocialSharingErrorCallback) => void
+	shareViaFacebook: (message?: string, fileOrFileArray?: string | ArrayLike<string>, url?: string, successCallback?: SocialSharingSuccessCallback<boolean>, errorCallback?: SocialSharingErrorCallback) => void
+	shareViaFacebookWithPasteMessageHint: (message?: string, fileOrFileArray?: string | ArrayLike<string>, url?: string, pasteMessageHint?: string, successCallback?: SocialSharingSuccessCallback<boolean>, errorCallback?: SocialSharingErrorCallback) => void
+	shareViaWhatsApp: (message?: string, fileOrFileArray?: string | ArrayLike<string>, url?: string, successCallback?: SocialSharingSuccessCallback<never>, errorCallback?: SocialSharingErrorCallback) => void
+	shareViaWhatsAppToReceiver: (receiver?: string, message?: string, fileOrFileArray?: string | ArrayLike<string>, url?: string, successCallback?: SocialSharingSuccessCallback<never>, errorCallback?: SocialSharingErrorCallback) => void
+	shareViaWhatsAppToPhone: (phone?: string, message?: string, fileOrFileArray?: string | ArrayLike<string>, url?: string, successCallback?: SocialSharingSuccessCallback<never>, errorCallback?: SocialSharingErrorCallback) => void
+	shareViaSMS: (options?: SocialSharingOptions | string, phoneNumbers?: ArrayLike<string>, successCallback?: SocialSharingSuccessCallback<boolean>, errorCallback?: SocialSharingErrorCallback) => void
+	shareViaEmail: (message?: string, subject?: string, toArray?: ArrayLike<string>, ccArray?: ArrayLike<string>, bccArray?: ArrayLike<string>, fileOrFileArray?: string | ArrayLike<string>, successCallback?: SocialSharingSuccessCallback<boolean>, errorCallback?: SocialSharingErrorCallback) => void
+	canShareVia: (via: string, message?: string, subject?: string, fileOrFileArray?: string | ArrayLike<string>, successCallback?: SocialSharingSuccessCallback<never>, errorCallback?: SocialSharingErrorCallback) => void
+	canShareViaEmail: (successCallback?: SocialSharingSuccessCallback<never>, errorCallback?: SocialSharingErrorCallback) => void
+	shareViaInstagram: (message?: string, fileOrFileArray?: string | ArrayLike<string>, successCallback?: SocialSharingSuccessCallback<never>, errorCallback?: SocialSharingErrorCallback) => void
+	shareVia: (via: string, message?: string, subject?: string, fileOrFileArray?: string | ArrayLike<string>, url?: string, successCallback?: SocialSharingSuccessCallback<boolean>, errorCallback?: SocialSharingErrorCallback) => void
+	saveToPhotoAlbum: (fileOrFileArray?: string | ArrayLike<string>, successCallback?: SocialSharingSuccessCallback<never>, errorCallback?: SocialSharingErrorCallback) => void
+}
+
+type SocialSharingW3C = (shareData: SocialSharingW3CData) => Promise<SocialSharingResult>
+
+interface SocialSharingW3CData {
+	title?: string
+	text?: string
+	url?: string
+}
+
+interface SocialSharingOptions {
+	message?: string
+	subject?: string
+	files?: ArrayLike<string>
+	url?: string
+	chooserTitle?: string
+	appPackageName?: string
+}
+
+type SocialSharingSuccessCallback<T> = (result: T) => void
+type SocialSharingErrorCallback = (msg?: string) => void
+
+interface SocialSharingResult {
+	completed: boolean
+	app?: string
+}

package/www/SocialSharing.js

@@ -0,0 +1,157 @@
+function SocialSharing() {
+}
+
+// Override this method (after deviceready) to set the location where you want the iPad popup arrow to appear.
+// If not overridden with different values, the popup is not used. Example:
+//
+//   window.plugins.socialsharing.iPadPopupCoordinates = function() {
+//     return "100,100,200,300";
+//   };
+SocialSharing.prototype.iPadPopupCoordinates = function () {
+  // left,top,width,height
+  return "-1,-1,-1,-1";
+};
+
+SocialSharing.prototype.setIPadPopupCoordinates = function (coords) {
+  console.log("Deprecated - setIPadPopupCoordinates no longer works since plugin version 5.5.0. See https://github.com/EddyVerbruggen/SocialSharing-PhoneGap-Plugin/issues/1052");
+  // left,top,width,height
+  cordova.exec(function() {}, this._getErrorCallback(function() {}, "setIPadPopupCoordinates"), "SocialSharing", "setIPadPopupCoordinates", [coords]);
+};
+
+SocialSharing.prototype.available = function (callback) {
+  cordova.exec(function (avail) {
+    callback(avail ? true : false);
+  }, null, "SocialSharing", "available", []);
+};
+
+// this is the recommended way to share as it is the most feature-rich with respect to what you pass in and get back
+SocialSharing.prototype.shareWithOptions = function (options, successCallback, errorCallback) {
+  cordova.exec(successCallback, this._getErrorCallback(errorCallback, "shareWithOptions"), "SocialSharing", "shareWithOptions", [options]);
+};
+
+SocialSharing.prototype.shareW3C = function (sharedata) {
+  return new Promise(function(resolve, reject) {
+    var options = {
+      subject: sharedata.title,
+      message: sharedata.text,
+      url: sharedata.url,
+      iPadCoordinates: sharedata.iPadCoordinates || undefined
+    };
+    if(sharedata.hasOwnProperty('title') ||
+        sharedata.hasOwnProperty('text') ||
+        sharedata.hasOwnProperty('url')) {
+          cordova.exec(resolve, reject, "SocialSharing", "shareWithOptions", [options]);
+    } else {
+      reject();
+    }
+  });
+};
+
+SocialSharing.prototype.share = function (message, subject, fileOrFileArray, url, iPadCoordinates, successCallback, errorCallback) {
+  if (typeof iPadCoordinates === 'function') {
+    errorCallback = successCallback;
+    successCallback = iPadCoordinates;
+    iPadCoordinates = "";
+  }
+  cordova.exec(successCallback, this._getErrorCallback(errorCallback, "share"), "SocialSharing", "share", [message, subject, this._asArray(fileOrFileArray), url, iPadCoordinates]);
+};
+
+SocialSharing.prototype.shareViaTwitter = function (message, file /* multiple not allowed by twitter */, url, successCallback, errorCallback) {
+  var fileArray = this._asArray(file);
+  var ecb = this._getErrorCallback(errorCallback, "shareViaTwitter");
+  if (fileArray.length > 1) {
+    ecb("shareViaTwitter supports max one file");
+  } else {
+    cordova.exec(successCallback, ecb, "SocialSharing", "shareViaTwitter", [message, null, fileArray, url]);
+  }
+};
+
+SocialSharing.prototype.shareViaFacebook = function (message, fileOrFileArray, url, successCallback, errorCallback) {
+  cordova.exec(successCallback, this._getErrorCallback(errorCallback, "shareViaFacebook"), "SocialSharing", "shareViaFacebook", [message, null, this._asArray(fileOrFileArray), url]);
+};
+
+SocialSharing.prototype.shareViaFacebookWithPasteMessageHint = function (message, fileOrFileArray, url, pasteMessageHint, successCallback, errorCallback) {
+  pasteMessageHint = pasteMessageHint || "If you like you can paste a message from your clipboard";
+  cordova.exec(successCallback, this._getErrorCallback(errorCallback, "shareViaFacebookWithPasteMessageHint"), "SocialSharing", "shareViaFacebookWithPasteMessageHint", [message, null, this._asArray(fileOrFileArray), url, pasteMessageHint]);
+};
+
+SocialSharing.prototype.shareViaWhatsApp = function (message, fileOrFileArray, url, successCallback, errorCallback) {
+  cordova.exec(successCallback, this._getErrorCallback(errorCallback, "shareViaWhatsApp"), "SocialSharing", "shareViaWhatsApp", [message, null, this._asArray(fileOrFileArray), url, null, null]);
+};
+
+SocialSharing.prototype.shareViaWhatsAppToReceiver = function (receiver, message, fileOrFileArray, url, successCallback, errorCallback) {
+  cordova.exec(successCallback, this._getErrorCallback(errorCallback, "shareViaWhatsAppToReceiver"), "SocialSharing", "shareViaWhatsApp", [message, null, this._asArray(fileOrFileArray), url, receiver, null]);
+};
+
+SocialSharing.prototype.shareViaWhatsAppToPhone = function (phone, message, fileOrFileArray, url, successCallback, errorCallback) {
+  cordova.exec(successCallback, this._getErrorCallback(errorCallback, "shareViaWhatsAppToPhone"), "SocialSharing", "shareViaWhatsApp", [message, null, this._asArray(fileOrFileArray), url, null, phone]);
+};
+
+SocialSharing.prototype.shareViaSMS = function (options, phonenumbers, successCallback, errorCallback) {
+  var opts = options;
+  if (typeof options === "string") {
+    opts = {"message":options}; // for backward compatibility as the options param used to be the message
+  }
+  cordova.exec(successCallback, this._getErrorCallback(errorCallback, "shareViaSMS"), "SocialSharing", "shareViaSMS", [opts, phonenumbers]);
+};
+
+SocialSharing.prototype.shareViaEmail = function (message, subject, toArray, ccArray, bccArray, fileOrFileArray, successCallback, errorCallback) {
+  cordova.exec(successCallback, this._getErrorCallback(errorCallback, "shareViaEmail"), "SocialSharing", "shareViaEmail", [message, subject, this._asArray(toArray), this._asArray(ccArray), this._asArray(bccArray), this._asArray(fileOrFileArray)]);
+};
+
+SocialSharing.prototype.canShareVia = function (via, message, subject, fileOrFileArray, url, successCallback, errorCallback) {
+  cordova.exec(successCallback, this._getErrorCallback(errorCallback, "canShareVia"), "SocialSharing", "canShareVia", [message, subject, this._asArray(fileOrFileArray), url, via]);
+};
+
+SocialSharing.prototype.canShareViaEmail = function (successCallback, errorCallback) {
+  cordova.exec(successCallback, this._getErrorCallback(errorCallback, "canShareViaEmail"), "SocialSharing", "canShareViaEmail", []);
+};
+
+SocialSharing.prototype.shareViaInstagram = function (message, fileOrFileArray, successCallback, errorCallback) {
+  cordova.exec(successCallback, this._getErrorCallback(errorCallback, "shareViaInstagram"), "SocialSharing", "shareViaInstagram", [message, null, this._asArray(fileOrFileArray), null]);
+};
+
+SocialSharing.prototype.shareVia = function (via, message, subject, fileOrFileArray, url, successCallback, errorCallback) {
+  cordova.exec(successCallback, this._getErrorCallback(errorCallback, "shareVia"), "SocialSharing", "shareVia", [message, subject, this._asArray(fileOrFileArray), url, via]);
+};
+
+SocialSharing.prototype.saveToPhotoAlbum = function (fileOrFileArray, successCallback, errorCallback) {
+  cordova.exec(successCallback, this._getErrorCallback(errorCallback, "saveToPhotoAlbum"), "SocialSharing", "saveToPhotoAlbum", [this._asArray(fileOrFileArray)]);
+};
+
+SocialSharing.prototype._asArray = function (param) {
+  if (param == null) {
+    param = [];
+  } else if (typeof param === 'string') {
+    param = new Array(param);
+  }
+  return param;
+};
+
+SocialSharing.prototype._getErrorCallback = function (ecb, functionName) {
+  if (typeof ecb === 'function') {
+    return ecb;
+  } else {
+    return function (result) {
+      console.log("The injected error callback of '" + functionName + "' received: " + JSON.stringify(result));
+    }
+  }
+};
+
+SocialSharing.install = function () {
+  if (!window.plugins) {
+    window.plugins = {};
+  }
+
+  window.plugins.socialsharing = new SocialSharing();
+
+  // Note only polyfill navigator.share if it is not defined, since shareW3C implements L1 of the spec,
+  // and an existing navigator.share method could implement L2.
+  if (!navigator.share) {
+    navigator.share = window.plugins.socialsharing.shareW3C;
+  }
+
+  return window.plugins.socialsharing;
+};
+
+cordova.addConstructor(SocialSharing.install);