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 plat

Answer 1

Google Cloud Print

Answer 2

@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);