rhodes 2.1.0 → 2.2.0.beta.1

data/platform/bb/rhodes/src/{rhomobile → com/rho/rubyext}/RhoPhonebook.java

@@ -1,5 +1,7 @@
-package rhomobile;
+package com.rho.rubyext;
 
+import com.rho.RhoEmptyLogger;
+import com.rho.RhoLogger;
 import com.xruby.runtime.builtin.RubyArray;
 import com.xruby.runtime.builtin.RubyString;
 import com.xruby.runtime.builtin.RubyHash;
@@ -10,6 +12,8 @@ import javax.microedition.pim.*;
 
 //@RubyLevelClass(name="Phonebook")
 public class RhoPhonebook extends RubyBasic {
+	private static final RhoLogger LOG = RhoLogger.RHO_STRIP_LOG ? new RhoEmptyLogger() : 
+		new RhoLogger("Phonebook");
 
 	private ContactList m_contactList;
 
@@ -339,13 +343,6 @@ public class RhoPhonebook extends RubyBasic {
 		return RubyConstant.QTRUE;
 	}
 
-	public static RubyValue getfirstPhonebookRecord(RubyValue arg0) {
-		return RubyConstant.QNIL;
-	}
-	public static RubyValue getnextPhonebookRecord(RubyValue arg0) {
-		return RubyConstant.QNIL;
-	}
-	
 	public static void initMethods( RubyClass klass){
 		klass.defineAllocMethod(new RubyNoArgMethod(){
 			protected RubyValue run(RubyValue receiver, RubyBlock block )	{
@@ -353,63 +350,123 @@ public class RhoPhonebook extends RubyBasic {
 		});
 		
 		klass.getSingletonClass().defineMethod("openPhonebook", new RubyNoArgMethod() {
-			protected RubyValue run(RubyValue receiver, RubyBlock block) {
-				return RhoPhonebook.openPhonebook();
+			protected RubyValue run(RubyValue receiver, RubyBlock block) 
+			{
+				try {
+					return RhoPhonebook.openPhonebook();
+				} catch(Exception e) {
+					LOG.ERROR("openPhonebook failed", e);
+					throw (e instanceof RubyException ? (RubyException)e : new RubyException(e.getMessage()));
+				}
+					
 			}
 		});
 		klass.getSingletonClass().defineMethod("closePhonebook", new RubyOneArgMethod() {
-			protected RubyValue run(RubyValue receiver, RubyValue arg0, RubyBlock block) {
-				return RhoPhonebook.closePhonebook(arg0);
+			protected RubyValue run(RubyValue receiver, RubyValue arg0, RubyBlock block) 
+			{
+				try {
+					return RhoPhonebook.closePhonebook(arg0);
+				} catch(Exception e) {
+					LOG.ERROR("closePhonebook failed", e);
+					throw (e instanceof RubyException ? (RubyException)e : new RubyException(e.getMessage()));
+				}
+					
 			}
 		});
 		klass.getSingletonClass().defineMethod("getallPhonebookRecords", new RubyOneArgMethod() {
-			protected RubyValue run(RubyValue receiver, RubyValue arg0, RubyBlock block) {
-				return RhoPhonebook.getallPhonebookRecords(arg0);
+			protected RubyValue run(RubyValue receiver, RubyValue arg0, RubyBlock block) 
+			{
+				try {
+					return RhoPhonebook.getallPhonebookRecords(arg0);
+				} catch(Exception e) {
+					LOG.ERROR("getallPhonebookRecords failed", e);
+					throw (e instanceof RubyException ? (RubyException)e : new RubyException(e.getMessage()));
+				}
+					
 			}
 		});
 		klass.getSingletonClass().defineMethod("openPhonebookRecord", new RubyTwoArgMethod() {
-			protected RubyValue run(RubyValue receiver, RubyValue arg0, RubyValue arg1, RubyBlock block) {
-				return RhoPhonebook.openPhonebookRecord(arg0, arg1);
+			protected RubyValue run(RubyValue receiver, RubyValue arg0, RubyValue arg1, RubyBlock block) 
+			{
+				try {
+					return RhoPhonebook.openPhonebookRecord(arg0, arg1);
+				} catch(Exception e) {
+					LOG.ERROR("openPhonebookRecord failed", e);
+					throw (e instanceof RubyException ? (RubyException)e : new RubyException(e.getMessage()));
+				}
+					
 			}
 		});
 		klass.getSingletonClass().defineMethod("getPhonebookRecord", new RubyTwoArgMethod() {
-			protected RubyValue run(RubyValue receiver, RubyValue arg0, RubyValue arg1, RubyBlock block) {
-				return RhoPhonebook.getPhonebookRecord(arg0, arg1);
-			}
-		});
-		klass.getSingletonClass().defineMethod("getfirstPhonebookRecord", new RubyOneArgMethod() {
-			protected RubyValue run(RubyValue receiver, RubyValue arg0, RubyBlock block) {
-				return RhoPhonebook.getfirstPhonebookRecord(arg0);
-			}
-		});
-		klass.getSingletonClass().defineMethod("getnextPhonebookRecord", new RubyOneArgMethod() {
-			protected RubyValue run(RubyValue receiver, RubyValue arg0, RubyBlock block) {
-				return RhoPhonebook.getnextPhonebookRecord(arg0);
+			protected RubyValue run(RubyValue receiver, RubyValue arg0, RubyValue arg1, RubyBlock block) 
+			{
+				try {
+					return RhoPhonebook.getPhonebookRecord(arg0, arg1);
+				} catch(Exception e) {
+					LOG.ERROR("getPhonebookRecord failed", e);
+					throw (e instanceof RubyException ? (RubyException)e : new RubyException(e.getMessage()));
+				}
+					
 			}
 		});
 		klass.getSingletonClass().defineMethod("createRecord", new RubyOneArgMethod() {
-			protected RubyValue run(RubyValue receiver, RubyValue arg0, RubyBlock block) {
-				return RhoPhonebook.createRecord(arg0);
+			protected RubyValue run(RubyValue receiver, RubyValue arg0, RubyBlock block) 
+			{
+				try {
+					return RhoPhonebook.createRecord(arg0);
+				} catch(Exception e) {
+					LOG.ERROR("createRecord failed", e);
+					throw (e instanceof RubyException ? (RubyException)e : new RubyException(e.getMessage()));
+				}
+					
 			}
 		});
 		klass.getSingletonClass().defineMethod("setRecordValue", new RubyVarArgMethod() {
-			protected RubyValue run(RubyValue receiver, RubyArray ar, RubyBlock block) {
-				return RhoPhonebook.setRecordValue(ar);
+			protected RubyValue run(RubyValue receiver, RubyArray ar, RubyBlock block) 
+			{
+				try {
+					return RhoPhonebook.setRecordValue(ar);
+				} catch(Exception e) {
+					LOG.ERROR("setRecordValue failed", e);
+					throw (e instanceof RubyException ? (RubyException)e : new RubyException(e.getMessage()));
+				}
+					
 			}
 		});
 		klass.getSingletonClass().defineMethod("addRecord", new RubyTwoArgMethod() {
-			protected RubyValue run(RubyValue receiver, RubyValue arg0, RubyValue arg1, RubyBlock block) {
-				return RhoPhonebook.addRecord(arg0, arg1);
+			protected RubyValue run(RubyValue receiver, RubyValue arg0, RubyValue arg1, RubyBlock block) 
+			{
+				try {
+					return RhoPhonebook.addRecord(arg0, arg1);
+				} catch(Exception e) {
+					LOG.ERROR("addRecord failed", e);
+					throw (e instanceof RubyException ? (RubyException)e : new RubyException(e.getMessage()));
+				}
+					
 			}
 		});
 		klass.getSingletonClass().defineMethod("saveRecord", new RubyTwoArgMethod() {
-			protected RubyValue run(RubyValue receiver, RubyValue arg0, RubyValue arg1, RubyBlock block) {
-				return RhoPhonebook.saveRecord(arg0, arg1);
+			protected RubyValue run(RubyValue receiver, RubyValue arg0, RubyValue arg1, RubyBlock block) 
+			{
+				try {
+					return RhoPhonebook.saveRecord(arg0, arg1);
+				} catch(Exception e) {
+					LOG.ERROR("saveRecord failed", e);
+					throw (e instanceof RubyException ? (RubyException)e : new RubyException(e.getMessage()));
+				}
+					
 			}
 		});
 		klass.getSingletonClass().defineMethod("deleteRecord", new RubyTwoArgMethod() {
-			protected RubyValue run(RubyValue receiver, RubyValue arg0, RubyValue arg1, RubyBlock block) {
-				return RhoPhonebook.deleteRecord(arg0, arg1);
+			protected RubyValue run(RubyValue receiver, RubyValue arg0, RubyValue arg1, RubyBlock block) 
+			{
+				try {
+					return RhoPhonebook.deleteRecord(arg0, arg1);
+				} catch(Exception e) {
+					LOG.ERROR("deleteRecord failed", e);
+					throw (e instanceof RubyException ? (RubyException)e : new RubyException(e.getMessage()));
+				}
+					
 			}
 		});
 		

data/platform/bb/rhodes/src/com/rho/rubyext/System.java

@@ -13,6 +13,7 @@ import com.xruby.runtime.builtin.ObjectFactory;
 import com.xruby.runtime.lang.*;
 import com.rho.RhoRubyHelper;
 import net.rim.device.api.system.DeviceInfo;
+import net.rim.device.api.system.Backlight;
 
 public class System {
 
@@ -109,12 +110,32 @@ public class System {
 		});
 		klass.getSingletonClass().defineMethod("exit", new RubyNoArgMethod() {
 			protected RubyValue run(RubyValue receiver, RubyBlock block) {
-				synchronized(RhodesApplication.getInstance().getEventLock()) {
+				//synchronized(RhodesApplication.getInstance().getEventLock()) {
 					RhodesApplication.getInstance().close();
 					return RubyConstant.QNIL;
+				//}
+			}
+		});
+		
+		klass.getSingletonClass().defineMethod( "set_sleeping", new RubyOneArgMethod(){ 
+			protected RubyValue run(RubyValue receiver, RubyValue arg1, RubyBlock block )
+			{
+				try {
+					RubyValue ret = !Backlight.isEnabled() ? RubyConstant.QTRUE : RubyConstant.QFALSE;
+					
+					if ( arg1 != RubyConstant.QTRUE )
+						Backlight.enable(true, 255);
+					else
+						Backlight.enable(false, Backlight.getTimeoutDefault());
+					
+					return ret;
+				} catch(Exception e) {
+					LOG.ERROR("set_sleeping failed", e);
+					throw (e instanceof RubyException ? (RubyException)e : new RubyException(e.getMessage()));
 				}
 			}
 		});
+		
 	}
     
     //@RubyLevelMethod(name="get_property", module=true)

data/platform/bb/rhodes/src/rhomobile/PushListeningThread.java

@@ -46,6 +46,26 @@ public class PushListeningThread extends Thread {
         }
     }
 
+    public static boolean isMDSPushEnabled()
+    {
+    	if ( !RhoConf.getInstance().isExist("push_options") )
+    		return true;
+    	
+    	String strOptions = RhoConf.getInstance().getString("push_options");
+    	
+    	return strOptions.indexOf("mds") >= 0;
+    }
+
+    public static boolean isPushServiceEnabled()
+    {
+    	if ( !RhoConf.getInstance().isExist("push_options") )
+    		return true;
+    	
+    	String strOptions = RhoConf.getInstance().getString("push_options");
+    	
+    	return strOptions.indexOf("push_service") >= 0;
+    }
+    
     public void run()
     {
 
@@ -179,7 +199,7 @@ public class PushListeningThread extends Thread {
         }
     }
     
-    private String[] split(String original, String separator) {
+    private static String[] split(String original, String separator) {
 		Vector nodes = new Vector();
 		// Parse nodes into vector
 		int index = original.indexOf(separator);
@@ -202,7 +222,7 @@ public class PushListeningThread extends Thread {
 		return result;
 	}
    
-    private String[] splitOnce(String original, String separator) {
+    private static String[] splitOnce(String original, String separator) {
 		String[] result;
     	int index = original.indexOf(separator);
     	if (index>=0) {
@@ -216,19 +236,19 @@ public class PushListeningThread extends Thread {
     	return result;
     }
     
-    private void showPopup(String message) {
+    private static void showPopup(String message) {
     	com.rho.rubyext.Alert.showPopup(message);
 	}
     
-    private void vibrate(String duration) {
+    private static void vibrate(String duration) {
     	com.rho.rubyext.Alert.vibrate(duration);
     }
 
-    private void play_file(String file_name, String media_type) {
+    private static void play_file(String file_name, String media_type) {
     	com.rho.rubyext.Alert.play_file(file_name, media_type);
     }
    
-    private void processPushMessage(final byte[] data, int nLen)
+    public static void processPushMessage(final byte[] data, int nLen)
     {
        /* Application.getApplication().invokeLater(new Runnable() 
         {

data/platform/bb/rhodes/src/rhomobile/RhodesApplication.java

@@ -52,7 +52,7 @@ import com.xruby.runtime.lang.RubyProgram;
 /**
  *
  */
-final public class RhodesApplication extends UiApplication implements SystemListener, ISyncStatusListener//, FileSystemListener
+final public class RhodesApplication extends RhodesApplicationPlatform implements SystemListener, ISyncStatusListener
 {
 	// Menu Labels
 	public static final String LABEL_HOME = "Home";
@@ -69,6 +69,7 @@ final public class RhodesApplication extends UiApplication implements SystemList
 	private static final RhoLogger LOG = RhoLogger.RHO_STRIP_LOG ? new RhoEmptyLogger() : 
 		new RhoLogger("RhodesApplication");
 	
+
 	class CKeyListener  implements KeyListener{
 
 		public boolean keyChar(char key, int status, int time) {
@@ -402,6 +403,7 @@ final public class RhodesApplication extends UiApplication implements SystemList
     void doClose(){   	
     	LOG.TRACE("Rhodes DO CLOSE ***--------------------------***");
 
+    	onPlatformClose();
     	if ( _pushListeningThread != null )
     		_pushListeningThread.stop();
 		
@@ -512,6 +514,8 @@ final public class RhodesApplication extends UiApplication implements SystemList
 		        	navigateHome();
 		        }    
 		
+		    	onPlatformActivate();	    		
+
 		    	LOG.TRACE("Rhodes end activate ***--------------------------***");
     		}
     		
@@ -1001,10 +1005,11 @@ final public class RhodesApplication extends UiApplication implements SystemList
 	        
 	    	try {
 	    		RhoClassFactory.getNetworkAccess().configure();
+	    		
 	    	} catch(IOException exc) {
 	    		LOG.ERROR(exc.getMessage());
 	    	}
-	    	
+
 	        PrimaryResourceFetchThread.Create(this);
 	        LOG.INFO("RHODES STARTUP COMPLETED: ***----------------------------------*** " );
 	        
@@ -1154,8 +1159,14 @@ final public class RhodesApplication extends UiApplication implements SystemList
 	    navigateUrl(strStartPage);
     }
     
-    public void close() {
-    	_mainScreen.close();
+    public void close() 
+    {
+    	this.invokeLater(new Runnable() {
+            public void run() 
+            {
+				_mainScreen.close();
+            }
+    	});
     }
 
     public void processConnection(HttpConnection connection, Object e) 
@@ -1209,10 +1220,13 @@ final public class RhodesApplication extends UiApplication implements SystemList
     	    		return;
     	    	}
     	    	
-    	    	if (com.rho.Capabilities.ENABLE_PUSH)
+    	    	if ( com.rho.Capabilities.ENABLE_PUSH  )
     	    	{
-	    	    	_pushListeningThread = new PushListeningThread();
-	    	    	_pushListeningThread.start();
+    	    		if ( PushListeningThread.isMDSPushEnabled() )
+    	    		{
+		    	    	_pushListeningThread = new PushListeningThread();
+		    	    	_pushListeningThread.start();
+    	    		}
     	    	}
     	    	
         		while( !m_bExit )

data/platform/bb/rhodes/src/rhomobile/bluetooth/BluetoothManager.java

@@ -0,0 +1,528 @@
+package rhomobile.bluetooth;
+
+import rhomobile.RhodesApplication;
+
+import net.rim.device.api.bluetooth.BluetoothSerialPort;
+import net.rim.device.api.bluetooth.BluetoothSerialPortInfo;
+import net.rim.device.api.io.http.HttpHeaders;
+import net.rim.device.api.system.DeviceInfo;
+import net.rim.device.api.ui.UiApplication;
+import net.rim.device.api.ui.container.MainScreen;
+
+import com.rho.RhoEmptyLogger;
+import com.rho.RhoLogger;
+import com.xruby.runtime.builtin.ObjectFactory;
+import com.xruby.runtime.builtin.RubyArray;
+import com.xruby.runtime.builtin.RubyFixnum;
+import com.xruby.runtime.builtin.RubyInteger;
+import com.xruby.runtime.builtin.RubyString;
+import com.xruby.runtime.lang.*;
+
+
+public class BluetoothManager /*extends RubyBasic*/  implements BluetoothScreen.BluetoothScreenCallback, BluetoothPort.BluetoothPortListener {
+	
+	private static final RhoLogger LOG = RhoLogger.RHO_STRIP_LOG ? new RhoEmptyLogger() : 
+		new RhoLogger("Bluetooth");
+	
+
+	public static String BT_OK = "OK";
+	public static String BT_CANCEL = "CANCEL";
+	public static String BT_ERROR = "ERROR";
+
+	public static String BT_ROLE_SERVER = "ROLE_SERVER";
+	public static String BT_ROLE_CLIENT = "ROLE_CLIENT";
+	
+	public static String BT_SESSION_INPUT_DATA_RECEIVED = "SESSION_INPUT_DATA_RECEIVED";
+	public static String BT_SESSION_DISCONNECT = "SESSION_DISCONNECT";
+	
+	private static BluetoothManager ourBluetoothManager = null;
+	
+	private String mCreateSessionCallback = null;
+	private String mSessionCallback = null;
+	private String mConnectedDeviceName = null;
+	private String mLocalDeviceName = null;
+	private BluetoothScreen mScreen = null;
+	private BluetoothSerialPortInfo[] mDevices = null;
+	private BluetoothPort mPort = null;
+
+
+	
+	public static void rhoLogInfo(String msg) {
+		LOG.INFO(msg);
+		//LOG.ERROR(msg);
+	}
+	
+	public static void rhoLogError(String msg) {
+		LOG.ERROR(msg);
+	}
+	
+	public static BluetoothManager getInstance() {
+		if (ourBluetoothManager == null) {
+			ourBluetoothManager = new BluetoothManager();
+			ourBluetoothManager.init();
+		}
+		return ourBluetoothManager;
+	}
+	
+	private void init() {
+		mLocalDeviceName = "Blackberry device";//DeviceInfo.getDeviceName();
+		mScreen = null;
+		mPort = null;
+	}
+	
+	private void freeAll() {
+		if (mScreen != null) {
+			rhoPopScreen(mScreen);
+			mScreen = null;
+		}
+	}
+	
+	public static void rhoPushScreen(MainScreen screen) {
+		RhodesApplication app = (RhodesApplication)UiApplication.getUiApplication();
+		final MainScreen scr = screen;
+        app.invokeLater(new Runnable() 
+        {
+            public void run() 
+            {
+            	UiApplication app = UiApplication.getUiApplication();
+            	app.pushScreen(scr);
+            	app.requestForeground();
+            }
+        });
+	}
+	
+	public static void rhoPopScreen(MainScreen screen) {
+		RhodesApplication app = (RhodesApplication)UiApplication.getUiApplication();
+		final MainScreen scr = screen;
+        app.invokeLater(new Runnable() 
+        {
+            public void run() 
+            {
+            	UiApplication app = UiApplication.getUiApplication();
+            	app.popScreen(scr);
+            	app.requestForeground();
+            }
+        });
+	}
+	
+	public void closeBluetoothScreenSilent() {
+		RhodesApplication app = (RhodesApplication)UiApplication.getUiApplication();
+		final BluetoothScreen scr = mScreen;
+		mScreen = null;
+		if (scr != null) {
+			app.invokeLater(new Runnable() 
+	        {
+	            public void run() 
+	            {
+					if (scr != null) {
+						scr.closeSilent();
+					}
+	            }
+	        });
+		}
+	}
+	
+	// BluetoothScreenCallback
+	public void onBluetoothScreenCancel() {
+		rhoLogInfo("onBluetoothScreenCancel()");
+		if (mPort != null) {
+			mPort.disconnect();
+			mPort = null;
+		}
+		fireCreateSessionCallback(BT_CANCEL, "");
+		mScreen = null;
+	}
+	
+	// BluetoothScreenCallback
+	public void onBluetoothScreenSelect(int index) {
+		rhoLogInfo("onBluetoothScreenSelect("+String.valueOf(index)+")");
+		UiApplication app = UiApplication.getUiApplication();
+		final int i = index;
+        app.invokeLater(new Runnable() 
+        {
+            public void run() 
+            {
+        		getInstance().mPort = new BluetoothPort(mDevices[i], getInstance());
+            }
+        });
+		mScreen = null;
+	}
+	
+	// BluetoothPortListener
+	public void onBluetoothPortDisconnect() {
+		fireSessionCallback(mPort.getConnectedDeviceName(), BT_SESSION_DISCONNECT);
+	}
+	
+	// BluetoothPortListener
+	public void onBluetoothPortError() {
+		fireSessionCallback(mPort.getConnectedDeviceName(), BT_ERROR);
+	}
+	
+	// BluetoothPortListener
+	public void onBluetoothPortDataReceived() {
+		fireSessionCallback(mPort.getConnectedDeviceName(), BT_SESSION_INPUT_DATA_RECEIVED);
+	}
+	
+	// BluetoothPortListener
+	public void onBluetoothPortConnected(boolean success) {
+		if (success) {
+			fireCreateSessionCallback(BT_OK, mPort.getConnectedDeviceName());
+		}
+		else {
+			fireCreateSessionCallback(BT_ERROR, mPort.getConnectedDeviceName());
+		}
+		closeBluetoothScreenSilent();
+	}
+	
+	private void fireCreateSessionCallback(String status, String connected_device_name) {
+		String body = "&status=";
+		body += status;
+		body += "&connected_device_name=";
+		body += connected_device_name;
+		if (mCreateSessionCallback != null) {
+			rhoLogInfo("fire Create Session Callback status="+status+", connected_device_name="+connected_device_name);
+			fireRhodeCallback(mCreateSessionCallback, body);
+		}
+		else {
+			rhoLogError("fire Create Session Callback ERROR - Create Session callback not defined");
+		}
+	}
+
+	private void fireSessionCallback(String connected_device_name, String event_type) {
+		String body = "&connected_device_name=";
+		body += connected_device_name;
+		body += "&event_type=";
+		body += event_type;
+		if (mSessionCallback != null) {
+			rhoLogInfo("fire Session Callback connected_device_name="+connected_device_name+", event="+event_type);
+			fireRhodeCallback(mSessionCallback, body);
+		}
+		else {
+			rhoLogError("fire Session Callback ERROR - Session callback not defined");
+		}
+	}
+	
+	private void fireRhodeCallback(String callback_url, String body) {
+		RhodesApplication app = (RhodesApplication)UiApplication.getUiApplication();
+		HttpHeaders headers = new HttpHeaders();
+		headers.addProperty("Content-Type", "application/x-www-form-urlencoded");
+		app.postUrl(callback_url, body, headers);
+	}
+	
+	
+	public static int is_bluetooth_available() {
+		return BluetoothSerialPort.isSupported()?1:0;
+	}
+	
+	public static void off_bluetooth() {
+		rhoLogInfo("off_bluetooth()");
+		getInstance().freeAll();
+		ourBluetoothManager = null;
+	}
+	
+	public static void set_device_name(String device_name) {
+		getInstance().mLocalDeviceName = device_name;
+	}
+	
+	public static String get_device_name() {
+		return getInstance().mLocalDeviceName;
+	}
+	public static String get_last_error() {
+		return BT_OK;
+	}
+	
+	public static String create_session(String role, String callback_url) {
+		rhoLogInfo("create_session("+role+", "+callback_url+")");
+		getInstance().mCreateSessionCallback = callback_url;
+		if (BT_ROLE_CLIENT.equals(role)) {
+			// client
+			if (is_bluetooth_available() != 0) {
+				getInstance().mDevices = BluetoothSerialPort.getSerialPortInfo();
+				int count = getInstance().mDevices.length;
+				String devices[] = new String[count];
+				int i;
+				for (i = 0; i < count; i++) {
+					devices[i] = getInstance().mDevices[i].getDeviceName(); 
+				}
+				getInstance().mScreen = new BluetoothScreen(BluetoothScreen.BLUETOOTH_SCREEN_TYPE_CLIENT, devices, getInstance());
+			}
+			else {
+				getInstance().mScreen = new BluetoothScreen(BluetoothScreen.BLUETOOTH_SCREEN_TYPE_UNSUPPORTED, null, getInstance());
+			}
+			rhoPushScreen(getInstance().mScreen);
+		}
+		else {
+			// server
+			if (is_bluetooth_available() != 0) {
+				getInstance().mPort = new BluetoothPort(null, getInstance());
+				getInstance().mScreen = new BluetoothScreen(BluetoothScreen.BLUETOOTH_SCREEN_TYPE_SERVER, null, getInstance());
+				rhoPushScreen(getInstance().mScreen);
+				getInstance().mPort.startListenThread();
+			}
+			else {
+				getInstance().mScreen = new BluetoothScreen(BluetoothScreen.BLUETOOTH_SCREEN_TYPE_UNSUPPORTED, null, getInstance());
+				rhoPushScreen(getInstance().mScreen);
+			}
+		}
+		return BT_OK;
+	}
+
+	public static void session_set_callback(String connected_device_name, String callback_url) {
+		rhoLogInfo("session_set_callback("+connected_device_name+", "+callback_url+")");
+		getInstance().mSessionCallback = callback_url;
+	}
+	
+	public static void session_disconnect(String connected_device_name) {
+		rhoLogInfo("session_disconnect("+connected_device_name+")");
+		if (getInstance().mPort != null) {
+			getInstance().mPort.disconnect();
+			getInstance().mPort = null;
+		}
+		else {
+			getInstance().fireSessionCallback("", BT_ERROR);
+		}
+	}
+	
+	public static int session_get_status(String connected_device_name) {
+		rhoLogInfo("session_get_status("+connected_device_name+")");
+		if (getInstance().mPort != null) {
+			int status = getInstance().mPort.getStatus();
+			rhoLogInfo("session_get_status() return = "+String.valueOf(status));
+			return status; 
+		}
+		else {
+			getInstance().fireSessionCallback("", BT_ERROR);
+		}
+		return 0;
+	}
+	
+	public static String session_read_string(String connected_device_name) {
+		rhoLogInfo("session_read_string("+connected_device_name+")");
+		if (getInstance().mPort != null) {
+			byte[] data = getInstance().mPort.readData(); 
+			String str = new String(data,0,data.length);
+			rhoLogInfo("session_read_string() return = ["+str+"]");
+			return str;
+		}
+		else {
+			getInstance().fireSessionCallback("", BT_ERROR);
+		}
+		return "";
+	}
+	
+	public static void session_write_string(String connected_device_name, String str) {
+		rhoLogInfo("session_write_string("+connected_device_name+", "+str+")");
+		if (getInstance().mPort != null) {
+			byte[] data = str.getBytes();
+			getInstance().mPort.writeData(data);
+		}
+		else {
+			getInstance().fireSessionCallback("", BT_ERROR);
+		}
+	}
+	
+	public static byte[] session_read_data(String connected_device_name) {
+		rhoLogInfo("session_read_data()");
+		if (getInstance().mPort != null) {
+			return getInstance().mPort.readData();
+		}
+		else {
+			getInstance().fireSessionCallback("", BT_ERROR);
+		}
+		byte[] m = new byte[0];
+		return m;
+	}
+	
+	public static void session_write_data(String connected_device_name, byte[] data) {
+		rhoLogInfo("session_write_data()");
+		if (getInstance().mPort != null) {
+			getInstance().mPort.writeData(data);
+		}
+		else {
+			getInstance().fireSessionCallback("", BT_ERROR);
+		}
+	}
+		
+	
+	public static void initMethods(RubyClass klass) {
+		
+		klass.getSingletonClass().defineMethod("is_bluetooth_available", new RubyNoArgMethod() {
+			protected RubyValue run(RubyValue receiver, RubyBlock block) {
+				RubyValue res = RubyConstant.QFALSE;
+				if (is_bluetooth_available() != 0) {
+					res = RubyConstant.QTRUE;
+				}
+				return res;
+			}
+		});
+		klass.getSingletonClass().defineMethod("off_bluetooth", new RubyNoArgMethod() {
+			protected RubyValue run(RubyValue receiver, RubyBlock block) {
+				off_bluetooth();
+				return RubyConstant.QNIL;
+			}
+		});
+		
+		klass.getSingletonClass().defineMethod("set_device_name", new RubyOneArgMethod() {
+			protected RubyValue run(RubyValue receiver, RubyValue arg0, RubyBlock block) {
+				if ( arg0 instanceof RubyString )
+				{
+					String device_name = arg0.toString();
+					set_device_name(device_name);
+				}
+				else {
+					  throw new RubyException(RubyRuntime.ArgumentErrorClass, "in RhoBluetooth.set_device_name: wrong argument type.Should be String");
+				}
+				return RubyConstant.QNIL;
+			}
+		});
+		klass.getSingletonClass().defineMethod("get_device_name", new RubyNoArgMethod() {
+			protected RubyValue run(RubyValue receiver, RubyBlock block) {
+				return ObjectFactory.createString(get_device_name());
+			}
+		});
+		klass.getSingletonClass().defineMethod("get_last_error", new RubyNoArgMethod() {
+			protected RubyValue run(RubyValue receiver, RubyBlock block) {
+				return ObjectFactory.createString(get_last_error());
+			}
+		});
+		klass.getSingletonClass().defineMethod("create_session", new RubyTwoArgMethod() {
+			protected RubyValue run(RubyValue receiver, RubyValue arg1, RubyValue arg2, RubyBlock block) {
+				if ( (arg1 instanceof RubyString) && (arg2 instanceof RubyString) )
+				{
+					String role = arg1.toString();
+					String callback_url = arg2.toString();
+					return ObjectFactory.createString(create_session(role, callback_url));
+				}
+				else {
+					  throw new RubyException(RubyRuntime.ArgumentErrorClass, "in RhoBluetooth.create_session: wrong argument type.Should be String");
+				}
+			}
+		});		
+		
+		klass.getSingletonClass().defineMethod("session_set_callback", new RubyTwoArgMethod() {
+			protected RubyValue run(RubyValue receiver, RubyValue arg1, RubyValue arg2, RubyBlock block) {
+				if ( (arg1 instanceof RubyString) && (arg2 instanceof RubyString) )
+				{
+					String connected_device_name = arg1.toString();
+					String callback_url = arg2.toString();
+					session_set_callback(connected_device_name, callback_url);
+				}
+				else {
+					  throw new RubyException(RubyRuntime.ArgumentErrorClass, "in RhoBluetooth.session_set_callback: wrong argument type.Should be String");
+				}
+				return RubyConstant.QNIL;
+			}
+		});		
+		klass.getSingletonClass().defineMethod("session_disconnect", new RubyOneArgMethod() {
+			protected RubyValue run(RubyValue receiver, RubyValue arg0, RubyBlock block) {
+				if ( arg0 instanceof RubyString )
+				{
+					String connected_device_name = arg0.toString();
+					session_disconnect(connected_device_name);
+				}
+				else {
+					  throw new RubyException(RubyRuntime.ArgumentErrorClass, "in RhoBluetooth.session_disconnect: wrong argument type.Should be String");
+				}
+				return RubyConstant.QNIL;
+			}
+		});
+		klass.getSingletonClass().defineMethod("session_get_status", new RubyOneArgMethod() {
+			protected RubyValue run(RubyValue receiver, RubyValue arg0, RubyBlock block) {
+				if ( arg0 instanceof RubyString )
+				{
+					String connected_device_name = arg0.toString();
+					int status = session_get_status(connected_device_name);
+					return ObjectFactory.createInteger(status);
+				}
+				else {
+					  throw new RubyException(RubyRuntime.ArgumentErrorClass, "in RhoBluetooth.session_get_status: wrong argument type.Should be String");
+				}
+			}
+		});
+		klass.getSingletonClass().defineMethod("session_read_string", new RubyOneArgMethod() {
+			protected RubyValue run(RubyValue receiver, RubyValue arg0, RubyBlock block) {
+				if ( arg0 instanceof RubyString )
+				{
+					String connected_device_name = arg0.toString();
+					String str = session_read_string(connected_device_name);
+					return ObjectFactory.createString(str);
+				}
+				else {
+					  throw new RubyException(RubyRuntime.ArgumentErrorClass, "in RhoBluetooth.session_read_string: wrong argument type.Should be String");
+				}
+			}
+		});
+		klass.getSingletonClass().defineMethod("session_write_string", new RubyTwoArgMethod() {
+			protected RubyValue run(RubyValue receiver, RubyValue arg1, RubyValue arg2, RubyBlock block) {
+				if ( (arg1 instanceof RubyString) && (arg2 instanceof RubyString) )
+				{
+					String connected_device_name = arg1.toString();
+					String str = arg2.toString();
+					session_write_string(connected_device_name, str);
+				}
+				else {
+					  throw new RubyException(RubyRuntime.ArgumentErrorClass, "in RhoBluetooth.session_write_string: wrong argument type.Should be String");
+				}
+				return RubyConstant.QNIL;
+			}
+		});		
+		klass.getSingletonClass().defineMethod("session_read_data", new RubyOneArgMethod() {
+			protected RubyValue run(RubyValue receiver, RubyValue arg0, RubyBlock block) {
+				if ( arg0 instanceof RubyString )
+				{
+					String connected_device_name = arg0.toString();
+					byte[] data = session_read_data(connected_device_name);
+					RubyArray ruby_ar = ObjectFactory.createArray(data.length, data.length, false);
+					int i;
+					for (i = 0; i < data.length; i++) {
+						ruby_ar.and(ObjectFactory.createFixnum(data[i]));
+					}
+					return ruby_ar;
+				}
+				else {
+					  throw new RubyException(RubyRuntime.ArgumentErrorClass, "in session_read_data: wrong argument type.Should be String");
+				}
+			}
+		});
+		klass.getSingletonClass().defineMethod("session_write_data", new RubyTwoArgMethod() {
+			protected RubyValue run(RubyValue receiver, RubyValue arg1, RubyValue arg2, RubyBlock block) {
+				if ( (arg1 instanceof RubyString) && (arg2 instanceof RubyArray) )
+				{
+					String connected_device_name = arg1.toString();
+					RubyArray ruby_ar = (RubyArray)arg2;
+					int i;
+					byte[] data = new byte[ruby_ar.size()];
+					for (i = 0; i < ruby_ar.size(); i++) {
+						RubyValue num = ruby_ar.get(i);
+						int b = 0;
+						if (num instanceof RubyFixnum) {
+							RubyFixnum rv = (RubyFixnum)num;
+							b = rv.toInt();
+						}
+						else {
+							if (num instanceof RubyInteger) {
+								RubyInteger rv = (RubyInteger)num;
+								b = rv.toInt();
+							}
+							else {
+								if (num instanceof RubySymbol) {
+									RubySymbol rv = (RubySymbol)num;
+									b = rv.toInt();
+								}
+								else {
+									  throw new RubyException(RubyRuntime.ArgumentErrorClass, "in RhoBluetooth.session_write_data: wrong argument type.Should be Array of Fixnums or Integers");
+								}
+							}
+						}
+    					data[i] = (byte)b;  
+					}
+					session_write_data(connected_device_name, data);	
+				}
+				else {
+					  throw new RubyException(RubyRuntime.ArgumentErrorClass, "in RhoBluetooth.session_write_data: wrong argument type.Should be String second should be Array");
+				}
+				return RubyConstant.QNIL;
+			}
+		});		
+	}
+}