如何传输图像和放大器;通过蓝牙Android设备之间的文本数据编程 [英] how to transfer image & text data between android devices via bluetooth programmatically

问题描述

我已经创建了一个Android应用程序，上市blutooth设备附近我d​​evice.How可我从配对的名单及放任何一个; HTTP：从数据传输到使用device.i code ：//android-er.blogspot.in/2011/05/scan-bluetooth-devices.html  对于blutooth devices.How的上市可能我发的图片或文字，以任何人的。

感谢。

解决方案

下面是完整的code

  

BluetoothTexting.java：

 进口java.io.IOException异常;
进口的java.io.InputStream;
进口java.io.OutputStream中;
进口的java.util.ArrayList;
进口java.util.UUID中;
进口android.app.Activity;
进口android.bluetooth.BluetoothAdapter;
进口android.bluetooth.BluetoothDevice;
进口android.bluetooth.BluetoothServerSocket;
进口android.bluetooth.BluetoothSocket;
进口android.content.BroadcastReceiver;
进口android.content.Context;
进口android.content.Intent;
进口android.content.IntentFilter;
进口android.os.AsyncTask;
进口android.os.Bundle;
进口android.os.Handler;
进口android.util.Log;
进口android.view.KeyEvent;
进口android.view.View;
进口android.view.View.OnClickListener;
进口android.view.View.OnKeyListener;
进口android.widget.AdapterView;
进口android.widget.ArrayAdapter;
进口android.widget.Button;
进口android.widget.EditText;
进口android.widget.ListView;
进口android.widget.TextView;
进口android.widget.AdapterView.OnItemClickListener;

公共类BluetoothTexting延伸活动{

  私有静态诠释DISCOVERY_REQUEST = 1;

  私人处理程序处理程序=新的处理程序（）;
  私人的ArrayList＆LT; BluetoothDevice类＆GT; foundDevices;
  私人ArrayAdapter＆LT; BluetoothDevice类＆GT; AA;
  私人的ListView列表;

  私人BluetoothAdapter蓝牙;
  私有的BluetoothSocket插座;
  私人的UUID的uuid = UUID.fromString（a60f35f0-b93a-11de-8a39-08002009c666）;

  @覆盖
  公共无效的onCreate（包savedInstanceState）{
    super.onCreate（savedInstanceState）;
    的setContentView（R.layout.main）;

    configureBluetooth（）;
    setupListView（）;
    setupSearchButton（）;
    setupListenButton（）;
  }

  私人无效configureBluetooth（）{
    蓝牙= BluetoothAdapter.getDefaultAdapter（）;
  }

  私人无效setupListenButton（）{
    按钮listenButton =（按钮）findViewById（R.id.button_listen）;
    listenButton.setOnClickListener（新OnClickListener（）{
      公共无效的onClick（视图查看）{
        意图盘=新的意图（BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE）;
        startActivityForResult（盘，DISCOVERY_REQUEST）;
      }
    }）;
  }

  @覆盖
  保护无效onActivityResult（INT申请code，INT结果code，意图数据）{
    如果（要求code == DISCOVERY_REQUEST）{
      布尔isDiscoverable =结果code取代; 0;
      如果（isDiscoverable）{
        字符串名称=bluetoothserver;
        尝试 {
          最后BluetoothServerSocket btserver =
            bluetooth.listenUsingRfcommWithServiceRecord（名称，UUID）;

          AsyncTask的＆LT;整数，无效的BluetoothSocket＆GT; acceptThread =
            新的AsyncTask＆LT;整数，无效的BluetoothSocket＆GT;（）{

            @覆盖
            受保护的BluetoothSocket doInBackground（整数... PARAMS）{
              尝试 {
                插座= btserver.accept（PARAMS [0] * 1000）;
                返回插座;
              }赶上（IOException异常E）{
                Log.d（蓝牙，e.getMessage（））;
              }
              返回null;
            }

            @覆盖
            保护无效onPostExecute（的BluetoothSocket结果）{
              如果（结果！= NULL）
                switchUI（）;
            }
          };
          acceptThread.execute（结果code）;
        }赶上（IOException异常E）{
          Log.d（蓝牙，e.getMessage（））;
        }
      }
    }
  }

  私人无效setupListView（）{
    AA =新的ArrayAdapter＆LT; BluetoothDevice类＆GT;（这一点，
               android.R.layout.simple_list_item_1，
               foundDevices）;
    名单=（ListView控件）findViewById（R.id.list_discovered）;
    list.setAdapter（AA）;

    list.setOnItemClickListener（新OnItemClickListener（）{
      公共无效onItemClick（适配器视图＆LT;＆GT;为arg0，视图中查看，
                              INT指数，长ARG3）{
        AsyncTask的＆LT;整数，虚空，虚空＆GT; connectTask =
          新的AsyncTask＆LT;整数，虚空，虚空＆GT;（）{
            @覆盖
            保护无效doInBackground（整数... PARAMS）{
              尝试 {
                BluetoothDevice类设备= foundDevices.get（PARAMS [0]）;
                插座= device.createRfcommSocketToServiceRecord（UUID）;
                Socket.connect（）的;
              }赶上（IOException异常E）{
                Log.d（BLUETOOTH_CLIENT，e.getMessage（））;
              }
              返回null;
            }

            @覆盖
            保护无效onPostExecute（无效的结果）{
              switchUI（）;
            }
          };
        connectTask.execute（指数）;
      }
    }）;
  }

  私人无效setupSearchButton（）{
    按钮searchButton =（按钮）findViewById（R.id.button_search）;

    sea​​rchButton.setOnClickListener（新OnClickListener（）{
      公共无效的onClick（视图查看）{
        registerReceiver（discoveryResult，
                         新的IntentFilter（BluetoothDevice.ACTION_FOUND））;

        如果（！bluetooth.isDiscovering（））{
          foundDevices.clear（）;
          bluetooth.startDiscovery（）;
        }
      }
    }）;
  }

  私人无效switchUI（）{
    最后的TextView =的MessageText（TextView中）findViewById（R.id.text_messages）;
    最后的EditText TEXTENTRY =（EditText上）findViewById（R.id.text_message）;

    messageText.setVisibility（View.VISIBLE）;
    list.setVisibility（View.GONE）;
    textEntry.setEnabled（真正的）;

    textEntry.setOnKeyListener（新OnKeyListener（）{
      公共布尔onKey（查看视图，INT关键code，KeyEvent的的keyEvent）{
        如果（（keyEvent.getAction（）== KeyEvent.ACTION_DOWN）及＆安培;
            （钥匙code == KeyEvent.KEY code_DPAD_CENTER））{
          的sendMessage（插座，textEntry.getText（）的toString（））;
          textEntry.setText（）;
          返回true;
        }
        返回false;
      }
    }）;
    BluetoothSocketListener BSL =新BluetoothSocketListener（插座，处理程序，的MessageText）;
    帖子消息监听=新主题（BSL）;
    messageListener.start（）;
  }

  私人无效的sendMessage（的BluetoothSocket插座，弦乐味精）{
    的OutputStream outStream;
    尝试 {
      outStream = socket.getOutputStream（）;
      byte []的字节字符串=（MSG +）.getBytes（）;
      字节字符串[byteString.length  -  1] = 0;
      outStream.write（字节字符串）;
    }赶上（IOException异常E）{
      Log.d（BLUETOOTH_COMMS，e.getMessage（））;
    }
  }

  BroadcastReceiver的discoveryResult =新的BroadcastReceiver（）{
    @覆盖
    公共无效的onReceive（上下文的背景下，意图意图）{
      BluetoothDevice类远端设备;
      远端设备= intent.getParcelableExtra（BluetoothDevice.EXTRA_DEVICE）;
      如果（bluetooth.getBondedDevices（）。包括（远端设备））{
        foundDevices.add（远端设备）;
        aa.notifyDataSetChanged（）;
      }
    }
  };

  私有类MessagePoster实现Runnable {
    私人的TextView TextView的;
    私人字符串信息;

    公共MessagePoster（TextView的TextView的，字符串消息）{
      this.textView = TextView的;
      this.message =消息;
    }

    公共无效的run（）{
      textView.setText（消息）;
    }
  }

  私有类BluetoothSocketListener实现Runnable {

      私有的BluetoothSocket插座;
      私人的TextView TextView的;
      私人处理程序处理程序;

      公共BluetoothSocketListener（的BluetoothSocket插座，
                                     处理程序处理程序，TextView的TextView的）{
        this.socket =插座;
        this.textView = TextView的;
        this.handler =处理程序;
      }

    公共无效的run（）{
      INT缓冲区大小= 1024;
      byte []的缓冲区=新的字节[BUFFERSIZE]
      尝试 {
        InputStream的河道= socket.getInputStream（）;
        INT读取动作= -1;
        字符串消息=;
        而（真）{
          消息=;
          读取动作= instream.read（缓冲液）;
          如果（读取动作！= -1）{
            而（（读取动作== BUFFERSIZE）及及（缓冲液[BUFFERSIZE-1] = 0）！）{
              消息=信息+新的String（缓冲，0，读取动作）;
              读取动作= instream.read（缓冲液）;
            }
            消息=信息+新的String（缓冲，0，读取动作 -  1）;

            handler.post（新MessagePoster（TextView的，消息））;
            socket.getInputStream（）;
          }
        }
      }赶上（IOException异常E）{
        Log.d（BLUETOOTH_COMMS，e.getMessage（））;
      }
    }
  }
}
 

  

main.xml中

 ＆LT; XML版本=1.0编码=UTF-8＆GT？;
＆LT; RelativeLayout的
的xmlns：机器人=htt​​p://schemas.android.com/apk/res/android
机器人：方向=垂直
机器人：layout_width =FILL_PARENT
机器人：layout_height =FILL_PARENT＆GT;

＆LT;的EditText
机器人：ID =@ + ID / text_message
机器人：layout_width =FILL_PARENT
机器人：layout_height =WRAP_CONTENT
机器人：layout_alignParentBottom =真
机器人：启用=假
/＆GT;
＆LT;按钮
机器人：ID =@ + ID / button_search
机器人：文本=搜索监听器
机器人：layout_width =FILL_PARENT
机器人：layout_height =WRAP_CONTENT
机器人：layout_above =@ ID / text_message
/＆GT;
＆LT;按钮
机器人：ID =@ + ID / button_listen
机器人：文本=监听连接
机器人：layout_width =FILL_PARENT
机器人：layout_height =WRAP_CONTENT
机器人：layout_above =@ ID / button_search
/＆GT;

＆LT;的ListView
机器人：ID =@ + ID / list_discovered
机器人：layout_width =FILL_PARENT
机器人：layout_height =FILL_PARENT
机器人：layout_above =@ ID / button_listen
机器人：layout_alignParentTop =真
/＆GT;
＆LT;的TextView
机器人：ID =@ + ID / text_messages
机器人：layout_width =FILL_PARENT
机器人：layout_height =FILL_PARENT
机器人：layout_above =@ ID / button_listen
机器人：layout_alignParentTop =真
机器人：能见度=水涨船高
/＆GT;
＆LT; / RelativeLayout的＆GT;
 

I've created an android app that listed blutooth devices nearby my device.How could i pair any one from that list & transfer data to that device.i used code from: http://android-er.blogspot.in/2011/05/scan-bluetooth-devices.html for listing of blutooth devices.How could i send image or text to anyone from that.

Thanks.

解决方案

Here is the full code

BluetoothTexting.java:

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.UUID;
import android.app.Activity;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothServerSocket;
import android.bluetooth.BluetoothSocket;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.AsyncTask;
import android.os.Bundle;
import android.os.Handler;
import android.util.Log;
import android.view.KeyEvent;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.View.OnKeyListener;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ListView;
import android.widget.TextView;
import android.widget.AdapterView.OnItemClickListener;

public class BluetoothTexting extends Activity {

  private static int DISCOVERY_REQUEST = 1;

  private Handler handler = new Handler();
  private ArrayList<BluetoothDevice> foundDevices;
  private ArrayAdapter<BluetoothDevice> aa; 
  private ListView list;

  private BluetoothAdapter bluetooth;
  private BluetoothSocket socket;
  private UUID uuid = UUID.fromString("a60f35f0-b93a-11de-8a39-08002009c666");

  @Override
  public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);

    configureBluetooth();
    setupListView();    
    setupSearchButton();
    setupListenButton();
  }

  private void configureBluetooth() {
    bluetooth = BluetoothAdapter.getDefaultAdapter();
  }

  private void setupListenButton() {
    Button listenButton = (Button)findViewById(R.id.button_listen);
    listenButton.setOnClickListener(new OnClickListener() {
      public void onClick(View view) {
        Intent disc = new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
        startActivityForResult(disc, DISCOVERY_REQUEST);     
      }
    });
  }

  @Override
  protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (requestCode == DISCOVERY_REQUEST) {
      boolean isDiscoverable = resultCode > 0;
      if (isDiscoverable) {
        String name = "bluetoothserver";
        try {
          final BluetoothServerSocket btserver = 
            bluetooth.listenUsingRfcommWithServiceRecord(name, uuid);

          AsyncTask<Integer, Void, BluetoothSocket> acceptThread = 
            new AsyncTask<Integer, Void, BluetoothSocket>() {

            @Override
            protected BluetoothSocket doInBackground(Integer... params) {
              try {
                socket = btserver.accept(params[0]*1000);
                return socket;
              } catch (IOException e) {
                Log.d("BLUETOOTH", e.getMessage());            
              }
              return null;
            }

            @Override
            protected void onPostExecute(BluetoothSocket result) {
              if (result != null)
                switchUI();
            }            
          };          
          acceptThread.execute(resultCode);
        } catch (IOException e) {
          Log.d("BLUETOOTH", e.getMessage());            
        }
      }
    }
  }

  private void setupListView() {
    aa = new ArrayAdapter<BluetoothDevice>(this, 
               android.R.layout.simple_list_item_1,
               foundDevices);
    list = (ListView)findViewById(R.id.list_discovered);    
    list.setAdapter(aa);

    list.setOnItemClickListener(new OnItemClickListener() {
      public void onItemClick(AdapterView<?> arg0, View view, 
                              int index, long arg3) {
        AsyncTask<Integer, Void, Void> connectTask = 
          new AsyncTask<Integer, Void, Void>() { 
            @Override
            protected Void doInBackground(Integer... params) {
              try {
                BluetoothDevice device = foundDevices.get(params[0]);
                socket = device.createRfcommSocketToServiceRecord(uuid);
                socket.connect();              
              } catch (IOException e) {
                Log.d("BLUETOOTH_CLIENT", e.getMessage());
              }
              return null;
            }

            @Override
            protected void onPostExecute(Void result) {
              switchUI();
            }
          };
        connectTask.execute(index);
      }      
    });
  }

  private void setupSearchButton() {
    Button searchButton = (Button)findViewById(R.id.button_search);

    searchButton.setOnClickListener(new OnClickListener() {
      public void onClick(View view) {
        registerReceiver(discoveryResult, 
                         new IntentFilter(BluetoothDevice.ACTION_FOUND));

        if (!bluetooth.isDiscovering()) {
          foundDevices.clear();
          bluetooth.startDiscovery();
        }
      }
    });
  }

  private void switchUI() {    
    final TextView messageText = (TextView)findViewById(R.id.text_messages);
    final EditText textEntry = (EditText)findViewById(R.id.text_message);

    messageText.setVisibility(View.VISIBLE);
    list.setVisibility(View.GONE);
    textEntry.setEnabled(true);

    textEntry.setOnKeyListener(new OnKeyListener() {
      public boolean onKey(View view, int keyCode, KeyEvent keyEvent) {
        if ((keyEvent.getAction() == KeyEvent.ACTION_DOWN) &&
            (keyCode == KeyEvent.KEYCODE_DPAD_CENTER)) {
          sendMessage(socket, textEntry.getText().toString());
          textEntry.setText("");
          return true;
        }
        return false;
      }      
    });
    BluetoothSocketListener bsl = new BluetoothSocketListener(socket, handler, messageText);
    Thread messageListener = new Thread(bsl);
    messageListener.start();
  }

  private void sendMessage(BluetoothSocket socket, String msg) {
    OutputStream outStream;
    try {
      outStream = socket.getOutputStream();
      byte[] byteString = (msg + " ").getBytes();
      byteString[byteString.length - 1] = 0;
      outStream.write(byteString);
    } catch (IOException e) {
      Log.d("BLUETOOTH_COMMS", e.getMessage());
    }    
  }

  BroadcastReceiver discoveryResult = new BroadcastReceiver() {
    @Override
    public void onReceive(Context context, Intent intent) {
      BluetoothDevice remoteDevice;
      remoteDevice = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
      if (bluetooth.getBondedDevices().contains(remoteDevice)) {  
        foundDevices.add(remoteDevice);
        aa.notifyDataSetChanged();
      }
    }
  };

  private class MessagePoster implements Runnable {
    private TextView textView;
    private String message;

    public MessagePoster(TextView textView, String message) {
      this.textView = textView;
      this.message = message;
    }

    public void run() {
      textView.setText(message);
    }     
  }

  private class BluetoothSocketListener implements Runnable {

      private BluetoothSocket socket;
      private TextView textView;
      private Handler handler;

      public BluetoothSocketListener(BluetoothSocket socket, 
                                     Handler handler, TextView textView) {
        this.socket = socket;
        this.textView = textView;
        this.handler = handler;
      }

    public void run() {
      int bufferSize = 1024;
      byte[] buffer = new byte[bufferSize];      
      try {
        InputStream instream = socket.getInputStream();
        int bytesRead = -1;
        String message = "";
        while (true) {
          message = "";
          bytesRead = instream.read(buffer);
          if (bytesRead != -1) {
            while ((bytesRead==bufferSize)&&(buffer[bufferSize-1] != 0)) {
              message = message + new String(buffer, 0, bytesRead);
              bytesRead = instream.read(buffer);
            }
            message = message + new String(buffer, 0, bytesRead - 1); 

            handler.post(new MessagePoster(textView, message));              
            socket.getInputStream();
          }
        }
      } catch (IOException e) {
        Log.d("BLUETOOTH_COMMS", e.getMessage());
      } 
    }
  }
}

main.xml

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent">

<EditText
android:id="@+id/text_message"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:layout_alignParentBottom="true"
android:enabled="false"
/>
<Button
android:id="@+id/button_search"
android:text="Search for listener"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:layout_above="@id/text_message"
/>
<Button
android:id="@+id/button_listen"
android:text="Listen for connection"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:layout_above="@id/button_search"
/>

<ListView
android:id="@+id/list_discovered"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:layout_above="@id/button_listen"
android:layout_alignParentTop="true"
/>
<TextView
android:id="@+id/text_messages"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:layout_above="@id/button_listen"
android:layout_alignParentTop="true"
android:visibility="gone"
/>
</RelativeLayout>

这篇关于如何传输图像和放大器;通过蓝牙Android设备之间的文本数据编程的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！