rhodes 2.1.0 → 2.2.0.beta.1

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

@@ -0,0 +1,66 @@
+package com.rhomobile.rhodes.bluetooth;
+
+import com.rhomobile.rhodes.util.PerformOnUiThread;
+
+import android.bluetooth.BluetoothDevice;
+import android.content.Intent;
+import android.util.Log;
+
+public interface IRhoBluetoothManager {
+	
+	// access from Native
+	
+	public int is_bluetooth_available();
+	
+	public void off_bluetooth();
+	
+	public void set_device_name(String device_name);
+
+	public String get_device_name();
+	
+	public String get_last_error();
+	
+	public String create_session(String role, String callback_url);
+	
+	public void session_set_callback(String connected_device_name, String callback_url);
+	
+	public void session_disconnect(String connected_device_name);
+	
+	public int session_get_status(String connected_device_name);
+
+	public String session_read_string(String connected_device_name);
+
+	public void session_write_string(String connected_device_name, String str);
+	
+	public int session_read_data(String connected_device_name, Byte[] buf, int max_length);
+
+	public void session_write_data(String connected_device_name, Byte[] buf, int length);
+	
+	// access from DeviceListActivity
+	   
+    public void onDeviceListActivityFinished( boolean is_ok, String adress);
+    
+    // access from Session
+    
+    public void onSessionConnectedOK();
+    
+    public void onSessionDisconnected();
+
+    public void onSessionReadMessage(byte[] buf, int bytes);
+    
+    public void onSessionConnectedDeviceName(String name);
+    
+    public void onSessionToast(String message);
+    
+    
+    // access from Manager
+    
+    public void init() ;
+    
+    public void onActivityResultPrivate(int requestCode, int resultCode, Intent data);
+
+    public RhoBluetoothSession getSession();
+    
+    public void setDeviceName(String device_name);
+    
+}

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

@@ -0,0 +1,201 @@
+package com.rhomobile.rhodes.bluetooth;
+
+import java.util.Set;
+
+import com.rhomobile.rhodes.AndroidR;
+
+import android.app.Activity;
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothDevice;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.os.Bundle;
+import android.util.Log;
+import android.view.View;
+import android.view.Window;
+import android.view.View.OnClickListener;
+import android.widget.AdapterView;
+import android.widget.ArrayAdapter;
+import android.widget.Button;
+import android.widget.ListView;
+import android.widget.TextView;
+import android.widget.AdapterView.OnItemClickListener;
+
+/**
+ * This Activity appears as a dialog. It lists any paired devices and
+ * devices detected in the area after discovery. When a device is chosen
+ * by the user, the MAC address of the device is sent back to the parent
+ * Activity in the result Intent.
+ */
+public class RhoBluetoothDeviceListActivity extends Activity {
+    // Debugging
+    private static final String TAG = "RhoBluetoothDeviceListActivity";
+    private static final boolean D = true;
+
+    // Return Intent extra
+    public static String EXTRA_DEVICE_ADDRESS = "device_address";
+
+    // Member fields
+    private BluetoothAdapter mBtAdapter;
+    private ArrayAdapter<String> mPairedDevicesArrayAdapter;
+    private ArrayAdapter<String> mNewDevicesArrayAdapter;
+
+    private String mReturnAdress = null;
+    
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        // Setup the window
+        requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);
+        setContentView(AndroidR.layout.bt_device_list);
+
+        // Set result CANCELED incase the user backs out
+        //setResult(Activity.RESULT_CANCELED);
+        mReturnAdress = null;
+        //RhoBluetoothManager.sharedInstance().onDeviceListActivityFinished(false, "");
+
+        // Initialize the button to perform device discovery
+        Button scanButton = (Button) findViewById(AndroidR.id.button_scan);
+        scanButton.setOnClickListener(new OnClickListener() {
+            public void onClick(View v) {
+                doDiscovery();
+                v.setVisibility(View.GONE);
+            }
+        });
+
+        // Initialize array adapters. One for already paired devices and
+        // one for newly discovered devices
+        mPairedDevicesArrayAdapter = new ArrayAdapter<String>(this, AndroidR.layout.bt_device_name);
+        mNewDevicesArrayAdapter = new ArrayAdapter<String>(this, AndroidR.layout.bt_device_name);
+
+        // Find and set up the ListView for paired devices
+        ListView pairedListView = (ListView) findViewById(AndroidR.id.paired_devices);
+        pairedListView.setAdapter(mPairedDevicesArrayAdapter);
+        pairedListView.setOnItemClickListener(mDeviceClickListener);
+
+        // Find and set up the ListView for newly discovered devices
+        ListView newDevicesListView = (ListView) findViewById(AndroidR.id.new_devices);
+        newDevicesListView.setAdapter(mNewDevicesArrayAdapter);
+        newDevicesListView.setOnItemClickListener(mDeviceClickListener);
+
+        // Register for broadcasts when a device is discovered
+        IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND);
+        this.registerReceiver(mReceiver, filter);
+
+        // Register for broadcasts when discovery has finished
+        filter = new IntentFilter(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
+        this.registerReceiver(mReceiver, filter);
+
+        // Get the local Bluetooth adapter
+        mBtAdapter = BluetoothAdapter.getDefaultAdapter();
+
+        // Get a set of currently paired devices
+        Set<BluetoothDevice> pairedDevices = mBtAdapter.getBondedDevices();
+
+        // If there are paired devices, add each one to the ArrayAdapter
+        if (pairedDevices.size() > 0) {
+            findViewById(AndroidR.id.title_paired_devices).setVisibility(View.VISIBLE);
+            for (BluetoothDevice device : pairedDevices) {
+                mPairedDevicesArrayAdapter.add(device.getName() + "\n" + device.getAddress());
+            }
+        } else {
+            String noDevices = getResources().getText(AndroidR.string.none_paired).toString();
+            mPairedDevicesArrayAdapter.add(noDevices);
+        }
+    }
+
+    @Override
+    protected void onDestroy() {
+        super.onDestroy();
+
+        // Make sure we're not doing discovery anymore
+        if (mBtAdapter != null) {
+            mBtAdapter.cancelDiscovery();
+        }
+
+        // Unregister broadcast listeners
+        this.unregisterReceiver(mReceiver);
+        
+        if (mReturnAdress == null) {
+        	RhoBluetoothManager.sharedInstance().onDeviceListActivityFinished(false, "");
+        }
+        else {
+            RhoBluetoothManager.sharedInstance().onDeviceListActivityFinished(true, mReturnAdress);
+        }
+    }
+
+    /**
+     * Start device discover with the BluetoothAdapter
+     */
+    private void doDiscovery() {
+        if (D) Log.d(TAG, "doDiscovery()");
+
+        // Indicate scanning in the title
+        setProgressBarIndeterminateVisibility(true);
+        setTitle(AndroidR.string.scanning);
+
+        // Turn on sub-title for new devices
+        findViewById(AndroidR.id.title_new_devices).setVisibility(View.VISIBLE);
+
+        // If we're already discovering, stop it
+        if (mBtAdapter.isDiscovering()) {
+            mBtAdapter.cancelDiscovery();
+        }
+
+        // Request discover from BluetoothAdapter
+        mBtAdapter.startDiscovery();
+    }
+
+    // The on-click listener for all devices in the ListViews
+    private OnItemClickListener mDeviceClickListener = new OnItemClickListener() {
+        public void onItemClick(AdapterView<?> av, View v, int arg2, long arg3) {
+            // Cancel discovery because it's costly and we're about to connect
+            mBtAdapter.cancelDiscovery();
+
+            // Get the device MAC address, which is the last 17 chars in the View
+            String info = ((TextView) v).getText().toString();
+            String address = info.substring(info.length() - 17);
+
+            // Create the result Intent and include the MAC address
+            //Intent intent = new Intent();
+            //intent.putExtra(EXTRA_DEVICE_ADDRESS, address);
+            mReturnAdress = address;
+
+            // Set result and finish this Activity
+            //setResult(Activity.RESULT_OK, intent);
+            //RhoBluetoothManager.sharedInstance().onDeviceListActivityFinished(true, address);
+            finish();
+        }
+    };
+
+    // The BroadcastReceiver that listens for discovered devices and
+    // changes the title when discovery is finished
+    private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            String action = intent.getAction();
+
+            // When discovery finds a device
+            if (BluetoothDevice.ACTION_FOUND.equals(action)) {
+                // Get the BluetoothDevice object from the Intent
+                BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
+                // If it's already paired, skip it, because it's been listed already
+                if (device.getBondState() != BluetoothDevice.BOND_BONDED) {
+                    mNewDevicesArrayAdapter.add(device.getName() + "\n" + device.getAddress());
+                }
+            // When discovery is finished, change the Activity title
+            } else if (BluetoothAdapter.ACTION_DISCOVERY_FINISHED.equals(action)) {
+                setProgressBarIndeterminateVisibility(false);
+                setTitle(AndroidR.string.select_device);
+                if (mNewDevicesArrayAdapter.getCount() == 0) {
+                    String noDevices = getResources().getText(AndroidR.string.none_found).toString();
+                    mNewDevicesArrayAdapter.add(noDevices);
+                }
+            }
+        }
+    };
+
+}

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

@@ -0,0 +1,139 @@
+package com.rhomobile.rhodes.bluetooth;
+
+import java.security.BasicPermission;
+import java.security.Permission;
+
+import android.app.Activity;
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothDevice;
+import android.content.Intent;
+import android.content.pm.FeatureInfo;
+import android.content.pm.PackageManager;
+import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.Message;
+import android.util.Log;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.ArrayAdapter;
+import android.widget.Button;
+import android.widget.EditText;
+import android.widget.ListView;
+import android.widget.TextView;
+import android.widget.Toast;
+import com.rhomobile.rhodes.RhodesService;
+import com.rhomobile.rhodes.phonebook.ContactAccessor;
+import com.rhomobile.rhodes.util.PerformOnUiThread;
+
+
+public class RhoBluetoothManager {
+
+	public static String BTC_OK = "OK";
+	public static String BTC_CANCEL = "CANCEL";
+	public static String BTC_ERROR = "ERROR";
+
+	public static String BT_ROLE_SERVER = "ROLE_SERVER";
+	public static String BT_ROLE_CLIENT = "ROLE_CLIENT";
+	
+    private static final String TAG = "RhoBluetoothManager";
+    private static final boolean D = true;
+	
+
+	// public only for external debug !!!
+	public static IRhoBluetoothManager ourInstance = null;
+	
+	public RhoBluetoothManager () {
+		if(D) Log.d(TAG, "RhoBluetoothManager()");
+	}
+	
+    public static void onActivityResult(int requestCode, int resultCode, Intent data) {
+		if (ourInstance != null) {
+			ourInstance.onActivityResultPrivate(requestCode, resultCode, data);
+		}
+	}
+	   
+	   
+	   
+	public static IRhoBluetoothManager sharedInstance() {
+		if (ourInstance == null) {
+			String className = "RhoBluetoothManagerNew";
+			int sdkVersion = Integer.parseInt(Build.VERSION.SDK);
+			if (sdkVersion < Build.VERSION_CODES.ECLAIR) {
+				if(D) Log.d(TAG, "sharedInstance - old version of System - NO Bluetooth !");
+				className = "RhoBluetoothManagerOld";
+			}
+			try {
+				String pkgname = RhoBluetoothManager.class.getPackage().getName();
+				String fullName = pkgname + "." + className;
+				Class<? extends IRhoBluetoothManager> klass =
+					Class.forName(fullName).asSubclass(IRhoBluetoothManager.class);
+				ourInstance = klass.newInstance();
+				ourInstance.init();
+			}
+			catch (Exception e) {
+				throw new IllegalStateException(e);
+			}
+		}
+		return ourInstance;
+	}
+
+	
+	public static int is_bluetooth_available() {
+		return sharedInstance().is_bluetooth_available();
+	}
+	
+	public static void off_bluetooth() {
+		sharedInstance().off_bluetooth();
+	}
+	
+	public static void set_device_name(String device_name) {
+		sharedInstance().set_device_name(device_name);
+	}
+
+	public static String get_device_name() {
+		return sharedInstance().get_device_name();
+	}
+	
+	public static String get_last_error() {
+		return sharedInstance().get_last_error();
+	}
+	
+	public static String create_session(String role, String callback_url) {
+		return sharedInstance().create_session(role, callback_url);
+	}
+	
+	public static void session_set_callback(String connected_device_name, String callback_url) {
+		sharedInstance().session_set_callback(connected_device_name, callback_url);
+	}
+	
+	// to native
+	public static native void onCallback(String callback_url, String body);
+
+	public static void session_disconnect(String connected_device_name) {
+		sharedInstance().session_disconnect(connected_device_name);
+	}
+	
+	public static int session_get_status(String connected_device_name) {
+		return sharedInstance().session_get_status(connected_device_name);
+	}
+
+	public static String session_read_string(String connected_device_name) {
+		return sharedInstance().session_read_string(connected_device_name);
+	}
+
+	public static void session_write_string(String connected_device_name, String str) {
+		sharedInstance().session_write_string(connected_device_name, str);
+	}
+	
+	public static int session_read_data(String connected_device_name, Byte[] buf, int max_length) {
+		return sharedInstance().session_read_data(connected_device_name, buf, max_length);
+	}
+
+	public static void session_write_data(String connected_device_name, Byte[] buf, int length) {
+		sharedInstance().session_write_data(connected_device_name, buf, length);
+	}
+
+
+
+}

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

@@ -0,0 +1,401 @@
+package com.rhomobile.rhodes.bluetooth;
+
+
+import java.security.BasicPermission;
+import java.security.Permission;
+
+import android.app.Activity;
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothDevice;
+import android.content.Intent;
+import android.content.pm.FeatureInfo;
+import android.content.pm.PackageManager;
+import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.Message;
+import android.util.Log;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.ArrayAdapter;
+import android.widget.Button;
+import android.widget.EditText;
+import android.widget.ListView;
+import android.widget.TextView;
+import android.widget.Toast;
+import com.rhomobile.rhodes.RhodesService;
+import com.rhomobile.rhodes.phonebook.ContactAccessor;
+import com.rhomobile.rhodes.util.PerformOnUiThread;
+
+public class RhoBluetoothManagerNew implements IRhoBluetoothManager {
+
+
+
+	private boolean mBluetoothIsEnabled = false;
+	
+    private static final String TAG = "RhoBluetoothManagerNew";
+    private static final boolean D = true;
+	
+	
+    // Key names received from the BluetoothChatService Handler
+    public static final String DEVICE_NAME = "DEVICE_NAME";
+    public static final String TOAST = "toast";
+
+    // Intent request codes
+    private static final int REQUEST_CONNECT_DEVICE = 958061;
+    private static final int REQUEST_ENABLE_BT = 958062;
+
+    // Name of the connected device
+    private String mDeviceName = null;
+    
+    private String mConnectedDeviceName = null;
+    StringBuffer mInput;
+ 	
+    // Local Bluetooth adapter
+    private BluetoothAdapter mBluetoothAdapter = null;
+
+    // Member object for the chat services
+    private RhoBluetoothSession mSession = null;
+    
+    private String mCreateSessionCallback;
+    
+    private String mRole;
+	
+	
+	private Activity mActivity;
+	
+	public RhoBluetoothManagerNew () {
+		if(D) Log.d(TAG, "RhoBluetoothManagerNew()");
+	}
+	
+	public void init() {
+		// constructor
+		mActivity = RhodesService.getInstance().getMainActivity();
+		mDeviceName = "NONAME";
+		
+		
+		mBluetoothIsEnabled = false;
+		// check feature
+		PackageManager pm = RhodesService.getInstance().getContext().getPackageManager();
+		FeatureInfo[] fs = pm.getSystemAvailableFeatures();
+		int i;
+		for (i = 0; i < fs.length; i++) {
+			if (fs[i] != null)
+				if (fs[i].name != null)
+					if (fs[i].name.equals(PackageManager.FEATURE_BLUETOOTH)) {
+						if(D) Log.d(TAG, "sharedInstance - found Bluetooth feature in device !");
+						mBluetoothIsEnabled = true;
+					}
+		}
+		// check permission
+		//if (pm.checkPermission(android.Manifest.permission.BLUETOOTH, RhodesService.getInstance().getMainActivity().getPackageName()) != PackageManager.PERMISSION_GRANTED) {
+		try {
+			BluetoothAdapter bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
+			if (bluetoothAdapter != null) {
+				if (!bluetoothAdapter.isEnabled()) {
+					if(D) Log.d(TAG, "sharedInstance - Bluetooth is not enabled !");
+					mBluetoothIsEnabled = false;
+				}
+			}
+			if(D) Log.d(TAG, "sharedInstance - Bluetooth permission is active !");
+		}
+		catch (SecurityException e) {
+			if(D) Log.d(TAG, "sharedInstance - Bluetooth permission is INACTIVE !");
+			mBluetoothIsEnabled = false;
+		}
+		
+		
+		mInput = new StringBuffer("");
+		
+		
+        // Get local Bluetooth adapter
+		if (mBluetoothIsEnabled) {
+			mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
+        
+        	if (mBluetoothAdapter != null) { 
+            	if (mBluetoothAdapter.isEnabled()) {
+            		if (mSession == null) {
+                		setupSession();
+                	}
+                	mDeviceName = mBluetoothAdapter.getName();
+            	}
+			}
+		}
+	}
+	
+	public void setDeviceName(String device_name) {
+		mDeviceName = device_name;
+        if (mBluetoothAdapter != null) {
+        	mBluetoothAdapter.setName(device_name);
+        }
+	}
+	
+    /**
+     * Sends a message.
+     * @param message  A string of text to send.
+     */
+    private void sendMessage(String message) {
+        if(D) Log.i(TAG, "sendMessage");
+        // Check that we're actually connected before trying anything
+        if (mSession.getState() != RhoBluetoothSession.STATE_CONNECTED) {
+            //Toast.makeText(this, R.string.not_connected, Toast.LENGTH_SHORT).show();
+            if(D) Log.i(TAG, "NOT CONNECTED");
+            return;
+        }
+
+        // Check that there's actually something to send
+        if (message.length() > 0) {
+            // Get the message bytes and tell the BluetoothChatService to write
+            byte[] send = message.getBytes();
+            mSession.write(send);
+
+         }
+    }
+	
+	
+   private void setupSession() {
+        Log.d(TAG, "setupSession()");
+
+        mSession = new RhoBluetoothSession(mActivity, null);
+        
+     }
+
+
+   public void onSessionConnectedOK() {
+       mInput.setLength(0);
+       PerformOnUiThread.exec( new Runnable() {
+			public void run() {
+				fireCreateSessionCallback(RhoBluetoothManager.BTC_OK, mConnectedDeviceName);
+			}
+	   },false);
+   }
+   
+   public void onSessionDisconnected() {
+	   PerformOnUiThread.exec( new Runnable() {
+			public void run() {
+				if (sharedInstance().getSession().getCallbackURL() == null) {
+					fireCreateSessionCallback(RhoBluetoothManager.BTC_ERROR, "");
+				}
+				else {
+					fireSessionCallback(mConnectedDeviceName, mSession.BT_SESSION_DISCONNECT);
+				}
+			}
+	   },false);
+   }
+
+   public void onSessionReadMessage(byte[] buf, int bytes) {
+	   final String message = new String(buf, 0, bytes);
+	   PerformOnUiThread.exec( new Runnable() {
+			public void run() {
+		       mInput.append(message);
+		       fireSessionCallback(mConnectedDeviceName, mSession.BT_SESSION_INPUT_DATA_RECEIVED);
+			}
+	   },false);
+   }
+   
+   public void onSessionConnectedDeviceName(String name) {
+	   mConnectedDeviceName = name;
+   }
+   
+   public void onSessionToast(String message) {
+	   if (D) Log.d(TAG, "TOAST: " + message);
+   }
+   
+ 
+    public void onDeviceListActivityFinished( boolean is_ok, String adress) {
+    	if (is_ok) {
+    		BluetoothDevice device = mBluetoothAdapter.getRemoteDevice(adress);
+    		// Attempt to connect to the device
+        	mSession.connect(device);
+    	}
+    }
+    
+    public void onActivityResultPrivate(int requestCode, int resultCode, Intent data) {
+        if(D) Log.d(TAG, "onActivityResult " + resultCode);
+        switch (requestCode) {
+        case REQUEST_CONNECT_DEVICE:
+            // When DeviceListActivity returns with a device to connect
+            if (resultCode == Activity.RESULT_OK) {
+                // Get the device MAC address
+                String address = data.getExtras()
+                                     .getString(RhoBluetoothDeviceListActivity.EXTRA_DEVICE_ADDRESS);
+                // Get the BLuetoothDevice object
+                BluetoothDevice device = mBluetoothAdapter.getRemoteDevice(address);
+                // Attempt to connect to the device
+                mSession.connect(device);
+            }
+            break;
+        case REQUEST_ENABLE_BT:
+            // When the request to enable Bluetooth returns
+            if (resultCode == Activity.RESULT_OK) {
+                // Bluetooth is now enabled, so set up a chat session
+                setupSession();
+            } else {
+                // User did not enable Bluetooth or an error occured
+                Log.d(TAG, "BT not enabled");
+                //Toast.makeText(this, R.string.bt_not_enabled_leaving, Toast.LENGTH_SHORT).show();
+                //finish();
+         	   PerformOnUiThread.exec( new Runnable() {
+         		   public void run() {
+     					fireCreateSessionCallback(RhoBluetoothManager.BTC_ERROR, "");
+         		   }
+         	   },false);
+            }
+        }
+    }
+    
+	   
+	   
+	public RhoBluetoothManagerNew sharedInstance() {
+		return (RhoBluetoothManagerNew)RhoBluetoothManager.sharedInstance();
+	}
+
+	public RhoBluetoothSession getSession() {
+		return mSession;
+	}
+	
+	
+	private void startClient() {
+		PerformOnUiThread.exec( new Runnable() {
+			public void run() {
+		    	if(D) Log.i(TAG, "startClient");
+		        Intent serverIntent = new Intent(mActivity, RhoBluetoothDeviceListActivity.class);
+		        //mActivity.startActivityForResult(serverIntent, REQUEST_CONNECT_DEVICE);
+		        RhodesService.getInstance().startActivity(serverIntent);
+			}
+		},false);
+	}
+	
+	private void startServer() {
+		PerformOnUiThread.exec( new Runnable() {
+			public void run() {
+		    	if(D) Log.i(TAG, "startServer");
+		        if (mBluetoothAdapter.getScanMode() !=
+		            BluetoothAdapter.SCAN_MODE_CONNECTABLE_DISCOVERABLE) {
+		            Intent discoverableIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
+		            discoverableIntent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 300);
+		            RhodesService.getInstance().startActivity(discoverableIntent);
+		        }
+			}
+		},false);
+	}
+	
+	public int is_bluetooth_available() {
+		if (!mBluetoothIsEnabled) return 0;
+		return 1;
+	}
+	
+	public void off_bluetooth() {
+		if (!mBluetoothIsEnabled) return;
+		//TODO
+		if (sharedInstance().getSession() != null) {
+			sharedInstance().getSession().stop();
+		}
+	}
+	
+	public void set_device_name(String device_name) {
+		if (!mBluetoothIsEnabled) return;
+    	if(D) Log.i(TAG, "set_device_name() : "+device_name);
+    	sharedInstance().setDeviceName(device_name);
+	}
+
+	public String get_device_name() {
+		if (!mBluetoothIsEnabled) return "bluetooth is not worked";
+    	if(D) Log.i(TAG, "get_device_name() : "+sharedInstance().mDeviceName);
+		return sharedInstance().mDeviceName;
+	}
+	
+	public String get_last_error() {
+		if (!mBluetoothIsEnabled) return RhoBluetoothManager.BTC_ERROR;
+		return RhoBluetoothManager.BTC_OK;
+	}
+	
+	public String create_session(String role, String callback_url) {
+		if (!mBluetoothIsEnabled) return RhoBluetoothManager.BTC_ERROR;
+    	if(D) Log.i(TAG, "create_session("+role+", "+callback_url+");");
+
+		sharedInstance().mCreateSessionCallback = callback_url;
+		sharedInstance().mRole = role;
+		if (role.equalsIgnoreCase(RhoBluetoothManager.BT_ROLE_SERVER)) {
+			sharedInstance().startServer();
+		}
+		else {
+			sharedInstance().startClient();
+		}
+		return RhoBluetoothManager.BTC_OK;
+	}
+	
+	public void fireCreateSessionCallback(String status, String connected_device_name) {
+    	if(D) Log.i(TAG, "fireCreateSessionCallback");
+		StringBuffer body = new StringBuffer();
+		body.append("&status=");
+		body.append(status);
+		body.append("&connected_device_name=");
+		body.append(connected_device_name);
+		if (mCreateSessionCallback != null) {
+			RhoBluetoothManager.onCallback(mCreateSessionCallback, body.toString());
+		}
+	}
+
+	
+	public void session_set_callback(String connected_device_name, String callback_url) {
+		if (!mBluetoothIsEnabled) return;
+		if(D) Log.i(TAG, "session_set_callback : "+callback_url);
+		sharedInstance().getSession().setCallbackURL(callback_url);
+	}
+	
+	public void fireSessionCallback(String connected_device_name, String event_type) {
+    	if(D) Log.i(TAG, "fireSessionCallback");
+		StringBuffer body = new StringBuffer();
+		body.append("&connected_device_name=");
+		body.append(connected_device_name);
+		body.append("&event_type=");
+		body.append(event_type);
+		if (mSession.getCallbackURL() != null) {
+			RhoBluetoothManager.onCallback(mSession.getCallbackURL(), body.toString());
+		}
+	}
+	
+
+	public void session_disconnect(String connected_device_name) {
+		if (!mBluetoothIsEnabled) return;
+		if(D) Log.i(TAG, "session_disconnect");
+		//TODO
+		if (sharedInstance().getSession() != null) {
+			sharedInstance().getSession().stop();
+		}
+	}
+	
+	public int session_get_status(String connected_device_name) {
+		if (!mBluetoothIsEnabled) return -1;
+		if(D) Log.i(TAG, "session_get_status");
+		//if (sharedInstance().mInputStringsArrayAdapter.isEmpty()) {
+		return sharedInstance().mInput.length();
+	}
+
+	public String session_read_string(String connected_device_name) {
+		if (!mBluetoothIsEnabled) return RhoBluetoothManager.BTC_ERROR;
+		if(D) Log.i(TAG, "session_read_string");
+    	String t = sharedInstance().mInput.toString();
+    	sharedInstance().mInput.setLength(0);
+		return t;
+	}
+
+	public void session_write_string(String connected_device_name, String str) {
+		if (!mBluetoothIsEnabled) return;
+		if(D) Log.i(TAG, "session_write_string");
+		sharedInstance().sendMessage(str);
+	}
+	
+	public int session_read_data(String connected_device_name, Byte[] buf, int max_length) {
+		if (!mBluetoothIsEnabled) return 0;
+		return 0;
+	}
+
+	public void session_write_data(String connected_device_name, Byte[] buf, int length) {
+		if (!mBluetoothIsEnabled) return;		
+	}
+
+
+
+}