Java --- Bluetooth Device & Service Discovery Code examples

最新推荐文章于 2024-02-26 10:37:44 发布
转载 最新推荐文章于 2024-02-26 10:37:44 发布 · 962 阅读 · 1 

import java.io.IOException;
import java.util.Vector;

import javax.bluetooth.DeviceClass;
import javax.bluetooth.DiscoveryAgent;
import javax.bluetooth.DiscoveryListener;
import javax.bluetooth.LocalDevice;
import javax.bluetooth.RemoteDevice;
import javax.bluetooth.ServiceRecord;

/**
 * Class that discovers all bluetooth devices in the neighborhood and displays their name and
 * bluetooth address.
 */
public class BluetoothDeviceDiscovery implements DiscoveryListener {

        // object used for waiting
        private static Object lock = new Object();

        // vector containing the devices discovered
        private static Vector<RemoteDevice> vecDevices = new Vector<RemoteDevice>();

        /**
         * Lists nearby bluetooth devices
         * 
         * @return
         */
        public void listDevices() throws IOException {

                // display local device address and name
                LocalDevice localDevice = LocalDevice.getLocalDevice();
                System.out.println("Address: " + localDevice.getBluetoothAddress());
                System.out.println("Name: " + localDevice.getFriendlyName());

                // find devices
                DiscoveryAgent agent = localDevice.getDiscoveryAgent();
                System.out.println("Starting device inquiry...");
                agent.startInquiry(DiscoveryAgent.GIAC, this);

                // avoid callback conflicts
                try {
                        synchronized (lock) {
                                lock.wait();
                        }
                } catch (InterruptedException e) {
                        e.printStackTrace();
                }

                System.out.println("Device Inquiry Completed. ");

                // print all devices in vecDevices
                int deviceCount = vecDevices.size();
                if (deviceCount <= 0) {
                        System.out.println("No Devices Found .");
                } else {
                        // print bluetooth device addresses and names in the format [ No. address (name) ]
                        System.out.println("Bluetooth Devices: ");
                        for (int i = 0; i < deviceCount; i++) {
                                RemoteDevice remoteDevice = (RemoteDevice) vecDevices.elementAt(i);
                                try {
                                        System.out.println((i + 1) + ". " + remoteDevice.getBluetoothAddress() + " (" + remoteDevice.getFriendlyName(true) + ")");
                                } catch (IOException ioe) {
                                        ioe.printStackTrace();
                                }
                        }
                }
        }

        /**
         * @return the vecDevices
         */
        public static Vector<RemoteDevice> getVecDevices() {
                return vecDevices;
        }

        /**
         * This call back method will be called for each discovered bluetooth devices.
         */
        public void deviceDiscovered(RemoteDevice btDevice, DeviceClass cod) {
                System.out.println("Device discovered: " + btDevice.getBluetoothAddress());
                // add the device to the vector
                if (!vecDevices.contains(btDevice)) {
                        vecDevices.addElement(btDevice);
                }
        }

        // no need to implement this method since services are not being discovered
        public void servicesDiscovered(int transID, ServiceRecord[] servRecord) {
        }

        // no need to implement this method since services are not being discovered
        public void serviceSearchCompleted(int transID, int respCode) {
        }

        /**
         * This callback method will be called when the device discovery is completed.
         */
        public void inquiryCompleted(int discType) {
                synchronized (lock) {
                        lock.notify();
                }

                switch (discType) {
                case DiscoveryListener.INQUIRY_COMPLETED:
                        System.out.println("INQUIRY_COMPLETED");
                        break;

                case DiscoveryListener.INQUIRY_TERMINATED:
                        System.out.println("INQUIRY_TERMINATED");
                        break;

                case DiscoveryListener.INQUIRY_ERROR:
                        System.out.println("INQUIRY_ERROR");
                        break;

                default:
                        System.out.println("Unknown Response Code");
                        break;
                }
        }// end method

}



import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Vector;

import javax.bluetooth.DeviceClass;
import javax.bluetooth.DiscoveryAgent;
import javax.bluetooth.DiscoveryListener;
import javax.bluetooth.LocalDevice;
import javax.bluetooth.RemoteDevice;
import javax.bluetooth.ServiceRecord;
import javax.bluetooth.UUID;

/**
 * 
 * Class that discovers all bluetooth devices in the neighborhood,
 * 
 * Connects to the chosen device and checks for the presence of OBEX push service in it. and
 * displays their name and bluetooth address.
 * 
 * 
 */
public class BluetoothServiceDiscovery implements DiscoveryListener {

        // object used for waiting
        private static Object lock = new Object();

        // vector containing the devices discovered
        private static Vector<RemoteDevice> vecDevices = new Vector<RemoteDevice>();

        // device connection address
        private static String connectionURL = null;

        /**
         * Lists nearby bluetooth device services
         */
        public void listServices() throws IOException {

                // display local device address and name
                LocalDevice localDevice = LocalDevice.getLocalDevice();
                System.out.println("Address: " + localDevice.getBluetoothAddress());
                System.out.println("Name: " + localDevice.getFriendlyName());

                // find devices
                DiscoveryAgent agent = localDevice.getDiscoveryAgent();
                System.out.println("Starting device inquiry...");
                agent.startInquiry(DiscoveryAgent.GIAC, this);

                // avoid callback conflicts
                try {
                        synchronized (lock) {
                                lock.wait();
                        }
                } catch (InterruptedException e) {
                        e.printStackTrace();
                }

                System.out.println("Device Inquiry Completed. ");

                // print all devices in vecDevices
                int deviceCount = vecDevices.size();
                if (deviceCount <= 0) {
                        System.out.println("No Devices Found .");
                } else {
                        // print bluetooth device addresses and names in the format [ No. address (name) ]
                        System.out.println("Bluetooth Devices: ");
                        for (int i = 0; i < deviceCount; i++) {
                                RemoteDevice remoteDevice = (RemoteDevice) vecDevices.elementAt(i);
                                try {
                                        System.out.println((i + 1) + ". " + remoteDevice.getBluetoothAddress() + " (" + remoteDevice.getFriendlyName(true) + ")");
                                } catch (IOException ioe) {
                                        ioe.printStackTrace();
                                }
                        }
                }

                // prompt user
                System.out.print("Choose the device to search for Obex Push service : ");
                BufferedReader bReader = new BufferedReader(new InputStreamReader(System.in));
                String chosenIndex = bReader.readLine();
                int index = Integer.parseInt(chosenIndex.trim());

                // check for obex service
                RemoteDevice remoteDevice = (RemoteDevice) vecDevices.elementAt(index - 1);
                UUID[] uuidSet = new UUID[1];
                uuidSet[0] = new UUID("1105", true);
                System.out.println("\nSearching for service...");
                agent.searchServices(null, uuidSet, remoteDevice, this);

                // avoid callback conflicts
                try {
                        synchronized (lock) {
                                lock.wait();
                        }
                } catch (InterruptedException e) {
                        e.printStackTrace();
                }

                // notify
                if (connectionURL == null) {
                        System.out.println("Device does not support Object Push.");
                } else {
                        System.out.println("Device supports Object Push.");
                }
        }

        /**
         * Called when a bluetooth device is discovered. Used for device search.
         */
        public void deviceDiscovered(RemoteDevice btDevice, DeviceClass cod) {
                // add the device to the vector
                if (!vecDevices.contains(btDevice)) {
                        vecDevices.addElement(btDevice);
                }
        }

        /**
         * Called when a bluetooth service is discovered. Used for service search.
         */
        public void servicesDiscovered(int transID, ServiceRecord[] servRecord) {
                if (servRecord != null && servRecord.length > 0) {
                        connectionURL = servRecord[0].getConnectionURL(0, false);
                }
                synchronized (lock) {
                        lock.notify();
                }
        }

        /**
         * Called when the service search is over.
         */
        public void serviceSearchCompleted(int transID, int respCode) {
                synchronized (lock) {
                        lock.notify();
                }
        }

        /**
         * Called when the device search is over.
         */
        public void inquiryCompleted(int discType) {
                synchronized (lock) {
                        lock.notify();
                }

        }// end method

}// end class

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Vector;

import javax.bluetooth.DeviceClass;
import javax.bluetooth.DiscoveryAgent;
import javax.bluetooth.DiscoveryListener;
import javax.bluetooth.LocalDevice;
import javax.bluetooth.RemoteDevice;
import javax.bluetooth.ServiceRecord;
import javax.bluetooth.UUID;
import javax.microedition.io.Connector;
import javax.microedition.io.StreamConnection;

import data.model.Node;
import data.parser.DataParser;



/**
 * A simple SPP client that connects with an SPP server
 */
public class SimpleSPPClient implements DiscoveryListener {

	// object used for waiting
	private static Object lock = new Object();

	// vector containing the devices discovered
	private static Vector<RemoteDevice> vecDevices = new Vector<RemoteDevice>();

	// device connection address
	private static String connectionURL = null;

	/**
	 * runs a bluetooth client that sends a string to a server and prints the
	 * response
	 */
	public void runClient() throws IOException {

		// display local device address and name
		LocalDevice localDevice = LocalDevice.getLocalDevice();
		System.out.println("Address: " + localDevice.getBluetoothAddress());
		System.out.println("Name: " + localDevice.getFriendlyName());

		// find devices
		DiscoveryAgent agent = localDevice.getDiscoveryAgent();
		System.out.println("Starting device inquiry...");
		agent.startInquiry(DiscoveryAgent.GIAC, this);

		// avoid callback conflicts
		try {
			synchronized (lock) {
				lock.wait();
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		System.out.println("Device Inquiry Completed. ");

		// print all devices in vecDevices
		int deviceCount = vecDevices.size();
		if (deviceCount <= 0) {
			System.out.println("No Devices Found .");
		} else {
			// print bluetooth device addresses and names in the format [ No.
			// address (name) ]
			System.out.println("Bluetooth Devices: ");
			for (int i = 0; i < deviceCount; i++) {
				RemoteDevice remoteDevice = (RemoteDevice) vecDevices
						.elementAt(i);
				try {
					System.out.println((i + 1) + ". "
							+ remoteDevice.getBluetoothAddress() + " ("
							+ remoteDevice.getFriendlyName(true) + ")");
				} catch (IOException ioe) {
					ioe.printStackTrace();
				}
			}
		}

		// prompt user
		System.out.print("Choose the device to search for service : ");
		BufferedReader bReader = new BufferedReader(new InputStreamReader(
				System.in));
		String chosenIndex = bReader.readLine();
		int index = Integer.parseInt(chosenIndex.trim());

		// check for services
		RemoteDevice remoteDevice = (RemoteDevice) vecDevices
				.elementAt(index - 1);
		UUID[] uuidSet = new UUID[1];

		uuidSet[0] = new UUID("1101", true); // serial, SPP
		// uuidSet[0] = new UUID("0003", true); // rfcomm
		// uuidSet[0] = new UUID("1106", true); // obex file transfer
		// uuidSet[0] = new UUID("1105", true); // obex obj push

		System.out.println("\nSearching for services...");
		agent.searchServices(null, uuidSet, remoteDevice, this);

		// avoid callback conflicts
		try {
			synchronized (lock) {
				lock.wait();
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		// check
		if (connectionURL == null) {
			System.out.println("Device does not support Service.");
			System.exit(0);
		}

		// connect to the server
		StreamConnection streamConnection = null;
		try {
			System.out.println("Connected to server. \nNow start reading data from " + connectionURL);
			
			streamConnection = (StreamConnection) Connector.open(connectionURL);
			
			System.out.println("open connection ok!");
			InputStream inStream = streamConnection.openInputStream();
			
//			DataParser dParser = new DataParser(inStream);
//			dParser.Parse();
			Node node = new Node(inStream);
			node.readFromPort();
			
		} catch (Exception e) {
			e.printStackTrace();
			System.exit(0);
		}
		System.out.println("End connection to server.");

	}

	// methods of DiscoveryListener
	public void deviceDiscovered(RemoteDevice btDevice, DeviceClass cod) {
		// add the device to the vector
		if (!vecDevices.contains(btDevice)) {
			vecDevices.addElement(btDevice);
		}
	}

	// implement this method since services are not being discovered
	public void servicesDiscovered(int transID, ServiceRecord[] servRecord) {
		if (servRecord != null && servRecord.length > 0) {
			connectionURL = servRecord[0].getConnectionURL(0, false);
		}
		synchronized (lock) {
			lock.notify();
		}
	}

	// implement this method since services are not being discovered
	public void serviceSearchCompleted(int transID, int respCode) {
		synchronized (lock) {
			lock.notify();
		}
	}

	public void inquiryCompleted(int discType) {
		synchronized (lock) {
			lock.notify();
		}

	}// end method
	
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;

import javax.bluetooth.*;
import javax.microedition.io.*;

/**
 * Class that implements an SPP Server which accepts single line of message from
 * an SPP client and sends a single line of response to the client.
 */
public class SimpleSPPServer {

	/**
	 * runs a bluetooth server that accepts a string from a client and sends a
	 * response
	 */
	public void runServer() throws IOException {

		// display local device address and name
		LocalDevice localDevice = LocalDevice.getLocalDevice();
		System.out.println("Address: " + localDevice.getBluetoothAddress());
		System.out.println("Name: " + localDevice.getFriendlyName());

		// SimpleSPPServer sampleSPPServer = new SimpleSPPServer();
		// sampleSPPServer.startServer();
		this.startServer();

	} // runServer

	// start server
	private void startServer() throws IOException {

		// Create a UUID
		UUID uuid = new UUID("1101", true); // serial, SPP
		// UUID uuid = new UUID("1105", true); // obex obj push
		// UUID uuid = new UUID("0003", true); // rfcomm
		// UUID uuid = new UUID("1106", true); // obex file transfer

		// Create the service url
		String connectionString = "btspp://localhost:" + uuid
				+ ";name=Sample SPP Server";

		// open server url
		StreamConnectionNotifier streamConnNotifier = (StreamConnectionNotifier) Connector
				.open(connectionString);

		// Wait for client connection
		System.out
				.println("\nServer Started. Waiting for clients to connect...");
		StreamConnection connection = streamConnNotifier.acceptAndOpen();

		// connect
		System.out.println("Connecting to client...");
		RemoteDevice dev = RemoteDevice.getRemoteDevice(connection);
		try {
			System.out.println("Remote device address: "
					+ dev.getBluetoothAddress());
			System.out.println("Remote device name: "
					+ dev.getFriendlyName(true));
		} catch (IOException ioe) {
			ioe.printStackTrace();
		}

		// read string from spp client
		// InputStream inStream = connection.openInputStream();
		// BufferedReader bReader = new BufferedReader(new
		// InputStreamReader(inStream));
		// String lineRead = bReader.readLine();
		// System.out.println("TEST"+lineRead);

		// read string from spp client
		Thread recvT = new Thread(new recvLoop(connection));
		recvT.start();

		// send response to spp client
		// OutputStream outStream = connection.openOutputStream();
		// PrintWriter pWriter = new PrintWriter(new
		// OutputStreamWriter(outStream));
		// pWriter.write("Response String from SPP Server\r\n");
		// pWriter.flush();

		// send response to spp client
		// Thread sendT = new Thread(new sendLoop(connection));
		// sendT.start();

		// close connection
		// pWriter.close();
		// streamConnNotifier.close();

		System.out.println("\nServer threads started");

		while (true) {
			try {
				Thread.sleep(2000);
				// System.out.println("\nServer looping.");
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

	} // startServer

	private static class recvLoop implements Runnable {
		private StreamConnection connection = null;
		private InputStream inStream = null;

		public recvLoop(StreamConnection c) {
			this.connection = c;
			try {
				this.inStream = this.connection.openInputStream();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}

		@Override
		public void run() {
			while (true) {
				try {

					BufferedReader bReader = new BufferedReader(
							new InputStreamReader(inStream));
					String lineRead = bReader.readLine();
					System.out.println("Server recv: " + lineRead);
					Thread.sleep(500);
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
	} // recvLoop

	private static class sendLoop implements Runnable {
		private StreamConnection connection = null;
		PrintWriter pWriter = null;

		public sendLoop(StreamConnection c) {
			this.connection = c;
			OutputStream outStream;
			try {
				outStream = this.connection.openOutputStream();
				this.pWriter = new PrintWriter(
						new OutputStreamWriter(outStream));
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

		@Override
		public void run() {
			while (true) {
				try {
					String line = "Response String from SPP Server\r\n"; // "\r\n"
																			// important
					pWriter.write(line);
					pWriter.flush();
					System.out.println("Server send: " + line);
					Thread.sleep(500);
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
	} // recvLoop

} // class

import java.io.IOException;

public class SprimeBT {

        /**
         * Main
         * 
         * @param args
         */

        // main method of the application
        public static void main(String[] args) throws IOException {

                /*
                 * Test bed for BT classes. Set to true/false for testing
                 */

                if (false) {
                        // scan and print nearby bluetooth devices
                        System.out.println("\n" + "Testing BT Device Discovery" + "\n");
                        BluetoothDeviceDiscovery bluetoothDeviceDiscovery = new BluetoothDeviceDiscovery();
                        bluetoothDeviceDiscovery.listDevices();
                }

                if (false) {
                        // scan and print nearby bluetooth device services
                        System.out.println("\n" + "Testing BT Service Discovery" + "\n");
                        BluetoothServiceDiscovery bluetoothServiceDiscovery = new BluetoothServiceDiscovery();
                        bluetoothServiceDiscovery.listServices();
                }

                if (false) {
                        // start a bluetooth server
                        System.out.println("\n" + "Testing BT Server" + "\n");
                        SimpleSPPServer sppServer = new SimpleSPPServer();
                        sppServer.runServer();
                }

                if (true) {
                        // start a bluetooth client
                        System.out.println("\n" + "Testing BT Client" + "\n");
                        SimpleSPPClient sppClient = new SimpleSPPClient();
                        sppClient.runClient();
                }

        }// end main

}// end class


11、Bluetooth and OBEX: Enabling Device Communication in J2ME Applications
7h6j5k4l3的博客
06-08 243
This blog post explores the integration of Bluetooth and OBEX in J2ME applications, covering fundamental concepts, advanced techniques for performance and security enhancement, real-world applications across various industries, and future trends in wireles
btstack ble ota开发笔记(2)-mcuboot移植
weixin_38177846的博客
07-20 1650
紧接上一篇文章，要实现一个完整的ota demo，除了实现ota image的传输通道外，还需要“bootloader”这个角色来帮我们实现ota image的校验、安全、引导以及启动，这里我选择开源的组件mcuboot，下面开始介绍mcuboot在stm32f4-discovery上的移植。首先估算下bootloader & application image的大小，确定好flash的分布情况，因为后续会涉及到flash的操作（读、写、擦除），为了方便程序的编写，各个image area在flash中的起
java 蓝牙_通过Java代码连接到蓝牙设备
weixin_28725949的博客
02-12 3679
我想通过我的笔记本电脑的蓝牙连接到另一个蓝牙设备 .我正在使用bluecove库供我参考 . 我的环境如下：机器：Ubuntu 12.4，四核，8GB Ram . Java：1.8 Blueove：bluecove-2.1.1-SNAPSHOT.jar，bluecove-gpl-2.1.0.jar我写了下面的代码连接到本地蓝牙设备 .LocalDevice localDevice = Local...
java 蓝牙设备_java-查找和配对蓝牙设备
weixin_39656686的博客
02-16 726
以下代码将在您必须实现客户端和服务器之后发现已配对和未配对设备的列表,该列表负责配对设备并将数据发送到设备,因为您可以利用BluetoothChatSample给你一个主意.private Set pairedDevices;public static ArrayList BondedDeviceList;public static ArrayList NewDeviceList;public v...
CachedBluetoothDevice.java该怎么用？
01-01 674
Android 本人纯菜鸟，现在想要删除蓝牙已配对设备记录，网上搜了半天找到了这个CachedBluetoothDevice.java /****这是复制网上的原话****/ BluetoothSettings.java 蓝牙设置应用，蓝牙状态变化及设备绑定信息处理等。各个菜单处理主要是通过CachedBluetoothDevice.java来实现。主要有添加蓝牙设备，删除蓝牙设备，点击获
bluetooth java_[原]BluetoothDevice详解
weixin_35920143的博客
02-23 734
一. BluetoothDevice简介1. 继承关系public static Class BluetoothDevice extends Object implement Parcelable该类实现了Parcelable接口, 实现了Parcelable接口的类的对象可以封装到Parcel对象中, 封装后的数据可以通过Intent或者IPC传递;实现Parcelable接口要点 :a. 实现...
UUID.java-J2ME 中javax.bluetooth里的UUID生成类
子魚＠NET
11-25 2074
 /* * * * Portions Copyright 2000-2007 Sun Microsystems, Inc. All Rights * Reserved. Use is subject to license terms. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER *
全网最全-DA14531-全球最小BLE芯片-开发笔记（上）
hejinwu1314的博客
10-11 895
DA14531开发笔记，笔者通过大量SDK软件调试并记录点点滴滴知识点，方便代码的记忆和查找，提高工作效率。
Chrome的启动参数
Criss@陈磊
02-23 5559
List of Chromium Command Line Switches Condition Explanation --[1]⊗ Classic, non-material, mode for the |kTopChromeMD| switch.↪ --0⊗ Value of the --profiler-timing flag that will disable timin...
Amazon Alexa通过云控制Bluetooth Mesh设备
weixin_48407519的博客
06-12 5080
Amazon Alexa通过云控制Bluetooth Mesh设备 The article is released under license CC BY-NC-ND 4.0 1. Project Background: As the development of the smart home market, the need for controlling smart devices using human voice grows rapidly. The leading companies all ov
java 调用 蓝牙协议
m0_37842431的博客
02-26 1819
蓝牙主端设备发起呼叫，首先是查找，找出周围处于可被查找的蓝牙设备。主端设备找到从端蓝牙设备后，与从端蓝牙设备进行配对，此时需要输入从端设备的PIN码，也有设备不需要输入PIN码。蓝牙技术规定每一对设备之间进行蓝牙通讯时，必须一个为主角色，另一为从角色，才能进行通信，通信时，必须由主端进行查找，发起配对，建链成功后，双方即可收发数据。配对完成后，从端蓝牙设备会记录主端设备的信任信息，此时主端即可向从端设备发起呼叫，已配对的设备在下次呼叫时，不再需要重新配对。在通信中，我们把主端成为客户端，从端称为服务端。
第一个蓝牙程序
zzxiaoma的专栏
01-28 627
import javax.bluetooth.DiscoveryListener;import javax.bluetooth.DeviceClass;import javax.bluetooth.ServiceRecord;import javax.bluetooth.RemoteDevice;import javax.microedition.lcdui.Command;i
android 蓝牙设置平板电脑,java – BlueCove,笔记本电脑和带蓝牙的Android平板电脑
weixin_26805597的博客
05-29 403
我正试图通过一个简单的应用程序获得使用蓝牙的基础知识.我也喜欢笔记本电脑应用程序,所以我可以简单地调试蓝牙通信.下面的代码是我尝试将笔记本电脑作为客户端(使用BlueCove 2.1.0)而平板电脑作为服务器(Android 2.2).根据我的理解,这应该按照书面形式工作,笔记本电脑正在提供平板电脑及其提供的服务.但是,行“StreamConnection conn =(StreamConnect...
Curator教程（三）服务注册&发现（Service Discovery）
Ricky
12-10 1万+
服务发现随着微服务的日趋火爆，系统拆分之后，各个服务模块的Provider和Consumer之间需要能够查找到对方，我们称之为服务发现。 In SOA/distributed systems, services need to find each other. i.e. a web service might need to find a caching service, etc. DNS ca
蓝牙code,转自无线乾坤
Legion.Tao(http://t.sina.com.cn/dastantao)
07-29 968
以下是我研究的蓝牙代码，因为时间紧没怎么好好的测试，目前在wtk2.2上运行通过，真机还有些问题。等我调试后再放更新版本，不过对初学者来说，这些应该足够了。也欢迎学过蓝牙的朋友一起讨论该项技术，指出错误。谢谢。代码分为3个类，一个主类，一个服务器端，一个客户端。以下是代码：package myblue;import javax.microedition.midlet.*;import ja
Java：PC端作为客户端连接蓝牙设备并接收蓝牙发送的数据
热门推荐
Jcsim~
12-21 1万+
感谢：（1）PC端实现蓝牙开发https://www.cnblogs.com/zeussbook/p/12827479.html （2）解决数据读取乱序https://blog.youkuaiyun.com/clliu_hust/article/details/80874272 一、蓝牙流程 蓝牙客户端Socket的与Sokcet流程是一样的，只不过参数不同而已。如下： 1、创建客户端蓝牙Sokcet 2、创建连接 3、读写数据 4、关闭 二、导入jar包 需要导入第三方的...
java 蓝牙_PC平台上JAVA蓝牙通信实现方法
weixin_30308101的博客
02-12 5970
什么是蓝牙蓝牙，是一种支持设备短距离通信(一般10m内)的无线电技术，能在包括移动电话、PDA、无线耳机、笔记本电脑、相关外设等众多设备之间进行无线信息交换。利用“蓝牙”技术，能够有效地简化移动通信终端设备之间的通信，也能够成功地简化设备与因特网Internet之间的通信，从而数据传输变得更加迅速高效，为无线通信拓宽道路。蓝牙技术是一种无线数据和语音通信开放的全球规范，它是基于低成本的近距离无线连...
ESP 32UUID
最新发布
02-26
### ESP32 UUID Usage and Examples in IoT Projects In Internet of Things (IoT) applications, Universally Unique Identifiers (UUIDs) play a significant role especially within the context of Bluetooth ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值