EMDK Bluetooth LocalDevices - bluetooth

Question

Just a quick question, how do I get the local Bluetooth devices that have already been paired using the Motorola's EMDK 2.4 for an MC75 device? Seems I can get the RemoteDevice list but there is no method to see the local stack and what's been paired already, this way I can read what serial port it has already been assigned and open up a SerialPort object automatically for the user.

Answer 1

The answer is you don't or can't...you instead use the Microsoft Bluetooth. Download this for windows mobile bluetooth on a motorola device...may work on other devices too. You can get from the mobile samples, I found it here on my hard drive...C:\Program Files (x86)\Windows Mobile 6 SDK\Samples\Common\CS\Bluetooth. I added this to my project then all I had to do was this to add all the currently paired devices to a listBox
BluetoothRadio radio = new BluetoothRadio();
listBox1.DataSource = radio.PairedDevices;
listBox1.DisplayMember = "Name";
And then when one was selected you can access it as a BlueTooth device like this:
BluetoothDevice device = listBox1.SelectedItem as BluetoothDevice;
You then start stream by
if (device != null) {
BTConnectionManager.Instance.startThread(
StandardServices.SerialPortServiceGuid,
new ThreadStart(StreamProcessor));
if (BTConnectionManager.Instance.Connect(device)) {
...Do something...
I had to modifiy the StreamProcessor and BTConnectionManager a bit to work for me but here is my version of it without the form references in it.
using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Threading;
using System.Net.Sockets;
using Microsoft.WindowsMobile.SharedSource.Bluetooth;
namespace Project2 {
/// <summary>
/// Connection Manager to marshal the data connection and reference the
/// data streams to push/pull data.
/// </summary>
public class BTConnectionManager {
BTConnectionManager() { }
/// <summary>
/// reference the Singleton and make a singleton object out of
/// this since we only want one for now.
/// </summary>
public static BTConnectionManager Instance {
get {
return Nested.instance;
}
}
/// <summary>
/// easiest way to make this a singleton that is thread safe.
/// </summary>
class Nested {
static Nested() { }
internal static readonly BTConnectionManager instance = new BTConnectionManager();
}
/// <summary>
/// The Bluetooth radio.
/// </summary>
private BluetoothRadio radio = new BluetoothRadio();
/// <summary>
/// Guid of the Bluetooth service
/// </summary>
private Guid guid;
/// <summary>
/// Thread function that processes data from the stream.
/// </summary>
private ThreadStart streamProcessor;
/// <summary>
/// The two-way communication stream to the other Bluetooth device.
/// </summary>
private NetworkStream stream;
/// <summary>
/// A BinaryReader on top of this.stream
/// </summary>
private BinaryReader reader;
/// <summary>
/// A BinaryWriter on top of this.stream
/// </summary>
private BinaryWriter writer;
/// <summary>
/// Should we stop the service thread, in preparation for
/// exiting the app?
/// </summary>
private bool exiting = false;
/// <summary>
/// The Bluetooth service.
/// </summary>
private BluetoothService bluetoothService;
/// <summary>
/// A BinaryWriter used to write to the other Bluetooth device.
/// </summary>
public BinaryWriter Writer {
get { return writer; }
}
/// <summary>
/// A BinaryReader used to read from the other Bluetooth device.
/// </summary>
public BinaryReader Reader {
get { return reader; }
}
/// <summary>
/// Gets a value indicating whether a connection is established with
/// the other Bluetooth device.
/// </summary>
public bool Connected {
get { return stream != null; }
}
/// <summary>
/// The two-way communication stream to the other Bluetooth device.
/// </summary>
private NetworkStream Stream {
get { return stream; }
set {
stream = value;
if (stream == null) {
if (writer != null) {
writer.Close();
writer = null;
}
if (reader != null) {
reader.Close();
reader = null;
}
} else {
writer = new BinaryWriter(stream);
reader = new BinaryReader(stream);
}
}
}
/// <summary>
/// Creates a new instance of a ConnectionManager.
/// </summary>
/// <param name="guid">The Bluetooth service guid.</param>
/// <param name="streamProcessor">A callback function that will read and process data from the stream.</param>
public void startThread(Guid guid, ThreadStart dataProcessor) {
this.guid = guid;
this.streamProcessor = dataProcessor;
Thread t = new Thread(new ThreadStart(ServiceThread));
t.Start();
}
/// <summary>
/// The thread that listens for Bluetooth connections, and processes
/// the data read from a connection once established.
/// </summary>
private void ServiceThread() {
bluetoothService = new BluetoothService(this.guid);
while (!exiting) {
if (!bluetoothService.Started) {
bluetoothService.Start();
}
try {
this.Stream = bluetoothService.AcceptConnection();
} catch (System.Net.Sockets.SocketException) {
// bluetoothService.Stop() was called.
// Treat this like a graceful return from AcceptConnection().
}
if (!exiting) {
// Call the streamProcessor to handle the data from the stream.
streamProcessor();
}
}
exiting = false;
}
/// <summary>
/// Force the service thread to exit.
/// </summary>
public void Exit() {
// This will cause us to fall out of the ServiceThread() loop.
exiting = true;
if (!Connected) {
// We must be waiting on AcceptConnection(), so we need to
// force an exception to break out.
bluetoothService.Stop();
}
}
/// <summary>
/// Connect to another Bluetooth device.
/// </summary>
public bool Connect(BluetoothDevice device) {
if (device != null) {
try {
this.Stream = device.Connect(this.guid);
} catch (System.Net.Sockets.SocketException) {
// Couldn't connect.
}
if (this.Stream == null) {
System.Windows.Forms.MessageBox.Show("Could not connect to device " + device.Name);
return false;
} else {
// Forcibly break out of the AcceptConnection in
// ServiceThread(), and continue on to streamProcessor().
bluetoothService.Stop();
return true;
}
}
return false;
}
/// <summary>
/// Disconnect from the other Bluetooth device.
/// </summary>
public void Disconnect() {
Stream = null;
}
internal void Disconnect(BluetoothDevice device) {
Disconnect();
}
}
}