rhodes 2.1.0 → 2.2.0.beta.1

data/platform/android/Rhodes/src/com/rhomobile/rhodes/bluetooth/UUIDHelper.java

@@ -0,0 +1,71 @@
+package com.rhomobile.rhodes.bluetooth;
+
+
+import java.util.UUID;
+
+public class UUIDHelper {
+
+	/** SDP 0x0001 16-bit */
+	public static final UUID SDP_PROTOCOL_UUID = fromUUID16(0x0001);
+
+	/** RFCOMM 0x0003 16-bit */
+	public static final UUID RFCOMM_PROTOCOL_UUID = fromUUID16(0x0003);
+
+	/** OBEX 0x0008 16-bit */
+	public static final UUID OBEX_PROTOCOL_UUID = fromUUID16(0x0008);
+
+	/** HTTP 0x000C 16-bit */
+	public static final UUID HTTP_PROTOCOL_UUID = fromUUID16(0x000C);
+
+	/** L2CAP 0x0100 16-bit */
+	public static final UUID L2CAP_PROTOCOL_UUID = fromUUID16(0x0100);
+
+	/** BNEP 0x000F 16-bit */
+	public static final UUID BNEP_PROTOCOL_UUID = fromUUID16(0x000F);
+
+	/** Serial Port 0x1101 16-bit */
+	public static final UUID SERIAL_PORT_PROTOCOL_UUID = fromUUID16(0x1101);
+
+	/** OBEX Object Push Profile 0x1105 16-bit */
+	public static final UUID OBEX_OBJECT_PUSH_PROTOCOL_UUID = fromUUID16(0x1105);
+
+	/** OBEX File Transfer Profile 0x1106 16-bit */
+	public static final UUID OBEX_FILE_TRANSFER_PROTOCOL_UUID = fromUUID16(0x1106);
+
+	/** Personal Area Networking User 0x1115 16-bit */
+	public static final UUID PERSONAL_AREA_NETWORKING_PROTOCOL_UUID = fromUUID16(0x1115);
+
+	private static final String UUID_BASE = "0000-1000-8000-00805F9B34FB";
+
+	private static final int MASK_UUID16 = 0x0000FFFF;
+
+	private static final int MASK_UUID128 = 0x0000FFFF;
+
+	public static final UUID fromUUID16(int uuid16) {
+
+		String s = uuidStringFromUuid16(uuid16);
+		UUID uuid = UUID.fromString(s);
+
+		return uuid;
+	}
+
+	public static final int toUUID16(UUID uuid128) {
+
+		long bits = uuid128.getMostSignificantBits();
+
+		return (int) ((bits >> 32) & MASK_UUID128);
+	}
+
+	private static final String uuidStringFromUuid16(int uuid16) {
+
+		StringBuilder b = new StringBuilder();
+		String hex = Integer.toHexString(uuid16 & MASK_UUID16);
+		b.append("00000000".substring(hex.length()));
+		b.append(hex);
+		b.append('-');
+		b.append(UUID_BASE);
+
+		return b.toString();
+	}
+
+}

data/platform/android/Rhodes/src/com/rhomobile/rhodes/camera/ImageCapture.java

@@ -93,7 +93,6 @@ public class ImageCapture extends RhoActivity implements SurfaceHolder.Callback,
 		public void onPictureTaken(byte[] data, Camera c) {
 			Logger.D(TAG, "PICTURE CALLBACK RAW");
 			camera.startPreview();
-			startAutoFocusIfExist();
 		}
 	};
 
@@ -107,7 +106,8 @@ public class ImageCapture extends RhoActivity implements SurfaceHolder.Callback,
 		switch (keyCode) {
 		case KeyEvent.KEYCODE_DPAD_CENTER:
 		case KeyEvent.KEYCODE_CAMERA:
-			takePicture();
+			takePictureWithAutofocus();
+			cameraButton.setVisibility(View.INVISIBLE);
 			return true;
 		case KeyEvent.KEYCODE_BACK:
 			return super.onKeyDown(keyCode, event);
@@ -148,7 +148,6 @@ public class ImageCapture extends RhoActivity implements SurfaceHolder.Callback,
 			camera.setParameters(p);
 			camera.setPreviewDisplay(holder);
 			camera.startPreview();
-			startAutoFocusIfExist();
 			isPreviewRunning = true;
 		} catch (Exception e) {
 			Logger.E(TAG, e.getMessage());
@@ -165,11 +164,16 @@ public class ImageCapture extends RhoActivity implements SurfaceHolder.Callback,
 
 	public void onClick(View v) {
 		if (v.getId() == AndroidR.id.cameraButton) {
-			takePicture();
+			takePictureWithAutofocus();
 			cameraButton.setVisibility(View.INVISIBLE);
 			
 		}
 	}
+
+	private void takePictureWithAutofocus() {
+		startAutoFocus();
+	}
+
 	
 	private void takePicture() {
 		if (!mIsActive) {
@@ -199,14 +203,15 @@ public class ImageCapture extends RhoActivity implements SurfaceHolder.Callback,
 		mIsActive = false;
 	}
 
-                        private void startAutoFocusIfExist() {
+	private void startAutoFocus() {
 		//this only from API v.5 and higher
 		//String focus_mode = camera.getParameters().getFocusMode();
 		//if ((focus_mode != Camera.Parameters.FOCUS_MODE_FIXED) && (focus_mode != Camera.Parameters.FOCUS_MODE_INFINITY)) {
-			camera.autoFocus(this);
+		camera.autoFocus(this);
 		//}
-                        }
+	}
 
 	public void onAutoFocus (boolean success, Camera camera) {
+		takePicture();
 	}
 }

data/platform/android/Rhodes/src/com/rhomobile/rhodes/event/Event.java

@@ -0,0 +1,19 @@
+package com.rhomobile.rhodes.event;
+
+import java.util.Date;
+
+public class Event {
+	
+	public Event(String eid) {
+		id = eid;
+	}
+	
+	public String id;
+	public String title;
+	public Date startDate;
+	public Date endDate;
+	public Date lastModified;
+	public String location;
+	public String notes;
+	public String privacy;
+}

data/platform/android/Rhodes/src/com/rhomobile/rhodes/event/EventStore.java

@@ -0,0 +1,261 @@
+package com.rhomobile.rhodes.event;
+
+import java.util.Date;
+import java.util.Vector;
+
+import android.database.Cursor;
+import android.content.ContentResolver;
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.net.Uri;
+import android.os.Build;
+
+import com.rhomobile.rhodes.Capabilities;
+import com.rhomobile.rhodes.Logger;
+import com.rhomobile.rhodes.RhodesService;
+
+public class EventStore {
+	
+	private static final String TAG = "EventStore";
+	
+	private static final String AUTHORITY = Build.VERSION.SDK_INT >= Build.VERSION_CODES.FROYO ? "com.android.calendar" : "calendar";
+	private static final Uri EVENTS_URI = Uri.parse("content://" + AUTHORITY + "/events");
+	
+	private static final String EVENTS_TITLE = "title";
+	private static final String EVENTS_START_DATE = "dtstart";
+	private static final String EVENTS_END_DATE = "dtend";
+	private static final String EVENTS_LOCATION = "eventLocation";
+	private static final String EVENTS_NOTES = "description";
+	private static final String EVENTS_PRIVACY = "visibility";
+	
+	private static void reportFail(String name, Exception e) {
+		Logger.E(TAG, "Call of \"" + name + "\" failed: " + e.getMessage());
+		e.printStackTrace();
+	}
+	
+	private static String dateToString(Date date) {
+		return String.format("%04d-%02d-%02d %02d:%02d:%02d",
+				date.getYear() + 1900, date.getMonth() + 1, date.getDate(),
+				date.getHours(), date.getMinutes(), date.getSeconds());
+	}
+	
+	private static void checkCapabilities() throws IllegalAccessException {
+		if (!Capabilities.CALENDAR_ENABLED)
+			throw new IllegalAccessException("Capability CALENDAR disabled");
+	}
+	
+	private static ContentResolver getContentResolver() {
+		return RhodesService.getInstance().getContext().getContentResolver();
+	}
+	
+	private static long getDefaultCalendarId() {
+		final Cursor calendarCursor = getContentResolver().query(
+				Uri.parse("content://" + AUTHORITY + "/calendars"),
+				new String[] {"_id"},
+				null, null, null);
+		try {
+			if (!calendarCursor.moveToFirst())
+				throw new RuntimeException("No calendars found!");
+			long id = calendarCursor.getLong(0);
+			return id;
+		}
+		finally {
+			calendarCursor.close();
+		}
+	}
+	
+	public static Object fetch(Date startDate, Date endDate, boolean includeRepeating) {
+		try {
+			checkCapabilities();
+			
+			Logger.D(TAG, "fetch(start, end), start: " + dateToString(startDate) + ", end: " + dateToString(endDate));
+			
+			Vector<Event> ret = new Vector<Event>();
+			
+			ContentResolver r = getContentResolver();
+			
+			Cursor eventCursor;
+			if (includeRepeating) {
+				Uri.Builder builder = Uri.parse("content://" + AUTHORITY + "/instances/when").buildUpon();
+				ContentUris.appendId(builder, startDate.getTime());
+				ContentUris.appendId(builder, endDate.getTime());
+				
+				eventCursor = r.query(builder.build(),
+						new String[] {"event_id", EVENTS_TITLE, "begin", "end", EVENTS_LOCATION,
+							EVENTS_NOTES, EVENTS_PRIVACY},
+						null, //"Calendars._id=" + id,
+						null, "startDay ASC, startMinute ASC");
+			}
+			else {
+				String where = String.format("(%s >= ? and %s <= ?) or (%s >= ? and %s <= ?)",
+						EVENTS_START_DATE, EVENTS_START_DATE, EVENTS_END_DATE, EVENTS_END_DATE);
+				String start = Long.toString(startDate.getTime());
+				String end = Long.toString(endDate.getTime());
+				eventCursor = r.query(EVENTS_URI,
+					new String[] {"_id", EVENTS_TITLE, EVENTS_START_DATE, EVENTS_END_DATE,
+						EVENTS_LOCATION, EVENTS_NOTES, EVENTS_PRIVACY},
+					where, new String[] {start, end, start, end},
+					null);
+			}
+			if (eventCursor == null)
+				throw new RuntimeException("Calendar provider not found");
+			try {
+				while (eventCursor.moveToNext()) {
+					String eid = eventCursor.getString(0);
+					Event event = new Event(eid);
+					
+					event.title = eventCursor.getString(1);
+					event.startDate = new Date(eventCursor.getLong(2));
+					event.endDate = new Date(eventCursor.getLong(3));
+					event.location = eventCursor.getString(4);
+					event.notes = eventCursor.getString(5);
+					switch (eventCursor.getInt(6)) {
+					case 1: event.privacy = "confidential"; break;
+					case 2: event.privacy = "private"; break;
+					case 3: event.privacy = "public"; break;
+					}
+					
+					Logger.D(TAG, "Event: id: " + event.id +
+							", title: " + event.title +
+							", begin: " + dateToString(event.startDate) +
+							", end: " + dateToString(event.endDate));
+					
+					ret.add(event);
+				}
+			}
+			finally {
+				eventCursor.close();
+			}
+			
+			return ret;
+		}
+		catch (Exception e) {
+			reportFail("fetch(start, end)", e);
+			String error = e.getMessage();
+			return error == null ? "unknown" : error;
+		}
+	}
+	
+	public static Object fetch(String id) {
+		try {
+			checkCapabilities();
+			
+			Logger.D(TAG, "fetch(id)");
+			
+			ContentResolver r = getContentResolver();
+			
+			Uri uri = ContentUris.withAppendedId(EVENTS_URI, Long.parseLong(id));
+			final Cursor eventCursor = r.query(uri,
+					new String[] {EVENTS_TITLE, EVENTS_START_DATE, EVENTS_END_DATE,
+						EVENTS_LOCATION, EVENTS_NOTES, EVENTS_PRIVACY},
+					null, null, null);
+			if (eventCursor == null)
+				throw new RuntimeException("Calendar provider not found");
+			
+			try {
+				if (!eventCursor.moveToFirst()) {
+					Logger.D(TAG, "fetch(id): result set is empty");
+					return null;
+				}
+				Event event = new Event(id);
+				event.title = eventCursor.getString(0);
+				event.startDate = new Date(eventCursor.getLong(1));
+				event.endDate = new Date(eventCursor.getLong(2));
+				event.location = eventCursor.getString(3);
+				event.notes = eventCursor.getString(4);
+				switch (eventCursor.getInt(5)) {
+				case 1: event.privacy = "confidential"; break;
+				case 2: event.privacy = "private"; break;
+				case 3: event.privacy = "public"; break;
+				}
+				
+				Logger.D(TAG, "Event: id: " + event.id +
+						", title: " + event.title +
+						", begin: " + dateToString(event.startDate) +
+						", end: " + dateToString(event.endDate));
+				
+				return event;
+			}
+			finally {
+				eventCursor.close();
+			}
+		}
+		catch (Exception e) {
+			reportFail("fetch(id)", e);
+			String error = e.getMessage();
+			return error == null ? "unknown" : error;
+		}
+	}
+	
+	public static String save(Event event) {
+		try {
+			checkCapabilities();
+			
+			Logger.D(TAG, "save(event)");
+			
+			ContentValues values = new ContentValues();
+			values.put(EVENTS_TITLE, event.title);
+			values.put(EVENTS_START_DATE, event.startDate.getTime());
+			values.put(EVENTS_END_DATE, event.endDate.getTime());
+			if (event.location != null)
+				values.put(EVENTS_LOCATION, event.location);
+			if (event.notes !=  null)
+				values.put(EVENTS_NOTES, event.notes);
+			if (event.privacy != null)
+			{
+				int privacy = 0;
+				if (event.privacy.equalsIgnoreCase("confidential"))
+					privacy = 1;
+				else if (event.privacy.equalsIgnoreCase("private"))
+					privacy = 2;
+				else if (event.privacy.equalsIgnoreCase("public"))
+					privacy = 3;
+				values.put(EVENTS_PRIVACY, privacy);
+			}
+
+			long calendarId = getDefaultCalendarId();
+			values.put("calendar_id", calendarId);
+			
+			ContentResolver r = getContentResolver();
+					
+			if (event.id == null || event.id.equalsIgnoreCase("")) {
+				Logger.D(TAG, "Insert new event...");
+				Uri euri = r.insert(EVENTS_URI, values);
+				event.id = Long.toString(ContentUris.parseId(euri));
+				Logger.D(TAG, "Event id of event is " + event.id);
+			}
+			else {
+				Logger.D(TAG, "Update event...");
+				Uri uri = ContentUris.withAppendedId(EVENTS_URI, Long.parseLong(event.id));
+				r.update(uri, values, null, null);
+				Logger.D(TAG, "Event updated");
+			}
+			
+			return null;
+		}
+		catch (Exception e) {
+			reportFail("save", e);
+			String error = e.getMessage();
+			return error == null ? "unknown" : error;
+		}
+	}
+	
+	public static String delete(String id) {
+		try {
+			checkCapabilities();
+			
+			Logger.D(TAG, "delete(id)");
+			
+			int rows = getContentResolver().delete(EVENTS_URI, "_id=?", new String[] {id});
+			Logger.D(TAG, String.format("%d rows deleted", rows));
+			
+			return null;
+		}
+		catch (Exception e) {
+			reportFail("delete", e);
+			String error = e.getMessage();
+			return error == null ? "unknown" : error;
+		}
+	}
+	
+}

data/platform/android/Rhodes/src/com/rhomobile/rhodes/mainview/SimpleMainView.java

@@ -291,15 +291,17 @@ public class SimpleMainView implements MainView {
 					group = new LinearLayout(ctx);
 					group.setGravity(gravity);
 					group.setOrientation(LinearLayout.HORIZONTAL);
-					group.setLayoutParams(new LinearLayout.LayoutParams(FILL_PARENT, FILL_PARENT, 1));
+					group.setLayoutParams(new LinearLayout.LayoutParams(WRAP_CONTENT, FILL_PARENT, 1));
 					bottom.addView(group);
 				}
 				group.addView(button);
 			}
 			
 			// Last group should have gravity RIGHT
-			if (group != null)
+			if (group != null) {
 				group.setGravity(Gravity.RIGHT);
+				bottom.requestLayout();
+			}
 		}
 		
 		webView.requestFocus();

data/platform/android/Rhodes/src/com/rhomobile/rhodes/mainview/TabbedMainView.java

@@ -131,7 +131,7 @@ public class TabbedMainView implements MainView {
 					tabIndex = Integer.parseInt(tabId);
 					TabData data = tabData.elementAt(tabIndex);
 					if (data.reload || !data.loaded) {
-						getView(tabIndex).navigate(data.url, tabIndex);
+						RhodesService.loadUrl(data.url);
 						data.loaded = true;
 					}
 				}
@@ -162,7 +162,7 @@ public class TabbedMainView implements MainView {
 				throw new IllegalArgumentException("'action' should be String");
 			
 			String label = (String)labelObj;
-			String action = r.normalizeUrl((String)actionObj);
+			String action = (String)actionObj;
 			String icon = null;
 			boolean reload = false;