Initial Move of the Javascript OUT of the shared directory: Android

framework/src/com/phonegap/AccelListener.java

@@ -0,0 +1,68 @@
+package com.phonegap;
+
+import static android.hardware.SensorManager.DATA_X;
+import static android.hardware.SensorManager.DATA_Y;
+import static android.hardware.SensorManager.DATA_Z;
+import android.hardware.SensorManager;
+import android.content.Context;
+import android.hardware.SensorListener;
+import android.webkit.WebView;
+
+@SuppressWarnings("deprecation")
+public class AccelListener implements SensorListener{
+
+	WebView mAppView;
+	Context mCtx;
+	String mKey;
+	int mTime = 10000;
+	boolean started = false;
+	
+	private SensorManager sensorManager;
+	
+	private long lastUpdate = -1;
+	
+	AccelListener(Context ctx, WebView appView)
+	{
+		mCtx = ctx;
+		mAppView = appView;		
+		sensorManager = (SensorManager) mCtx.getSystemService(Context.SENSOR_SERVICE);
+	}
+	
+	public void start(int time)
+	{
+		mTime = time;
+		if (!started)
+		{
+			sensorManager.registerListener(this,
+	            SensorManager.SENSOR_ACCELEROMETER,
+	            SensorManager.SENSOR_DELAY_GAME);
+		}
+	}
+	
+	public void stop()
+	{
+		if(started)
+			sensorManager.unregisterListener(this);
+	}
+	
+	public void onAccuracyChanged(int sensor, int accuracy) {
+		// This should call the FAIL method
+	}
+	
+	public void onSensorChanged(int sensor, float[] values) {
+		if (sensor != SensorManager.SENSOR_ACCELEROMETER || values.length < 3)
+		      return;
+		long curTime = System.currentTimeMillis();
+		if (lastUpdate == -1 || (curTime - lastUpdate) > mTime) {
+			
+			lastUpdate = curTime;
+			
+			float x = values[DATA_X];
+			float y = values[DATA_Y];
+			float z = values[DATA_Z];
+			mAppView.loadUrl("javascript:gotAccel(" + x +  ", " + y + "," + z + " )");
+		}
+	}
+	
+	
+}

framework/src/com/phonegap/AccelTuple.java

@@ -0,0 +1,29 @@
+package com.phonegap;
+/* License (MIT)
+ * Copyright (c) 2008 Nitobi
+ * website: http://phonegap.com
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * “Software”), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+public class AccelTuple {
+	public long accelX;
+	public long accelY;
+	public long accelZ;
+}

framework/src/com/phonegap/AudioHandler.java

@@ -0,0 +1,193 @@
+package com.phonegap;
+
+import java.io.File;
+import java.io.IOException;
+
+import android.content.Context;
+import android.media.AudioManager;
+import android.media.MediaPlayer;
+import android.media.MediaPlayer.OnErrorListener;
+import android.media.MediaRecorder;
+import android.media.MediaPlayer.OnBufferingUpdateListener;
+import android.media.MediaPlayer.OnCompletionListener;
+import android.media.MediaPlayer.OnPreparedListener;
+import android.util.Log;
+
+public class AudioHandler implements OnCompletionListener, OnPreparedListener, OnErrorListener {
+	private MediaRecorder recorder;
+	private boolean isRecording = false;
+	MediaPlayer mPlayer;
+	private boolean isPlaying = false;
+	private String recording;
+	private String saveFile;
+	private Context mCtx;
+	
+	public AudioHandler(String file, Context ctx) {
+		this.recording = file;
+		this.mCtx = ctx;
+	}	
+	
+	protected void startRecording(String file){
+		if (!isRecording){
+			saveFile=file;
+			recorder = new MediaRecorder();
+			recorder.setAudioSource(MediaRecorder.AudioSource.MIC);
+			recorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);
+			recorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);
+			recorder.setOutputFile(this.recording);
+			try {
+				recorder.prepare();
+			} catch (IllegalStateException e) {
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+			} catch (IOException e) {
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+			}
+			isRecording = true;
+			recorder.start();
+		}
+	}
+	
+	private void moveFile(String file) {
+		/* this is a hack to save the file as the specified name */
+		File f = new File (this.recording);
+		f.renameTo(new File("/sdcard" + file));
+	}
+	
+	protected void stopRecording(){
+		try{
+			if((recorder != null)&&(isRecording))
+			{
+				isRecording = false;
+				recorder.stop();
+		        recorder.release(); 
+			}
+			moveFile(saveFile);
+		}
+		catch (Exception e)
+		{
+			e.printStackTrace();
+		}
+	}	
+	
+	protected void startPlaying(String file) {
+		if (isPlaying==false) {
+			try {
+				mPlayer = new MediaPlayer();
+				isPlaying=true;
+				Log.d("Audio startPlaying", "audio: " + file);
+				if (isStreaming(file))
+				{
+					Log.d("AudioStartPlaying", "Streaming");
+					// Streaming prepare async
+					mPlayer.setDataSource(file);
+					mPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);  
+					mPlayer.prepareAsync();
+				} else {
+					Log.d("AudioStartPlaying", "File");
+					// Not streaming prepare synchronous, abstract base directory
+					mPlayer.setDataSource("/sdcard/" + file);
+					mPlayer.prepare();
+				}
+				mPlayer.setOnPreparedListener(this);
+			} catch (Exception e) 
+			{ 
+				e.printStackTrace(); 
+			}
+		}
+	} 
+
+	public void stopPlaying() {
+		if (isPlaying) {
+			mPlayer.stop();
+			mPlayer.release();
+			isPlaying=false;
+		}
+	}
+	
+	public void onCompletion(MediaPlayer mPlayer) {
+		mPlayer.stop();
+		mPlayer.release();
+		isPlaying=false;
+    } 
+	
+	protected long getCurrentPosition() {
+		if (isPlaying) 
+		{
+			return(mPlayer.getCurrentPosition());
+		} else { return(-1); }
+	}
+	
+	private boolean isStreaming(String file) 
+	{
+		if (file.contains("http://")) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+	
+	protected long getDuration(String file) {
+		long duration = -2;
+		if (!isPlaying & !isStreaming(file)) {
+			try {
+				mPlayer = new MediaPlayer();
+				mPlayer.setDataSource("/sdcard/" + file);
+				mPlayer.prepare();
+				duration = mPlayer.getDuration();
+				mPlayer.release();
+			} catch (Exception e) { e.printStackTrace(); return(-3); }
+		} else
+		if (isPlaying & !isStreaming(file)) {
+			duration = mPlayer.getDuration();
+		} else 
+		if (isPlaying & isStreaming(file)) {
+			try {
+				duration = mPlayer.getDuration();
+			} catch (Exception e) { e.printStackTrace(); return(-4); }
+		}else { return -1; }
+		return duration;
+	}
+
+	public void onPrepared(MediaPlayer mPlayer) {
+		if (isPlaying) {
+			mPlayer.setOnCompletionListener(this);
+			mPlayer.setOnBufferingUpdateListener(new OnBufferingUpdateListener()
+			{
+				public void onBufferingUpdate(MediaPlayer mPlayer, int percent)
+				{
+					/* TODO: call back, e.g. update outer progress bar */
+					Log.d("AudioOnBufferingUpdate", "percent: " + percent); 
+				}
+			});
+			mPlayer.start();
+		}
+	}
+
+	public boolean onError(MediaPlayer mPlayer, int arg1, int arg2) {
+		Log.e("AUDIO onError", "error " + arg1 + " " + arg2);
+		return false;
+	}
+	
+	protected void setAudioOutputDevice(int output){
+		// Changes the default audio output device to speaker or earpiece 
+		AudioManager audiMgr = (AudioManager) mCtx.getSystemService(Context.AUDIO_SERVICE);
+		if (output == (2))
+			audiMgr.setRouting(AudioManager.MODE_NORMAL, AudioManager.ROUTE_SPEAKER, AudioManager.ROUTE_ALL);
+		else if (output == (1)){
+			audiMgr.setRouting(AudioManager.MODE_NORMAL, AudioManager.ROUTE_EARPIECE, AudioManager.ROUTE_ALL);
+		}else
+			Log.e("AudioHandler setAudioOutputDevice", " unknown output device");	
+	}
+	
+	protected int getAudioOutputDevice(){
+		AudioManager audiMgr = (AudioManager) mCtx.getSystemService(Context.AUDIO_SERVICE);
+		if (audiMgr.getRouting(AudioManager.MODE_NORMAL) == AudioManager.ROUTE_EARPIECE)
+			return 1;
+		else if (audiMgr.getRouting(AudioManager.MODE_NORMAL) == AudioManager.ROUTE_SPEAKER)
+			return 2;
+		else
+			return -1;
+	}
+}

framework/src/com/phonegap/CameraLauncher.java

@@ -0,0 +1,34 @@
+package com.phonegap;
+
+import android.webkit.WebView;
+
+
+public class CameraLauncher {
+		
+	private WebView mAppView;
+	private DroidGap mGap;
+	int quality;	
+	
+	CameraLauncher(WebView view, DroidGap gap)
+	{
+		mAppView = view;
+		mGap = gap;
+	}
+	
+	public void takePicture(int quality)
+	{
+		mGap.startCamera(quality);
+	}
+	
+	/* Return Base64 Encoded String to Javascript */
+	public void processPicture( String js_out )
+	{		
+		mAppView.loadUrl("javascript:navigator.camera.win('" + js_out + "');");			
+	}
+	
+	public void failPicture(String err)
+	{
+		mAppView.loadUrl("javascript:navigator.camera.fail('" + err + "');");
+	}
+	
+}

framework/src/com/phonegap/CameraPreview.java

@@ -0,0 +1,190 @@
+package com.phonegap;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+
+import org.apache.commons.codec.binary.Base64;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.PixelFormat;
+import android.graphics.Bitmap.CompressFormat;
+import android.hardware.Camera;
+import android.net.Uri;
+import android.os.Bundle;
+import android.util.Log;
+import android.view.KeyEvent;
+import android.view.MenuItem;
+import android.view.SurfaceHolder;
+import android.view.SurfaceView;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.Button;
+
+public class CameraPreview extends Activity implements SurfaceHolder.Callback{
+
+    private static final String TAG = "PhoneGapCamera";
+    private SurfaceView mSurfaceView;
+    private SurfaceHolder mSurfaceHolder;
+    
+    Camera mCamera;
+    boolean mPreviewRunning = false;
+    
+    int quality;
+    Intent mIntent;
+    
+    public void onCreate(Bundle icicle)
+    {
+        super.onCreate(icicle);
+
+        Log.e(TAG, "onCreate");
+
+        getWindow().setFormat(PixelFormat.TRANSLUCENT);
+
+        setContentView(R.layout.preview);
+        mSurfaceView = (SurfaceView)findViewById(R.id.surface);
+
+        mSurfaceHolder = mSurfaceView.getHolder();
+        mSurfaceHolder.addCallback(this);
+        mSurfaceHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);                    
+        mIntent = this.getIntent();
+        
+        quality = mIntent.getIntExtra("quality", 100);
+        
+        Button stopButton = (Button) findViewById(R.id.go);
+        stopButton.setOnClickListener(mSnapListener);
+    }
+    
+    private OnClickListener mSnapListener = new OnClickListener() {
+        public void onClick(View v) {
+        	mCamera.takePicture(null, null, mPictureCallback);
+        }
+    };
+
+    public boolean onCreateOptionsMenu(android.view.Menu menu) {
+        MenuItem item = menu.add(0, 0, 0, "goto gallery");
+        item.setOnMenuItemClickListener(new MenuItem.OnMenuItemClickListener() {
+            public boolean onMenuItemClick(MenuItem item) {
+                Uri target = Uri.parse("content://media/external/images/media");
+                Intent intent = new Intent(Intent.ACTION_VIEW, target);
+                startActivity(intent);
+                return true;
+            }
+        });
+        return true;
+    }
+    
+    @Override
+    protected void onRestoreInstanceState(Bundle savedInstanceState)
+    {
+        super.onRestoreInstanceState(savedInstanceState);
+    }
+
+    /*
+     * We got the data, send it back to PhoneGap to be handled and processed.
+     * 
+     */
+    
+    Camera.PictureCallback mPictureCallback = new Camera.PictureCallback() {
+        public void onPictureTaken(byte[] data, Camera c) {
+            Log.e(TAG, "PICTURE CALLBACK: data.length = " + data.length);
+            storeAndExit(data);
+        }
+    };
+
+    /*
+     * We can't just store and exit, because Android freezes up when we try to cram a picture across a process in a Bundle.
+     * We HAVE to compress this data and send back the compressed data  
+     */
+    public void storeAndExit(byte[] data)
+    {
+    	ByteArrayOutputStream jpeg_data = new ByteArrayOutputStream();
+		Bitmap myMap = BitmapFactory.decodeByteArray(data, 0, data.length);
+		try {
+			if (myMap.compress(CompressFormat.JPEG, quality, jpeg_data))
+			{
+				byte[] code  = jpeg_data.toByteArray();
+				byte[] output = Base64.encodeBase64(code);
+				String js_out = new String(output);
+				mIntent.putExtra("picture", js_out);
+				setResult(RESULT_OK, mIntent);
+			}	
+		}
+		catch(Exception e)
+		{
+			//Do shit here
+		}
+        finish();
+    }
+    
+    public boolean onKeyDown(int keyCode, KeyEvent event)
+    {
+        if (keyCode == KeyEvent.KEYCODE_BACK) {        	
+            return super.onKeyDown(keyCode, event);
+        }
+ 
+        if (keyCode == KeyEvent.KEYCODE_CAMERA || keyCode == KeyEvent.KEYCODE_DPAD_CENTER || keyCode == KeyEvent.KEYCODE_SEARCH) {
+            mCamera.takePicture(null, null, mPictureCallback);
+            return true;
+        }
+
+        return false;
+    }
+
+    protected void onResume()
+    {
+        Log.e(TAG, "onResume");
+        super.onResume();
+    }
+
+    protected void onSaveInstanceState(Bundle outState)
+    {
+        super.onSaveInstanceState(outState);
+    }
+
+    protected void onStop()
+    {
+        Log.e(TAG, "onStop");
+        super.onStop();
+    }
+
+    public void surfaceCreated(SurfaceHolder holder)
+    {
+        Log.e(TAG, "surfaceCreated");
+        mCamera = Camera.open();
+        //mCamera.startPreview();
+    }
+
+    public void surfaceChanged(SurfaceHolder holder, int format, int w, int h)
+    {
+        Log.e(TAG, "surfaceChanged");
+
+        // XXX stopPreview() will crash if preview is not running
+        if (mPreviewRunning) {
+            mCamera.stopPreview();
+        }
+
+        Camera.Parameters p = mCamera.getParameters();
+        p.setPreviewSize(w, h);
+        mCamera.setParameters(p);
+        try {
+			mCamera.setPreviewDisplay(holder);
+		} catch (IOException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+        mCamera.startPreview();
+        mPreviewRunning = true;
+    }
+
+    public void surfaceDestroyed(SurfaceHolder holder)
+    {
+        Log.e(TAG, "surfaceDestroyed");
+        mCamera.stopPreview();
+        mPreviewRunning = false;
+        mCamera.release();
+    }
+
+}

framework/src/com/phonegap/CompassListener.java

@@ -0,0 +1,54 @@
+package com.phonegap;
+
+import java.util.List;
+
+import android.hardware.Sensor;
+import android.hardware.SensorEvent;
+import android.hardware.SensorEventListener;
+import android.hardware.SensorManager;
+import android.content.Context;
+import android.webkit.WebView;
+
+public class CompassListener implements SensorEventListener{
+	WebView mAppView;
+	Context mCtx;
+	Sensor mSensor;	
+	
+	private SensorManager sensorManager;
+	
+	CompassListener(Context ctx, WebView appView)
+	{
+		mCtx = ctx;
+		mAppView = appView;		
+		sensorManager = (SensorManager) mCtx.getSystemService(Context.SENSOR_SERVICE);
+	}
+	
+
+	public void start()
+	{
+		List<Sensor> list = this.sensorManager.getSensorList(Sensor.TYPE_ORIENTATION);
+		if (list.size() > 0)
+		{
+			this.mSensor = list.get(0);
+			this.sensorManager.registerListener(this, this.mSensor, SensorManager.SENSOR_DELAY_NORMAL);
+		}
+		
+	}
+	
+	public void stop()
+	{
+		this.sensorManager.unregisterListener(this);
+	}
+	
+	public void onAccuracyChanged(Sensor sensor, int accuracy) {
+		// TODO Auto-generated method stub
+		
+	}
+
+
+	public void onSensorChanged(SensorEvent event) {
+		// We only care about the orientation as far as it refers to Magnetic North
+		float heading = event.values[0];
+		mAppView.loadUrl("javascript:gotBearing(" + heading + ")");
+	}
+}

framework/src/com/phonegap/ContactManager.java

@@ -0,0 +1,291 @@
+package com.phonegap;
+
+import android.provider.Contacts.ContactMethods;
+import android.provider.Contacts.People;
+import android.util.Log;
+import android.webkit.WebView;
+import android.app.Activity;
+import android.content.ContentResolver;
+import android.net.Uri;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteException;
+
+public class ContactManager {
+	
+	public class ContactTriplet
+	{
+		public String name = "";
+		public String email = "";
+		public String phone = "";
+	}
+	
+	private static final String LOG_TAG = "Contact Query";
+	Activity mApp;
+	WebView mView;
+	Uri mPeople = android.provider.Contacts.People.CONTENT_URI;
+	Uri mPhone = android.provider.Contacts.Phones.CONTENT_URI;	
+	Uri mEmail = android.provider.Contacts.ContactMethods.CONTENT_URI;
+	
+	ContactManager(Activity app, WebView view)
+	{
+		mApp = app;
+		mView = view;
+	}
+			
+	// This is to add backwards compatibility to the OLD Contacts API\
+	public void getContactsAndSendBack()
+	{
+		String[] projection = new String[] {
+				People._ID,
+				People.NAME,
+				People.NUMBER,
+				People.PRIMARY_EMAIL_ID
+			};
+
+		try{
+			Cursor myCursor = mApp.managedQuery(mPeople, projection, 
+				null, null , People.NAME + " ASC");
+			processResults(myCursor, true);
+		}
+		catch (SQLiteException ex)
+		{
+			Log.d(LOG_TAG, ex.getMessage());
+		}		
+	}
+	
+	public void search(String name, String npa, String email)
+	{
+		
+		if (email.length() > 0)
+			searchByEmail(email);		
+		else
+			searchPeople(name, npa);
+	}
+	
+	private void searchByEmail(String email)
+	{						
+		String[] projection = new String[] {
+								ContactMethods._ID,
+								ContactMethods.DATA,
+								ContactMethods.KIND,
+								ContactMethods.PERSON_ID
+							};
+		String[] variables = new String[] {
+				 email
+		};
+		
+		try{
+			Cursor myCursor = mApp.managedQuery(mEmail, projection, 
+						"contact_methods." + ContactMethods.DATA + " = ?" + "AND contact_methods.kind = 1", variables , ContactMethods.DATA + " ASC");
+			getMethodData(myCursor);
+						
+		}
+		catch (SQLiteException ex)
+		{
+			Log.d(LOG_TAG, ex.getMessage());
+		}
+				
+	}
+	
+	private void searchPeople(String name, String number)
+	{
+			String conditions = "";
+		
+			if (name.length() == 0)
+			{
+				name = "%";
+				conditions += People.NAME + "LIKE ? AND ";
+			}
+			else
+			{
+				conditions += People.NAME + " = ? AND ";
+			}
+		
+			if (number.length() == 0)
+				number = "%";
+			else
+			{
+				number = number.replace('+', '%');
+				number = number.replace('.', '%');
+				number = number.replace('-', '%');
+			}
+			
+			conditions += People.NUMBER + " LIKE ? ";
+			
+			String[] projection = new String[] {
+								People._ID,
+								People.NAME,
+								People.NUMBER,
+								People.PRIMARY_EMAIL_ID
+			};
+			
+			String[] variables = new String[] {
+					name, number
+			};
+			
+			try{
+				Cursor myCursor = mApp.managedQuery(mPeople, projection, 
+								conditions, variables , People.NAME + " ASC");
+				processResults(myCursor, false);
+			}
+			catch (SQLiteException ex)
+			{
+					Log.d(LOG_TAG, ex.getMessage());
+			}		
+	
+	}
+
+	private void processResults(Cursor cur, boolean all){
+		
+	    if (cur.moveToFirst()) {
+
+	        String name; 
+	        String phoneNumber;	        
+	        String email_id;
+	        String email;
+	        
+	        int nameColumn = cur.getColumnIndex(People.NAME);
+	        int phoneColumn = cur.getColumnIndex(People.NUMBER);
+	        int emailIdColumn = cur.getColumnIndex(People.PRIMARY_EMAIL_ID);
+	        
+	        do {
+	            // Get the field values
+	            name = cur.getString(nameColumn);	            
+	            phoneNumber = cur.getString(phoneColumn);
+	            email_id = cur.getString(emailIdColumn);
+	            if (email_id != null)
+	            	email = getEmail(email_id);
+	            else
+	            	email = "";
+	            
+	            // Code for backwards compatibility with the OLD Contacts API
+	            if (all)
+	            	mView.loadUrl("javascript:navigator.ContactManager.droidAddContact('" + name + "','" + phoneNumber + "','" + email +"')");	            	
+	            else
+	            	mView.loadUrl("javascript:navigator.AddressBook.droidFoundContact('" + name + "','" + phoneNumber + "','" + email +"')");
+	            	            
+	        } while (cur.moveToNext());
+	        if (all)
+	        	mView.loadUrl("javascript:navigator.ContactManager.droidDone()");
+	        else
+	        	mView.loadUrl("javascript:navigator.AddressBook.droidDoneContacts();");
+	    }
+	    else
+	    {
+	    	if(all)
+	    		mView.loadUrl("javascript:navigator.ContactManager.fail()");
+	    	else
+	    		mView.loadUrl("javascript:navigator.AddressBook.fail('None found!')");
+	    }
+	}	
+	
+	private void getMethodData(Cursor cur)
+	{        
+        ContactTriplet data = new ContactTriplet();
+        String id;    
+        String email;
+        
+	    if (cur.moveToFirst()) {
+
+	        int idColumn = cur.getColumnIndex(ContactMethods._ID);
+	        int emailColumn = cur.getColumnIndex(ContactMethods.DATA);	        
+	        do {
+	            // Get the field values	            
+	            id = cur.getString(idColumn);
+	            email = cur.getString(emailColumn);
+	            
+	            data = getContactData(id);
+	            if(data != null)
+	            {
+	            	data.email = email;	            
+	            	mView.loadUrl("javascript:navigator.AddressBook.droidFoundContact('" + data.name + "','" + data.phone + "','" + data.email +"')");
+	            }	           
+	        } while (cur.moveToNext());
+	        mView.loadUrl("javascript:navigator.AddressBook.droidDoneContacts();");	        
+	    }	 
+	}		
+	
+	private ContactTriplet getContactData(String id) {
+		ContactTriplet data = null;
+		String[] projection = new String[] {
+				People._ID,
+				People.NAME,
+				People.NUMBER,
+				People.PRIMARY_EMAIL_ID
+		};
+
+		String[] variables = new String[] {
+				id
+		};
+
+		try{
+			Cursor myCursor = mApp.managedQuery(mPeople, projection, 
+				People.PRIMARY_EMAIL_ID + " = ?", variables , People.NAME + " ASC");
+			data = getTriplet(myCursor);
+		}
+		catch (SQLiteException ex)
+		{
+			Log.d(LOG_TAG, ex.getMessage());
+		}		
+		
+		return data;
+	}
+
+	private ContactTriplet getTriplet(Cursor cur) {
+		 ContactTriplet data = new ContactTriplet();         
+		 if (cur.moveToFirst()) {
+
+			 int nameColumn = cur.getColumnIndex(People.NAME); 
+		     int numberColumn = cur.getColumnIndex(People.NUMBER);	        
+		     do {
+		         	            
+		    	 data.name = cur.getString(nameColumn);
+		    	 data.phone = cur.getString(numberColumn);
+		    	 
+		     } while (cur.moveToNext());	       
+		 }
+		return data;
+	}
+
+	private String getEmailColumnData(Cursor cur)
+	{					        
+        String email = "";         
+	    if (cur.moveToFirst()) {
+
+	        int emailColumn = cur.getColumnIndex(ContactMethods.DATA);	        
+	        do {
+	            // Get the field values	            
+	            email = cur.getString(emailColumn);	            	            
+	        } while (cur.moveToNext());	       
+	    }
+	    return email;
+	}
+	
+	private String getEmail(String id)
+	{		
+		String email = "";		
+		String[] projection = new String[] {
+								ContactMethods._ID,
+								ContactMethods.DATA,
+								ContactMethods.KIND
+							};
+		String[] variables = new String[] {
+				 id
+		};
+		
+		try
+		{
+			Cursor myCursor = mApp.managedQuery(mEmail, projection, 
+						"contact_methods." + ContactMethods._ID + " = ?" + " AND contact_methods.kind = 1", variables , ContactMethods.DATA + " ASC");
+			email = getEmailColumnData(myCursor);
+		}
+		catch (SQLiteException ex)
+		{
+			Log.d(LOG_TAG, ex.getMessage());
+		}
+		
+		return email;		
+	}
+	
+	
+}

framework/src/com/phonegap/DirectoryManager.java

@@ -0,0 +1,126 @@
+package com.phonegap;
+
+import java.io.File;
+
+import android.os.Environment;
+import android.os.StatFs;
+import android.util.Log;
+
+public class DirectoryManager {
+	
+	protected boolean testFileExists (String name){
+		boolean status;
+		if ((testSaveLocationExists())&&(!name.equals(""))){
+    		File path = Environment.getExternalStorageDirectory();
+            File newPath = constructFilePaths(path.toString(), name);
+            status = newPath.exists();
+    	}else{
+    		status = false;
+    	}
+		return status;
+	}
+	
+	protected long getFreeDiskSpace(){
+		/*
+		 * gets the available SD card free space or returns -1 if the SD card is not mounted.
+		 */
+		String status = Environment.getExternalStorageState();
+		long freeSpace = 0;
+		if (status.equals(Environment.MEDIA_MOUNTED)) {
+			try {
+				File path = Environment.getExternalStorageDirectory();
+				StatFs stat = new StatFs(path.getPath());
+				long blockSize = stat.getBlockSize();
+				long availableBlocks = stat.getAvailableBlocks();
+				freeSpace = availableBlocks*blockSize/1024;
+			} catch (Exception e) {e.printStackTrace(); }
+		} else { return -1; }
+		return (freeSpace);
+	}	
+	
+	protected boolean createDirectory(String directoryName){
+		boolean status;
+		if ((testSaveLocationExists())&&(!directoryName.equals(""))){
+			File path = Environment.getExternalStorageDirectory();
+            File newPath = constructFilePaths(path.toString(), directoryName);
+			status = newPath.mkdir();
+			status = true;
+		}else
+			status = false;
+		return status;
+	}
+	
+	protected boolean testSaveLocationExists(){
+		String sDCardStatus = Environment.getExternalStorageState();
+		boolean status;
+		if (sDCardStatus.equals(Environment.MEDIA_MOUNTED)){
+			status = true;
+		}else
+			status = false;
+		return status;
+	}
+	
+	protected boolean deleteDirectory(String fileName){
+		boolean status;
+		SecurityManager checker = new SecurityManager();
+			
+		if ((testSaveLocationExists())&&(!fileName.equals(""))){
+		
+			File path = Environment.getExternalStorageDirectory();
+            File newPath = constructFilePaths(path.toString(), fileName);
+			checker.checkDelete(newPath.toString());
+			if(newPath.isDirectory()){
+				String[] listfile = newPath.list();
+				// delete all files within the specified directory and then delete the directory
+				try{
+					for (int i=0; i < listfile.length; i++){
+						File deletedFile = new File (newPath.toString()+"/"+listfile[i].toString());
+						deletedFile.delete();
+					}
+					newPath.delete();
+					Log.i("DirectoryManager deleteDirectory", fileName);
+					status = true;
+				}catch (Exception e){
+					e.printStackTrace();
+					status = false;
+				}
+				
+			}else
+				status = false;
+		}else
+			status = false;
+		return status;
+	}
+	
+	protected boolean deleteFile(String fileName){
+		boolean status;
+		SecurityManager checker = new SecurityManager();
+			
+		if ((testSaveLocationExists())&&(!fileName.equals(""))){
+		
+			File path = Environment.getExternalStorageDirectory();
+            File newPath = constructFilePaths(path.toString(), fileName);
+			checker.checkDelete(newPath.toString());
+			if (newPath.isFile()){
+				try {
+					Log.i("DirectoryManager deleteFile", fileName);
+					newPath.delete();
+					status = true;
+				}catch (SecurityException se){
+					se.printStackTrace();
+					status = false;
+				}
+			}else
+				status = false;
+		}else
+			status = false;
+		return status;
+	}
+	
+	private File constructFilePaths (String file1, String file2){
+		File newPath;
+		newPath = new File(file1+"/"+file2);
+		return newPath;
+	}
+
+}

framework/src/com/phonegap/DroidGap.java

@@ -0,0 +1,175 @@
+package com.phonegap;
+/* License (MIT)
+ * Copyright (c) 2008 Nitobi
+ * website: http://phonegap.com
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * Software), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+import java.lang.reflect.Field;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.content.Context;
+import android.content.Intent;
+import android.content.res.Configuration;
+import android.os.Bundle;
+import android.util.Log;
+import android.view.Window;
+import android.view.WindowManager;
+import android.webkit.JsResult;
+import android.webkit.WebChromeClient;
+import android.webkit.WebSettings;
+import android.webkit.WebView;
+import android.webkit.WebSettings.LayoutAlgorithm;
+
+public class DroidGap extends Activity {
+	
+	private static final String LOG_TAG = "DroidGap";
+	private WebView appView;
+	private String uri;
+	private PhoneGap gap;
+	private GeoBroker geo;
+	private AccelListener accel;
+	private CameraLauncher launcher;
+	private ContactManager mContacts;
+	private FileUtils fs;
+	private NetworkManager netMan;
+	
+    /** Called when the activity is first created. */
+	@Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        getWindow().requestFeature(Window.FEATURE_NO_TITLE); 
+        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN,
+                WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN); 
+        setContentView(R.layout.main);        
+         
+        appView = (WebView) findViewById(R.id.appView);
+        
+        /* This changes the setWebChromeClient to log alerts to LogCat!  Important for Javascript Debugging */
+        
+        appView.setWebChromeClient(new GapClient(this));
+        appView.setInitialScale(100);
+        WebSettings settings = appView.getSettings();
+        settings.setJavaScriptEnabled(true);
+        settings.setJavaScriptCanOpenWindowsAutomatically(true);
+        settings.setLayoutAlgorithm(LayoutAlgorithm.NORMAL);
+
+        
+        /* Bind the appView object to the gap class methods */
+        bindBrowser(appView);
+        
+        /* Load a URI from the strings.xml file */
+        Class<R.string> c = R.string.class;
+        Field f;
+        
+        int i = 0;
+        
+        try {
+          f = c.getField("url");
+          i = f.getInt(f);
+          this.uri = this.getResources().getString(i);
+        } catch (Exception e)
+        {
+          this.uri = "http://www.phonegap.com";
+        }
+        appView.loadUrl(this.uri);
+        
+    }
+	
+	@Override
+    public void onConfigurationChanged(Configuration newConfig) {
+      //don't reload the current page when the orientation is changed
+      super.onConfigurationChanged(newConfig);
+    } 
+    
+    private void bindBrowser(WebView appView)
+    {
+    	gap = new PhoneGap(this, appView);
+    	geo = new GeoBroker(appView, this);
+    	accel = new AccelListener(this, appView);
+    	launcher = new CameraLauncher(appView, this);
+    	mContacts = new ContactManager(this, appView);
+    	fs = new FileUtils(appView);
+    	netMan = new NetworkManager(this, appView);
+    	
+    	// This creates the new javascript interfaces for PhoneGap
+    	appView.addJavascriptInterface(gap, "DroidGap");
+    	appView.addJavascriptInterface(geo, "Geo");
+    	appView.addJavascriptInterface(accel, "Accel");
+    	appView.addJavascriptInterface(launcher, "GapCam");
+    	appView.addJavascriptInterface(mContacts, "ContactHook");
+    	appView.addJavascriptInterface(fs, "FileUtil");
+    	appView.addJavascriptInterface(netMan, "NetworkManager");
+    }
+        
+    /**
+     * Provides a hook for calling "alert" from javascript. Useful for
+     * debugging your javascript.
+     */
+    final class GapClient extends WebChromeClient {
+    	
+    	Context mCtx;
+    	GapClient(Context ctx)
+    	{
+    		mCtx = ctx;
+    	}
+    	
+    	@Override
+        public boolean onJsAlert(WebView view, String url, String message, JsResult result) {
+            Log.d(LOG_TAG, message);
+            // This shows the dialog box.  This can be commented out for dev
+            AlertDialog.Builder alertBldr = new AlertDialog.Builder(mCtx);
+            alertBldr.setMessage(message);
+            alertBldr.setTitle("Alert");
+            alertBldr.show();
+            result.confirm();
+            return true;
+        }
+    	
+    }
+    
+    	    	
+    // This is required to start the camera activity!  It has to come from the previous activity
+    public void startCamera(int quality)
+    {
+    	Intent i = new Intent(this, CameraPreview.class);
+    	i.setAction("android.intent.action.PICK");
+    	i.putExtra("quality", quality);
+    	startActivityForResult(i, 0);
+    }
+    
+    protected void onActivityResult(int requestCode, int resultCode, Intent intent)
+    {
+    	String data;
+    	super.onActivityResult(requestCode, resultCode, intent);
+    	if (resultCode == RESULT_OK)
+    	{
+    		data = intent.getStringExtra("picture");    	     
+    		// Send the graphic back to the class that needs it
+    		launcher.processPicture(data);
+    	}
+    	else
+    	{
+    		launcher.failPicture("Did not complete!");
+    	}
+    }
+    
+}

framework/src/com/phonegap/FileUtils.java

@@ -0,0 +1,129 @@
+package com.phonegap;
+
+import java.io.*;
+
+import android.webkit.WebView;
+
+public class FileUtils {
+
+
+	WebView mView;
+	DirectoryManager fileManager;
+	FileReader f_in;
+	FileWriter f_out;
+	
+	FileUtils(WebView view)
+	{
+		mView = view;
+	}
+	
+    public int testSaveLocationExists(){
+        if (fileManager.testSaveLocationExists())
+            return 0;
+        else
+            return 1;
+    }
+    
+    public long getFreeDiskSpace(){
+        long freeDiskSpace=fileManager.getFreeDiskSpace();
+        return freeDiskSpace;
+    }
+
+    public int testFileExists(String file){
+        if (fileManager.testFileExists(file))
+            return 0;
+        else
+            return 1;
+    }
+    
+    public int testDirectoryExists(String file){
+        if (fileManager.testFileExists(file))
+            return 0;
+        else
+            return 1;
+    } 
+
+    /**
+	 * Delete a specific directory. 
+	 * Everyting in side the directory would be gone.
+	 * TODO: JavaScript Call backs for success and error handling 
+	 */
+    public int deleteDirectory (String dir){
+        if (fileManager.deleteDirectory(dir))
+            return 0;
+        else
+            return 1;
+    }
+    
+
+    /**
+	 * Delete a specific file. 
+	 * TODO: JavaScript Call backs for success and error handling 
+	 */
+    public int deleteFile (String file){
+        if (fileManager.deleteFile(file))
+            return 0;
+        else
+            return 1;
+    }
+    
+
+    /**
+	 * Create a new directory. 
+	 * TODO: JavaScript Call backs for success and error handling 
+	 */
+    public int createDirectory(String dir){
+    	if (fileManager.createDirectory(dir))
+            return 0;
+        else
+            return 1;
+    } 
+	
+    public String read(String filename)
+    {
+    	String data = "";
+    	String output = "";
+    	try {
+    		FileInputStream fstream = new FileInputStream(filename);
+			DataInputStream in = new DataInputStream(fstream);
+			  while (in.available() !=0)
+				{                 
+					data += in.readLine();
+				}
+			  
+		} catch (FileNotFoundException e) {
+			data = "FAIL: File not found";
+		} catch (IOException e) {
+			data = "FAIL: IO ERROR";		
+		}
+		
+		mView.loadUrl("javascript:navigator.file.hasRead('" + data + "')");
+    	return data;
+    }
+    
+    public int write(String filename, String data, boolean append)
+    {
+    		int i=0;
+    		String FilePath= filename;
+    		try {
+    			ByteArrayInputStream in = new ByteArrayInputStream(data.getBytes());    			
+    			byte buff[] = new byte[1024];    
+    			FileOutputStream out=
+    				new FileOutputStream(FilePath, append);
+    			do {
+    				int numread = in.read(buff);
+    				if (numread <= 0)
+                       	break;
+    				out.write(buff, 0, numread);
+    				System.out.println("numread" + numread);
+    				i++;
+    			} while (true);
+    			out.flush();
+    			out.close();
+    			mView.loadUrl("javascript:navigator.file.winCallback('File written')");
+    		} catch (Exception e) { 
+    			mView.loadUrl("javascript:navigator.file.failCallback('Fail')"); 
+    		}
+		return 0;
+    }
+}

framework/src/com/phonegap/GeoBroker.java

@@ -0,0 +1,41 @@
+package com.phonegap;
+
+import java.util.HashMap;
+
+import android.content.Context;
+import android.webkit.WebView;
+
+/*
+ * This class is the interface to the Geolocation.  It's bound to the geo object.
+ * 
+ * This class only starts and stops various GeoListeners, which consist of a GPS and a Network Listener
+ */
+
+public class GeoBroker {
+    private WebView mAppView;
+	private Context mCtx;
+	private HashMap<String, GeoListener> geoListeners;
+	
+	GeoBroker(WebView view, Context ctx)
+	{
+		mCtx = ctx;
+		mAppView = view;
+	}
+	
+	public void getCurrentLocation()
+	{
+		GeoListener listener = new GeoListener("global", mCtx, 10000, mAppView);
+	}
+	
+	public String start(int freq, String key)
+	{
+		GeoListener listener = new GeoListener(key, mCtx, freq, mAppView);
+		geoListeners.put(key, listener);
+		return key;
+	}
+	
+	public void stop(String key)
+	{
+		GeoListener geo = geoListeners.get(key);
+	}
+}

framework/src/com/phonegap/GeoListener.java

@@ -0,0 +1,76 @@
+package com.phonegap;
+
+import android.content.Context;
+import android.location.Location;
+import android.webkit.WebView;
+
+public class GeoListener {
+	String id;
+	String successCallback;
+	String failCallback;
+    GpsListener mGps; 
+    NetworkListener mNetwork;
+    Context mCtx;
+    private WebView mAppView;
+	
+	int interval;
+	
+	GeoListener(String i, Context ctx, int time, WebView appView)
+	{
+		id = i;
+		interval = time;
+		mCtx = ctx;
+        mGps = new GpsListener(mCtx, interval, this);
+        mNetwork = new NetworkListener(mCtx, interval, this);
+        mAppView = appView;
+	}
+	
+	void success(Location loc)
+	{
+		/*
+		 * We only need to figure out what we do when we succeed!
+		 */
+		
+		String params; 
+		/*
+		 * Build the giant string to send back to Javascript!
+		 */
+		params = loc.getLatitude() + "," + loc.getLongitude() + ", " + loc.getAltitude() + "," + loc.getAccuracy() + "," + loc.getBearing();
+		params += "," + loc.getSpeed() + "," + loc.getTime();
+		if(id != "global")
+		{
+			mAppView.loadUrl("javascript:navigator.geolocation.success(" + id + "," +  params + ")");
+		}
+		else
+		{
+			mAppView.loadUrl("javascript:navigator.geolocation.gotCurrentPosition(" + params + ")");
+			this.stop();
+		}
+	}
+	
+	void fail()
+	{
+		// Do we need to know why?  How would we handle this?
+		if (id != "global") {
+			mAppView.loadUrl("javascript:navigator.geolocation.fail(" + id + ")");
+		}
+		else
+		{
+			mAppView.loadUrl("javascript:navigator.geolocation.fail()");
+		}
+	}
+	
+	// This stops the listener
+	void stop()
+	{
+		mGps.stop();
+		mNetwork.stop();
+	}
+
+	public Location getCurrentLocation() {
+		Location loc = mGps.getLocation();
+		if (loc == null)
+			loc = mNetwork.getLocation();
+		return loc;
+	}
+}

framework/src/com/phonegap/GeoTuple.java

@@ -0,0 +1,32 @@
+package com.phonegap;
+/* License (MIT)
+ * Copyright (c) 2008 Nitobi
+ * website: http://phonegap.com
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * “Software”), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+
+public class GeoTuple {
+	
+	public double lat;
+	public double lng;
+	public double ele;
+	
+}

framework/src/com/phonegap/GpsListener.java

@@ -0,0 +1,99 @@
+package com.phonegap;
+/* License (MIT)
+ * Copyright (c) 2008 Nitobi
+ * website: http://phonegap.com
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * “Software”), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+import android.content.Context;
+import android.location.Location;
+import android.location.LocationManager;
+import android.location.LocationListener;
+import android.os.Bundle;
+import android.util.Log;
+
+public class GpsListener implements LocationListener {
+	
+	private Context mCtx;
+	private Location cLoc;
+	private LocationManager mLocMan;
+	private static final String LOG_TAG = "PhoneGap";
+	private GeoListener owner;
+	
+	public GpsListener(Context ctx, int interval, GeoListener m)
+	{
+		owner = m;
+		mCtx = ctx;
+		mLocMan = (LocationManager) mCtx.getSystemService(Context.LOCATION_SERVICE);
+		mLocMan.requestLocationUpdates(LocationManager.GPS_PROVIDER, interval, 0, this);
+		cLoc = mLocMan.getLastKnownLocation(LocationManager.GPS_PROVIDER);
+	}
+	
+	public Location getLocation()
+	{
+		cLoc = mLocMan.getLastKnownLocation(LocationManager.GPS_PROVIDER);
+		return cLoc;
+	}
+	
+	public void onProviderDisabled(String provider) {
+		// TODO Auto-generated method stub
+		Log.d(LOG_TAG, "The provider " + provider + " is disabled");
+		owner.fail();
+	}
+
+	public void onProviderEnabled(String provider) {
+		// TODO Auto-generated method stub
+		Log.d(LOG_TAG, "The provider "+ provider + " is enabled");
+	}
+
+
+	public void onStatusChanged(String provider, int status, Bundle extras) {
+		// TODO Auto-generated method stub
+		Log.d(LOG_TAG, "The status of the provider " + provider + " has changed");
+		if(status == 0)
+		{
+			Log.d(LOG_TAG, provider + " is OUT OF SERVICE");
+			owner.fail();
+		}
+		else if(status == 1)
+		{
+			Log.d(LOG_TAG, provider + " is TEMPORARILY_UNAVAILABLE");
+		}
+		else
+		{
+			Log.d(LOG_TAG, provider + " is Available");
+		}
+	}
+
+
+	public void onLocationChanged(Location location) {
+		Log.d(LOG_TAG, "The location has been updated!");
+		owner.success(location);
+	}
+
+	public boolean hasLocation() {
+		return (cLoc != null);
+	}
+
+	public void stop()
+	{
+		mLocMan.removeUpdates(this);
+	}
+	
+}

framework/src/com/phonegap/HttpHandler.java

@@ -0,0 +1,65 @@
+package com.phonegap;
+
+import java.io.EOFException;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+
+import org.apache.http.HttpEntity;
+import org.apache.http.HttpResponse;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.impl.client.DefaultHttpClient;
+
+public class HttpHandler {
+
+	protected Boolean get(String url, String file)
+	{
+		HttpEntity entity = getHttpEntity(url);
+		try {
+			writeToDisk(entity, file);
+		} catch (Exception e) { e.printStackTrace(); return false; }
+		try {
+			entity.consumeContent();
+		} catch (Exception e) { e.printStackTrace(); return false; }
+		return true;
+	}
+	
+	private HttpEntity getHttpEntity(String url)
+	/**
+	 * get the http entity at a given url
+	 */
+	{
+		HttpEntity entity=null;
+		try {
+			DefaultHttpClient httpclient = new DefaultHttpClient();
+			HttpGet httpget = new HttpGet(url);
+			HttpResponse response = httpclient.execute(httpget);
+			entity = response.getEntity();
+		} catch (Exception e) { e.printStackTrace(); return null; }
+		return entity;
+	}
+	
+	private void writeToDisk(HttpEntity entity, String file) throws EOFException
+	/**
+	 * writes a HTTP entity to the specified filename and location on disk
+	 */
+	{  
+		int i=0;
+		String FilePath="/sdcard/" + file;
+		try {
+			InputStream in = entity.getContent();
+			byte buff[] = new byte[1024];    
+			FileOutputStream out=
+				new FileOutputStream(FilePath);
+			do {
+				int numread = in.read(buff);
+				if (numread <= 0)
+                   	break;
+				out.write(buff, 0, numread);
+				System.out.println("numread" + numread);
+				i++;
+			} while (true);
+			out.flush();
+			out.close();	
+		} catch (Exception e) { e.printStackTrace(); }
+	}
+}

framework/src/com/phonegap/NetworkListener.java

@@ -0,0 +1,102 @@
+package com.phonegap;
+/* License (MIT)
+ * Copyright (c) 2008 Nitobi
+ * website: http://phonegap.com
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * “Software”), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+import android.content.Context;
+import android.location.Location;
+import android.location.LocationManager;
+import android.location.LocationListener;
+import android.os.Bundle;
+import android.util.Log;
+
+public class NetworkListener implements LocationListener {
+
+	private Context mCtx;
+	private Location cLoc;
+	private LocationManager mLocMan;
+	private static final String LOG_TAG = "PhoneGap";
+	GeoListener owner;
+	
+	public NetworkListener(Context ctx, int interval, GeoListener m)
+	{
+		owner = m;
+		mCtx = ctx;
+		mLocMan = (LocationManager) mCtx.getSystemService(Context.LOCATION_SERVICE);
+		mLocMan.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, interval, 0, this);
+		cLoc = mLocMan.getLastKnownLocation(LocationManager.NETWORK_PROVIDER);
+	}
+	
+	public Location getLocation()
+	{
+		cLoc = mLocMan.getLastKnownLocation(LocationManager.NETWORK_PROVIDER);
+		return cLoc;
+	}
+
+	public void onProviderDisabled(String provider) {
+		// TODO Auto-generated method stub
+		Log.d(LOG_TAG, "The provider " + provider + " is disabled");
+	}
+
+
+	public void onProviderEnabled(String provider) {
+		// TODO Auto-generated method stub
+		Log.d(LOG_TAG, "The provider "+ provider + " is enabled");
+	}
+
+
+	public void onStatusChanged(String provider, int status, Bundle extras) {
+		// TODO Auto-generated method stub
+		Log.d(LOG_TAG, "The status of the provider " + provider + " has changed");
+		if(status == 0)
+		{
+			Log.d(LOG_TAG, provider + " is OUT OF SERVICE");
+		}
+		else if(status == 1)
+		{
+			Log.d(LOG_TAG, provider + " is TEMPORARILY_UNAVAILABLE");
+		}
+		else
+		{
+			Log.d(LOG_TAG, provider + " is Available");
+		}
+	}
+
+
+	/*
+	 * The GPS is the primary form of Geolocation in PhoneGap.  Only fire the success variables if the GPS is down
+	 * for some reason
+	 */
+	public void onLocationChanged(Location location) {
+		Log.d(LOG_TAG, "The location has been updated!");
+		if (!owner.mGps.hasLocation())
+		{
+			owner.success(location);
+		}
+		cLoc = location;
+	}
+	
+	public void stop()
+	{
+		mLocMan.removeUpdates(this);
+	}
+	
+}

framework/src/com/phonegap/NetworkManager.java

@@ -0,0 +1,53 @@
+package com.phonegap;
+
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.impl.client.DefaultHttpClient;
+
+import android.content.Context;
+import android.net.*;
+import android.webkit.WebView;
+
+public class NetworkManager {
+
+	Context mCtx;
+	WebView mView;
+	ConnectivityManager sockMan;
+	
+	NetworkManager(Context ctx, WebView view)
+	{
+		mCtx = ctx;
+		mView = view;
+		sockMan = (ConnectivityManager) mCtx.getSystemService(Context.CONNECTIVITY_SERVICE);
+	}
+	
+	public boolean isAvailable()
+	{
+		NetworkInfo info = sockMan.getActiveNetworkInfo();
+		boolean conn = info.isConnected();
+		return conn;
+	}
+	
+	public boolean isWifiActive()
+	{
+		NetworkInfo info = sockMan.getActiveNetworkInfo();
+		String type = info.getTypeName();
+		return type.equals("WIFI");
+	}
+	
+	public boolean isReachable(String uri)
+	{
+		if (uri.indexOf("http://") == -1)
+			uri = "http://" + uri;
+		boolean reached = isAvailable();
+		try {
+			DefaultHttpClient httpclient = new DefaultHttpClient();
+			HttpGet httpget = new HttpGet(uri);
+			httpclient.execute(httpget);			
+		} catch (Exception e) { 
+			reached = false;
+		}
+		return reached;
+	}
+	
+	
+}

framework/src/com/phonegap/Orientation.java

@@ -0,0 +1,69 @@
+package com.phonegap;
+/* License (MIT)
+ * Copyright (c) 2008 Nitobi
+ * website: http://phonegap.com
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * “Software”), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+import android.content.Context;
+import android.hardware.SensorManager;
+import android.hardware.SensorListener;
+import android.webkit.WebView;
+
+public class Orientation implements SensorListener{
+
+	private WebView mAppView;
+    private SensorManager sensorManager;
+	private Context mCtx;
+    
+	Orientation(WebView kit, Context ctx) {
+		mAppView = kit;
+		mCtx = ctx;
+        sensorManager = (SensorManager) mCtx.getSystemService(Context.SENSOR_SERVICE);
+        this.resumeAccel();
+	}
+	
+	public void onSensorChanged(int sensor, final float[] values) {
+		if (sensor != SensorManager.SENSOR_ACCELEROMETER || values.length < 3)
+			return;
+        float x = values[0];
+        float y = values[1];
+        float z = values[2];
+        mAppView.loadUrl("javascript:gotAcceleration(" + x + ", " + y + "," + z + ")");
+	}
+
+	public void onAccuracyChanged(int arg0, int arg1) {
+		// This is a stub method.
+		
+	}
+
+	public void pauseAccel()
+	{
+        sensorManager.unregisterListener(this);	
+	}
+	
+	public void resumeAccel()
+	{
+		sensorManager.registerListener(this, 
+				   SensorManager.SENSOR_ACCELEROMETER,
+				   SensorManager.SENSOR_DELAY_GAME);
+	}
+	
+}

framework/src/com/phonegap/PhoneGap.java

@@ -0,0 +1,239 @@
+package com.phonegap;
+/* License (MIT)
+ * Copyright (c) 2008 Nitobi
+ * website: http://phonegap.com
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * Software), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED AS IS, WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+import java.util.TimeZone;
+
+import android.content.Context;
+import android.content.IntentFilter;
+import android.hardware.SensorManager;
+import android.net.Uri;
+import android.os.Vibrator;
+import android.telephony.TelephonyManager;
+import android.webkit.WebView;
+import android.media.Ringtone;
+import android.media.RingtoneManager;
+
+public class PhoneGap{
+	
+	private static final String LOG_TAG = "PhoneGap";
+	/*
+	 * UUID, version and availability	
+	 */
+	public boolean droid = true;
+	public static String version = "0.8.0";
+	public static String platform = "Android";
+	public static String uuid;
+	private Context mCtx;
+    private WebView mAppView;
+    SmsListener mSmsListener;
+    AudioHandler audio; 
+    
+	public PhoneGap(Context ctx, WebView appView) {
+        this.mCtx = ctx;
+        this.mAppView = appView;
+
+        mSmsListener = new SmsListener(ctx,mAppView);        
+        audio = new AudioHandler("/sdcard/tmprecording.mp3", ctx);
+        uuid = getUuid();
+    }
+	
+	public void beep(long pattern)
+	{
+		Uri ringtone = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
+		Ringtone notification = RingtoneManager.getRingtone(mCtx, ringtone);
+		for (long i = 0; i < pattern; ++i)
+		{
+			notification.play();
+		}
+	}
+	
+	public void vibrate(long pattern){
+        // Start the vibration, 0 defaults to half a second.
+		if (pattern == 0)
+			pattern = 500;
+        Vibrator vibrator = (Vibrator) mCtx.getSystemService(Context.VIBRATOR_SERVICE);
+        vibrator.vibrate(pattern);
+	}
+	
+	public String getPlatform()
+	{
+		return this.platform;
+	}
+	
+	public String getUuid()
+	{		
+		TelephonyManager operator = (TelephonyManager) mCtx.getSystemService(Context.TELEPHONY_SERVICE);
+		String uuid = operator.getDeviceId();
+		return uuid;
+	}
+	
+	public void init()
+	{
+		mAppView.loadUrl("javascript:Device.setData('Android','" + version + "','" + this.getUuid() + "')");
+	}
+	
+	public String getModel()
+	{
+		String model = android.os.Build.MODEL;
+		return model;
+	}
+	public String getProductName()
+	{
+		String productname = android.os.Build.PRODUCT;
+		return productname;
+	}
+	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 getVersion()
+	{
+		return version;
+	}	
+	
+	// Old SMS code, figure out what to do with this!
+	// BTW: This is awesome!
+	
+	public void notificationWatchPosition(String filter)
+	/**
+	 * Starts the listener for incoming notifications of type filter
+	 * TODO: JavaScript Call backs for success and error handling. More filter types. 
+	 */
+	{
+		if (filter.contains("SMS"))
+		{
+    		IntentFilter mFilter = new IntentFilter("android.provider.Telephony.SMS_RECEIVED");
+    		mCtx.registerReceiver(mSmsListener,mFilter);
+		}
+	}
+	
+    public void notificationClearWatch(String filter) 
+	/**
+	 * Stops the listener for incoming notifications of type filter
+	 * TODO: JavaScript Call backs for success and error handling 
+	 */
+    {
+    	if (filter.contains("SMS")) 
+    	{
+    		mCtx.unregisterReceiver(mSmsListener);
+    	}	
+    }
+    
+    public void httpGet(String url, String file)
+    /**
+     * grabs a file from specified url and saves it to a name and location
+     * the base directory /sdcard is abstracted so that paths may be the same from one mobile OS to another
+     * TODO: JavaScript call backs and error handling
+     */
+    {
+    	HttpHandler http = new HttpHandler();
+    	http.get(url, file);
+    }
+    
+    /**
+     * AUDIO
+     * TODO: Basic functions done but needs more work on error handling and call backs, remove record hack
+     */
+    
+    public void startRecordingAudio(String file)
+    {
+    	/* for this to work the recording needs to be specified in the constructor,
+    	 * a hack to get around this, I'm moving the recording after it's complete 
+    	 */
+    	audio.startRecording(file);
+    }
+    
+    public void stopRecordingAudio()
+    {
+    	audio.stopRecording();
+    }
+    
+    public void startPlayingAudio(String file)
+    {
+    	audio.startPlaying(file);
+    }
+    
+    public void stopPlayingAudio()
+    {
+    	audio.stopPlaying();
+    }
+    
+    public long getCurrentPositionAudio()
+    {
+    	System.out.println(audio.getCurrentPosition());
+    	return(audio.getCurrentPosition());
+    }
+    
+    public long getDurationAudio(String file)
+    {
+    	System.out.println(audio.getDuration(file));
+    	return(audio.getDuration(file));
+    }  
+    
+    public void setAudioOutputDevice(int output){
+    	audio.setAudioOutputDevice(output);
+    }
+    
+    public int getAudioOutputDevice(){
+    	return audio.getAudioOutputDevice();
+    }
+    
+    public String getLine1Number() {
+        TelephonyManager tm =
+            (TelephonyManager)mCtx.getSystemService(Context.TELEPHONY_SERVICE);
+        return(tm.getLine1Number());
+    }
+    
+    public String getVoiceMailNumber() {
+    	TelephonyManager tm =
+    		(TelephonyManager)mCtx.getSystemService(Context.TELEPHONY_SERVICE);
+        return(tm.getVoiceMailNumber());
+    }
+    
+    public String getNetworkOperatorName(){
+    	TelephonyManager tm =
+    		(TelephonyManager)mCtx.getSystemService(Context.TELEPHONY_SERVICE);
+        return(tm.getNetworkOperatorName());
+    }
+    
+    public String getSimCountryIso(){
+    	TelephonyManager tm =
+    		(TelephonyManager)mCtx.getSystemService(Context.TELEPHONY_SERVICE);
+        return(tm.getSimCountryIso());
+    }
+    
+    public String getTimeZoneID() {
+       TimeZone tz = TimeZone.getDefault();
+        return(tz.getID());
+    } 
+    
+}
+

framework/src/com/phonegap/PhoneGapView.java

@@ -0,0 +1,74 @@
+package com.phonegap;
+
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.Intent;
+import android.webkit.WebView;
+
+
+public class PhoneGapView extends WebView {
+
+	private Activity mCtx;
+	private PhoneGap gap;
+	private GeoBroker geo;
+	private AccelListener accel;	
+	private ContactManager mContacts;
+	private FileUtils fs;
+	private NetworkManager netMan;
+	private CameraLauncher launcher;
+	
+	public PhoneGapView(Activity action){
+		super((Context) action);
+		mCtx = action;
+	}
+	
+	public void loadUrl(String url)
+	{
+		super.loadUrl(url);
+		bindBrowser();
+	}
+	
+    private void bindBrowser()
+    {
+    	gap = new PhoneGap(mCtx, this);
+    	geo = new GeoBroker(this, mCtx);
+    	accel = new AccelListener(mCtx, this);
+    	mContacts = new ContactManager(mCtx, this);
+    	fs = new FileUtils(this);
+    	netMan = new NetworkManager(mCtx, this);
+    	
+    	// This creates the new javascript interfaces for PhoneGap
+    	this.addJavascriptInterface(gap, "DroidGap");
+    	this.addJavascriptInterface(geo, "Geo");
+    	this.addJavascriptInterface(accel, "Accel");
+    	this.addJavascriptInterface(mContacts, "ContactHook");
+    	this.addJavascriptInterface(fs, "FileUtil");
+    	this.addJavascriptInterface(netMan, "NetworkManager");
+    }    
+
+    // This is required to start the camera activity!  It has to come from the previous activity
+    public void startCamera(int quality)
+    {
+    	Intent i = new Intent(mCtx, CameraPreview.class);
+    	i.setAction("android.intent.action.PICK");
+    	i.putExtra("quality", quality);
+    	mCtx.startActivityForResult(i, 0);
+    }
+    
+    protected void processResult(int requestCode, int resultCode, Intent intent)
+    {
+    	String data;
+    	if (resultCode == mCtx.RESULT_OK)
+    	{
+    		data = intent.getStringExtra("picture");    	     
+    		// Send the graphic back to the class that needs it
+    		launcher.processPicture(data);
+    	}
+    	else
+    	{
+    		launcher.failPicture("Did not complete!");
+    	}
+    }
+    
+}

framework/src/com/phonegap/SmsListener.java

@@ -0,0 +1,68 @@
+package com.phonegap;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+import android.telephony.gsm.SmsMessage;
+import android.util.Log;
+import android.webkit.WebView;
+
+public class SmsListener extends BroadcastReceiver 
+{
+	private WebView mAppView;
+	
+	public SmsListener(Context ctx, WebView mAppView) 
+	{
+        this.mAppView = mAppView;
+	}
+
+    String ACTION = "android.provider.Telephony.SMS_RECEIVED"; 
+  	
+    public void onReceive(Context ctx, Intent intent) 
+    {
+    	SmsMessage[] msg;
+    	if (intent.getAction().equals(ACTION))         	
+    	{
+    		msg = getMessagesFromIntent(intent);
+    		String smsContent = null;
+    		String sendersNumber = null;
+    		for(int i=0; i < msg.length; i++)
+    		{
+    			sendersNumber = msg[i].getDisplayOriginatingAddress();
+    			smsContent = msg[i].getDisplayMessageBody();
+    		}
+                onReceiveSMS(sendersNumber, smsContent);
+        }
+    }
+        
+    protected void onReceiveSMS(String sendersNumber, String smsContent) 
+    /**
+     * Call back to Java Script
+     */
+    {
+    	mAppView.loadUrl("javascript:onReceiveSms('"+sendersNumber+"',"+"'"+ smsContent +"'"+")");
+    }
+        
+    private SmsMessage[] getMessagesFromIntent(Intent intent)
+    {
+    	SmsMessage retMsgs[] = null;
+    	Bundle bdl = intent.getExtras();
+    	try
+    	{
+    		Object pdus[] = (Object [])bdl.get("pdus");
+    		retMsgs = new SmsMessage[pdus.length];
+    		for(int n=0; n < pdus.length; n++)
+    		{
+    			byte[] byteData = (byte[])pdus[n];
+    			retMsgs[n] = SmsMessage.createFromPdu(byteData);
+    		}                              
+        } catch(Exception e)
+            {
+                Log.e("SMS_getMessagesFromIntent", "fail", e);
+            }
+            return retMsgs;
+    }
+
+}
+

framework/src/com/phonegap/TempListener.java

@@ -0,0 +1,53 @@
+package com.phonegap;
+
+import java.util.List;
+
+import android.hardware.Sensor;
+import android.hardware.SensorEvent;
+import android.hardware.SensorEventListener;
+import android.hardware.SensorManager;
+import android.content.Context;
+import android.webkit.WebView;
+
+public class TempListener implements SensorEventListener {
+	WebView mAppView;
+	Context mCtx;
+	Sensor mSensor;	
+	
+	private SensorManager sensorManager;
+	
+	TempListener(Context ctx, WebView appView)
+	{
+		mCtx = ctx;
+		mAppView = appView;		
+		sensorManager = (SensorManager) mCtx.getSystemService(Context.SENSOR_SERVICE);
+	}
+
+	public void start()
+	{
+		List<Sensor> list = this.sensorManager.getSensorList(Sensor.TYPE_TEMPERATURE);
+		if (list.size() > 0)
+		{
+			this.mSensor = list.get(0);
+			this.sensorManager.registerListener(this, this.mSensor, SensorManager.SENSOR_DELAY_NORMAL);
+		}
+		
+	}
+	
+	public void stop()
+	{
+		this.sensorManager.unregisterListener(this);
+	}
+	
+	public void onAccuracyChanged(Sensor sensor, int accuracy) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	public void onSensorChanged(SensorEvent event) {
+		// We want to know what temp this is.
+		float temp = event.values[0];
+		mAppView.loadUrl("javascript:gotTemp(" + temp + ")");
+	}
+
+}

framework/src/com/phonegap/VideoPreview.java

@@ -0,0 +1,8 @@
+package com.phonegap;
+
+import android.app.Activity;
+
+
+public class VideoPreview extends Activity {
+
+}