mobile_template 0.0.1

data/templates/cordova_android/framework/src/org/apache/cordova/CordovaWebViewClient.java

@@ -0,0 +1,306 @@
+/*
+       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;
+
+import org.apache.cordova.api.LOG;
+
+import android.content.Intent;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
+import android.content.pm.PackageManager.NameNotFoundException;
+import android.graphics.Bitmap;
+import android.net.Uri;
+import android.net.http.SslError;
+import android.util.Log;
+import android.view.View;
+import android.webkit.HttpAuthHandler;
+import android.webkit.SslErrorHandler;
+import android.webkit.WebView;
+import android.webkit.WebViewClient;
+
+/**
+ * This class is the WebViewClient that implements callbacks for our web view.
+ */
+public class CordovaWebViewClient extends WebViewClient {
+    
+    private static final String TAG = "Cordova";
+    DroidGap ctx;
+    private boolean doClearHistory = false;
+
+    /**
+     * Constructor.
+     * 
+     * @param ctx
+     */
+    public CordovaWebViewClient(DroidGap ctx) {
+        this.ctx = ctx;
+    }
+    
+    /**
+     * Give the host application a chance to take over the control when a new url 
+     * is about to be loaded in the current WebView.
+     * 
+     * @param view          The WebView that is initiating the callback.
+     * @param url           The url to be loaded.
+     * @return              true to override, false for default behavior
+     */
+    @Override
+    public boolean shouldOverrideUrlLoading(WebView view, String url) {
+        
+        // First give any plugins the chance to handle the url themselves
+        if (this.ctx.pluginManager.onOverrideUrlLoading(url)) {
+        }
+        
+        // If dialing phone (tel:5551212)
+        else if (url.startsWith(WebView.SCHEME_TEL)) {
+            try {
+                Intent intent = new Intent(Intent.ACTION_DIAL);
+                intent.setData(Uri.parse(url));
+                ctx.startActivity(intent);
+            } catch (android.content.ActivityNotFoundException e) {
+                LOG.e(TAG, "Error dialing "+url+": "+ e.toString());
+            }
+        }
+
+        // If displaying map (geo:0,0?q=address)
+        else if (url.startsWith("geo:")) {
+            try {
+                Intent intent = new Intent(Intent.ACTION_VIEW);
+                intent.setData(Uri.parse(url));
+                ctx.startActivity(intent);
+            } catch (android.content.ActivityNotFoundException e) {
+                LOG.e(TAG, "Error showing map "+url+": "+ e.toString());
+            }
+        }
+
+        // If sending email (mailto:abc@corp.com)
+        else if (url.startsWith(WebView.SCHEME_MAILTO)) {
+            try {
+                Intent intent = new Intent(Intent.ACTION_VIEW);
+                intent.setData(Uri.parse(url));
+                ctx.startActivity(intent);
+            } catch (android.content.ActivityNotFoundException e) {
+                LOG.e(TAG, "Error sending email "+url+": "+ e.toString());
+            }
+        }
+
+        // If sms:5551212?body=This is the message
+        else if (url.startsWith("sms:")) {
+            try {
+                Intent intent = new Intent(Intent.ACTION_VIEW);
+
+                // Get address
+                String address = null;
+                int parmIndex = url.indexOf('?');
+                if (parmIndex == -1) {
+                    address = url.substring(4);
+                }
+                else {
+                    address = url.substring(4, parmIndex);
+
+                    // If body, then set sms body
+                    Uri uri = Uri.parse(url);
+                    String query = uri.getQuery();
+                    if (query != null) {
+                        if (query.startsWith("body=")) {
+                            intent.putExtra("sms_body", query.substring(5));
+                        }
+                    }
+                }
+                intent.setData(Uri.parse("sms:"+address));
+                intent.putExtra("address", address);
+                intent.setType("vnd.android-dir/mms-sms");
+                ctx.startActivity(intent);
+            } catch (android.content.ActivityNotFoundException e) {
+                LOG.e(TAG, "Error sending sms "+url+":"+ e.toString());
+            }
+        }
+
+        // All else
+        else {
+
+            // If our app or file:, then load into a new Cordova webview container by starting a new instance of our activity.
+            // Our app continues to run.  When BACK is pressed, our app is redisplayed.
+            if (url.startsWith("file://") || url.indexOf(this.ctx.baseUrl) == 0 || ctx.isUrlWhiteListed(url)) {
+                this.ctx.loadUrl(url);
+            }
+
+            // If not our application, let default viewer handle
+            else {
+                try {
+                    Intent intent = new Intent(Intent.ACTION_VIEW);
+                    intent.setData(Uri.parse(url));
+                    ctx.startActivity(intent);
+                } catch (android.content.ActivityNotFoundException e) {
+                    LOG.e(TAG, "Error loading url "+url, e);
+                }
+            }
+        }
+        return true;
+    }
+    
+    /**
+     * On received http auth request.
+     * The method reacts on all registered authentication tokens. There is one and only one authentication token for any host + realm combination 
+     * 
+     * @param view
+     *            the view
+     * @param handler
+     *            the handler
+     * @param host
+     *            the host
+     * @param realm
+     *            the realm
+     */
+    @Override
+    public void onReceivedHttpAuthRequest(WebView view, HttpAuthHandler handler, String host,
+            String realm) {
+       
+        // get the authentication token
+        AuthenticationToken token = ctx.getAuthenticationToken(host,realm);
+        
+        if(token != null) {
+            handler.proceed(token.getUserName(), token.getPassword());
+        }
+    }
+
+    
+    @Override
+    public void onPageStarted(WebView view, String url, Bitmap favicon) {
+        // Clear history so history.back() doesn't do anything.  
+        // So we can reinit() native side CallbackServer & PluginManager.
+        view.clearHistory(); 
+        this.doClearHistory = true;
+    }
+    
+    /**
+     * Notify the host application that a page has finished loading.
+     * 
+     * @param view          The webview initiating the callback.
+     * @param url           The url of the page.
+     */
+    @Override
+    public void onPageFinished(WebView view, String url) {
+        super.onPageFinished(view, url);
+
+        /**
+         * Because of a timing issue we need to clear this history in onPageFinished as well as 
+         * onPageStarted. However we only want to do this if the doClearHistory boolean is set to 
+         * true. You see when you load a url with a # in it which is common in jQuery applications
+         * onPageStared is not called. Clearing the history at that point would break jQuery apps.
+         */
+        if (this.doClearHistory) {
+            view.clearHistory();
+            this.doClearHistory = false;
+        }
+
+        // Clear timeout flag
+        this.ctx.loadUrlTimeout++;
+
+        // Try firing the onNativeReady event in JS. If it fails because the JS is
+        // not loaded yet then just set a flag so that the onNativeReady can be fired
+        // from the JS side when the JS gets to that code.
+        if (!url.equals("about:blank")) {
+            ctx.appView.loadUrl("javascript:try{ require('cordova/channel').onNativeReady.fire();}catch(e){_nativeReady = true;}");
+        }
+
+        // Make app visible after 2 sec in case there was a JS error and Cordova JS never initialized correctly
+        if (ctx.appView.getVisibility() == View.INVISIBLE) {
+            Thread t = new Thread(new Runnable() {
+                public void run() {
+                    try {
+                        Thread.sleep(2000);
+                        ctx.runOnUiThread(new Runnable() {
+                            public void run() {
+                                ctx.appView.setVisibility(View.VISIBLE);
+                                ctx.spinnerStop();
+                            }
+                        });
+                    } catch (InterruptedException e) {
+                    }
+                }
+            });
+            t.start();
+        }
+
+
+        // Shutdown if blank loaded
+        if (url.equals("about:blank")) {
+            if (this.ctx.callbackServer != null) {
+                this.ctx.callbackServer.destroy();
+            }
+            this.ctx.endActivity();
+        }
+    }
+    
+    /**
+     * Report an error to the host application. These errors are unrecoverable (i.e. the main resource is unavailable). 
+     * The errorCode parameter corresponds to one of the ERROR_* constants.
+     *
+     * @param view          The WebView that is initiating the callback.
+     * @param errorCode     The error code corresponding to an ERROR_* value.
+     * @param description   A String describing the error.
+     * @param failingUrl    The url that failed to load. 
+     */
+    @Override
+    public void onReceivedError(WebView view, int errorCode, String description, String failingUrl) {
+        LOG.d(TAG, "DroidGap: GapViewClient.onReceivedError: Error code=%s Description=%s URL=%s", errorCode, description, failingUrl);
+
+        // Clear timeout flag
+        this.ctx.loadUrlTimeout++;
+
+        // Stop "app loading" spinner if showing
+        this.ctx.spinnerStop();
+
+        // Handle error
+        this.ctx.onReceivedError(errorCode, description, failingUrl);
+    }
+    
+    public void onReceivedSslError(WebView view, SslErrorHandler handler, SslError error) {
+        
+        final String packageName = this.ctx.getPackageName();
+        final PackageManager pm = this.ctx.getPackageManager();
+        ApplicationInfo appInfo;
+        try {
+            appInfo = pm.getApplicationInfo(packageName, PackageManager.GET_META_DATA);
+            if ((appInfo.flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0) {
+                // debug = true
+                handler.proceed();
+                return;
+            } else {
+                // debug = false
+                super.onReceivedSslError(view, handler, error);    
+            }
+        } catch (NameNotFoundException e) {
+            // When it doubt, lock it out!
+            super.onReceivedSslError(view, handler, error);
+        }
+    }
+
+    @Override
+    public void doUpdateVisitedHistory(WebView view, String url, boolean isReload) {
+        /* 
+         * If you do a document.location.href the url does not get pushed on the stack
+         * so we do a check here to see if the url should be pushed.
+         */
+        if (!this.ctx.peekAtUrlStack().equals(url)) {
+            this.ctx.pushUrl(url);
+        }
+    }
+}

data/templates/cordova_android/framework/src/org/apache/cordova/Device.java

@@ -0,0 +1,219 @@
+/*
+       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;
+
+import java.util.TimeZone;
+
+import org.apache.cordova.api.LOG;
+import org.apache.cordova.api.CordovaInterface;
+import org.apache.cordova.api.Plugin;
+import org.apache.cordova.api.PluginResult;
+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.provider.Settings;
+import android.telephony.TelephonyManager;
+
+public class Device extends Plugin {
+    public static final String TAG = "Device";
+
+    public static String cordovaVersion = "1.5.0";              // Cordova version
+	public static String platform = "Android";					// Device OS
+	public static String uuid;									// Device UUID
+    
+    BroadcastReceiver telephonyReceiver = null;
+
+    /**
+     * Constructor.
+     */
+	public Device() {
+    }
+	
+	/**
+	 * Sets the context of the Command. This can then be used to do things like
+	 * get file paths associated with the Activity.
+	 * 
+	 * @param ctx The context of the main Activity.
+	 */
+	public void setContext(CordovaInterface ctx) {
+		super.setContext(ctx);
+        Device.uuid = getUuid();
+        this.initTelephonyReceiver();
+	}
+
+	/**
+	 * Executes the request and returns PluginResult.
+	 * 
+	 * @param action 		The action to execute.
+	 * @param args 			JSONArry of arguments for the plugin.
+	 * @param callbackId	The callback id used when calling back into JavaScript.
+	 * @return 				A PluginResult object with a status and message.
+	 */
+	public PluginResult execute(String action, JSONArray args, String callbackId) {
+		PluginResult.Status status = PluginResult.Status.OK;
+		String result = "";		
+	
+		try {
+			if (action.equals("getDeviceInfo")) {
+				JSONObject r = new JSONObject();
+				r.put("uuid", Device.uuid);
+				r.put("version", this.getOSVersion());
+				r.put("platform", Device.platform);
+				r.put("name", this.getProductName());
+				r.put("cordova", Device.cordovaVersion);
+				//JSONObject pg = new JSONObject();
+				//pg.put("version", Device.CordovaVersion);
+				//r.put("cordova", pg);
+				return new PluginResult(status, r);
+			}
+			return new PluginResult(status, result);
+		} catch (JSONException e) {
+			return new PluginResult(PluginResult.Status.JSON_EXCEPTION);
+		}
+	}
+
+	/**
+	 * Identifies if action to be executed returns a value and should be run synchronously.
+	 * 
+	 * @param action	The action to execute
+	 * @return			T=returns value
+	 */
+	public boolean isSynch(String action) {
+		if (action.equals("getDeviceInfo")) {
+			return true;
+		}
+		return false;
+	}
+    
+    /**
+     * Unregister receiver.
+     */
+    public void onDestroy() {
+        this.ctx.unregisterReceiver(this.telephonyReceiver);
+    }
+
+    //--------------------------------------------------------------------------
+    // LOCAL METHODS
+    //--------------------------------------------------------------------------
+    
+    /**
+     * Listen for telephony events: RINGING, OFFHOOK and IDLE
+     * Send these events to all plugins using
+     *      DroidGap.onMessage("telephone", "ringing" | "offhook" | "idle")
+     */
+    private void initTelephonyReceiver() {
+        IntentFilter intentFilter = new IntentFilter() ;
+        intentFilter.addAction(TelephonyManager.ACTION_PHONE_STATE_CHANGED);
+        final CordovaInterface myctx = this.ctx;
+        this.telephonyReceiver = new BroadcastReceiver() {
+            
+            @Override
+            public void onReceive(Context context, Intent intent) {
+                
+                // If state has changed
+                if ((intent != null) && intent.getAction().equals(TelephonyManager.ACTION_PHONE_STATE_CHANGED)) {
+                    if (intent.hasExtra(TelephonyManager.EXTRA_STATE)) {
+                        String extraData = intent.getStringExtra(TelephonyManager.EXTRA_STATE);
+                        if (extraData.equals(TelephonyManager.EXTRA_STATE_RINGING)) {
+                            LOG.i(TAG, "Telephone RINGING");
+                            myctx.postMessage("telephone", "ringing");
+                        }
+                        else if (extraData.equals(TelephonyManager.EXTRA_STATE_OFFHOOK)) {
+                            LOG.i(TAG, "Telephone OFFHOOK");
+                            myctx.postMessage("telephone", "offhook");
+                        }
+                        else if (extraData.equals(TelephonyManager.EXTRA_STATE_IDLE)) {
+                            LOG.i(TAG, "Telephone IDLE");
+                            myctx.postMessage("telephone", "idle");
+                        }
+                    }
+                }
+            }
+        };
+        
+        // Register the receiver
+        this.ctx.registerReceiver(this.telephonyReceiver, intentFilter);
+    }
+
+	/**
+	 * Get the OS name.
+	 * 
+	 * @return
+	 */
+	public String getPlatform()	{
+		return Device.platform;
+	}
+	
+	/**
+	 * Get the device's Universally Unique Identifier (UUID).
+	 * 
+	 * @return
+	 */
+	public String getUuid()	{		
+		String uuid = Settings.Secure.getString(this.ctx.getContentResolver(), android.provider.Settings.Secure.ANDROID_ID);
+		return uuid;
+	}
+
+	/**
+	 * Get the Cordova version.
+	 * 
+	 * @return
+	 */
+	public String getCordovaVersion() {
+		return Device.cordovaVersion;
+	}	
+	
+	public String getModel() {
+		String model = android.os.Build.MODEL;
+		return model;
+	}
+	
+	public String getProductName() {
+		String productname = android.os.Build.PRODUCT;
+		return productname;
+	}
+	
+	/**
+	 * Get the OS version.
+	 * 
+	 * @return
+	 */
+	public String getOSVersion() {
+		String osversion = android.os.Build.VERSION.RELEASE;
+		return osversion;
+	}
+	
+	public String getSDKVersion() {
+		String sdkversion = android.os.Build.VERSION.SDK;
+		return sdkversion;
+	}
+	
+    
+    public String getTimeZoneID() {
+       TimeZone tz = TimeZone.getDefault();
+        return(tz.getID());
+    } 
+    
+}
+

data/templates/cordova_android/framework/src/org/apache/cordova/DirectoryManager.java

@@ -0,0 +1,161 @@
+/*
+       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;
+
+import java.io.File;
+
+import android.content.Context;
+import android.os.Environment;
+import android.os.StatFs;
+
+/**
+ * This class provides file directory utilities.  
+ * All file operations are performed on the SD card.
+ *   
+ * It is used by the FileUtils class.
+ */
+public class DirectoryManager {
+	
+	private static final String LOG_TAG = "DirectoryManager";
+
+	/**
+	 * Determine if a file or directory exists.
+	 * 
+	 * @param name				The name of the file to check.
+	 * @return					T=exists, F=not found
+	 */
+	protected static boolean testFileExists(String name) {
+		boolean status;
+		
+		// If SD card exists
+		if ((testSaveLocationExists()) && (!name.equals(""))) {
+    		File path = Environment.getExternalStorageDirectory();
+            File newPath = constructFilePaths(path.toString(), name);
+            status = newPath.exists();
+    	}
+		// If no SD card
+		else{
+    		status = false;
+    	}
+		return status;
+	}
+	
+	/**
+	 * Get the free disk space
+	 * 
+	 * @return 		Size in KB or -1 if not available
+	 */
+	protected static long getFreeDiskSpace(boolean checkInternal) {
+		String status = Environment.getExternalStorageState();
+		long freeSpace = 0;
+		
+		// If SD card exists
+		if (status.equals(Environment.MEDIA_MOUNTED)) {
+			freeSpace = freeSpaceCalculation(Environment.getExternalStorageDirectory().getPath());
+		} 
+		else if (checkInternal) {
+		    freeSpace = freeSpaceCalculation("/");
+		}		
+		// If no SD card and we haven't been asked to check the internal directory then return -1
+		else { 
+			return -1; 
+		}
+		
+		return freeSpace;
+	}	
+	
+	/**
+	 * Given a path return the number of free KB
+	 * 
+	 * @param path to the file system
+	 * @return free space in KB
+	 */
+	private static long freeSpaceCalculation(String path) {
+        StatFs stat = new StatFs(path);
+        long blockSize = stat.getBlockSize();
+        long availableBlocks = stat.getAvailableBlocks();
+        return availableBlocks*blockSize/1024;
+	}
+	
+	/**
+	 * Determine if SD card exists.
+	 * 
+	 * @return				T=exists, F=not found
+	 */
+	protected static boolean testSaveLocationExists() {
+		String sDCardStatus = Environment.getExternalStorageState();
+		boolean status;
+		
+		// If SD card is mounted
+		if (sDCardStatus.equals(Environment.MEDIA_MOUNTED)) {
+			status = true;
+		}
+		
+		// If no SD card
+		else {
+			status = false;
+		}
+		return status;
+	}
+	
+	/**
+	 * Create a new file object from two file paths.
+	 * 
+	 * @param file1			Base file path
+	 * @param file2			Remaining file path
+	 * @return				File object
+	 */
+	private static File constructFilePaths (String file1, String file2) {
+		File newPath;
+		if (file2.startsWith(file1)) {
+			newPath = new File(file2);
+		}
+		else {
+			newPath = new File(file1+"/"+file2);
+		}
+		return newPath;
+	}
+    
+    /**
+     * Determine if we can use the SD Card to store the temporary file.  If not then use 
+     * the internal cache directory.
+     * 
+     * @return the absolute path of where to store the file
+     */
+    protected static String getTempDirectoryPath(Context ctx) {
+        File cache = null;
+        
+        // SD Card Mounted
+        if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
+            cache = new File(Environment.getExternalStorageDirectory().getAbsolutePath() + 
+                    "/Android/data/" + ctx.getPackageName() + "/cache/");
+        } 
+        // Use internal storage
+        else {
+            cache = ctx.getCacheDir();
+        }
+
+        // Create the cache directory if it doesn't exist
+        if (!cache.exists()) {
+            cache.mkdirs();
+        }
+
+        return cache.getAbsolutePath();
+    }
+}