2016-11-18 18:45:05 qq_32280557 阅读数 7181

需求:开发一个app将手机麦克风的语音数据实时发送给蓝牙音箱设备(耳机也可以),实现扩音的目的。也有单独数据传输的部分。
在网上找了很多,没有找到一个合适的demo,弄了几天终于弄出来了!下面把这个过程分享一下,希望帮助到有需要的朋友!

一   既然是在手机上开发,那第一步就应该是获取手机的本机蓝牙设备,通过本机蓝牙搜索其他蓝牙并实现连接。蓝牙的使用类可以参见这篇文章:
[http://blog.csdn.net/q610098308/article/details/45248423]
BluetoothAdapter mAdapter = BluetoothAdapter.getDefaultAdapter();//获取蓝牙适配器,蓝牙的打开 关闭 搜索设备 都是通过蓝牙适配器来完成的。
二   打开蓝牙并搜,这里的打开有两种方式,一种直接打开不做任何提示,另一种就是给用户提示。
if(!mAdapter.isEnabled()){//如果蓝牙没有打开,
	mAdapter.enable();//打开,直接打开
	
	 //弹出对话框提示用户是后打开,选择一种即可
	Intent intent= new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
	startActivityForResult(intent, REQUEST_ENABLE);
}

三  蓝牙打开后就是搜索其他的蓝牙设备了,这里会有一个蓝牙状态的改变,
在Android系统中,我们可以通过广播的形式来接收蓝牙搜索到的设备,广播的使用如下,搜索:mAdapter.startDiscovery();//开始搜索蓝牙
BroadcastReceiver mReceiver = new BroadcastReceiver(){
		@Override
		public void onReceive(Context context, Intent intent) {
			String action = intent.getAction();
			BluetoothDevice device;
			switch (action) {
			case BluetoothDevice.ACTION_FOUND://发现蓝牙
				device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
				String str = device.getName();//获取收缩到的蓝牙的名称
				break;
			case BluetoothAdapter.ACTION_DISCOVERY_FINISHED:
				//这里可以做提示 搜索完成	
				}
				break;

通过以上步骤,就可以发现蓝牙设备,蓝牙耳机的,手机的,蓝牙音箱的都可以!你也可以用ListView来将他们显示在列表中(ListView的使用自己搜了!)

一开始我以为语音数据也是数据流,可以直接发送给蓝牙音箱它就会播放了,但语音(音乐)的播放,和传输数据不一样,平常我们手机连接蓝牙耳机后,播放歌曲就可以在耳机上听到,那是因为我们手机在和蓝牙耳机连接时,是通过A2dp协议连接的,就是语音协议,关于蓝牙的传输协议有很多种!可以自行搜索,比如文件传输协议!


因为要实现的是实时的语音采集,并且通过蓝牙耳机播放。所以涉及到手机麦克风采集语音数据,关于手机采集声音的模式一般有两种:

一是通过 MediaRecorder 类来采集录音,这种方式在采集的时候需要指定语音保存的路径!也是就说相当于录音,这些语音数据都是经过处理的,进行一定格式的编码在存放到一个文件中 如 .pm3。所以没法满足我们实时录音的需求!
关于MediaRecorder(录音)MediaPlayer(播放)的使用网上很容易找到,可以了解一下,方便和下面做个对比。

二是通过AudioRecord  AudioTrack 来实现实时的录放音!AudioRecord  采集到的就是纯粹的语音数据,没有进行过任何的编码;就是实时的数据流。而 AudioTrack 就是专门播放这种语音数据的,所以我们应该选择AudioRecord  来采集语音,那为什么要用到 AudioTrack 来播放呢? 

事实上,我们的需求也可以分析为:实时的录放音,既 实时采集手机麦克风的声音,并在手机上实时播放,如果能实现在手机上播放,那么当我们连接上蓝牙耳机后,声音就会在蓝牙耳机上输出。为什会这样呢?
那是因为Android系统在通过A2dp协议连接上蓝牙耳机后,当系统中有播放语音数据时,比如 放音乐,电影,录音。这些语音数据都会通过A2dp协议传输到蓝牙耳机上进行播放。所以我们只要能做到手机上实时录音播放就能完成需求!需要实现一个实时的录放音!我把它放到一个speaking方法中!

	private int mRecBuffSize;//录音缓存区大小
	private AudioRecord  mAudioRecord;//声明一个录音对象
	private int mPlayBufSize;//放音缓存区大小
	private AudioTrack mAudioTrack;//声明一个放音对象
	static final int frequency = 44100;//频率
	static final int channelConfiguration = AudioFormat.CHANNEL_CONFIGURATION_MONO;  //通道配置
	static final int audioEncoding = AudioFormat.ENCODING_PCM_16BIT;   //声音编码 


	private void init_AudioRecordAndTrack() {
		// 调用getMinBufferSize方法获得录音的最小缓冲空间  
		mRecBuffSize = mAudioRecord.getMinBufferSize(frequency, channelConfiguration, audioEncoding);//频率 通道配置  声音格式
		System.out.println("得录音的最小缓冲空间  "+mRecBuffSize);
		// 调用构造函数实例化录音对象  
		mAudioRecord = new AudioRecord(MediaRecorder.AudioSource.MIC, frequency,
				channelConfiguration, audioEncoding, 
				mRecBuffSize);
		
		// 调用getMinBufferSize方法获得放音最小的缓冲区大小  
		mPlayBufSize = AudioTrack.getMinBufferSize(frequency,  
                channelConfiguration, audioEncoding); 
        // 调用构造函数实例化放音对象,以听筒模式播放  
			mAudioTrack = new AudioTrack(AudioManager.STREAM_VOICE_CALL, frequency, channelConfiguration,
        		audioEncoding, mPlayBufSize,  AudioTrack.MODE_STREAM);
	}

	public void speaking(){
		Thread speakThread = new Thread(){
				public void run(){
					byte[] byteBuff = new byte[mRecBuffSize]; //缓存数组
					int size ;
					mAudioRecord.startRecording();//开始录音
					mAudioTrack.play();// 开始播放  
					isPlay = true;
					while(isPlay){
						size = mAudioRecord.read(byteBuff, 0, mRecBuffSize); //将读到的录音 放到缓存数组中
						mAudioTrack.write(byteBuff, 0, size);//播放,这里是通过听筒播放的
		               		
					}
				}
			};
			speakThread.start();
		
		}
	}

接下来就是连接的部分了!也是最关键的部分!之前说过,蓝牙连接的的方式有几种,协议也有几种!由于之前误认为是传输数据流!所以把蓝牙的数据传输部分也弄了一遍,顺便写一下!先说蓝牙与蓝牙之间的连接,在我们Android手机系统中自带的蓝牙就可以实现连接 配对 并且传输文件!但没法传输指定的数据!所以下面就一传输数据为例!将上面搜索的设备赋值mSerDevice = device; //就是代表你搜索到的设备

1 传输数据 需要搭建一个客户端 一个服务端 ,就和Java TCP 通信类似!蓝牙的客户端,服务端 这篇文章里也有相关的介绍 http://blog.csdn.net/q610098308/article/details/45248423
这里再整理一下!
int State = mSerDevice.getBondState(); //获取蓝牙设备的状态
	switch (State) {
			case BluetoothDevice.BOND_NONE://未配对
				//做配对处理
				Method createBondMethod;
				try {
					createBondMethod = BluetoothDevice.class.getMethod("createBond");
					createBondMethod.invoke(mSerDevice);
				} catch (Exception e) {
					e.printStackTrace();
				}  
			
		case BluetoothDevice.BOND_BONDED://以配对
			//准备连接,下面根据需要选其中一种
			// connetServer();//以数据传输的方式连接
			 connect();//以语音通信的方式连接
			
		default:
			break;
		}

客户端 连接的两种方法 ,数据 语音,先说传数据的

	public void connetServer(){
		if(mSerDevice!=null){
		 String SPP_UUID ="10001105-0000-1000-8000-00805f9b34fb";//准备一个UUID码
						 //10001101-0000-1000-8000-00805f9b34fb
 
			 UUID uuid = UUID.fromString(SPP_UUID);  
			 try {
				mSocket = mSerDevice.createRfcommSocketToServiceRecord(uuid);
				mSocket.connect();//在连接上之前会一种阻塞
				mOutputStream = mSocket.getOutputStream();
				mInputStream = mSocket.getInputStream();
				
				byte[] buffer = new byte[1024];
				while(true){
					//在这里做读取服务端的数据
				}
			} catch (IOException e) {
				try {
					mSocket.close();
				} catch (IOException e1) {
					e1.printStackTrace();
				}
			}
		}
	} 

上面的UUID需要说明一下:它有唯一标识的作用,上面准备了两个!网上大多都说连接一般的手机需要用10001101-0000-1000-8000-00805f9b34fb;但我使用怎么都连不上 后面换了10001105-0000-1000-8000-00805f9b34fb 就可以连上,这是连接手机的,当然就算连上了你也只能像系统原有的蓝牙功能一样发送文件!(就和你使用Android自带的蓝牙连接一样)。这个UUID就是连接系统的蓝牙!
要实现数据的发送,我们还需要一个服务端(用到另一个手机做一个服务端)

	public void listenconn(){//监听连接
		new Thread(){
			public void run(){
				listener();
			}
		}.start();
	}
		public void listener(){
		String SPP_UUID ="10001105-0000-1000-8000-00805f9b34fb";//准备一个UUID码
		UUID uuid = UUID.fromString(SPP_UUID); 
		BluetoothServerSocket ServerSocket;
		try {
			ServerSocket = mAdapter.listenUsingRfcommWithServiceRecord("BluetoothChatSecure",uuid);
			mSocket = ServerSocket.accept();//阻塞,,,,,,,
			mOutputStream = mSocket.getOutputStream();
			mInputStream = mSocket.getInputStream();
			while(true){
			//这里可以读取客户端发送过来的数据
			}
			
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

对于只传输数据来说就需要重写一个APP充当服务端了,然后加入上面的两个方法并在一开始就监听,这里要注意:UUID要和客户端的一样!我在操作的时候有一个现象!我身边的手机用10001105-0000-1000-8000-00805f9b34fb就可以连上!但做数据传输时。如果是10001105它就会连接手机原有的那个服务!没法连接我自己做的服务端!所以我改变了UUID,随便换一个数就可以!但要服务和客户端的一样!,通过上面一旦连接成功你就会得到输入输出流!使用它们就可以实现数据的传输。

实现了数据的传输,接下来就说说语音的传输。用 connect()方法中实现连接。在连接之前需要先获取BluetoothA2DP,用于传输语音数据。

	private void getBluetoothA2DP(){
        if(mAdapter == null){
            return;
        }

        if(mBluetoothA2dp != null){
            return;
        }

        mAdapter.getProfileProxy(this, new BluetoothProfile.ServiceListener() {
            public void onServiceConnected(int profile, BluetoothProfile proxy) {
                if(profile == BluetoothProfile.A2DP){
                    //Service连接成功,获得BluetoothA2DP
                    mBluetoothA2dp = (BluetoothA2dp)proxy;
                }
            }
            @Override
            public void onServiceDisconnected(int profile) {

            }
        },BluetoothProfile.A2DP);
    }

接下来就开始连接

	public void connect(){
	        if(mBluetoothA2dp == null){
	            return;
	        }
	        if(mSerDevice == null){
	            return;
	        }
	        try {
	            Method connect = mBluetoothA2dp.getClass().getDeclaredMethod("connect", BluetoothDevice.class);
	            connect.setAccessible(true);
	            connect.invoke(mBluetoothA2dp,mSerDevice);
	        } catch (Exception e) {
	        	title_tv.setText("连接失败");
	            e.printStackTrace();
	        }
	}

那我们怎么知道是否连接上了呢?一开始我们说过,蓝牙的状态我们使用广播来接收!只要我们设置了意图过滤器,那蓝牙的状态我们就可以接收
所以在上面的广播中在添加如下代码:

			case BluetoothA2dp.ACTION_CONNECTION_STATE_CHANGED://蓝牙耳机设备状态改变
				int action1 = intent.getIntExtra(BluetoothA2dp.EXTRA_STATE, -1);
				switch (action1) {
				case BluetoothA2dp.STATE_CONNECTING://正在连接中
					//"正在连接中"
					break;
				case BluetoothA2dp.STATE_CONNECTED://连接上了
					//"连接上了"
					break;
				case BluetoothA2dp.STATE_DISCONNECTING://断开中
					//"断开中"]
					break;
				case BluetoothA2dp.STATE_DISCONNECTED://断开了
					//"连接已断开";
					break;

				default:
					break;
				}		

还有一个断开连接:

	private void disconnect(){
	        if(mBluetoothA2dp == null){
	            return;
	        }
	        if(mSerDevice == null){
	            return;
	        }
	        try {
	            Method disconnect = mBluetoothA2dp.getClass().getDeclaredMethod("disconnect", BluetoothDevice.class);
	            disconnect.setAccessible(true);
	            disconnect.invoke(mBluetoothA2dp,mSerDevice);
	        } catch (Exception e) {
	            e.printStackTrace();
	        }
	    }

当然别忘了注册哟!

    <uses-permission android:name="android.permission.BLUETOOTH"/>
    <uses-permission android:name="android.permission.BLUETOOTH_ADMIN"/>
    <uses-permission android:name="android.permission.RECORD_AUDIO"/>

还有设置意图过滤器!如果不明白的话需要你对广播进行了解:

        IntentFilter filter = new IntentFilter();
        filter.addAction(BluetoothA2dp.ACTION_CONNECTION_STATE_CHANGED);
        filter.addAction(BluetoothA2dp.ACTION_PLAYING_STATE_CHANGED);
        
        filter.addAction(BluetoothDevice.ACTION_FOUND);
        filter.addAction(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
        
        filter.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED);
        filter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED);
        registerReceiver(mReceiver, filter);

好了,整个流程就是这样!上面我将各个功能分开讲!都可以单独使用的。再来整理一下流程:
1 获取蓝牙适配器,打开蓝牙 ,开始搜索
2 通过获得的设备,来准备连接,这里有两种连接方式!一种是以语音的协议来连接,另一种就是单独的发送数据的方式!
3 如果是传输语音:在广播中可得到连接的状态!只要连接成功!开始录音就可以在蓝牙耳机听到!传输数据:在连接成功后获得输入输出流就可以传输数据!

以上是如有说不对的地方欢迎指正!有需要源码的也可以私信我!

有评论需要代码,这里贴载地址:源码
有问题评论解决。

2016-05-30 15:26:17 weijiqian 阅读数 898

Android 蓝牙传输数据.

一个简单的从一个手机传输数据到另外的一个手机里面.如果要传输文件的,可以自己增加文件读写功能.

demo下载:http://download.csdn.net/detail/weijiqian/9535393
参考:
http://blog.csdn.net/q610098308/article/details/45248423
http://blog.csdn.net/qinjuning/article/details/7726093
所有代码都在MainActivity里面,附代码如下:



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.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import android.view.View;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.ListView;
import android.widget.Toast;

import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Set;
import java.util.UUID;

public class MainActivity extends Activity implements AdapterView.OnItemClickListener {

    Button open;
    Button close;
    Button listBtn;
    ListView listview;
    Button  search;

    /**
     * 设备列表
     */
    ArrayList deviceList;

    ArrayAdapter adapter;
    /**
     * //已经配对的设备
     */
    Set<BluetoothDevice> deviceSet;

    /**
     * 蓝牙适配器
     */
    BluetoothAdapter bluetoothAdapter;

    /**
     * UUID,是随便写的,两个配对的设备UUID要是一样的.
     */
    private final UUID MY_UUID = UUID.fromString("e220ff28-b64a-4cbc-804b-a73dfcdc3941");

    private final String NAME = "bluetoothSocket";

    /**
     * 蓝牙客户端
     */
    private BluetoothSocket clientSocket;

    /**
     * 蓝牙设备
     */
    private BluetoothDevice device;

    /**
     * 输出流
     */
    private OutputStream ous;

    /**
     * 线程,接受传递过来的数据.
     */
    private AcceptThread acceptThread ;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        open = (Button) findViewById(R.id.open);
        close = (Button) findViewById(R.id.close);
        listBtn = (Button) findViewById(R.id.show_list);
        search = (Button) findViewById(R.id.search);
        listview = (ListView) findViewById(R.id.list_view);

        //实例化蓝牙
        bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();

        //初始化蓝牙列表显示.
        deviceList = new ArrayList();
        adapter = new ArrayAdapter
                (this,android.R.layout.simple_list_item_1, deviceList);
        listview.setAdapter(adapter);
        listview.setOnItemClickListener(this);

        //注册广播,接受扫描附近蓝牙的结果.
        IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND);
        registerReceiver(mReceiver, filter);
        filter = new IntentFilter(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
        registerReceiver(mReceiver, filter);

        //开启线程.监听数据.
        acceptThread = new AcceptThread();
        acceptThread.start();

        open.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                openBluetooth();
            }

        });

        search.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                searchBluetooth();
            }


        });


        close.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                    closeBluetooth();
            }
        });

        listBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                showList();
            }
        });


    }




    private void openBluetooth() {
        //打开蓝牙
        if(!bluetoothAdapter.isEnabled()){
            //弹出对话框提示用户是后打开
            Intent enabler = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
            startActivityForResult(enabler, 0);
            Toast.makeText(MainActivity.this,"打开蓝牙",Toast.LENGTH_LONG).show();
        }else {
            Toast.makeText(MainActivity.this,"蓝牙已经打开",Toast.LENGTH_LONG).show();
        }

        //打开本机的蓝牙发现功能(默认打开120秒,可以将时间最多延长至300秒)
         Intent discoveryIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
        discoveryIntent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 300);//设置持续时间(最多300秒)
        startActivityForResult(discoveryIntent,0);
    }


    private void searchBluetooth() {
        if ( !bluetoothAdapter.isDiscovering()){
            deviceList.clear();
            bluetoothAdapter.startDiscovery();
            Toast.makeText(MainActivity.this,"蓝牙开始扫描",Toast.LENGTH_LONG).show();
        }else {
            Toast.makeText(MainActivity.this,"蓝牙正在扫描",Toast.LENGTH_LONG).show();
        }

    }

    private void showList() {
        //已经配对的设备
        deviceSet = bluetoothAdapter.getBondedDevices();
        deviceList.clear();

        for(BluetoothDevice bt : deviceSet)
            deviceList.add(bt.getName() +":"+bt.getAddress());

        adapter.notifyDataSetChanged();
    }

    private void closeBluetooth() {
        if (bluetoothAdapter.isEnabled()){
            bluetoothAdapter.disable();
        }

    }


    BroadcastReceiver mReceiver = new BroadcastReceiver() {
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();
            //找到设备.搜索附近的设备.
            if (BluetoothDevice.ACTION_FOUND.equals(action)) {
                BluetoothDevice device = intent
                        .getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);

                Toast.makeText(MainActivity.this,"搜索到设备",Toast.LENGTH_LONG).show();
                if (device.getBondState() != BluetoothDevice.BOND_BONDED) {

                    Log.e("dddd", "find device:" + device.getName()
                            + device.getAddress());
                    deviceList.add(device.getName()+":"+ device.getAddress());
                    adapter.notifyDataSetChanged();
                }
            }
            //搜索完成
            else if (BluetoothAdapter.ACTION_DISCOVERY_FINISHED
                    .equals(action)) {
                Toast.makeText(MainActivity.this,"搜索完成",Toast.LENGTH_LONG).show();

            }
        }
    };


    @Override
    public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
        //点击配对.
        //客户端
        String s =(String) adapter.getItem(position);
        String address = s.substring(s.indexOf(":")+1).trim();

        try{
            Log.e("ddd","开始配对");
            if (bluetoothAdapter.isDiscovering()){
                bluetoothAdapter.cancelDiscovery();
            }
            if (device == null ){
                device = bluetoothAdapter.getRemoteDevice(address);
            }
            if (clientSocket ==  null ){
                clientSocket = device.createRfcommSocketToServiceRecord(MY_UUID);
                clientSocket.connect();

            }
            //得到输出流
            ous = clientSocket.getOutputStream();

            //把数据放到输出流.
            if (ous != null ){
                ous.write("发送数据到另外一个手机".getBytes("utf-8"));
            }

        }catch (Exception e){
            Log.e("ddd","连接出错:"+e.getMessage());
        }
    }


    //服务端
    private Handler handle = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            Log.e("ddd","接受到数据");
            Toast.makeText(MainActivity.this,String.valueOf(msg.obj),Toast.LENGTH_SHORT).show();
            super.handleMessage(msg);
        }
    };


    private class  AcceptThread extends  Thread{
        private BluetoothSocket socket;
        private BluetoothServerSocket serverSocket;

        private InputStream is;
        private OutputStream os;

        private AcceptThread (){
            try{
                serverSocket = bluetoothAdapter.listenUsingInsecureRfcommWithServiceRecord(NAME,MY_UUID);
            }catch (Exception e){

            }

        }

        public  void run(){
            try{
                socket = serverSocket.accept();
                is = socket.getInputStream();
                os = socket.getOutputStream();

                while (true){
                    byte[] buffer = new byte[128];
                    int count = is.read(buffer);
                    Message msg = new Message();
                    msg.obj = new String (buffer,0,count,"utf-8");
                    handle.sendMessage(msg);

                }

            }catch (Exception e){

            }
        }
    }
}

xml文件布局:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    android:orientation="vertical"
    >


    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="horizontal">

        <Button
            android:id="@+id/open"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="打开蓝牙" />


        <Button
            android:id="@+id/search"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="搜索蓝牙" />

        <Button
            android:id="@+id/close"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="关闭蓝牙" />

        <Button
            android:id="@+id/show_list"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="显示蓝牙列表" />
    </LinearLayout>


    <ListView
        android:id="@+id/list_view"
        android:layout_width="match_parent"
        android:layout_height="match_parent">

    </ListView>

</LinearLayout>

2016-02-26 21:58:55 qingzhouzhen 阅读数 1907

本篇文章介绍两部android手机之间如何通过蓝牙传输数据

1 权限声明

<uses-permission android:name="android.permission.BLUETOOTH"></uses-permission>
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN"></uses-permission>
2  搜索附近的设备

bluetoothAdapter.startDiscovery();
注册广播,从接收到的广播的onReceive的intent参数中获取BluetoothDevice对象
BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
注册广播
IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND);
this.registerReceiver(receive, filter);
filter = new IntentFilter(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
this.registerReceiver(receive, filter);
3 发送消息
根据对方MAC地址获取对方蓝牙设备
device = bluetoothAdapter.getRemoteDevice(address);
根据设备获取socket
bluetoothSocket = device.createRfcommSocketToServiceRecord(MY_UUID);
建立连接
bluetoothSocket.connect();
获取输出流对象
os = bluetoothSocket.getOutputStream();
往输出流写入想要发送的东西
os.write("Hwllo World".getBytes("utf-8"));
4在接收端获取数据
接收端获得 socket
serverSocket = bluetoothAdapter.listenUsingRfcommWithServiceRecord(NAME, MY_UUID);
从输入socket中获得输入流
socket = serverSocket.accept();
is = socket.getInputStream();



package com.example.huanghanqing.bluetoothsocket;

import android.bluetooth.BluetoothA2dp;
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.Handler;
import android.os.Message;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.ListView;
import android.widget.Toast;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.UUID;

public class MainActivity extends AppCompatActivity implements AdapterView.OnItemClickListener {

    Button btnsearch, stopsearch;
    BluetoothAdapter bluetoothAdapter = null;
    private List<String> bluetoothDevice = new ArrayList<String>();
    private ArrayAdapter<String> adapter;
    private ListView listView;
    private final UUID MY_UUID = UUID
            .fromString("db764ac8-4b08-7f25-aafe-59d03c27bae3");
    private BluetoothDevice device;
    private BluetoothSocket bluetoothSocket;
    private OutputStream os;
    private final String NAME = "Bluetooth_Socket";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
        Set<BluetoothDevice> pairdDevice = bluetoothAdapter.getBondedDevices();
        if (pairdDevice.size() > 0) {
            for (BluetoothDevice device : pairdDevice
                    ) {
                bluetoothDevice.add(device.getName() + ":" + device.getAddress() + "\n");
            }
        }

        listView = (ListView) findViewById(R.id.listview);
        btnsearch = (Button) findViewById(R.id.btn_search);
        stopsearch = (Button) findViewById(R.id.btn_stop_search);
        btnsearch.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {

                searchDevice();
            }
        });
        stopsearch.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                bluetoothAdapter.cancelDiscovery();
                setTitle("搜索已经停止");
            }
        });

        adapter = new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, android.R.id.text1, bluetoothDevice);
        listView.setAdapter(adapter);
        listView.setOnItemClickListener(this);

        IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND);
        this.registerReceiver(receive, filter);
        filter = new IntentFilter(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
        this.registerReceiver(receive, filter);

        new AcceptThread().start();
    }

    public void searchDevice() {
        setProgressBarIndeterminateVisibility(true);
        setTitle("正在扫描...");
        if (bluetoothAdapter.isDiscovering()) {
            bluetoothAdapter.cancelDiscovery();
        }
        bluetoothAdapter.startDiscovery();
    }

    private BroadcastReceiver receive = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            // String action = getIntent().getAction(); this is a mistake make by me ,getIntent means get the intent form the activiy who atart this activity
            String action = intent.getAction();
            if (BluetoothDevice.ACTION_FOUND.equals(action)) {

                BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);

                if (device.getBondState() != BluetoothDevice.BOND_BONDED) {
                    bluetoothDevice.add(device.getName() + ":" + device.getAddress() + "\n");
                    adapter.notifyDataSetChanged();
                }
            } else if (BluetoothAdapter.ACTION_DISCOVERY_FINISHED.equals(action)) {
                setProgressBarVisibility(false);
                setTitle("已搜索完成");
            }
        }
    };

    @Override
    public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
        String s = adapter.getItem(position);
        String address = s.substring(s.indexOf(":") + 1).trim();
        try {
            if (bluetoothAdapter.isDiscovering()) {
                bluetoothAdapter.cancelDiscovery();
            }
            try {
                if (device == null) {
                    device = bluetoothAdapter.getRemoteDevice(address);
                }
                if (bluetoothSocket == null) {

                    bluetoothSocket = device.createRfcommSocketToServiceRecord(MY_UUID);
                    bluetoothSocket.connect();
                    os = bluetoothSocket.getOutputStream();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            if (os != null) {
                os.write("Hwllo World".getBytes("utf-8"));
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    private Handler handler = new Handler() {
        public void handleMessage(Message msg) {
            Toast.makeText(MainActivity.this, String.valueOf(msg.obj),
                    Toast.LENGTH_LONG).show();
            super.handleMessage(msg);
        }
    };

    private class AcceptThread extends Thread {
        private BluetoothServerSocket serverSocket;
        private BluetoothSocket socket;
        private InputStream is;
        private OutputStream os;

        public AcceptThread() {
            try {
                serverSocket = bluetoothAdapter
                        .listenUsingRfcommWithServiceRecord(NAME, MY_UUID);
            } catch (Exception e) {
                // TODO: handle exception
            }
        }

        public void run() {
            try {
                socket = serverSocket.accept();
                is = socket.getInputStream();
                os = socket.getOutputStream();

                while (true) {
                    byte[] buffer = new byte[128];
                    int count = is.read(buffer);
                    Message msg = new Message();
                    msg.obj = new String(buffer, 0, count, "utf-8");
                    handler.sendMessage(msg);
                }
            } catch (Exception e) {
                // TODO: handle exception
            }

        }
    }
}





2019-01-02 17:45:45 HHL110120 阅读数 1588

   最近对蓝牙传输比较感兴趣,所以抽时间研究了一下。由于身边没有合适的外部设备,我这边就一台手机作为中心设备,一台手机作为从设备来进行调试,开发。由于关于蓝牙设备配对,连接,简单发送数据网上相关的文章已经很多了,我今天对于这些就不再详细的说明了,大家感兴趣的话。可以看看下面的这些文章。
《iOS开发之玩转蓝牙CoreBluetooth》

  我今天主要和大家分享的是蓝牙传输时大量数据的传输方案。我们结合网上的蓝牙demo,简单的传输一个字符串没有问题,但是如果涉及到大量数据的参数就不行了。

蓝牙进行大量数据的使用场景

  coreBluetooth属于低功耗蓝牙,所以在进行数据传输时一般数据量比较小,但是也存在一些大量数据传输的需求,比如固件升级,文件传输等场景,音频传输等。这些场景由于需要传输的数据比较大,多以要进行分包处理。相对简单的几个字符的传输,操作起来要麻烦的多。

CoreBlueTooth知识点普及

1,蓝牙传输的字节顺序是小端
2,coreBlueTooth 的最大传输单元是20个字节。

通过蓝牙实现大量数据传输的原理

&esmp 为了保证数据传输的准确性和有序性。我们需要在每个传输单元中分出一部分字节,用来标记这部分数据的顺序。并且我们还需要给数据创建包头,来表明数据的总长度。

JKTransferDataHelper简介

  知道了原理,实现起来还是有一定的难度的,我在网上搜了一下,并没有发现类似的pod库,无奈之下,决定自己来写一个。下面来给大家介绍一下这个库。 pod 'JKTransferDataHelper' 源码地址:https://github.com/xindizhiyin2014/JKTransferDataHelper
下面结合源码来说明下
JKTransferDataConfig 类

@interface JKTransferDataConfig : NSObject

@property (nonatomic,assign) NSUInteger mtuSize;       ///< the transportlation unit  the size is byte
@property (nonatomic,assign) NSUInteger packetHeadSize;///<  the data head,the unit is byte
@property (nonatomic,assign) JKTransferByteSortType byteSortType;///<

+ (instancetype)configMTUSize:(NSUInteger)mtuSize packetHeadSize:(NSUInteger)packetHeadSize byteSortType:(JKTransferByteSortType)byteSortType;

@end

其中mtuSize是最大传输单元,由于该框架适用于coreBlueTooth,同时也适用于UDP传输。packetHeadSize是每个传输单元上标记顺序的包头所占用的字节长度。byteSortType 是指传输的字节顺序

JKTransferDataHelper类

@interface JKTransferDataHelper : NSObject

/**
 handle the data with packet sort Num
//主要是对要传输的数据进行转换,根据需求为每个传输单元加上序列号
 @param data binary data
 @param dataConfig dataConfig
 @return data with sort Num
 */
+ (NSMutableData *)formatData:(NSData *)data dataConfig:(JKTransferDataConfig *)dataConfig;

/**
 remove the sort Num in binary data
//对接收到的含有序列号的数据,去掉序列号的包头,然后重新拼接成为我们真正需求要的数据
 @param data binary data
 @param dataConfig dataConfig
 @return binary without sorNum
 */
+ (NSMutableData *)unFormatData:(NSMutableData *)data dataConfig:(JKTransferDataConfig *)dataConfig;

/**
 append unitPacketData
//数据接收到单元数据,然后感觉需求进行拼接的操作
 @param unitPacketData unitPacketData
 @param originData the origin data
 @param dataLength the target data length
 @param dataConfig dataConfig
 @return <#return value description#>
 */
+ (NSMutableData *)appendUnitPacketData:(NSData *)unitPacketData originData:(NSMutableData *)originData dataLength:(NSUInteger)dataLength dataConfig:(JKTransferDataConfig *)dataConfig;

/**
 config the binary data head
//根据数据的长度,生成包头数据
 @param originDataLength the data length
 @param dataConfig dataConfig
 @return the binary data of data head
 */
+ (NSData *)configPacketHead:(NSUInteger)originDataLength dataConfig:(JKTransferDataConfig *)dataConfig;

/**
 get the origin data length
//获取包头数据,并解析出数据的长度
 @param data  binary data
 @param dataConfig dataConfig
 @return the origin length of the data
 */
+ (NSUInteger)getOriginDataLength:(NSData *)data dataConfig:(JKTransferDataConfig *)dataConfig;

/**
 get the format dataLength with packet sort Num
//根据需求,获取数据添加万序列号以后的长度。
 @param originData originData
 @param dataConfig dataConfig
 @return the dataLenght
 */
+ (NSUInteger)getFormatBodyDataLengthWithOriginData:(NSData *)originData dataConfig:(JKTransferDataConfig *)dataConfig;


/**
 get appropriate PacketHeadSize with originData and mtuSize
//根据要传输的数据,计算出合适的传输包序列号所占的字节长度。
 @param originData originData
 @param mtuSize mtuSize
 @return PacketHeasSize
 */
+ (NSUInteger)getPacketHeadSizeWithOriginData:(NSData *)originData mtuSize:(NSUInteger)mtuSize;

@end

更多优质文章,可以微信扫码关注:
这里写图片描述

2014-11-10 20:22:41 nefulwp 阅读数 1348

在开发通过Mobile连接蓝牙串口传输GPS数据时遇到的问题记录一下。

一、蓝牙串口的建立
想在mobile平台上通过蓝牙串口发送数据,遇到过一些问题,在此记录一下,由于在mobile上无法像CE上直接通过代码操作蓝牙去查找设备,连接设备,在mobile上需要先在程序外面配对后建立发送端口,然后才能像操作串口那样去连接设备,接收数据。具体方法如下:
在【设置】-->【蓝牙】中添加新设备中搜索到需要连接的设备,下一步,输入密码进行配对,此时并未真正完成蓝牙的配对操作,切换到【COM端口标签页】,新建发送端口,给设备添加一下可用端口,经测试{com0,com5,com8,com9}可用,其它好像不能用,具体情况根据机器有可能不同。此时端口配对操作完成,在应用程序中选择新配置的COM口及波特率与设备进行连接。

二、端口号与设备的对应关系
以上动作完成后会有一个问题:当配对的机器多了之后根本无法知道哪个COM口对应的哪台设备,经过百般查找,后来意识到微软的东西几乎都是存在注册表里的,在设置里能看到对应关系,那么就自然可以将设备名称与端口号对应起来,不用每次都去设置里查看。具体办法如下:

在LOCAL_MACHINE\Software\Microsoft\Bluetooth\Device与LOCAL_MACHINE\Software\Microsoft\Bluetooth\Serial\Ports下存在一些注册表项,经过验证Ports下保存的为新建发送端口的设备,Device下保存的是配对成功但是没有新建发送端口的设备,现在的对应关系是在Ports里找到一个设备新建的端口号,再通过Device下去查找设备名,两者组合起来就完成了对应关系,注意:Device下的设备号比Ports下前面少4个0,后面的数字一样,这是对应关系的关键。代码(C#)如下:

private List<string> GetDevicePort()
        {
            RegistryKey key = null;
            List<string> results = new List<string>();
            try
            {
                key = Registry.LocalMachine.OpenSubKey("Software\\Microsoft\\Bluetooth\\Serial\\Ports", false);
                if (key != null)
                {
                    string[] coms = key.GetSubKeyNames();//获取已配置设备MAC
                    if (coms != null)
                    {
                        for (int i = 0; i < coms.Length; i++)
                        {
                            string result = string.Empty;
                            //获取设备名[HKEY_LOCAL_MACHINE\Software\Microsoft\Bluetooth\Device\00025a0091d2]
                            key = Registry.LocalMachine.OpenSubKey("Software\\Microsoft\\Bluetooth\\Device\\" + coms[i].Substring(4), false);
                            if (key != null)
                            {
                                object deviceName = key.GetValue("name");
                                if(deviceName!=null)
                                {
                                    result += deviceName.ToString().Trim('\0');
                                }
                            }
                            //获取设备COM口
                            key = Registry.LocalMachine.OpenSubKey("Software\\Microsoft\\Bluetooth\\Serial\\Ports\\" + coms[i], false);
                            if (key != null)
                            {
                                object comNum = key.GetValue("Port");
                                if (comNum != null)
                                {
                                    result+="("+comNum.ToString().Trim('\0')+")";
                                }
                            }
                            results.Add(result);
                        }

                    }

                }
                return results;
            }
            finally
            {
                if (key != null)
                    key.Close();
            }
        }
三、蓝牙的重启动
这样在自己的应用程序中就可以清楚的看到哪个端口对应的哪台设备了。
在Mobile设置连接蓝牙后异常断开会出现很难再连接的情况,目前我的解决办法如下:
通过蓝牙API进行蓝牙的重启,经过测试效率较高:
蓝牙有三种状态,PowerOff、Connectable、Discoverable; PowerOff为蓝牙电源关、Connectable为蓝牙可连接、Discoverable为蓝牙不可补发现
当出现蓝牙无法连接时:首先调用BthSetMode(PowerOff)关闭蓝牙,然后调用BthSetMode(Connectable)开启蓝牙,这样成功率较高,注意开启后好像要等待几秒后才会生效。API如下(C#调用):
[DllImport("BthUtil.dll", SetLastError = true)]
public static extern int BthSetMode(RadioMode dwMode);
[DllImport("BthUtil.dll", SetLastError = true)]
public static extern int BthGetMode(ref RadioMode dwMode);

public enum RadioMode
{
    PowerOff = 0,
    Connectable = 1,
    Discoverable
<span style="font-family: Arial, Helvetica, sans-serif;">}</span>


蓝牙之数据传输问题

阅读数 12171

没有更多推荐了,返回首页