android - 使用带有 android 的手持式蓝牙打印机

Question

我有一台蓝牙手持打印机，我可以使用 Mac 上的 SPP 连接(使用 Coolterm)与之通信。当我尝试在 Android 上做同样的事情(使用平台 7)时，我遇到了多个问题:

• 打印机似乎不支持/不需要 PIN 验证。从 OSX 连接时，我只是选择了“不使用 pin”选项，然后它就配对了。在 Android 中，当我使用 device.createRfcommSocketToServiceRecord() 时，它总是最终要求我提供 PIN/Key(我没有/不需要)。我使用反射技巧解决了这个问题:

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

  我不确定这是否真的有效，但打印机上闪烁的 LED 停止闪烁，这让我相信它确实有效。

• 一旦有了套接字，我就尝试使用以下方法将字节数据写入流:

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

  在 OSX 上从 Coolterm 发送相同的三字节序列会从打印机打印测试页。但是，这似乎使线程在 Android 上挂起(读取)。

这里有什么我遗漏的吗？

编辑:这似乎只在我将 channel 设置为 1 时才有效。所以这意味着我在这里做一些事情。

Answer 1

@Trevor Page 我认为是在正确的道路上。这是我用来连接基本邮票微 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);