android - दूरस्थ डिवाइस से कनेक्ट करते समय कठिनाइयां एक से अधिक प्रयास की आवश्यकता है



bluetooth android-bluetooth (1)

मैं एक ऐसी परियोजना के साथ काम कर रहा हूं जहां मुझे ब्लूटूथ टू यूएटीटी कनवर्टर (माइक्रोचिप द्वारा आरएन 42) के लिए अपने टैबलेट (एंड्रॉइड 4.2.2) से कनेक्ट करना होगा। मैं ब्लूटूथ कनेक्शन का प्रबंधन करने के लिए ब्लूटूथ उदाहरण का उपयोग कर रहा हूं, लेकिन इसकी कनेक्ट करने में मुश्किल है कभी-कभी प्रोग्राम विधि में विफल रहता है mmSocket.connect (); - यह IOException फेंकता है कभी-कभी मुझे अपने रिमोट डिवाइस से कनेक्ट करने के लिए तीन या अधिक प्रयास की आवश्यकता होती है I कनेक्शन के बाद, यह बहुत स्थिर है। मैंने यूयूआईडी बदलने की कोशिश की, आरएन 42 मॉड्यूल को बदलने की कोशिश की (मैंने भी एचसी -55 मॉड्यूल का उपयोग करने की कोशिश की) मैंने सुरक्षित और असुरक्षित आरएफसीएम कनेक्शन की कोशिश की, अभी भी कोई भाग्य नहीं है यहां मेरा कोड है: मुख्य गतिविधि में:

  @Override
public void onButtonPressed(View view, Device device){
    switch (view.getId()){
    case R.id.buttonRedaguotiIrengini:
        // Edit button is pressed
        Intent i = new Intent(this, DeviceActivity.class);
        i.putExtra("device", device);
        i.putExtra("requestCode", REQUEST_EDIT_DEVICE);
        startActivityForResult(i, REQUEST_EDIT_DEVICE);
        break;
    case R.id.buttonPrisijungti:
        if (mBtService.getState()==BluetoothService.STATE_CONNECTED){
            mBtService.stop();
        } else {
            BluetoothDevice btDevice = mBluetoothAdapter.getRemoteDevice(device.getMac());
            mBtService.connect(btDevice, false);
        }
        break;
    }
}

ब्लूटूथ सेवा वर्ग में:

   // Name for the SDP record when creating server socket
private static final String NAME_SECURE = "BluetoothChatSecure";
private static final String NAME_INSECURE = "BluetoothChatInsecure";

// Unique UUID for this application
private static final UUID MY_UUID_SECURE =UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");
private static final UUID MY_UUID_INSECURE = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");


// Member fields
private final BluetoothAdapter mAdapter;
private final Handler mHandler;
private AcceptThread mSecureAcceptThread;
private AcceptThread mInsecureAcceptThread;
private ConnectThread mConnectThread;
private ConnectedThread mConnectedThread;
private int mState;

// Constants that indicate the current connection state
public static final int STATE_NONE = 0;       // we're doing nothing
public static final int STATE_LISTEN = 1;     // now listening for incoming connections
public static final int STATE_CONNECTING = 2; // now initiating an outgoing connection
public static final int STATE_CONNECTED = 3;  // now connected to a remote device

   public synchronized void connect(BluetoothDevice device, boolean secure) {
    if (D) Log.d(TAG, "connect to: " + device);

    // Cancel any thread attempting to make a connection
    if (mState == STATE_CONNECTING) {
        if (mConnectThread != null) {mConnectThread.cancel(); mConnectThread = null;}
    }

    // Cancel any thread currently running a connection
    if (mConnectedThread != null) {mConnectedThread.cancel(); mConnectedThread = null;}

    // Start the thread to connect with the given device
    mConnectThread = new ConnectThread(device, secure);
    mConnectThread.start();
    setState(STATE_CONNECTING);
}

   private class ConnectThread extends Thread {
    private final BluetoothSocket mmSocket;
    private final BluetoothDevice mmDevice;
    private String mSocketType;

    public ConnectThread(BluetoothDevice device, boolean secure) {
        mmDevice = device;
        BluetoothSocket tmp = null;
        mSocketType = secure ? "Secure" : "Insecure";

        // Get a BluetoothSocket for a connection with the
        // given BluetoothDevice
        try {
            if (secure) {
                tmp = device.createRfcommSocketToServiceRecord(
                        MY_UUID_SECURE);
            } else {
                tmp = device.createInsecureRfcommSocketToServiceRecord(
                        MY_UUID_INSECURE);
            }
        } catch (IOException e) {
            Log.e(TAG, "Socket Type: " + mSocketType + "create() failed", e);
        }
        mmSocket = tmp;
    }

    public void run() {
        Log.i(TAG, "BEGIN mConnectThread SocketType:" + mSocketType);
        setName("ConnectThread" + mSocketType);

        // Always cancel discovery because it will slow down a connection
        mAdapter.cancelDiscovery();

        // Make a connection to the BluetoothSocket
        try {
            // This is a blocking call and will only return on a
            // successful connection or an exception
            if (D) {Log.d(TAG,  "will try to connect to socket");};
            mmSocket.connect();
        } catch (IOException e) {
            // Close the socket
            if (D) {Log.d(TAG, "failed to connect to socket");};
            e.printStackTrace();
            try {
                mmSocket.close();
            } catch (IOException e2) {
                Log.e(TAG, "unable to close() " + mSocketType +
                        " socket during connection failure", e2);
            }
            connectionFailed();
            return;
        }
        if (D){Log.d(TAG,  "Success");};
        // Reset the ConnectThread because we're done
        synchronized (BluetoothService.this) {
            mConnectThread = null;
        }

        // Start the connected thread
        connected(mmSocket, mmDevice, mSocketType);
    }

    public void cancel() {
        try {
            mmSocket.close();
        } catch (IOException e) {
            Log.e(TAG, "close() of connect " + mSocketType + " socket failed", e);
        }
    }
}

    private void connectionFailed() {
    // Send a failure message back to the Activity
    Message msg = mHandler.obtainMessage(MainActivity.MESSAGE_TOAST);
    Bundle bundle = new Bundle();
    bundle.putString(MainActivity.TOAST, "Unable to connect device");
    msg.setData(bundle);
    mHandler.sendMessage(msg);
    if (D){Log.d(TAG,  "Failed, unable to connect device");};
    setState(STATE_NONE);
}

यहां लॉगकैट आउटपुट दिए गए हैं

  03-12 16:01:38.992: D/mBT(9947): connect to: 00:06:66:67:44:3E
  03-12 16:01:38.992: I/BluetoothSocket_MTK(9947): [JSR82] Bluetooth Socket Constructor
  03-12 16:01:38.992: I/BluetoothSocket_MTK(9947): [JSR82] type=1 fd=-1 auth=false encrypt=false port=-1
  03-12 16:01:38.993: D/BTSocketService(452): [JSR82][Service] initSocket
  03-12 16:01:38.993: I/BluetoothSocketService.cpp(452): [JSR82][JNI] initSocketNative +++.
  03-12 16:01:38.993: I/BluetoothSocketService.cpp(452): [JSR82][JNI] initSocketNative: start to initialize socket.
  03-12 16:01:38.993: I/BluetoothSocketService.cpp(452): [JSR82][JNI] type=1, auth=0, encrypt=0, port=-1
  03-12 16:01:38.993: I/BluetoothSocketService.cpp(452): [JSR82][JNI] initSocketNative: Initialize socket done.
  03-12 16:01:38.993: E/BluetoothSocketService.cpp(452): [JSR82] alloc context : index=2
  03-12 16:01:38.993: E/BluetoothSocketService.cpp(452): [JSR82] Clear context : index=2, ctx.index=0, ctx.fd=0
  03-12 16:01:38.993: I/BluetoothSocketService.cpp(452): [JSR82][JNI] jsr82ConnectCond (2) initialization success 
  03-12 16:01:38.993: I/BluetoothSocketService.cpp(452): [JSR82][JNI] jsr82ReadCond (2) initialization success <READ> 
  03-12 16:01:38.993: I/BluetoothSocketService.cpp(452): [JSR82][JNI] jsr82WriteCond (2) initialization success <WRITE> 
  03-12 16:01:38.993: I/BluetoothSocketService.cpp(452): [JSR82][JNI] jsr82RegisterCond (2) initialization success <REGISTER> 
  03-12 16:01:38.993: I/BluetoothSocketService.cpp(452): [JSR82][JNI] initSocketNative ---. fdHandle=32770
  03-12 16:01:38.995: D/mBT(9947): setState() 1 -> 2
  03-12 16:01:38.998: I/mBT(9947): BEGIN mConnectThread SocketType:Insecure
  03-12 16:01:39.001: D/BluetoothService(452): [API] cancelDiscovery()
  03-12 16:01:39.001: I/BluetoothService.cpp(452): [GAP][API] stopDiscoveryNative
  03-12 16:01:39.001: I/BluetoothService.cpp(452): [GAP] btmtk_gap_discovery_cancel
  03-12 16:01:39.001: I/BluetoothService.cpp(452): [GAP] btmtk_gap_discovery_cancel already cancelled
  03-12 16:01:39.001: I/BluetoothService.cpp(452): [GAP] btmtk_gap_send_discovery_stop_event
  03-12 16:01:39.001: I/BluetoothService.cpp(452): [JNI] bt_sendind(ptr=0x5C6AEA50, len=28)
  03-12 16:01:39.001: I/BluetoothService.cpp(452): [JNI] send ind=3528
  03-12 16:01:39.001: I/BluetoothEventLoop.cpp(452): [MSG] Polling returned
  03-12 16:01:39.001: I/BluetoothEventLoop.cpp(452): [MSG] Start retrieve data
  03-12 16:01:39.002: I/BluetoothEventLoop.cpp(452): [MSG] fd 1 data ready
  03-12 16:01:39.002: I/BluetoothEventLoop.cpp(452): [MSG] nat->pollData[i].fd data ready : revents = 0x1
  03-12 16:01:39.002: I/BluetoothEventLoop.cpp(452): [MSG] msg 3528 received : size=28
  03-12 16:01:39.002: I/BluetoothEventLoop.cpp(452): [GAP] receive event=3528
  03-12 16:01:39.002: I/BluetoothEventLoop.cpp(452): [GAP] btmtk_util_update_adapter_property_discovering: is_discovering = 0
  03-12 16:01:39.002: D/BluetoothEventLoop(452): Property Changed: Discovering : false
  03-12 16:01:39.006: I/BluetoothService.cpp(452): [JNI] send ind success : 28
  03-12 16:01:39.007: I/BluetoothEventLoop.cpp(452): [MSG] Start polling
  03-12 16:01:39.008: V/BluetoothEventManager(1562): Received android.bluetooth.adapter.action.DISCOVERY_FINISHED
  03-12 16:01:39.011: D/mBT(9947): will try to connect to socket
  03-12 16:01:39.011: I/BluetoothSocket_MTK(9947): [JSR82] connect: do SDP
  03-12 16:01:39.012: D/BluetoothService(452): [API] fetchRemoteUuids(00:06:66:67:44:3E)
  03-12 16:01:39.012: V/BluetoothAdapterProperties(452): getObjectPath():MTKBT/dev_
  03-12 16:01:39.012: I/BluetoothService.cpp(452): [GAP][API] discoverServicesNative : addr=MTKBT/dev_00_06_66_67_44_3E, pattern=00001101-0000-1000-8000-00805f9b34fb
  03-12 16:01:39.013: I/BluetoothService.cpp(452): [GAP] btmtk_gap_service_search_raw_request addr=67443E:66:6, size=19
  03-12 16:01:39.013: D/[BT](142): mtk_bt_write: buffer bebcbcc8, len 5
  03-12 16:01:39.013: I/BluetoothService.cpp(452): [GAP] btmtk_gap_send_sdp_discover_event
  03-12 16:01:39.013: I/BluetoothService.cpp(452): [JNI] bt_sendind(ptr=0x54B921A0, len=60)
  03-12 16:01:39.013: I/BluetoothService.cpp(452): [JNI] send ind=3535
  03-12 16:01:39.013: I/BluetoothService.cpp(452): [JNI] send ind success : 60
  03-12 16:01:39.013: I/BluetoothEventLoop.cpp(452): [MSG] Polling returned
  03-12 16:01:39.013: I/BluetoothEventLoop.cpp(452): [MSG] Start retrieve data
  03-12 16:01:39.013: I/BluetoothEventLoop.cpp(452): [MSG] fd 1 data ready
  03-12 16:01:39.014: I/BluetoothEventLoop.cpp(452): [MSG] nat->pollData[i].fd data ready : revents = 0x1
  03-12 16:01:39.014: I/BluetoothEventLoop.cpp(452): [MSG] msg 3535 received : size=60
  03-12 16:01:39.014: I/BluetoothEventLoop.cpp(452): [GAP] receive event=3535
  03-12 16:01:39.014: I/BluetoothEventLoop.cpp(452): [GAP] receive event ANDROID_EV_SDP_DEVICE_CREATE 0x67443E:0x66:0x6
  03-12 16:01:39.014: I/BluetoothEventLoop.cpp(452): [GAP] pattern (16)  0: 0:11: 1
  03-12 16:01:39.014: I/BluetoothEventLoop.cpp(452): [MSG] Start polling
  03-12 16:01:39.015: V/BluetoothDiscoveryReceiver(1562): Received: android.bluetooth.adapter.action.DISCOVERY_FINISHED
  03-12 16:01:39.018: D/[BT](142): mtk_bt_read: buffer 401c901c, len 1
  03-12 16:01:39.018: D/[BT](142): mtk_bt_read: buffer 401c9024, len 2
  03-12 16:01:39.018: D/[BT](142): mtk_bt_read: buffer 401980e6, len 4
  03-12 16:01:39.018: D/[BT](142): mtk_bt_read: buffer 401c901c, len 1
  03-12 16:01:39.019: D/[BT](142): mtk_bt_write: buffer bebcbcc8, len 5
  03-12 16:01:39.026: D/[BT](142): mtk_bt_read: buffer 401c901c, len 1
  03-12 16:01:39.026: D/[BT](142): mtk_bt_read: buffer 401c9024, len 2
  03-12 16:01:39.026: D/[BT](142): mtk_bt_read: buffer 401981e7, len 4
  03-12 16:01:39.026: D/[BT](142): mtk_bt_read: buffer 401c901c, len 1
  03-12 16:01:39.026: D/[BT](142): mtk_bt_write: buffer bebcbcc8, len 17
  03-12 16:01:39.032: D/[BT](142): mtk_bt_read: buffer 401c901c, len 1
  03-12 16:01:39.032: D/[BT](142): mtk_bt_read: buffer 401c9024, len 2
  03-12 16:01:39.032: D/[BT](142): mtk_bt_read: buffer 401982e8, len 4
  03-12 16:01:39.033: D/[BT](142): mtk_bt_read: buffer 401c901c, len 1
  03-12 16:01:40.017: D/[BT](142): mtk_bt_read: buffer 401c901c, len 1
  03-12 16:01:40.017: D/[BT](142): mtk_bt_read: buffer 401c9024, len 2
  03-12 16:01:40.017: D/[BT](142): mtk_bt_read: buffer 401983e9, len 4
  03-12 16:01:40.017: D/[BT](142): mtk_bt_read: buffer 401c901c, len 1
  03-12 16:01:44.775: D/Bluetooth HS/HF(692): [BT][HFG] [API] mStateReceiver.onReceive(android.intent.action.BATTERY_CHANGED)
  03-12 16:01:44.776: D/Bluetooth HS/HF(692): [BT][HFG] [API] mHandler.handleMessage(9)
  03-12 16:01:44.776: D/Bluetooth HS/HF(692): [BT][HFG] [API] updateBatteryState
  03-12 16:01:45.014: D/BluetoothService(452): [API] getUuidFromCache(00:06:66:67:44:3E)
  03-12 16:01:45.015: D/BluetoothService(452): [API] getUuidFromCache=00001101-0000-1000-8000-00805f9b34fb)
  03-12 16:01:45.016: D/BluetoothService(452): [API] getUuidFromCache=00001101-0000-1000-8000-00805f9b34fb)
  03-12 16:01:45.016: D/BluetoothService(452): [API] sendUuidIntent(00:06:66:67:44:3E)
  03-12 16:01:45.020: D/Bluetooth HSHFP(692): [BT][HFG][Intent] action=android.bluetooth.device.action.UUID, state=0
  03-12 16:01:45.022: D/BluetoothService(452): [API] makeServiceChannelCallbacks(00:06:66:67:44:3E)
  03-12 16:01:45.022: D/BluetoothService(452): Cleaning up failed UUID channel lookup: 00:06:66:67:44:3E 00001101-0000-1000-8000-00805f9b34fb
  03-12 16:01:45.022: I/BluetoothSocket_MTK(9947): [JSR82] SdpHelper::onRfcommChannelFound: channel=-1
  03-12 16:01:45.023: D/mBT(9947): failed to connect to socket
  03-12 16:01:45.023: W/System.err(9947): java.io.IOException: Service discovery failed
  03-12 16:01:45.024: W/System.err(9947):   at android.bluetooth.BluetoothSocket$SdpHelper.doSdp(BluetoothSocket.java:813)
  03-12 16:01:45.024: W/System.err(9947):   at android.bluetooth.BluetoothSocket.connect(BluetoothSocket.java:382)
  03-12 16:01:45.024: W/System.err(9947):   at p.demoui.BluetoothService$ConnectThread.run(BluetoothService.java:389)
  03-12 16:01:45.024: I/BluetoothSocket_MTK(9947): [JSR82] close
  03-12 16:01:45.024: I/BluetoothSocket_MTK(9947): [JSR82] readLock got.
  03-12 16:01:45.025: D/BTSocketService(452): [JSR82][Service] abort
  03-12 16:01:45.025: I/BluetoothSocketService.cpp(452): [JSR82][JNI] abortNative +++. fd=32770.
  03-12 16:01:45.025: I/BluetoothSocketService.cpp(452): [JSR82][JNI] abortNative ---.
  03-12 16:01:45.025: I/BluetoothSocket_MTK(9947): [JSR82] Start to aquire writeLock.
  03-12 16:01:45.026: I/BluetoothSocket_MTK(9947): [JSR82] writeLock got.
  03-12 16:01:45.026: D/BTSocketService(452): [JSR82][Service] destroy
  03-12 16:01:45.026: I/BluetoothSocketService.cpp(452): [JSR82][JNI] destroyNative: fd=32770.
  03-12 16:01:45.026: E/BluetoothSocketService.cpp(452): [JSR82] Clear context : index=2, ctx.index=-1, ctx.fd=32770
  03-12 16:01:45.030: D/mBT(9947): Failed, unable to connect device
  03-12 16:01:45.030: D/mBT(9947): setState() 2 -> 0

गलती कहाँ है? मैं इस कोड को कैसे सुधार सकता हूं? इस मामले में IOException क्यों फेंक दिया जाता है?

आपकी सहायता के लिए धन्यवाद.


यहां मैंने ऐसा ही ब्लूटूथ कनेक्शन किया है और कमांड भेजना है। मैं पूरा डेमो कोड पोस्ट कर रहा हूं कृपया इसे एक कोशिश दें

ब्लूटूथ सेवा। जावा (ब्लूटूथ के उदाहरण से समान वर्ग)
यहां पाया जा सकता है http://stanford.edu/~tpurtell/BluetoothChatService.java

मेरे मामले में MacID पहले से ही मुझे दिया गया था

MainActivity.java

    public class MainActivity extends Activity implements OnClickListener {


        // Layout Views
        private Button bt_on_off;
        private TextView statuses;
        private Button connectIt;

        private Button click;

        //Timer timer;
        private boolean isBTOnOrOff = false;

        // Debugging
        private static final String TAG = "BluetoothChat";
        private static final boolean D = true;

        // Message types sent from the BluetoothChatService Handler
        public static final int MESSAGE_STATE_CHANGE = 1;
        public static final int MESSAGE_READ = 2;
        public static final int MESSAGE_WRITE = 3;
        public static final int MESSAGE_DEVICE_NAME = 4;
        public static final int MESSAGE_TOAST = 5;

        // 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 = 1;
        private static final int REQUEST_ENABLE_BT = 2;

        // Name of the connected device
        private String mConnectedDeviceName = null;
        // Array adapter for the conversation thread
        //private ArrayAdapter<String> mConversationArrayAdapter;
        // String buffer for outgoing messages
        private StringBuffer mOutStringBuffer;
        // Local Bluetooth adapter
        private BluetoothAdapter mBluetoothAdapter = null;
        // Member object for the chat services
        private BluetoothService mChatService = null;

        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);

            initViews();
            enableDissableViews(false);
            listeners();

            preBTConfigCheck();
        }

        private void initViews() {

            bt_on_off = (Button) findViewById(R.id.bt_on_off);
            connectIt= (Button) findViewById(R.id.connect);
            statuses= (TextView) findViewById(R.id.statuses);

            click= (Button) findViewById(R.id.click);

        }

        private void listeners() {
            bt_on_off.setOnClickListener(this);
            connectIt.setOnClickListener(this);
            click.setOnClickListener(this);
        }

        // Broadcast reciever for BT
        private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                final String action = intent.getAction();

                if (action.equals(BluetoothAdapter.ACTION_STATE_CHANGED)) {
                    final int state = intent.getIntExtra(
                            BluetoothAdapter.EXTRA_STATE, BluetoothAdapter.ERROR);
                    switch (state) {
                    case BluetoothAdapter.STATE_OFF:
                        enableDissableViews(false);
                        isBTOnOrOff=false;
                        bt_on_off.setText(getResources().getString(
                                R.string.on_off_status)
                                + "OFF");
                        if (D)
                            Log.d(TAG, "STATE OFF");
                        break;
                    case BluetoothAdapter.STATE_TURNING_OFF:
                        enableDissableViews(false);
                        bt_on_off.setText(getResources().getString(
                                R.string.on_off_status)
                                + "Turning off...");
                        if (D)
                            Log.d(TAG, "STATE Turning off...");
                        break;
                    case BluetoothAdapter.STATE_ON:
                        bt_on_off.setText(getResources().getString(
                                R.string.on_off_status)
                                + "ON");
                        if (D)
                            Log.d(TAG, "STATE ON");
                        enableDissableViews(true);
                        isBTOnOrOff=true;
                        break;
                    case BluetoothAdapter.STATE_TURNING_ON:
                        bt_on_off.setText(getResources().getString(
                                R.string.on_off_status)
                                + "Turning on...");
                        if (D)
                            Log.d(TAG, "STATE Turning on...");
                        break;
                    }
                }
            }
        };

        private void preBTConfigCheck() {

            // Register for broadcasts on BluetoothAdapter state change
            IntentFilter filter = new IntentFilter(
                    BluetoothAdapter.ACTION_STATE_CHANGED);
            this.registerReceiver(mReceiver, filter);

            // Get local Bluetooth adapter
            mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();

              // If the adapter is null, then Bluetooth is not supported
            if (mBluetoothAdapter == null) {
                // Device does not support Bluetooth
                Toast.makeText(MainActivity.this,
                        "BlueTooth Not supported on your device!", 0).show();
                bt_on_off.setText(getResources().getString(R.string.on_off_status)
                        + "NOT SUPPORTED");
                enableDissableViews(false);
            } else {
                // status of BT
                isBTOnOrOff = mBluetoothAdapter.isEnabled();
                if (D)
                    Log.d(TAG, "BT status @ preBTConfigCheck() ->" + isBTOnOrOff);
                if (isBTOnOrOff) {
                    // Bluetooth is enable,
                    bt_on_off.setText(getResources().getString(
                            R.string.on_off_status)
                            + "ON");
                    enableDissableViews(isBTOnOrOff);
                } else {
                    bt_on_off.setText(getResources().getString(
                            R.string.on_off_status)
                            + "OFF");
                    // User did not enable Bluetooth or an error occurred
                    if (D)
                        Log.d(TAG, "BT not enabled");
                    enableDissableViews(isBTOnOrOff);
                }
            }
        }


         @Override
            public void onStart() {
                super.onStart();
                if(D) Log.e(TAG, "++ ON START ++");

                // If BT is not on, request that it be enabled.
                // setupChat() will then be called during onActivityResult
                if (!mBluetoothAdapter.isEnabled()) {
                    Intent enableIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
                    startActivityForResult(enableIntent, REQUEST_ENABLE_BT);
                // Otherwise, setup the chat session
                } else {
                    if (mChatService == null) setupCommand();
                }
            }
         @Override
            public synchronized void onResume() {
                super.onResume();
                if(D) Log.e(TAG, "+ ON RESUME +");

                // Performing this check in onResume() covers the case in which BT was
                // not enabled during onStart(), so we were paused to enable it...
                // onResume() will be called when ACTION_REQUEST_ENABLE activity returns.
                if (mChatService != null) {
                    // Only if the state is STATE_NONE, do we know that we haven't started already
                    if (mChatService.getState() == BluetoothService.STATE_NONE) {
                      // Start the Bluetooth chat services
                      mChatService.start();
                    }
                }
            }


         @Override
            public synchronized void onPause() {
                super.onPause();
                if(D) Log.e(TAG, "- ON PAUSE -");
            }

            @Override
            public void onStop() {
                super.onStop();
                if(D) Log.e(TAG, "-- ON STOP --");
            }

            @Override
            public void onDestroy() {
                super.onDestroy();
                // Stop the Bluetooth chat services
                if (mChatService != null) mChatService.stop();
                this.unregisterReceiver(mReceiver);
                if(D) Log.e(TAG, "--- ON DESTROY ---");
            }

         private void setupCommand() {
                Log.d(TAG, "setupChat()");

                // Initialize the BluetoothService to perform bluetooth connections
                mChatService = new BluetoothService(this, mHandler);

                // Initialize the buffer for outgoing messages
                mOutStringBuffer = new StringBuffer("");
            }
        private void resultMacId(String address) {


              // Performing this check in onResume() covers the case in which BT was
            // not enabled during onStart(), so we were paused to enable it...
            // onResume() will be called when ACTION_REQUEST_ENABLE activity returns.
            if (mChatService != null) {
                // Only if the state is STATE_NONE, do we know that we haven't started already
                if (mChatService.getState() == BluetoothService.STATE_NONE) {
                  // Start the Bluetooth chat services
                  mChatService.start();
                }
            }
            // Get the BLuetoothDevice object
            BluetoothDevice device = mBluetoothAdapter.getRemoteDevice(address);

            // Attempt to connect to the device
            mChatService.connect(device, false);
        }
          @Override
            public boolean onCreateOptionsMenu(Menu menu) {
                MenuInflater inflater = getMenuInflater();
                inflater.inflate(R.menu.main, menu);
                return true;
            }
         @Override
            public boolean onOptionsItemSelected(MenuItem item) 
            {
                switch (item.getItemId()) 
                {
                case R.id.action_settings:
                    // Launch the DeviceListActivity to see devices and do scan

                    return true;
                }
                return false;
            }
        // The Handler that gets information back from the BluetoothChatService
        private final Handler mHandler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                switch (msg.what) {
                case MESSAGE_STATE_CHANGE:
                    if(D) Log.i(TAG, "MESSAGE_STATE_CHANGE: " + msg.arg1);



                    switch (msg.arg1) {
                    case BluetoothService.STATE_CONNECTED:
                        statuses.setText("connected to :"+mConnectedDeviceName);
                       // mTitle.setText(R.string.title_connected_to);
                        //mTitle.append(mConnectedDeviceName);
                        //mConversationArrayAdapter.clear();

                        break;
                    case BluetoothService.STATE_CONNECTING:
                        statuses.setText("connecting ... ");

                       // mTitle.setText(R.string.title_connecting);

                        break;
                    case BluetoothService.STATE_LISTEN:
                    case BluetoothService.STATE_NONE:
                        statuses.setText("Not Connected");
                       // mTitle.setText(R.string.title_not_connected);
                        break;
                    }
                    break;
                case MESSAGE_WRITE:
                    byte[] writeBuf = (byte[]) msg.obj;
                    // construct a string from the buffer
                    String writeMessage = new String(writeBuf);
                    Log.d(TAG, "MESSAGE_WRITE++++++++"+writeMessage);
                    //mConversationArrayAdapter.add("Me:  " + writeMessage);
                    break;
                case MESSAGE_READ:
                    byte[] readBuf = (byte[]) msg.obj;
                    // construct a string from the valid bytes in the buffer
                    String readMessage = new String(readBuf, 0, msg.arg1);
                    Log.d(TAG, "MESSAGE_READ++++++++"+readMessage);

                   // mConversationArrayAdapter.add(mConnectedDeviceName+":  " + readMessage);
                    break;
                case MESSAGE_DEVICE_NAME:
                    // save the connected device's name
                    mConnectedDeviceName = msg.getData().getString(DEVICE_NAME);

                    statuses.setText("Connected to "+ mConnectedDeviceName);

                    Toast.makeText(getApplicationContext(), "Connected to "
                                   + mConnectedDeviceName, Toast.LENGTH_SHORT).show();
                    connectIt.setText("Connected to "+ mConnectedDeviceName);
                    connectIt.setEnabled(false);
                    break;
                case MESSAGE_TOAST:
                    statuses.setText(msg.getData().getString(TOAST));

                    Toast.makeText(getApplicationContext(), msg.getData().getString(TOAST),
                                   Toast.LENGTH_SHORT).show();
                    break;
                }
            }
        };


        /**
         * Sends a message.
         * @param message  A string of text to send.
         */
        private void sendMessage(byte[] message) {
            // Check that we're actually connected before trying anything
             if (mChatService.getState() != BluetoothService.STATE_CONNECTED) {
                 Toast.makeText(this, "not_connected", Toast.LENGTH_SHORT).show();
                return;
            } 

            // Check that there's actually something to send
            if (message.length > 0) {
                // Get the message bytes and tell the BluetoothChatService to write

                mChatService.write(message);

                // Reset out string buffer to zero and clear the edit text field
                //mOutStringBuffer.setLength(0);
                 //mOutEditText.setText(mOutStringBuffer);
            }
        }
        private void btOnOffClick() {

            if (D)
                Log.d(TAG, "BT status @ btOnOffClick() ->" + isBTOnOrOff);
            if (isBTOnOrOff) {
                // make BT off & set isBTOnOrOff to false
                btOFF();
                isBTOnOrOff = false;

            } else if (!isBTOnOrOff) {
                // make BT on & set isBTOnOrOff to true

                btON(REQUEST_ENABLE_BT);
                isBTOnOrOff = true;
            }

        }

        private void btOFF() {
            enableDissableViews(false);
            if (D)
                Log.d(TAG, "BT status @ btOFF() -> OFF");

            mBluetoothAdapter.disable();
            bt_on_off.setText(getResources().getString(R.string.on_off_status)
                    + "OFF");
        }

        private void btON(int requestType) {
            if (D)
                Log.d(TAG, "BT status @ btON() -> Turning on dialog");

            Intent enableBtIntent = new Intent(
                    BluetoothAdapter.ACTION_REQUEST_ENABLE);
            startActivityForResult(enableBtIntent, requestType);

        }
        public void onActivityResult(int requestCode, int resultCode, Intent data) {
            if (D)
                Log.d(TAG, "onActivityResult " + resultCode);
            switch (requestCode) {
            case REQUEST_ENABLE_BT:
                // When the request to enable Bluetooth returns
                if (resultCode == Activity.RESULT_OK) {
                    // Bluetooth is now enabled,
                    isBTOnOrOff=true;
                    enableDissableViews(true);
                    bt_on_off.setText(getResources().getString(
                            R.string.on_off_status)
                            + "ON");
                    if (D)
                        Log.d(TAG, "onActivityResult - status ON ");
                } else {
                    isBTOnOrOff=false;
                    enableDissableViews(false);
                    bt_on_off.setText(getResources().getString(
                            R.string.on_off_status)
                            + "OFF");
                    if (D)
                        Log.d(TAG, "onActivityResult - BT not enabled");
                    // User did not enable Bluetooth or an error occurred
                }
            }
        }


        @Override
        public void onClick(View v) {
            switch (v.getId()) {
            case R.id.bt_on_off:
                if (D)
                    Log.d(TAG, "...........ON OFF button clicked ........ ");
                // check for BT adaptor available then check its on or off
                try {
                    if (D)
                        Log.d(TAG, "Before sleep");
                    // Thread.sleep(SLEEP_THREAD_FOR_ACTION);
                    if (D)
                        Log.d(TAG, "after sleep");
                    btOnOffClick();
                    if (D)
                        Log.d(TAG, "after btn click completed");
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

                break;
            case R.id.connect:
                resultMacId("00:08:F4:00:12:A4");
                break;
            case R.id.click:
                sendMessage("commands in bytes".getBytes());
                break;
            default:
                break;
            }

        }


        private void disconnectIt() {
             if (mChatService != null) mChatService.stop();
             connectIt.setEnabled(true);
        }


        void enableDissableViews(boolean state)
        {   
            if (!state) {
                connectIt.setText("Not Connected");
            }
              connectIt.setEnabled(state);
        }

    }

activity_main.xml

<LinearLayout
    android:id="@+id/top"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:layout_weight="1"
    android:background="#bababa"
    android:gravity="center" >

    <Button
        android:id="@+id/bt_on_off"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_margin="5dp"
        android:layout_weight="1"
        android:text="@string/on_off_status" />

    <TextView
        android:id="@+id/statuses"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_weight="1"
        android:gravity="center_horizontal"
        android:text="@string/all_status"
        android:textAppearance="?android:attr/textAppearanceLarge"
        android:textColor="#FF0000" />

    <Button
        android:id="@+id/connect"
        style="?android:attr/buttonStyleSmall"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_margin="5dp"
        android:layout_weight="1"
        android:text="@string/socket_connected_status" />
</LinearLayout>

<LinearLayout
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:layout_below="@+id/top"
    android:layout_weight="1" >

    <LinearLayout
        android:layout_width="wrap_content"
        android:layout_height="match_parent"
        android:orientation="vertical" >

        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="0dp"
            android:layout_weight="1" >
        </LinearLayout>

        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="0dp"
            android:layout_weight="1" >
        </LinearLayout>

        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="0dp"
            android:layout_weight="1" >
        </LinearLayout>
    </LinearLayout>

    <LinearLayout
        android:layout_width="wrap_content"
        android:layout_height="match_parent"
        android:orientation="vertical" >

        <TextView
            android:id="@+id/TextView01"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:layout_weight="1"
            android:gravity="center"
            android:text="GPS"
            android:textAppearance="?android:attr/textAppearanceLarge"
            android:visibility="gone" />
    </LinearLayout>

    <LinearLayout
        android:layout_width="wrap_content"
        android:layout_height="match_parent"
        android:orientation="vertical" >

        <Button
            android:id="@+id/click"
            android:layout_width="317dp"
            android:layout_height="match_parent"
            android:text="Send" />
    </LinearLayout>
</LinearLayout>




android-bluetooth