Use a handheld bluetooth printer with android

Question

I have a bluetooth Handheld printer that I am able to communicate to using a SPP connection from my Mac(using Coolterm). When I'm trying to do the same from Android (using platform 7) I am running into multiple issues:

• The printer doesn't seem to support/need PIN Authentication. When connecting from OSX, I just selected the option that said "Do not use a pin" and it got paired. In Android, when I use device.createRfcommSocketToServiceRecord(), it always ends up asking me for a PIN/Key(which I don't have/need). I solved this using the reflection trick:

  Method m = device.getClass().getMethod("createInsecureRfcommSocket", new Class[] {int.class}); BluetoothSocket connection = (BluetoothSocket) m.invoke(device, 1); 

  I am unsure whether this actually worked, but the blinking LED on the printer stops blinking, which makes me believe it did.

• Once I have the socket, I try to write byte data to the stream using:

  byte[] buffer = new byte[3]; buffer[0] = (byte) 0x8A; buffer[1] = (byte) 0xC1; buffer[2] = (byte) 0x04; outStream.write(buffer); int response = inStream.read(); mySocket.close(); 

  Sending the same three-byte sequence from Coolterm on OSX printed a test page from the printer. However, this seems to make the thread hang on Android(the read).

Is there something I am missing out here?

EDIT: This seems to work only when I set channel to 1. So that means I am on to something here.

Answer 1

@Trevor Page I think was on the right path. Here is a google's example I've used to connect to a basic stamp micro-controller.

      /*      * Copyright (C) 2009 The Android Open Source Project      *      * Licensed under the Apache License, Version 2.0 (the "License");      * you may not use this file except in compliance with the License.      * You may obtain a copy of the License at      *      *      http://www.apache.org/licenses/LICENSE-2.0      *      * Unless required by applicable law or agreed to in writing, software      * distributed under the License is distributed on an "AS IS" BASIS,      * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.      * See the License for the specific language governing permissions and      * limitations under the License.      */     package com.your_package;      import java.io.IOException;     import java.io.InputStream;     import java.io.OutputStream;     import java.util.UUID;      import android.bluetooth.BluetoothAdapter;     import android.bluetooth.BluetoothDevice;     import android.bluetooth.BluetoothServerSocket;     import android.bluetooth.BluetoothSocket;     import android.content.Context;     import android.os.Bundle;     import android.os.Handler;     import android.os.Message;     import android.util.Log;      /**      * This class does all the work for setting up and managing Bluetooth      * connections with other devices. It has a thread that listens for      * incoming connections, a thread for connecting with a device, and a      * thread for performing data transmissions when connected.      */     public class BluetoothService     {         // Debugging         private static final String TAG = "BluetoothService_BoeBot";         private static final boolean D = true;         // Name for the SDP record when creating server socket         private static final String NAME_SECURE = "BluetoothSecure";         private static final String NAME_INSECURE = "BluetoothInsecure";         // 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          /**          * Constructor. Prepares a new BluetoothChat session.          * @param context  The UI Activity Context          * @param handler  A Handler to send messages back to the UI Activity          */         public BluetoothService(Context context, Handler handler)         {             mAdapter = BluetoothAdapter.getDefaultAdapter();             mState = STATE_NONE;             mHandler = handler;         }           /**          * Set the current state of the chat connection          * @param state  An integer defining the current connection state          */         private synchronized void setState(int state)         {             if (D)                 Log.d(TAG, "setState() " + mState + " -> " + state);              mState = state;              // Give the new state to the Handler so the UI Activity can update             mHandler.obtainMessage(BoeBot.MESSAGE_STATE_CHANGE, state, -1).sendToTarget();         }          /**          * Return the current connection state. */         public synchronized int getState()         {             return mState;         }          /**          * Start the chat service. Specifically start AcceptThread to begin a          * session in listening (server) mode. Called by the Activity onResume() */         public synchronized void start()         {             if (D)                 Log.d(TAG, "start");              // Cancel any thread attempting to make a connection             if (mConnectThread != null)             {                 mConnectThread.cancel();                 mConnectThread = null;             }              // Cancel any thread currently running a connection             if (mConnectedThread != null)             {                 mConnectedThread.cancel();                 mConnectedThread = null;             }              setState(STATE_LISTEN);              // Start the thread to listen on a BluetoothServerSocket             if (mSecureAcceptThread == null)             {                 mSecureAcceptThread = new AcceptThread(true);                 mSecureAcceptThread.start();             }             if (mInsecureAcceptThread == null)             {                 mInsecureAcceptThread = new AcceptThread(false);                 mInsecureAcceptThread.start();             }         }          /**          * Start the ConnectThread to initiate a connection to a remote device.          * @param device  The BluetoothDevice to connect          * @param secure Socket Security type - Secure (true) , Insecure (false)          */         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;             }              try             {                 // Start the thread to connect with the given device                 mConnectThread = new ConnectThread(device, secure);                 mConnectThread.start();                 setState(STATE_CONNECTING);             }catch(Exception e)             {              }         }          /**          * Start the ConnectedThread to begin managing a Bluetooth connection          * @param socket  The BluetoothSocket on which the connection was made          * @param device  The BluetoothDevice that has been connected          */         public synchronized void connected(BluetoothSocket socket, BluetoothDevice device, final String socketType)         {                 if (D)                     Log.d(TAG, "connected, Socket Type:" + socketType);                  // Cancel the thread that completed the connection                 if (mConnectThread != null)                 {                     mConnectThread.cancel();                     mConnectThread = null;                 }                  // Cancel any thread currently running a connection                 if (mConnectedThread != null)                 {                     mConnectedThread.cancel();                     mConnectedThread = null;                 }                  // Cancel the accept thread because we only want to connect to one device                 if (mSecureAcceptThread != null)                 {                     mSecureAcceptThread.cancel();                     mSecureAcceptThread = null;                 }                 if (mInsecureAcceptThread != null)                 {                     mInsecureAcceptThread.cancel();                     mInsecureAcceptThread = null;                 }                  // Start the thread to manage the connection and perform transmissions                 mConnectedThread = new ConnectedThread(socket, socketType);                 mConnectedThread.start();                  // Send the name of the connected device back to the UI Activity                 Message msg = mHandler.obtainMessage(BoeBot.MESSAGE_DEVICE_NAME);                 Bundle bundle = new Bundle();                 bundle.putString(BoeBot.DEVICE_NAME, device.getName());                 msg.setData(bundle);                 mHandler.sendMessage(msg);                  setState(STATE_CONNECTED);          }          /**          * Stop all threads          */         public synchronized void stop()         {             if (D)                 Log.d(TAG, "stop");              if (mConnectThread != null)             {                 mConnectThread.cancel();                 mConnectThread = null;             }              if (mConnectedThread != null)             {                 mConnectedThread.cancel();                 mConnectedThread = null;             }              if (mSecureAcceptThread != null)             {                 mSecureAcceptThread.cancel();                 mSecureAcceptThread = null;             }              if (mInsecureAcceptThread != null)             {                 mInsecureAcceptThread.cancel();                 mInsecureAcceptThread = null;             }             setState(STATE_NONE);         }          /**          * Write to the ConnectedThread in an unsynchronized manner          * @param out The bytes to write          * @see ConnectedThread#write(byte[])          */         public void write(byte[] out)         {             // Create temporary object             ConnectedThread r;             // Synchronize a copy of the ConnectedThread             synchronized (this)             {                 if (mState != STATE_CONNECTED)                     return;                  r = mConnectedThread;             }             // Perform the write unsynchronized             r.write(out);         }          /**          * Indicate that the connection attempt failed and notify the UI Activity.          */         private void connectionFailed()         {             // Send a failure message back to the Activity             Message msg = mHandler.obtainMessage(BoeBot.MESSAGE_TOAST);             Bundle bundle = new Bundle();             bundle.putString(BoeBot.TOAST, "Unable to connect device");             msg.setData(bundle);             mHandler.sendMessage(msg);              // Start the service over to restart listening mode             BluetoothService.this.start();         }          /**          * Indicate that the connection was lost and notify the UI Activity.          */         private void connectionLost()         {             // Send a failure message back to the Activity             Message msg = mHandler.obtainMessage(BoeBot.MESSAGE_TOAST);             Bundle bundle = new Bundle();             bundle.putString(BoeBot.TOAST, "Device connection was lost");             msg.setData(bundle);             mHandler.sendMessage(msg);              // Start the service over to restart listening mode             BluetoothService.this.start();         }          /**          * This thread runs while listening for incoming connections. It behaves          * like a server-side client. It runs until a connection is accepted          * (or until cancelled).          */         private class AcceptThread extends Thread         {             // The local server socket             private final BluetoothServerSocket mmServerSocket;             private String mSocketType;              public AcceptThread(boolean secure)             {                  BluetoothServerSocket tmp = null;                 mSocketType = secure ? "Secure" : "Insecure";                  // Create a new listening server socket                 try                 {                     if (secure)                     {                         tmp = mAdapter.listenUsingRfcommWithServiceRecord(NAME_SECURE, MY_UUID_SECURE);                     } else                     {                         tmp = mAdapter.listenUsingInsecureRfcommWithServiceRecord(                                 NAME_INSECURE, MY_UUID_INSECURE);                     }                 } catch (IOException e)                 {                     Log.e(TAG, "Socket Type: " + mSocketType + "listen() failed", e);                 }                 mmServerSocket = tmp;             }              @Override             public void run()             {                 if (D)                 {                     Log.d(TAG, "Socket Type: " + mSocketType + "BEGIN mAcceptThread" + this);                 }                 setName("AcceptThread" + mSocketType);                  BluetoothSocket socket = null;                  // Listen to the server socket if we're not connected                 while (mState != STATE_CONNECTED)                 {                     try                     {                         // This is a blocking call and will only return on a                         // successful connection or an exception                         socket = mmServerSocket.accept();                     } catch (IOException e)                     {                         Log.e(TAG, "Socket Type: " + mSocketType + "accept() failed", e);                         break;                     }                      // If a connection was accepted                     if (socket != null)                     {                         synchronized (BluetoothService.this)                         {                             switch (mState)                             {                                 case STATE_LISTEN:                                 case STATE_CONNECTING:                                     // Situation normal. Start the connected thread.                                     connected(socket, socket.getRemoteDevice(), mSocketType);                                     break;                                 case STATE_NONE:                                 case STATE_CONNECTED:                                     // Either not ready or already connected. Terminate new socket.                                     try                                     {                                         socket.close();                                     } catch (IOException e)                                     {                                         Log.e(TAG, "Could not close unwanted socket", e);                                     }                                     break;                             }                         }                     }                 }                 if (D)                 {                     Log.i(TAG, "END mAcceptThread, socket Type: " + mSocketType);                 }              }              public void cancel()             {                 if (D)                 {                     Log.d(TAG, "Socket Type" + mSocketType + "cancel " + this);                 }                 try                 {                     mmServerSocket.close();                 } catch (IOException e)                 {                     Log.e(TAG, "Socket Type" + mSocketType + "close() of server failed", e);                 }             }         }          /**          * This thread runs while attempting to make an outgoing connection          * with a device. It runs straight through; the connection either          * succeeds or fails.          */         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;             }              @Override             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                     mmSocket.connect();                 } catch (IOException e)                 {                     // Close the socket                     try                     {                         mmSocket.close();                     } catch (IOException e2)                     {                         Log.e(TAG, "unable to close() " + mSocketType + " socket during connection failure", e2);                     }                     connectionFailed();                     return;                 }                  // Reset the ConnectThread because we're done                 synchronized (BluetoothService.this)                 {                     mConnectThread = null;                 }                  try                 {                     // Start the connected thread                     connected(mmSocket, mmDevice, mSocketType);                 }catch(Exception e)                 {                     Log.e(TAG, "", e);                 }             }              public void cancel()             {                 try                 {                     mmSocket.close();                 } catch (IOException e)                 {                     Log.e(TAG, "close() of connect " + mSocketType + " socket failed", e);                 }             }         }          /**          * This thread runs during a connection with a remote device.          * It handles all incoming and outgoing transmissions.          */         private class ConnectedThread extends Thread         {             private final BluetoothSocket mmSocket;             private final InputStream mmInStream;             private final OutputStream mmOutStream;              public ConnectedThread(BluetoothSocket socket, String socketType)             {                 Log.d(TAG, "create ConnectedThread: " + socketType);                 mmSocket = socket;                 InputStream tmpIn = null;                 OutputStream tmpOut = null;                  // Get the BluetoothSocket input and output streams                 try                 {                     tmpIn = socket.getInputStream();                     tmpOut = socket.getOutputStream();                 } catch (IOException e)                 {                     Log.e(TAG, "temp sockets not created", e);                 }                  mmInStream = tmpIn;                 mmOutStream = tmpOut;             }              @Override             public void run()             {                 Log.i(TAG, "BEGIN mConnectedThread");                 byte[] buffer = new byte[1024];                 int bytes;                  // Keep listening to the InputStream while connected                 while (true)                 {                     try                     {                         // Read from the InputStream                         bytes = mmInStream.read(buffer);                          // Send the obtained bytes to the UI Activity                         mHandler.obtainMessage(BoeBot.MESSAGE_READ, bytes, -1, buffer).sendToTarget();                     } catch (IOException e)                     {                         Log.e(TAG, "disconnected", e);                         connectionLost();                         break;                     }                 }             }              /**              * Write to the connected OutStream.              * @param buffer  The bytes to write              */             public void write(byte[] buffer)             {                 try                 {                     mmOutStream.write(buffer);                      // Share the sent message back to the UI Activity                     mHandler.obtainMessage(BoeBot.MESSAGE_WRITE, -1, -1, buffer).sendToTarget();                 } catch (IOException e)                 {                     Log.e(TAG, "Exception during write", e);                 }             }              public void cancel()             {                 try                 {                     mmSocket.close();                 } catch (IOException e)                 {                     Log.e(TAG, "close() of connect socket failed", e);                 }             }         }     }  

Test to see if it works.

BluetoothService mService = new BluetoothService(this, mHandler); mService.write(Bytes);