Sử dụng máy in bluetooth cầm tay với android

Question

Tôi có một máy in cầm tay bluetooth mà tôi có thể giao tiếp với việc sử dụng kết nối SPP từ máy Mac của tôi (sử dụng Coolterm). Khi tôi đang cố gắng để làm điều tương tự từ Android (sử dụng nền tảng 7) Tôi chạy vào nhiều vấn đề:

• Máy in dường như không hỗ trợ/cần PIN xác thực. Khi kết nối từ OSX, tôi chỉ chọn tùy chọn có nội dung "Không sử dụng ghim" và nó đã được ghép nối. Trong Android, khi tôi sử dụng device.createRfcommSocketToServiceRecord(), nó luôn luôn kết thúc yêu cầu tôi cho một PIN/Key (mà tôi không có/cần). tôi giải quyết này bằng cách sử dụng thủ thuật phản ánh:

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

  Tôi không chắc chắn liệu điều này thực sự làm việc, nhưng nhấp nháy LED trên máy in ngừng nhấp nháy, mà làm cho tôi tin rằng nó đã làm.

• Khi tôi có ổ cắm, tôi cố gắng ghi dữ liệu byte vào dòng sử dụng:

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

  Gửi chuỗi ba byte tương tự từ Coolterm trên OSX in một trang kiểm tra từ máy in. Tuy nhiên, điều này dường như làm cho thread treo trên Android (đọc).

Có điều gì tôi thiếu ở đây không?

CHỈNH SỬA: Điều này dường như chỉ hoạt động khi tôi đặt kênh thành 1. Vì vậy, điều đó có nghĩa là tôi đang thực hiện điều gì đó ở đây.

Answer 1

@Trevor Page Tôi nghĩ là đã đi đúng hướng. Dưới đây là ví dụ của Google mà tôi đã sử dụng để kết nối với bộ điều khiển vi điều khiển cơ bản.

 

    /* 
    * 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); 
       } 
      } 
     } 
    } 

Kiểm tra xem nó có hoạt động hay không.

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

Answer 2

Google Cloud Print