app skeleton

12 files changed, 1353 insertions, 0 deletions

diff --git a/StoneIsland/plugins/cordova-plugin-network-information/src/android/NetworkManager.java b/StoneIsland/plugins/cordova-plugin-network-information/src/android/NetworkManager.java
new file mode 100755
index 00000000..4c85ddab
--- /dev/null
+++ b/StoneIsland/plugins/cordova-plugin-network-information/src/android/NetworkManager.java
@@ -0,0 +1,267 @@
+/*
+       Licensed to the Apache Software Foundation (ASF) under one
+       or more contributor license agreements.  See the NOTICE file
+       distributed with this work for additional information
+       regarding copyright ownership.  The ASF licenses this file
+       to you under the Apache License, Version 2.0 (the
+       "License"); you may not use this file except in compliance
+       with the License.  You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+       Unless required by applicable law or agreed to in writing,
+       software distributed under the License is distributed on an
+       "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+       KIND, either express or implied.  See the License for the
+       specific language governing permissions and limitations
+       under the License.
+*/
+package org.apache.cordova.networkinformation;
+
+import org.apache.cordova.CallbackContext;
+import org.apache.cordova.CordovaInterface;
+import org.apache.cordova.CordovaPlugin;
+import org.apache.cordova.PluginResult;
+import org.apache.cordova.CordovaWebView;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.net.ConnectivityManager;
+import android.net.NetworkInfo;
+import android.util.Log;
+
+public class NetworkManager extends CordovaPlugin {
+
+    public static int NOT_REACHABLE = 0;
+    public static int REACHABLE_VIA_CARRIER_DATA_NETWORK = 1;
+    public static int REACHABLE_VIA_WIFI_NETWORK = 2;
+
+    public static final String WIFI = "wifi";
+    public static final String WIMAX = "wimax";
+    // mobile
+    public static final String MOBILE = "mobile";
+    
+    // Android L calls this Cellular, because I have no idea! 
+    public static final String CELLULAR = "cellular";
+    // 2G network types
+    public static final String GSM = "gsm";
+    public static final String GPRS = "gprs";
+    public static final String EDGE = "edge";
+    // 3G network types
+    public static final String CDMA = "cdma";
+    public static final String UMTS = "umts";
+    public static final String HSPA = "hspa";
+    public static final String HSUPA = "hsupa";
+    public static final String HSDPA = "hsdpa";
+    public static final String ONEXRTT = "1xrtt";
+    public static final String EHRPD = "ehrpd";
+    // 4G network types
+    public static final String LTE = "lte";
+    public static final String UMB = "umb";
+    public static final String HSPA_PLUS = "hspa+";
+    // return type
+    public static final String TYPE_UNKNOWN = "unknown";
+    public static final String TYPE_ETHERNET = "ethernet";
+    public static final String TYPE_WIFI = "wifi";
+    public static final String TYPE_2G = "2g";
+    public static final String TYPE_3G = "3g";
+    public static final String TYPE_4G = "4g";
+    public static final String TYPE_NONE = "none";
+
+    private static final String LOG_TAG = "NetworkManager";
+
+    private CallbackContext connectionCallbackContext;
+
+    ConnectivityManager sockMan;
+    BroadcastReceiver receiver;
+    private JSONObject lastInfo = null;
+
+    /**
+     * Sets the context of the Command. This can then be used to do things like
+     * get file paths associated with the Activity.
+     *
+     * @param cordova The context of the main Activity.
+     * @param webView The CordovaWebView Cordova is running in.
+     */
+    public void initialize(CordovaInterface cordova, CordovaWebView webView) {
+        super.initialize(cordova, webView);
+        this.sockMan = (ConnectivityManager) cordova.getActivity().getSystemService(Context.CONNECTIVITY_SERVICE);
+        this.connectionCallbackContext = null;
+
+        // We need to listen to connectivity events to update navigator.connection
+        IntentFilter intentFilter = new IntentFilter();
+        intentFilter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
+        if (this.receiver == null) {
+            this.receiver = new BroadcastReceiver() {
+                @Override
+                public void onReceive(Context context, Intent intent) {
+                    // (The null check is for the ARM Emulator, please use Intel Emulator for better results)
+                    if(NetworkManager.this.webView != null)
+                        updateConnectionInfo(sockMan.getActiveNetworkInfo());
+                }
+            };
+            webView.getContext().registerReceiver(this.receiver, intentFilter);
+        }
+
+    }
+
+    /**
+     * Executes the request and returns PluginResult.
+     *
+     * @param action            The action to execute.
+     * @param args              JSONArry of arguments for the plugin.
+     * @param callbackContext   The callback id used when calling back into JavaScript.
+     * @return                  True if the action was valid, false otherwise.
+     */
+    public boolean execute(String action, JSONArray args, CallbackContext callbackContext) {
+        if (action.equals("getConnectionInfo")) {
+            this.connectionCallbackContext = callbackContext;
+            NetworkInfo info = sockMan.getActiveNetworkInfo();
+            String connectionType = "";
+            try {
+                connectionType = this.getConnectionInfo(info).get("type").toString();
+            } catch (JSONException e) { }
+
+            PluginResult pluginResult = new PluginResult(PluginResult.Status.OK, connectionType);
+            pluginResult.setKeepCallback(true);
+            callbackContext.sendPluginResult(pluginResult);
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Stop network receiver.
+     */
+    public void onDestroy() {
+        if (this.receiver != null) {
+            try {
+                webView.getContext().unregisterReceiver(this.receiver);
+            } catch (Exception e) {
+                Log.e(LOG_TAG, "Error unregistering network receiver: " + e.getMessage(), e);
+            } finally {
+                receiver = null;
+            }
+        }
+    }
+
+    //--------------------------------------------------------------------------
+    // LOCAL METHODS
+    //--------------------------------------------------------------------------
+
+    /**
+     * Updates the JavaScript side whenever the connection changes
+     *
+     * @param info the current active network info
+     * @return
+     */
+    private void updateConnectionInfo(NetworkInfo info) {
+        // send update to javascript "navigator.network.connection"
+        // Jellybean sends its own info
+        JSONObject thisInfo = this.getConnectionInfo(info);
+        if(!thisInfo.equals(lastInfo))
+        {
+            String connectionType = "";
+            try {
+                connectionType = thisInfo.get("type").toString();
+            } catch (JSONException e) { }
+
+            sendUpdate(connectionType);
+            lastInfo = thisInfo;
+        }
+    }
+
+    /**
+     * Get the latest network connection information
+     *
+     * @param info the current active network info
+     * @return a JSONObject that represents the network info
+     */
+    private JSONObject getConnectionInfo(NetworkInfo info) {
+        String type = TYPE_NONE;
+        String extraInfo = "";
+        if (info != null) {
+            // If we are not connected to any network set type to none
+            if (!info.isConnected()) {
+                type = TYPE_NONE;
+            }
+            else {
+                type = getType(info);
+            }
+            extraInfo = info.getExtraInfo();
+        }
+
+        Log.d("CordovaNetworkManager", "Connection Type: " + type);
+        Log.d("CordovaNetworkManager", "Connection Extra Info: " + extraInfo);
+
+        JSONObject connectionInfo = new JSONObject();
+
+        try {
+            connectionInfo.put("type", type);
+            connectionInfo.put("extraInfo", extraInfo);
+        } catch (JSONException e) { }
+
+        return connectionInfo;
+    }
+
+    /**
+     * Create a new plugin result and send it back to JavaScript
+     *
+     * @param connection the network info to set as navigator.connection
+     */
+    private void sendUpdate(String type) {
+        if (connectionCallbackContext != null) {
+            PluginResult result = new PluginResult(PluginResult.Status.OK, type);
+            result.setKeepCallback(true);
+            connectionCallbackContext.sendPluginResult(result);
+        }
+        webView.postMessage("networkconnection", type);
+    }
+
+    /**
+     * Determine the type of connection
+     *
+     * @param info the network info so we can determine connection type.
+     * @return the type of mobile network we are on
+     */
+    private String getType(NetworkInfo info) {
+        if (info != null) {
+            String type = info.getTypeName();
+
+            if (type.toLowerCase().equals(WIFI)) {
+                return TYPE_WIFI;
+            }
+            else if (type.toLowerCase().equals(MOBILE) || type.toLowerCase().equals(CELLULAR)) {
+                type = info.getSubtypeName();
+                if (type.toLowerCase().equals(GSM) ||
+                        type.toLowerCase().equals(GPRS) ||
+                        type.toLowerCase().equals(EDGE)) {
+                    return TYPE_2G;
+                }
+                else if (type.toLowerCase().startsWith(CDMA) ||
+                        type.toLowerCase().equals(UMTS) ||
+                        type.toLowerCase().equals(ONEXRTT) ||
+                        type.toLowerCase().equals(EHRPD) ||
+                        type.toLowerCase().equals(HSUPA) ||
+                        type.toLowerCase().equals(HSDPA) ||
+                        type.toLowerCase().equals(HSPA)) {
+                    return TYPE_3G;
+                }
+                else if (type.toLowerCase().equals(LTE) ||
+                        type.toLowerCase().equals(UMB) ||
+                        type.toLowerCase().equals(HSPA_PLUS)) {
+                    return TYPE_4G;
+                }
+            }
+        }
+        else {
+            return TYPE_NONE;
+        }
+        return TYPE_UNKNOWN;
+    }
+}
diff --git a/StoneIsland/plugins/cordova-plugin-network-information/src/blackberry10/index.js b/StoneIsland/plugins/cordova-plugin-network-information/src/blackberry10/index.js
new file mode 100644
index 00000000..d47d840e
--- /dev/null
+++ b/StoneIsland/plugins/cordova-plugin-network-information/src/blackberry10/index.js
@@ -0,0 +1,64 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+*/
+
+//map from BB10 to cordova connection types:
+//https://github.com/apache/cordova-js/blob/master/lib/common/plugin/Connection.js
+function mapConnectionType(con) {
+    switch (con.type) {
+    case 'wired':
+        return 'ethernet';
+    case 'wifi':
+        return 'wifi';
+    case 'none':
+        return 'none';
+    case 'cellular':
+        switch (con.technology) {
+        case 'edge':
+        case 'gsm':
+            return '2g';
+        case 'evdo':
+            return '3g';
+        case 'umts':
+            return '3g';
+        case 'lte':
+            return '4g';
+        }
+        return "cellular";
+    }
+    return 'unknown';
+}
+
+function currentConnectionType() {
+    try {
+        //possible for webplatform to throw pps exception
+        return mapConnectionType(window.qnx.webplatform.device.activeConnection || { type : 'none' });
+    }
+    catch (e) {
+        return 'unknown';
+    }
+}
+
+module.exports = {
+    getConnectionInfo: function (success, fail, args, env) {
+        var result = new PluginResult(args, env);
+        result.ok(currentConnectionType());
+    }
+};
diff --git a/StoneIsland/plugins/cordova-plugin-network-information/src/firefoxos/NetworkProxy.js b/StoneIsland/plugins/cordova-plugin-network-information/src/firefoxos/NetworkProxy.js
new file mode 100644
index 00000000..40d61637
--- /dev/null
+++ b/StoneIsland/plugins/cordova-plugin-network-information/src/firefoxos/NetworkProxy.js
@@ -0,0 +1,97 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ */
+
+/*
+  Network API overview: http://www.w3.org/TR/netinfo-api/
+  and http://w3c.github.io/netinfo/
+*/
+
+var cordova = require('cordova'),
+    Connection = require('./Connection'),
+    modulemapper = require('cordova/modulemapper');
+
+var origConnection = modulemapper.getOriginalSymbol(window, 'navigator.connection');
+
+module.exports = {
+
+  getConnectionInfo: function(successCallback, errorCallback) {
+    var connection = origConnection || navigator.mozConnection,
+        connectionType = Connection.UNKNOWN;
+
+    if (!connection) {
+        setTimeout(function() {
+            successCallback(connectionType);
+        }, 0);
+        return;
+    }
+
+    var bandwidth = connection.bandwidth,
+      metered = connection.metered,
+      type = connection.type;
+
+    if (type != undefined) {
+      // For more information see:
+      // https://developer.mozilla.org/en-US/docs/Web/API/Network_Information_API
+
+      switch(type) {
+        case "cellular":
+          connectionType = Connection.CELL;
+          break;
+        case "ethernet":
+          connectionType = Connection.ETHERNET;
+          break;
+        case "wifi":
+          connectionType = Connection.WIFI;
+          break;
+        case "none":
+          connectionType = Connection.NONE;
+          break;
+      }
+    } else if (bandwidth != undefined && metered != undefined) {
+      /*
+      bandwidth of type double, readonly
+      The user agent must set the value of the bandwidth attribute to:
+      0 if the user is currently offline;
+      Infinity if the bandwidth is unknown;
+      an estimation of the current bandwidth in MB/s (Megabytes per seconds)
+      available for communication with the browsing context active document's
+      domain.
+
+      For more information see:
+      https://developer.mozilla.org/en-US/docs/Web/API/Connection
+      */
+
+      if (bandwidth === 0) {
+        connectionType = Connection.NONE;
+      } else if (metered && isFinite(bandwidth)) {
+        connectionType = Connection.CELL;
+      } else if (!metered && isFinite(bandwidth)) {
+        connectionType = Connection.WIFI;
+      }
+    }
+
+    setTimeout(function() {
+      successCallback(connectionType);
+    }, 0);
+  }
+};
+
+require("cordova/exec/proxy").add("NetworkStatus", module.exports);
diff --git a/StoneIsland/plugins/cordova-plugin-network-information/src/ios/CDVConnection.h b/StoneIsland/plugins/cordova-plugin-network-information/src/ios/CDVConnection.h
new file mode 100644
index 00000000..8add0279
--- /dev/null
+++ b/StoneIsland/plugins/cordova-plugin-network-information/src/ios/CDVConnection.h
@@ -0,0 +1,34 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements.  See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership.  The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License.  You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied.  See the License for the
+ specific language governing permissions and limitations
+ under the License.
+ */
+
+#import <Foundation/Foundation.h>
+#import <Cordova/CDVPlugin.h>
+#import "CDVReachability.h"
+
+@interface CDVConnection : CDVPlugin {
+    NSString* type;
+    NSString* _callbackId;
+
+    CDVReachability* internetReach;
+}
+
+@property (copy) NSString* connectionType;
+@property (strong) CDVReachability* internetReach;
+
+@end
diff --git a/StoneIsland/plugins/cordova-plugin-network-information/src/ios/CDVConnection.m b/StoneIsland/plugins/cordova-plugin-network-information/src/ios/CDVConnection.m
new file mode 100644
index 00000000..37497675
--- /dev/null
+++ b/StoneIsland/plugins/cordova-plugin-network-information/src/ios/CDVConnection.m
@@ -0,0 +1,127 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements.  See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership.  The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License.  You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied.  See the License for the
+ specific language governing permissions and limitations
+ under the License.
+ */
+
+#import "CDVConnection.h"
+#import "CDVReachability.h"
+
+@interface CDVConnection (PrivateMethods)
+- (void)updateOnlineStatus;
+- (void)sendPluginResult;
+@end
+
+@implementation CDVConnection
+
+@synthesize connectionType, internetReach;
+
+- (void)getConnectionInfo:(CDVInvokedUrlCommand*)command
+{
+    _callbackId = command.callbackId;
+    [self sendPluginResult];
+}
+
+- (void)sendPluginResult
+{
+    CDVPluginResult* result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsString:self.connectionType];
+
+    [result setKeepCallbackAsBool:YES];
+    [self.commandDelegate sendPluginResult:result callbackId:_callbackId];
+}
+
+- (NSString*)w3cConnectionTypeFor:(CDVReachability*)reachability
+{
+    NetworkStatus networkStatus = [reachability currentReachabilityStatus];
+
+    switch (networkStatus) {
+        case NotReachable:
+            return @"none";
+
+        case ReachableViaWWAN:
+        {
+            BOOL isConnectionRequired = [reachability connectionRequired];
+            if (isConnectionRequired) {
+                return @"none";
+            } else {
+                return @"cellular";
+            }
+        }
+        case ReachableViaWiFi:
+            return @"wifi";
+
+        default:
+            return @"unknown";
+    }
+}
+
+- (BOOL)isCellularConnection:(NSString*)theConnectionType
+{
+    return [theConnectionType isEqualToString:@"2g"] ||
+           [theConnectionType isEqualToString:@"3g"] ||
+           [theConnectionType isEqualToString:@"4g"] ||
+           [theConnectionType isEqualToString:@"cellular"];
+}
+
+- (void)updateReachability:(CDVReachability*)reachability
+{
+    if (reachability) {
+        // check whether the connection type has changed
+        NSString* newConnectionType = [self w3cConnectionTypeFor:reachability];
+        if ([newConnectionType isEqualToString:self.connectionType]) { // the same as before, remove dupes
+            return;
+        } else {
+            self.connectionType = [self w3cConnectionTypeFor:reachability];
+        }
+    }
+    [self sendPluginResult];
+}
+
+- (void)updateConnectionType:(NSNotification*)note
+{
+    CDVReachability* curReach = [note object];
+
+    if ((curReach != nil) && [curReach isKindOfClass:[CDVReachability class]]) {
+        [self updateReachability:curReach];
+    }
+}
+
+- (void)onPause
+{
+    [self.internetReach stopNotifier];
+}
+
+- (void)onResume
+{
+    [self.internetReach startNotifier];
+    [self updateReachability:self.internetReach];
+}
+
+- (void)pluginInitialize
+{
+    self.connectionType = @"none";
+    self.internetReach = [CDVReachability reachabilityForInternetConnection];
+    self.connectionType = [self w3cConnectionTypeFor:self.internetReach];
+    [self.internetReach startNotifier];
+    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(updateConnectionType:)
+                                                 name:kReachabilityChangedNotification object:nil];
+    if (&UIApplicationDidEnterBackgroundNotification && &UIApplicationWillEnterForegroundNotification) {
+        [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(onPause) name:UIApplicationDidEnterBackgroundNotification object:nil];
+        [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(onResume) name:UIApplicationWillEnterForegroundNotification object:nil];
+    }
+}
+
+@end
diff --git a/StoneIsland/plugins/cordova-plugin-network-information/src/ios/CDVReachability.h b/StoneIsland/plugins/cordova-plugin-network-information/src/ios/CDVReachability.h
new file mode 100644
index 00000000..01a95c35
--- /dev/null
+++ b/StoneIsland/plugins/cordova-plugin-network-information/src/ios/CDVReachability.h
@@ -0,0 +1,85 @@
+/*
+
+ File: Reachability.h
+ Abstract: Basic demonstration of how to use the SystemConfiguration Reachability APIs.
+ Version: 2.2
+
+ Disclaimer: IMPORTANT:  This Apple software is supplied to you by Apple Inc.
+ ("Apple") in consideration of your agreement to the following terms, and your
+ use, installation, modification or redistribution of this Apple software
+ constitutes acceptance of these terms.  If you do not agree with these terms,
+ please do not use, install, modify or redistribute this Apple software.
+
+ In consideration of your agreement to abide by the following terms, and subject
+ to these terms, Apple grants you a personal, non-exclusive license, under
+ Apple's copyrights in this original Apple software (the "Apple Software"), to
+ use, reproduce, modify and redistribute the Apple Software, with or without
+ modifications, in source and/or binary forms; provided that if you redistribute
+ the Apple Software in its entirety and without modifications, you must retain
+ this notice and the following text and disclaimers in all such redistributions
+ of the Apple Software.
+ Neither the name, trademarks, service marks or logos of Apple Inc. may be used
+ to endorse or promote products derived from the Apple Software without specific
+ prior written permission from Apple.  Except as expressly stated in this notice,
+ no other rights or licenses, express or implied, are granted by Apple herein,
+ including but not limited to any patent rights that may be infringed by your
+ derivative works or by other works in which the Apple Software may be
+ incorporated.
+
+ The Apple Software is provided by Apple on an "AS IS" basis.  APPLE MAKES NO
+ WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED
+ WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND OPERATION ALONE OR IN
+ COMBINATION WITH YOUR PRODUCTS.
+
+ IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL OR
+ CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR
+ DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF
+ CONTRACT, TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF
+ APPLE HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ Copyright (C) 2010 Apple Inc. All Rights Reserved.
+
+*/
+
+#import <Foundation/Foundation.h>
+#import <SystemConfiguration/SystemConfiguration.h>
+#import <netinet/in.h>
+
+typedef enum {
+    NotReachable = 0,
+    ReachableViaWWAN, // this value has been swapped with ReachableViaWiFi for Cordova backwards compat. reasons
+    ReachableViaWiFi  // this value has been swapped with ReachableViaWWAN for Cordova backwards compat. reasons
+} NetworkStatus;
+#define kReachabilityChangedNotification @"kNetworkReachabilityChangedNotification"
+
+@interface CDVReachability : NSObject
+{
+    BOOL localWiFiRef;
+    SCNetworkReachabilityRef reachabilityRef;
+}
+
+// reachabilityWithHostName- Use to check the reachability of a particular host name.
++ (CDVReachability*)reachabilityWithHostName:(NSString*)hostName;
+
+// reachabilityWithAddress- Use to check the reachability of a particular IP address.
++ (CDVReachability*)reachabilityWithAddress:(const struct sockaddr_in*)hostAddress;
+
+// reachabilityForInternetConnection- checks whether the default route is available.
+//  Should be used by applications that do not connect to a particular host
++ (CDVReachability*)reachabilityForInternetConnection;
+
+// reachabilityForLocalWiFi- checks whether a local wifi connection is available.
++ (CDVReachability*)reachabilityForLocalWiFi;
+
+// Start listening for reachability notifications on the current run loop
+- (BOOL)startNotifier;
+- (void)stopNotifier;
+
+- (NetworkStatus)currentReachabilityStatus;
+// WWAN may be available, but not active until a connection has been established.
+// WiFi may require a connection for VPN on Demand.
+- (BOOL)connectionRequired;
+@end
diff --git a/StoneIsland/plugins/cordova-plugin-network-information/src/ios/CDVReachability.m b/StoneIsland/plugins/cordova-plugin-network-information/src/ios/CDVReachability.m
new file mode 100644
index 00000000..c60261ae
--- /dev/null
+++ b/StoneIsland/plugins/cordova-plugin-network-information/src/ios/CDVReachability.m
@@ -0,0 +1,260 @@
+/*
+
+ File: Reachability.m
+ Abstract: Basic demonstration of how to use the SystemConfiguration Reachability APIs.
+ Version: 2.2
+
+ Disclaimer: IMPORTANT:  This Apple software is supplied to you by Apple Inc.
+ ("Apple") in consideration of your agreement to the following terms, and your
+ use, installation, modification or redistribution of this Apple software
+ constitutes acceptance of these terms.  If you do not agree with these terms,
+ please do not use, install, modify or redistribute this Apple software.
+
+ In consideration of your agreement to abide by the following terms, and subject
+ to these terms, Apple grants you a personal, non-exclusive license, under
+ Apple's copyrights in this original Apple software (the "Apple Software"), to
+ use, reproduce, modify and redistribute the Apple Software, with or without
+ modifications, in source and/or binary forms; provided that if you redistribute
+ the Apple Software in its entirety and without modifications, you must retain
+ this notice and the following text and disclaimers in all such redistributions
+ of the Apple Software.
+ Neither the name, trademarks, service marks or logos of Apple Inc. may be used
+ to endorse or promote products derived from the Apple Software without specific
+ prior written permission from Apple.  Except as expressly stated in this notice,
+ no other rights or licenses, express or implied, are granted by Apple herein,
+ including but not limited to any patent rights that may be infringed by your
+ derivative works or by other works in which the Apple Software may be
+ incorporated.
+
+ The Apple Software is provided by Apple on an "AS IS" basis.  APPLE MAKES NO
+ WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED
+ WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND OPERATION ALONE OR IN
+ COMBINATION WITH YOUR PRODUCTS.
+
+ IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL OR
+ CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR
+ DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF
+ CONTRACT, TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF
+ APPLE HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ Copyright (C) 2010 Apple Inc. All Rights Reserved.
+
+*/
+
+#import <sys/socket.h>
+#import <netinet/in.h>
+#import <netinet6/in6.h>
+#import <arpa/inet.h>
+#import <ifaddrs.h>
+#import <netdb.h>
+
+#import <CoreFoundation/CoreFoundation.h>
+
+#import "CDVReachability.h"
+
+#define kShouldPrintReachabilityFlags 0
+
+static void CDVPrintReachabilityFlags(SCNetworkReachabilityFlags flags, const char* comment)
+{
+#if kShouldPrintReachabilityFlags
+        NSLog(@"Reachability Flag Status: %c%c %c%c%c%c%c%c%c %s\n",
+            (flags & kSCNetworkReachabilityFlagsIsWWAN)               ? 'W' : '-',
+            (flags & kSCNetworkReachabilityFlagsReachable)            ? 'R' : '-',
+
+            (flags & kSCNetworkReachabilityFlagsTransientConnection)  ? 't' : '-',
+            (flags & kSCNetworkReachabilityFlagsConnectionRequired)   ? 'c' : '-',
+            (flags & kSCNetworkReachabilityFlagsConnectionOnTraffic)  ? 'C' : '-',
+            (flags & kSCNetworkReachabilityFlagsInterventionRequired) ? 'i' : '-',
+            (flags & kSCNetworkReachabilityFlagsConnectionOnDemand)   ? 'D' : '-',
+            (flags & kSCNetworkReachabilityFlagsIsLocalAddress)       ? 'l' : '-',
+            (flags & kSCNetworkReachabilityFlagsIsDirect)             ? 'd' : '-',
+            comment
+            );
+#endif
+}
+
+@implementation CDVReachability
+
+static void CDVReachabilityCallback(SCNetworkReachabilityRef target, SCNetworkReachabilityFlags flags, void* info)
+{
+#pragma unused (target, flags)
+    //	NSCAssert(info != NULL, @"info was NULL in ReachabilityCallback");
+    //	NSCAssert([(NSObject*) info isKindOfClass: [Reachability class]], @"info was wrong class in ReachabilityCallback");
+
+    // Converted the asserts above to conditionals, with safe return from the function
+    if (info == NULL) {
+        NSLog(@"info was NULL in ReachabilityCallback");
+        return;
+    }
+
+    if (![(__bridge NSObject*)info isKindOfClass :[CDVReachability class]]) {
+        NSLog(@"info was wrong class in ReachabilityCallback");
+        return;
+    }
+
+    // We're on the main RunLoop, so an NSAutoreleasePool is not necessary, but is added defensively
+    // in case someon uses the Reachability object in a different thread.
+    @autoreleasepool {
+        CDVReachability* noteObject = (__bridge CDVReachability*)info;
+        // Post a notification to notify the client that the network reachability changed.
+        [[NSNotificationCenter defaultCenter] postNotificationName:kReachabilityChangedNotification object:noteObject];
+    }
+}
+
+- (BOOL)startNotifier
+{
+    BOOL retVal = NO;
+    SCNetworkReachabilityContext context = {0, (__bridge void*)(self), NULL, NULL, NULL};
+
+    if (SCNetworkReachabilitySetCallback(reachabilityRef, CDVReachabilityCallback, &context)) {
+        if (SCNetworkReachabilityScheduleWithRunLoop(reachabilityRef, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode)) {
+            retVal = YES;
+        }
+    }
+    return retVal;
+}
+
+- (void)stopNotifier
+{
+    if (reachabilityRef != NULL) {
+        SCNetworkReachabilityUnscheduleFromRunLoop(reachabilityRef, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);
+    }
+}
+
+- (void)dealloc
+{
+    [self stopNotifier];
+    if (reachabilityRef != NULL) {
+        CFRelease(reachabilityRef);
+    }
+}
+
++ (CDVReachability*)reachabilityWithHostName:(NSString*)hostName;
+{
+    CDVReachability* retVal = NULL;
+    SCNetworkReachabilityRef reachability = SCNetworkReachabilityCreateWithName(NULL, [hostName UTF8String]);
+    if (reachability != NULL) {
+        retVal = [[self alloc] init];
+        if (retVal != NULL) {
+            retVal->reachabilityRef = reachability;
+            retVal->localWiFiRef = NO;
+        }
+    }
+    return retVal;
+}
+
++ (CDVReachability*)reachabilityWithAddress:(const struct sockaddr_in*)hostAddress;
+{
+    SCNetworkReachabilityRef reachability = SCNetworkReachabilityCreateWithAddress(kCFAllocatorDefault, (const struct sockaddr*)hostAddress);
+    CDVReachability* retVal = NULL;
+    if (reachability != NULL) {
+        retVal = [[self alloc] init];
+        if (retVal != NULL) {
+            retVal->reachabilityRef = reachability;
+            retVal->localWiFiRef = NO;
+        }
+    }
+    return retVal;
+}
+
++ (CDVReachability*)reachabilityForInternetConnection;
+{
+    struct sockaddr_in zeroAddress;
+    bzero(&zeroAddress, sizeof(zeroAddress));
+    zeroAddress.sin_len = sizeof(zeroAddress);
+    zeroAddress.sin_family = AF_INET;
+    return [self reachabilityWithAddress:&zeroAddress];
+}
+
++ (CDVReachability*)reachabilityForLocalWiFi;
+{
+    struct sockaddr_in localWifiAddress;
+    bzero(&localWifiAddress, sizeof(localWifiAddress));
+    localWifiAddress.sin_len = sizeof(localWifiAddress);
+    localWifiAddress.sin_family = AF_INET;
+    // IN_LINKLOCALNETNUM is defined in <netinet/in.h> as 169.254.0.0
+    localWifiAddress.sin_addr.s_addr = htonl(IN_LINKLOCALNETNUM);
+    CDVReachability* retVal = [self reachabilityWithAddress:&localWifiAddress];
+    if (retVal != NULL) {
+        retVal->localWiFiRef = YES;
+    }
+    return retVal;
+}
+
+#pragma mark Network Flag Handling
+
+- (NetworkStatus)localWiFiStatusForFlags:(SCNetworkReachabilityFlags)flags
+{
+    CDVPrintReachabilityFlags(flags, "localWiFiStatusForFlags");
+
+    BOOL retVal = NotReachable;
+    if ((flags & kSCNetworkReachabilityFlagsReachable) && (flags & kSCNetworkReachabilityFlagsIsDirect)) {
+        retVal = ReachableViaWiFi;
+    }
+    return retVal;
+}
+
+- (NetworkStatus)networkStatusForFlags:(SCNetworkReachabilityFlags)flags
+{
+    CDVPrintReachabilityFlags(flags, "networkStatusForFlags");
+    if ((flags & kSCNetworkReachabilityFlagsReachable) == 0) {
+        // if target host is not reachable
+        return NotReachable;
+    }
+
+    NetworkStatus retVal = NotReachable;
+
+    if ((flags & kSCNetworkReachabilityFlagsConnectionRequired) == 0) {
+        // if target host is reachable and no connection is required
+        //  then we'll assume (for now) that your on Wi-Fi
+        retVal = ReachableViaWiFi;
+    }
+
+    if ((((flags & kSCNetworkReachabilityFlagsConnectionOnDemand) != 0) ||
+        ((flags & kSCNetworkReachabilityFlagsConnectionOnTraffic) != 0))) {
+        // ... and the connection is on-demand (or on-traffic) if the
+        //     calling application is using the CFSocketStream or higher APIs
+
+        if ((flags & kSCNetworkReachabilityFlagsInterventionRequired) == 0) {
+            // ... and no [user] intervention is needed
+            retVal = ReachableViaWiFi;
+        }
+    }
+
+    if ((flags & kSCNetworkReachabilityFlagsIsWWAN) == kSCNetworkReachabilityFlagsIsWWAN) {
+        // ... but WWAN connections are OK if the calling application
+        //     is using the CFNetwork (CFSocketStream?) APIs.
+        retVal = ReachableViaWWAN;
+    }
+    return retVal;
+}
+
+- (BOOL)connectionRequired;
+{
+    NSAssert(reachabilityRef != NULL, @"connectionRequired called with NULL reachabilityRef");
+    SCNetworkReachabilityFlags flags;
+    if (SCNetworkReachabilityGetFlags(reachabilityRef, &flags)) {
+        return flags & kSCNetworkReachabilityFlagsConnectionRequired;
+    }
+    return NO;
+}
+
+- (NetworkStatus)currentReachabilityStatus
+{
+    NSAssert(reachabilityRef != NULL, @"currentNetworkStatus called with NULL reachabilityRef");
+    NetworkStatus retVal = NotReachable;
+    SCNetworkReachabilityFlags flags;
+    if (SCNetworkReachabilityGetFlags(reachabilityRef, &flags)) {
+        if (localWiFiRef) {
+            retVal = [self localWiFiStatusForFlags:flags];
+        } else {
+            retVal = [self networkStatusForFlags:flags];
+        }
+    }
+    return retVal;
+}
+
+@end
diff --git a/StoneIsland/plugins/cordova-plugin-network-information/src/tizen/NetworkProxy.js b/StoneIsland/plugins/cordova-plugin-network-information/src/tizen/NetworkProxy.js
new file mode 100644
index 00000000..cd9506e1
--- /dev/null
+++ b/StoneIsland/plugins/cordova-plugin-network-information/src/tizen/NetworkProxy.js
@@ -0,0 +1,92 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+*/
+
+var cordova = require('cordova');
+var Connection = require('./Connection');
+
+module.exports = {
+    getConnectionInfo: function(successCallback, errorCallback) {
+        var cncType = Connection.NONE;
+        var infoCount = 0;
+        var deviceCapabilities = null;
+        var timerId = 0;
+        var timeout = 300;
+
+
+        function connectionCB() {
+            if (timerId !== null) {
+                clearTimeout(timerId);
+                timerId = null;
+            }
+
+            infoCount++;
+
+            if (infoCount > 1) {
+                if (successCallback) {
+                    successCallback(cncType);
+                }
+            }
+        }
+
+        function errorCB(error) {
+            console.log("Error: " + error.code + "," + error.name + "," + error.message);
+
+            if (errorCallback) {
+                errorCallback();
+            }
+        }
+
+        function wifiSuccessCB(wifi) {
+            if ((wifi.status === "ON")  && (wifi.ipAddress.length !== 0)) {
+                cncType = Connection.WIFI;
+            }
+            connectionCB();
+        }
+
+        function cellularSuccessCB(cell) {
+            if ((cncType === Connection.NONE) && (cell.status === "ON") && (cell.ipAddress.length !== 0)) {
+                cncType = Connection.CELL_2G;
+            }
+            connectionCB();
+        }
+
+
+        deviceCapabilities = tizen.systeminfo.getCapabilities();
+
+
+        timerId = setTimeout(function() {
+            timerId = null;
+            infoCount = 1;
+            connectionCB();
+        }, timeout);
+
+
+        if (deviceCapabilities.wifi) {
+            tizen.systeminfo.getPropertyValue("WIFI_NETWORK", wifiSuccessCB, errorCB);
+        }
+
+        if (deviceCapabilities.telephony) {
+            tizen.systeminfo.getPropertyValue("CELLULAR_NETWORK", cellularSuccessCB, errorCB);
+        }
+    }
+};
+
+require("cordova/tizen/commandProxy").add("NetworkStatus", module.exports);
diff --git a/StoneIsland/plugins/cordova-plugin-network-information/src/ubuntu/network_information.cpp b/StoneIsland/plugins/cordova-plugin-network-information/src/ubuntu/network_information.cpp
new file mode 100644
index 00000000..8fdb4949
--- /dev/null
+++ b/StoneIsland/plugins/cordova-plugin-network-information/src/ubuntu/network_information.cpp
@@ -0,0 +1,63 @@
+/*
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include "network_information.h"
+
+void NetworkInformation::getConnectionInfo(int scId, int ecId) {
+    Q_UNUSED(ecId);
+
+    QString result;
+    QNetworkInfo::NetworkMode networkMode = m_systemNetworkInfo.currentNetworkMode();
+    QNetworkInfo::NetworkStatus networkStatus = m_systemNetworkInfo.networkStatus(networkMode, 0);
+    QNetworkInfo::CellDataTechnology cellDataTechnology = m_systemNetworkInfo.currentCellDataTechnology(0);
+
+    if (networkStatus == QNetworkInfo::NoNetworkAvailable)
+        result = "Connection.NONE";
+
+    switch (networkMode) {
+    case QNetworkInfo::WimaxMode:
+    case QNetworkInfo::WlanMode:
+        result = "Connection.WIFI";
+        break;
+    case QNetworkInfo::EthernetMode:
+        result = "Connection.ETHERNET";
+        break;
+    case QNetworkInfo::LteMode:
+        result = "Connection.CELL_4G";
+        break;
+    case QNetworkInfo::GsmMode:
+    case QNetworkInfo::CdmaMode:
+    case QNetworkInfo::TdscdmaMode:
+    case QNetworkInfo::WcdmaMode:
+        switch (cellDataTechnology) {
+        case QNetworkInfo::UmtsDataTechnology:
+        case QNetworkInfo::HspaDataTechnology:
+            result = "Connection.CELL_3G";
+            break;
+        case QNetworkInfo::EdgeDataTechnology:
+        case QNetworkInfo::GprsDataTechnology:
+            result = "Connection.CELL_2G";
+            break;
+        case QNetworkInfo::UnknownDataTechnology:
+            result = "Connection.UNKNOWN";
+            break;
+        }
+    case QNetworkInfo::BluetoothMode:
+    case QNetworkInfo::UnknownMode:
+        result = "Connection.UNKNOWN";
+        break;
+    }
+
+    this->callback(scId, result);
+}
diff --git a/StoneIsland/plugins/cordova-plugin-network-information/src/ubuntu/network_information.h b/StoneIsland/plugins/cordova-plugin-network-information/src/ubuntu/network_information.h
new file mode 100644
index 00000000..aca20e7b
--- /dev/null
+++ b/StoneIsland/plugins/cordova-plugin-network-information/src/ubuntu/network_information.h
@@ -0,0 +1,47 @@
+/*
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#ifndef NETWORK_INFORMATION_H
+#define NETWORK_INFORMATION_H
+
+#include <cplugin.h>
+
+#include <QtSystemInfo>
+#include <QtCore>
+
+class NetworkInformation: public CPlugin {
+    Q_OBJECT
+public:
+    explicit NetworkInformation(Cordova *cordova): CPlugin(cordova) {}
+
+    virtual const QString fullName() override {
+        return NetworkInformation::fullID();
+    }
+
+    virtual const QString shortName() override {
+        return "Connection";
+    }
+
+    static const QString fullID() {
+        return "NetworkStatus";
+    }
+
+public slots:
+    void getConnectionInfo(int scId, int ecId);
+
+private:
+    QNetworkInfo m_systemNetworkInfo;
+};
+
+#endif
diff --git a/StoneIsland/plugins/cordova-plugin-network-information/src/windows/NetworkInfoProxy.js b/StoneIsland/plugins/cordova-plugin-network-information/src/windows/NetworkInfoProxy.js
new file mode 100644
index 00000000..27ad2f06
--- /dev/null
+++ b/StoneIsland/plugins/cordova-plugin-network-information/src/windows/NetworkInfoProxy.js
@@ -0,0 +1,88 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+*/
+
+/*global Windows:true */
+
+var cordova = require('cordova');
+var Connection = require('./Connection');
+
+var winNetConn = Windows.Networking.Connectivity;
+var networkInfo = winNetConn.NetworkInformation;
+var networkCostInfo = winNetConn.NetworkCostType;
+var networkConnectivityInfo = winNetConn.NetworkConnectivityLevel;
+var networkAuthenticationInfo = winNetConn.NetworkAuthenticationType;
+var networkEncryptionInfo = winNetConn.NetworkEncryptionType;
+
+function getCurrrentConnectionType() {
+
+    var profile = networkInfo.getInternetConnectionProfile();
+
+    if (!profile) {
+        return Connection.NONE;
+    }
+
+    var conLevel = profile.getNetworkConnectivityLevel();
+    var interfaceType = profile.networkAdapter.ianaInterfaceType;
+
+    // since we use this to detect whether we are online or offline we do check agains InternetAccess
+    // localAccess (airplane mode as an example) or constrainedInternetAccess mean there is no access to the internet available
+    // https://msdn.microsoft.com/library/windows/apps/windows.networking.connectivity.networkconnectivitylevel.aspx
+    if (conLevel != Windows.Networking.Connectivity.NetworkConnectivityLevel.internetAccess) {
+        return Connection.NONE;
+    }
+
+    var connectionType;
+
+    switch (interfaceType) {
+        case 71:
+            connectionType = Connection.WIFI;
+            break;
+        case 6:
+            connectionType = Connection.ETHERNET;
+            break;
+        case 243: // (3GPP WWAN) // Fallthrough is intentional
+        case 244: // (3GPP2 WWAN)
+            connectionType = Connection.CELL_3G;
+            break;
+        default:
+            connectionType = Connection.UNKNOWN;
+            break;
+    }
+
+    return connectionType;
+}
+
+module.exports = {
+
+    getConnectionInfo:function(win,fail,args)
+    {
+        var reportConnectionInfoOnce = function () {
+            win(getCurrrentConnectionType(), { keepCallback: true });
+        }
+
+        // report current connection  type
+        setTimeout(reportConnectionInfoOnce, 0);
+        // start traking future changes
+        networkInfo.addEventListener("networkstatuschanged", reportConnectionInfoOnce);
+    }
+};
+
+require("cordova/exec/proxy").add("NetworkStatus",module.exports);
diff --git a/StoneIsland/plugins/cordova-plugin-network-information/src/wp/NetworkStatus.cs b/StoneIsland/plugins/cordova-plugin-network-information/src/wp/NetworkStatus.cs
new file mode 100644
index 00000000..12eb061d
--- /dev/null
+++ b/StoneIsland/plugins/cordova-plugin-network-information/src/wp/NetworkStatus.cs
@@ -0,0 +1,129 @@
+/*  
+	Licensed under the Apache License, Version 2.0 (the "License");
+	you may not use this file except in compliance with the License.
+	You may obtain a copy of the License at
+	
+	http://www.apache.org/licenses/LICENSE-2.0
+	
+	Unless required by applicable law or agreed to in writing, software
+	distributed under the License is distributed on an "AS IS" BASIS,
+	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+	See the License for the specific language governing permissions and
+	limitations under the License.
+*/
+
+using System;
+using System.Diagnostics;
+using System.Net;
+using System.Net.NetworkInformation;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Documents;
+using System.Windows.Ink;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Media.Animation;
+using System.Windows.Shapes;
+using Microsoft.Phone.Net.NetworkInformation;
+
+namespace WPCordovaClassLib.Cordova.Commands
+{
+
+    // http://msdn.microsoft.com/en-us/library/microsoft.phone.net.networkinformation(v=VS.92).aspx
+    // http://msdn.microsoft.com/en-us/library/microsoft.phone.net.networkinformation.devicenetworkinformation(v=VS.92).aspx
+
+    public class NetworkStatus : BaseCommand
+    {
+        const string UNKNOWN = "unknown";
+        const string ETHERNET = "ethernet";
+        const string WIFI = "wifi";
+        const string CELL_2G = "2g";
+        const string CELL_3G = "3g";
+        const string CELL_4G = "4g";
+        const string NONE = "none";
+        const string CELL = "cellular";
+
+        private bool HasCallback = false;
+
+        public NetworkStatus()
+        {
+            DeviceNetworkInformation.NetworkAvailabilityChanged += new EventHandler<NetworkNotificationEventArgs>(ChangeDetected);
+        }
+
+        public override void OnResume(object sender, Microsoft.Phone.Shell.ActivatedEventArgs e)
+        {
+            this.getConnectionInfo("");
+        }
+
+        public void getConnectionInfo(string empty)
+        {
+            HasCallback = true;
+            updateConnectionType(checkConnectionType());
+        }
+
+        private string checkConnectionType()
+        {
+            if (DeviceNetworkInformation.IsNetworkAvailable)
+            {
+                if (DeviceNetworkInformation.IsWiFiEnabled)
+                {
+                    return WIFI;
+                }
+                else
+                {
+                    return DeviceNetworkInformation.IsCellularDataEnabled ? CELL : UNKNOWN;
+                }
+            }
+            return NONE;
+        }
+
+        private string checkConnectionType(NetworkInterfaceSubType type)
+        {
+            switch (type)
+            {
+                case NetworkInterfaceSubType.Cellular_1XRTT: //cell
+                case NetworkInterfaceSubType.Cellular_GPRS: //cell
+                    return CELL;
+                case NetworkInterfaceSubType.Cellular_EDGE: //2
+                    return CELL_2G;
+                case NetworkInterfaceSubType.Cellular_3G:
+                case NetworkInterfaceSubType.Cellular_EVDO: //3
+                case NetworkInterfaceSubType.Cellular_EVDV: //3 
+                case NetworkInterfaceSubType.Cellular_HSPA: //3
+                    return CELL_3G;
+                case NetworkInterfaceSubType.WiFi:
+                    return WIFI;
+                case NetworkInterfaceSubType.Unknown:
+                case NetworkInterfaceSubType.Desktop_PassThru:
+                default:
+                    return UNKNOWN;
+            }
+        }
+
+        void ChangeDetected(object sender, NetworkNotificationEventArgs e)
+        {
+            switch (e.NotificationType)
+            {
+                case NetworkNotificationType.InterfaceConnected:
+                    updateConnectionType(checkConnectionType(e.NetworkInterface.InterfaceSubtype));
+                    break;
+                case NetworkNotificationType.InterfaceDisconnected:
+                    updateConnectionType(NONE);
+                    break;
+                default:
+                    break;
+            }
+        }
+
+        private void updateConnectionType(string type)
+        {
+            // This should also implicitly fire offline/online events as that is handled on the JS side
+            if (this.HasCallback)
+            {
+                PluginResult result = new PluginResult(PluginResult.Status.OK, type);
+                result.KeepCallback = true;
+                DispatchCommandResult(result);
+            }
+        }
+    }
+}