Android学习笔记之蓝牙通信...

最新推荐文章于 2022-11-18 16:09:38 发布
最新推荐文章于 2022-11-18 16:09:38 发布
阅读量730 收藏 1
点赞数
分类专栏： 04 Android有关

From：http://www.cnblogs.com/RGogoing/p/4680306.html

 

学习内容：

1.如何实现蓝牙通信技术...

 

  蓝牙通信其实是手机里很常用的一种通信方式，现在的手机中是必然存在蓝牙的，蓝牙通信也是有一部分优点的，功耗低，安全性比较高，但是缺点想必大家都知道，传输的速率也确实是不快，相比于Wifi通信，确实不值一提...虽然影响范围并不高，但是既然蓝牙存在，那么还是有必要知道蓝牙是如何进行通信的...蓝牙通信有两种方式，最常用的就是使用socket套接字来实现蓝牙通信...

  蓝牙通信原理：蓝牙通信的原理很简单，一个设备作为服务端，另一个设备作为客户端，服务端对外暴露，客户端通过发送连接请求，服务端进行响应，然后返回一个BluetoothSocket套接字来管理这个连接...那么服务端个客户端就会共享一个RFCOMM端口，进行数据传递...听起来其实蛮简单的，实现过程还是有点复杂的...这里我还是直接上一个代码吧...

  这个是Activity.java文件...这是个非常长的代码块，看完谁都头痛...我们还是进行分块解释...先把这些代码都略过...还是看最下面的解释...

  View Code

   这个是我自定义了一个类，用来判断蓝牙的连接类型...

复制代码 
package com.qualcomm.bluetoothclient;

public class BluetoothMsg {

    /** 
     * 蓝牙连接类型  
     * 
     */  
    public enum ServerOrCilent {
        NONE,  
        SERVICE,  
        CILENT  
    };
    
    //蓝牙连接方式  
    public static ServerOrCilent serviceOrCilent = ServerOrCilent.NONE;  
    //连接蓝牙地址  
    public static String BlueToothAddress = null, lastblueToothAddress = null;  
    //通信线程是否开启  
    public static boolean isOpen = false;
    
}
复制代码

  这个是保存我们发送的数据信息的自定义类...

复制代码 
package com.qualcomm.bluetoothclient;
/*
 *  这里定义一个类，用来保存我们发送的数据信息...
 * 
 */
public class ChatMessage {

    private String message;
    private boolean isSiri;
    
    public ChatMessage(String message, boolean siri) {
        // TODO Auto-generated constructor stub
        this.message = message;
        this.isSiri = siri;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public boolean isSiri() {
        return isSiri;
    }

    public void setSiri(boolean isSiri) {
        this.isSiri = isSiri;
    }
    
    
}
复制代码

  最后这个是适配器...因为我这里使用到了ListView，因此我需要使用一个适配器来设置ListView以何种方式显示在屏幕上...

复制代码 
package com.qualcomm.bluetoothclient;

import java.util.ArrayList;

import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.TextView;

/*
 * 
 * 
 * 
 * 
 * 
 */
public class ClientAdapter extends BaseAdapter {

    private ArrayList<ChatMessage> list;
    private LayoutInflater mInflater;
    
    public ClientAdapter(Context context, ArrayList<ChatMessage> messages) {
        // TODO Auto-generated constructor stub
        this.list = messages;
        this.mInflater = LayoutInflater.from(context);
    }
    
    @Override
    public int getCount() {
        // TODO Auto-generated method stub
        return list.size();
    }

    @Override
    public Object getItem(int position) {
        // TODO Auto-generated method stub
        return list.get(position);
    }

    @Override
    public long getItemId(int position) {
        // TODO Auto-generated method stub
        return position;
    }
    
    @Override
    public int getItemViewType(int position) {
        // TODO Auto-generated method stub
        return position;
    }

    @Override
    public View getView(int position, View convertView, ViewGroup parent) {
        // TODO Auto-generated method stub
        ViewHolder viewHolder = null;
        ChatMessage message = list.get(position);
        if (convertView == null) {
            convertView = mInflater.inflate(R.layout.list_item, null);
            viewHolder = new ViewHolder((View)convertView.findViewById(R.id.list_child)
                    , (TextView)convertView.findViewById(R.id.chat_msg));
            convertView.setTag(viewHolder);
        } else {
            viewHolder = (ViewHolder) convertView.getTag();
        }
        if (message.isSiri()) {
            viewHolder.child.setBackgroundResource(R.drawable.msgbox_rec);
        } else {
            viewHolder.child.setBackgroundResource(R.drawable.msgbox_send);
        }
        viewHolder.msg.setText(message.getMessage());
        
        return convertView;
    }

    class ViewHolder {
          protected View child;
        protected TextView msg;

        public ViewHolder(View child, TextView msg){
            this.child = child;
            this.msg = msg;
            
        }
    }

}
复制代码

  在这里我进行正式的解释...先说第二部分..第二部分是一些初始化的操作...也就是获取本地蓝牙，注册广播，设置监听的一些过程...因为实现通信，我们首先要判断我们的手机是否有蓝牙...获取到本机的蓝牙... 也就是这句话是实现通信的第一步...mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();我们才能够打开蓝牙...然后进行操作...详细解释在代码中...

复制代码 
    //→_→ 第二部分...
    
    // 变量初始化
    private void init() {
        // TODO Auto-generated method stub
        mContext = this;
        mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();//获取本地蓝牙...实现通信的第一步...
        
        list = new ArrayList<ChatMessage>();// 初始化list,由于我们最后会将数据以列表的形式进行显示，因此使用ListView...
        clientAdapter = new ClientAdapter(mContext, list);  //适配器,用来限制如何显示ListView...
        
        mListView = (ListView) findViewById(R.id.list);
        
        mListView.setFastScrollEnabled(true);  //使用快速滑动功能..目的是能够快速滑动到指定位置...
        
        mListView.setAdapter(clientAdapter);
        
        mListView.setOnItemClickListener(this);
        
        /* 下面是注册receiver监听，注册广播...说一下为什么要注册广播...
         * 因为蓝牙的通信，需要进行设备的搜索，搜索到设备后我们才能够实现连接..如果没有搜索，那还谈什么连接...
         * 因此我们需要搜索，搜索的过程中系统会自动发出三个广播...这三个广播为：
         * ACTION_DISCOVERY_START:开始搜索...
         * ACTION_DISCOVERY_FINISH:搜索结束...
         * ACTION_FOUND:正在搜索...一共三个过程...因为我们需要对这三个响应过程进行接收，然后实现一些功能，因此
         * 我们需要对广播进行注册...知道广播的人应该都知道，想要对广播进行接收，必须进行注册，否则是接收不到的...
         * */
        IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND);
        registerReceiver(mReceiver, filter);
        
        // 定义一个集合，来保存已经配对过的设备...
        Set<BluetoothDevice> pairedDevices = mBluetoothAdapter.getBondedDevices();
        
        if (pairedDevices.size() > 0) {  //如果存在设备...
            for (BluetoothDevice device : pairedDevices) {//遍历...
                
                //将手机名字和物理地址放入到listview中...
                list.add(new ChatMessage(device.getName() + "\n" + device.getAddress(), true));
                
                clientAdapter.notifyDataSetChanged();  //重新绘制ListView
                
                mListView.setSelection(list.size() - 1); //设置list保存的信息的位置...说白了该条信息始终在上一条信息的下方...
            }
        } else {  
            list.add(new ChatMessage("没有已经配对过的设备", true));
            clientAdapter.notifyDataSetChanged();
            mListView.setSelection(list.size() - 1);
        }
        
        editText = (EditText) findViewById(R.id.edit);
        editText.setEnabled(false);  
        editText.clearFocus();  //设置没有焦点..也就是无法输入任何文字...
        
        sendButton = (Button) findViewById(R.id.btn_send);
        sendButton.setEnabled(false);

        sendButton.setOnClickListener(new OnClickListener() {//设置监听，只有获取到焦点后才能进行此过程...
            
            @Override
            public void onClick(View arg0) {
                // TODO Auto-generated method stub
                String msg = editText.getText().toString();
                
                if (msg.length() > 0) {
                    //调用第五部分线程，通过线程发送我们输入的文本...
                    sendMessageHandler(msg);
                    //发送完清空...
                    editText.setText("");
                    editText.clearFocus();
                    
                    InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);//定义一个输入法对象...通过Context.INPUT_METHOD_SERVICE获取实例...
                    //当EditText没有焦点的时候，阻止输入法的弹出...其实就是在没点击EditText获取焦点的时候，没有输入法的显示...
                    imm.hideSoftInputFromWindow(editText.getWindowToken(), 0);
                } else {
                    Toast.makeText(mContext, "发送内容不能为空", Toast.LENGTH_SHORT).show();
                }
            }
        });
        
        disconnect = (Button) findViewById(R.id.disconnect);
        disconnect.setEnabled(false);
        //为断开连接设置监听...
        disconnect.setOnClickListener(new OnClickListener() {
            
            @Override
            public void onClick(View arg0) {
                // TODO Auto-generated method stub
                
                // 关闭相关服务，调用第六部分的函数...
                closeClient();
                //表示蓝牙状态需要关闭...
                BluetoothMsg.isOpen = false;
                
                BluetoothMsg.serviceOrCilent = BluetoothMsg.ServerOrCilent.NONE;
                Toast.makeText(mContext, "连接已断开", Toast.LENGTH_SHORT).show();
            }
        });
    }
复制代码

  接着就是第三部分了...我们获取到了本地的蓝牙设备，我们就需要把蓝牙进行打开了..只有开启了蓝牙，才能够进行搜索，连接等操作..因此这一步是实现蓝牙通信的关键...

复制代码 
//→_→ 第三部分...
    @Override
    protected void onStart() {
        // TODO Auto-generated method stub
        super.onStart();
        if (mBluetoothAdapter != null) {  //本地蓝牙存在...
            if (!mBluetoothAdapter.isEnabled()) {   //判断蓝牙是否被打开...
                
                // 发送打开蓝牙的意图，系统会弹出一个提示对话框,打开蓝牙是需要传递intent的...
                // intent这个重要的东西，大家应该都知道，它能够实现应用之间通信和交互....
                Intent enableIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
                //打开本机的蓝牙功能...使用startActivityForResult（）方法...这里我们开启的这个Activity是需要它返回执行结果给主Activity的...
                startActivityForResult(enableIntent, RESULT_FIRST_USER);
                
                        
                Intent displayIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
                // 设置蓝牙的可见性，最大值3600秒，默认120秒，0表示永远可见(作为客户端，可见性可以不设置，服务端必须要设置)
                displayIntent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 0);
                //这里只需要开启另一个activity，让其一直显示蓝牙...没必要把信息返回..因此调用startActivity()
                startActivity(displayIntent);
                
                // 直接打开蓝牙
                mBluetoothAdapter.enable();//这步才是真正打开蓝牙的部分....
            }
        }
    }
    
    //这步就是当线程从Pause状态到Avtive状态要执行的过程...
    @Override
    protected void onResume() {
        // TODO Auto-generated method stub
        super.onResume();
        // 扫描
        scanDevice();  //调用第七部分的扫描过程...
    }
复制代码

  然后是第四部分....第四部分是对广播响应后的接收过程..这个过程也是重要的，因为我们在开启蓝牙后扫描的时候，如果有设备可以连接，我们得做一些操作让用户知道有设备可以连接，总不能有设备连接，我们什么也不告诉用户，这就不合理吧....因此我们在这一步是需要给用户反馈信息的...让用户知道下一步应该做什么...这一部分倒是很简单，没复杂的东西..

复制代码 
//→_→ 第四部分...
    private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
          
            String action = intent.getAction(); //获取当前正在执行的动作...


            if (BluetoothDevice.ACTION_FOUND.equals(action)) //正在搜索过程...
            {
                // 通过EXTRA_DEVICE附加域来得到一个BluetoothDevice设备
                BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
                
                // 如果这个设备是不曾配对过的，添加到list列表
                if (device.getBondState() != BluetoothDevice.BOND_BONDED) 
                {
                    list.add(new ChatMessage(device.getName() + "\n" + device.getAddress(), false));
                    clientAdapter.notifyDataSetChanged();
                    mListView.setSelection(list.size() - 1);
                }
            } 
            else if (BluetoothAdapter.ACTION_DISCOVERY_FINISHED.equals(action)) //搜索结束后的过程...
            {
                setProgressBarIndeterminateVisibility(false);  //这步是如果设备过多是否显示滚动条...
                if (mListView.getCount() == 0) 
                {
                    list.add(new ChatMessage("没有发现蓝牙设备", false));
                    clientAdapter.notifyDataSetChanged();
                    mListView.setSelection(list.size() - 1);
                }
            }
        }
    };
复制代码

  第五部分就是线程部分了，所有的线程部分...涉及UI的更新，数据信息的显示，将数据进行发送，接收服务器返回的数据信息...这步是实现数据传递的关键...

复制代码 
   //→_→ 第五部分...
    
    private Handler LinkDetectedHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            //这步多了一个判断..判断的是ListView保存的数据是我们要传输给服务端的数据，还是那些我们定义好的提示数据...
            if(msg.what==1)
            {
                list.add(new ChatMessage((String)msg.obj, true));
            }
            else
            {
                list.add(new ChatMessage((String)msg.obj, false));
            }
            clientAdapter.notifyDataSetChanged();
            mListView.setSelection(list.size() - 1);
            
        }
        
    };
    // Handler更新UI...
    // 当连接上服务器的时候才可以选择发送数据和断开连接，并且要对界面进行刷新操作...
    private Handler refreshUI = new Handler() {
        public void handleMessage(Message msg) {
            if (msg.what == 0) {
                disconnect.setEnabled(true);
                sendButton.setEnabled(true);
                editText.setEnabled(true);
            }
        }
    };
    
    // 开启客户端连接服务端，一个新的线程...
    private class ClientThread extends Thread {
        @Override
        public void run() {
            // TODO Auto-generated method stub
            if (device != null) {
                try {
                    /* 下面这步也是关键，我们如果想要连接服务器，我们需要调用方法createRfcommSocketToServiceRecord
                     * 参数00001101-0000-1000-8000-00805F9B34FB表示的是默认的蓝牙串口...通过传递参数调用方法，
                     * 会返回给我们一个套接字..这一步就是获取套接字，实现连接的过程...
                     * 
                     * */
                    socket = device.createRfcommSocketToServiceRecord(UUID.fromString("00001101-0000-1000-8000-00805F9B34FB"));
                    // 连接
                    Message msg = new Message();
                    msg.obj = "请稍候，正在连接服务器: "+ BluetoothMsg.BlueToothAddress;
                    msg.what = 0;
                    LinkDetectedHandler.sendMessage(msg); //调用线程，显示msg信息...
                    
                    // 通过socket连接服务器，正式形成连接...这是一个阻塞过程，直到连接建立或者连接失效...
                    socket.connect();
                    //如果实现了连接，那么服务端和客户端就共享一个RFFCOMM信道...
                    Message msg2 = new Message();
                    msg2.obj = "已经连接上服务端！可以发送信息";
                    msg2.what = 0;
                    LinkDetectedHandler.sendMessage(msg2); //调用线程，显示msg信息...
                    
                    // 如果连接成功了...这步就会执行...更新UI界面...否则走catch（IOException e）
                    Message uiMessage = new Message();
                    uiMessage.what = 0;
                    refreshUI.sendMessage(uiMessage);
                    
                    // 可以开启读数据线程
                    mReadThread = new ReadThread();
                    mReadThread.start();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    // socket.connect()连接失效
                    Message msg = new Message();
                    msg.obj = "连接服务端异常！断开连接重新试一试。";
                    msg.what = 0;
                    LinkDetectedHandler.sendMessage(msg);
                }
            }
        }
    }
    
    // 通过socket获取InputStream流..
    private class ReadThread extends Thread {
        @Override
        public void run() {
            // TODO Auto-generated method stub
    
            byte[] buffer = new byte[1024];
            int bytes;
            InputStream is = null;
            try {
                is = socket.getInputStream(); //获取服务器发过来的所有字节...
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            while(true) {
                try {//读取过程，将数据信息保存在ListView中...
                    if ((bytes = is.read(buffer)) > 0) {
                        byte[] data = new byte[bytes];
                        for (int i = 0; i < data.length; i++) {
                            data[i] = buffer[i];
                        }
                        String s = new String(data);
                        Message msg = new Message();
                        msg.obj = s;
                        msg.what = 1;  //这里的meg.what=1...表示的是服务器发送过来的数据信息..
                        LinkDetectedHandler.sendMessage(msg);
                    }
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    try {
                        is.close();
                    } catch (IOException e1) {
                        // TODO Auto-generated catch block
                        e1.printStackTrace();
                    }
                    break;
                }
            }
        }
    }
    //这一步表示的是发送数据的过程...
    private void sendMessageHandler(String msg) {
        if (socket == null) {
            Toast.makeText(mContext, "没有可用的连接", Toast.LENGTH_SHORT).show();
            return;
        }
        //如果连接上了，那么获取输出流...
        try {
            OutputStream os = socket.getOutputStream();
            os.write(msg.getBytes());//获取所有的自己然后往外发送...
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        list.add(new ChatMessage(msg, false));  //将数据存放到list中
        clientAdapter.notifyDataSetChanged();
        mListView.setSelection(list.size() - 1);
    }
复制代码

  第六部分就是一个停止服务的一个过程，就不细说了，第七部分就是一个扫描的过程，扫描附近的设别...

复制代码 
 // →_→ 第七部分...
    // 扫描设备
    private void scanDevice() {
        // TODO Auto-generated method stub
        if (mBluetoothAdapter.isDiscovering()) {  //如果正在处于扫描过程...
            mBluetoothAdapter.cancelDiscovery();  //取消扫描...
        } else {
            list.clear();  
            clientAdapter.notifyDataSetChanged();
            
            // 每次扫描前都先判断一下是否存在已经配对过的设备
            Set<BluetoothDevice> pairedDevices = mBluetoothAdapter.getBondedDevices();
            if (pairedDevices.size() > 0) {  //如果存在配对过的设备，那么就直接遍历集合，然后显示..
                    for (BluetoothDevice device : pairedDevices) {
                        list.add(new ChatMessage(device.getName() + "\n" + device.getAddress(), true));
                        clientAdapter.notifyDataSetChanged();
                        mListView.setSelection(list.size() - 1);
                    }
            } else {  //如果没有就进行添加...
                    list.add(new ChatMessage("No devices have been paired", true));
                    clientAdapter.notifyDataSetChanged();
                    mListView.setSelection(list.size() - 1);
              }                
            /* 开始搜索 */
            mBluetoothAdapter.startDiscovery();
        }
    }
复制代码

  第八部分为连接过程做了一些初始化的工作，获取其他设备的物理地址，通过物理地址实现连接...至于第九部分就是销过程了，第一部分就是变量的定义过程...就没什么好说的了...

复制代码 
 //→_→  第八部分...
    @Override
    public void onItemClick(AdapterView<?> arg0, View arg1, int arg2, long arg3) {
        // TODO Auto-generated method stub
        ChatMessage item = list.get(arg2);  //item保存着message和一个boolean数值...
        String info = item.getMessage();    //单纯获取message的信息...
        
        String address = info.substring(info.length() - 17);//获取MAC地址...其实就是硬件地址...因为连接设别必然从物理地址下手...
        
        
        BluetoothMsg.BlueToothAddress = address;//赋值
        
        // 停止扫描
        // BluetoothAdapter.startDiscovery()很耗资源，在尝试配对前必须中止它
        mBluetoothAdapter.cancelDiscovery();
        
        // 通过Mac地址去尝试连接一个设备，
        device = mBluetoothAdapter.getRemoteDevice(BluetoothMsg.BlueToothAddress);
        
        mClientThread = new ClientThread();  
        mClientThread.start();   //开启新的线程...开始连接...这里只是做了一些初始化的工作..连接过程还是ClientThread线程...
        BluetoothMsg.isOpen = true;
        
    }
复制代码

xml文件我就不贴了，直接放一个源码吧...这个源码包含一个客户端，一个服务端...（注意，这个测试需要在两个真机上测试，模拟器是没有作用的...）

源码地址：http://files.cnblogs.com/files/RGogoing/Bluetooth.zip

 

It_BeeCoder
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
物联网Android bluetooth 蓝牙通信
05-14
Android 开发进阶课程蓝牙通信    本教程介绍了Android 蓝牙通信的原理及具体实现，其中包括：客户端服务器结构和对等结构。然后介绍了基于Socket实现的蓝牙通信，以及基于蓝牙实现对等结构网络通讯。我们还介绍了蓝牙r发现服务协议的使用。Android 蓝牙开发基本流程https://blog.csdn.net/q610098308/article/details/45248423android 蓝牙 通信 bluetoothhttps://blog.csdn.net/q610098308/article/details/45605389
蓝牙通信的简要设计与开发
Goblin147的博客
12-13 235
目录蓝牙的两个广播介绍蓝牙通信原理介绍具体代码结果 蓝牙的两个广播介绍 （1）：蓝牙状态的改变是通过广播接收到的。 // 注册蓝牙状态接收广播 IntentFilter intentFilter = new ntentFilter(BluetoothAdapter.ACTION_STATE_CHANGED); registerReceiver(mReceiverBluetoothStatus,intentFilter); /** * 定义接收蓝牙状态广播receiver
Android蓝牙通信
qq_51771271的博客
12-13 4635
Android 平台包含蓝牙网络堆栈支持，此支持能让设备以无线方式与其他蓝牙设备交换数据。应用框架提供通过 Android Bluetooth API 访问蓝牙功能的权限。这些 API 允许应用以无线方式连接到其他蓝牙设备，从而实现点到点和多点无线功能。 使用蓝牙进行通信的四大必需任务：设置蓝牙、查找局部区域内的配对设备或可用设备、连接设备，以及在设备之间传输数据。 为了让支持蓝牙的设备能够在彼此之间传输数据，它们必须先通过配对过程形成通信通道。其中一台设备（可检测到的设备）需将自身设置为可接收传入的连接请
蓝牙学习二（连接和通讯简述）
qq_26226375的博客
11-18 4005
蓝牙的通信是双向的，为了创建和维护一个BLE通信连接，在蓝牙中引入了“角色”这一概念，一个BLE设备不是主机（集中器）就是从机（外围设备）角色，这是根据是谁发起这个连接来确定的。主机（集中器）设备总是连接的发起者，而从机（外围设备）总是被连接者。整个访问与连接过程都是在GAP（Generic Access Profile-通用访问规范）进行实现的。
蓝牙基础知识
热门推荐
dianji2015_的博客
05-30 1万+
蓝牙基础知识1.蓝牙简介2. 蓝牙芯片 1.蓝牙简介 蓝牙技术是一种无线通信的方式，利用特定频率的波段（2.4-2.485GHz左右），进行电磁波传输。 蓝牙分为经典蓝牙(传统蓝牙和告诉蓝牙)和低功耗蓝牙（Bluetooth Low Energy） 2. 蓝牙芯片 蓝牙芯片由主要由射频芯片，处理器，存储器等。 ...
Android学习笔记(20220104202419).pdf
11-18
Android学习笔记(20220104202419).pdf
android学习笔记RadioGroup实现单选.pdf
11-17
android学习笔记RadioGroup实现单选.pdf
Swift学习笔记含项目代码.zip
02-18
Swift学习笔记含项目代码.zipSwift学习笔记含项目代码.zipSwift学习笔记含项目代码.zipSwift学习笔记含项目代码.zipSwift学习笔记含项目代码.zipSwift学习笔记含项目代码.zipSwift学习笔记含项目代码.zipSwift学习...
2023年通信学习笔记.docx
10-27
2023年通信学习笔记.docx
SPSS学习笔记非参数检验.pdf
07-13
SPSS学习笔记非参数检验.pdfSPSS学习笔记非参数检验.pdfSPSS学习笔记非参数检验.pdfSPSS学习笔记非参数检验.pdfSPSS学习笔记非参数检验.pdfSPSS学习笔记非参数检验.pdf
Android BLE蓝牙与硬件通信(原生API)
11-07
源码包含内容介绍: 1.Android手机通过蓝牙(BLE)与硬件进行通信(包括扫描,连接,发送,接收,注册服务等等) 2.控制手机音量 3. 实现控制第三方音乐播放器暂停、播放 4.使用AudioRecord和AudioTrack边录边播 详情请查看:https://blog.csdn.net/dengshunhao/article/details/82222296
Android 蓝牙通信简单实例
09-19
这是一个Android蓝牙开发的小程序，代码简单，实现了蓝牙打开、搜索、配对、连接、通信等功能。两个Android项目，一个服务器一个客户端
蓝牙通信协议
09-22
蓝牙协议:介绍蓝牙通信原理，已经蓝牙协议结构。
android ev3 蓝牙连接,分享一下自己研究EV3蓝牙通信原理的成果 （完结）
weixin_36299242的博客
05-31 1307
本帖最后由 太空虫虫 于 2016-7-13 22:47 编辑写在最前面：本帖是介绍与EV3进行蓝牙通信的基本原理，所以可能需要一点计算机及编程语言方法的知识来帮助理解。另外，本帖不涉及如何编写手机APP等方面的知识，也没有现成的软件供下载，如果是有这方面需求的小伙伴，可以去搜搜论坛的其他帖子。谢谢~-------------------------------------------------...
Android Phone蓝牙通信方式总结（Socket与Gatt）
dingpwen的博客
04-16 3216
Android手机间通过蓝牙方式进行通信，有两种常见的方式，一种是socket方式，另一种是通过Gatt Server（Android 5.0以后）通信，socket方式最为简单，但是很多低功耗的蓝牙设备，如单片机上的蓝牙模块可能不支持。而Gatt方式说起来就比较复杂，我研究了好会儿，搜索了不少资料，走了不少弯路才总结出来。 首先来看比较简单的socket方式 其实无论是socket方式还是Ga...
2024-2030全球及中国PCB接触式探头行业研究及十五五规划分析报告.docx
最新发布
04-18
2024-2030全球及中国PCB接触式探头行业研究及十五五规划分析报告
网站界面设计mortal0418代码
04-18
网站界面设计mortal0418代码
python3基础学习笔记(精品).pdf
11-27
《Python3基础学习笔记(精品).pdf》是一本关于Python3基础学习的精品教材。该教材的内容包括Python3的基本语法、数据类型、控制流程、函数的定义和使用、文件的读写等基础知识点。 首先，教材详细介绍了Python3的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值