Bluetooth

When you want to use bluetooth or NFC the first thing you’ll need to do is add the Proximity capability in the WMAppManifest.xml file in the capabilities tab.

When we’ve done this we’re ready to start building an app to communicate with another device through Bluetooth. Communicating with Bluetooth works through a client server type of connection. One phone needs to be the server and then another phone can connect to this server and the phones can communicate with each other.

To set up the server and client we’ll add 2 buttons, 1 to start the server and 1 to start the client.

   1: <StackPanel x:Name="ContentPanel" Grid.Row="1" Margin="12,0,12,0">

   2:     <Button x:Name="ServerButton" Click="ServerButton_Click_1" Content="server"></Button>

   3:     <Button x:Name="ClientButton" Click="ClientButton_Click_1" Content="client"></Button>

   4: </StackPanel>

at the click event of the server button we’ll add the following code to set up a PeerFinder object to listen to events. when another peer connects to our phone a ConnectionRequested event will be handled and we’ll show a MessageBox to confirm the user another device is connected.

   1: private void ServerButton_Click_1(object sender, RoutedEventArgs e)

   2: {

   3:     PeerFinder.Start();

   4:     PeerFinder.ConnectionRequested += PeerFinder_ConnectionRequested;

   5: }

   6:  

   7: async void PeerFinder_ConnectionRequested(object sender, ConnectionRequestedEventArgs args)

   8: {

   9:     MessageBox.Show("Connected");

  10:     _ss = await PeerFinder.ConnectAsync(args.PeerInformation);

  11: }

To connect to the server we’ll need to implement the client part. Under the click event we’ll add the following code to search for server phones and connect to them if we found one. We’ll use the PeerFinder again to search for other peers. when the FindAllPeers method returns we’ll check if there is an active server by checking the count property and when the count is greater than 0 we’ll connect to this peer and check it’s displayname.

   1: protected async void ClientButton_Click_1(object sender, RoutedEventArgs e)

   2: {

   3:     PeerFinder.Start(); 

   4:     var p = await PeerFinder.FindAllPeersAsync(); 

   5:     if (p.Count > 0) 

   6:     { 

   7:         _ss = await PeerFinder.ConnectAsync(p[0]);

   8:         string phoneName = p[0].DisplayName;

   9:     }

So now we have 2 phones connected we can send a message from one phone to the other. We’ll add another button to the main page and add code to the click event to send a message to another phone.

   1: private async void SendMessageButton_Click_1(object sender, RoutedEventArgs e)

   2:         {

   3:             if (_ss == null)

   4:                 throw new Exception("Socket not initialized");

   5:  

   6:             DataWriter dw = new DataWriter(ss.OutputStream);

   7:             dw.WriteString("Hello Windows Phone 8");

   8:             await dw.StoreAsync();

   9:         }

We’ll use the StreamSocket initialized when we created our connection to send the message.  If the socket isnt initialize we’ll throw an exception but continue otherwise. Create a DataWriter from the StreamSocket OutputStream and use the WriteString method to write a string to the DataWriter. Now we can call the StoreAsync method to actually send the message to the other phone.

The last thing we need to add is receiving the message on the phone. We’ll connect the PeerFinder StreamSocket and call a new private method called WaitForMessage.

In this asynchronous method we’ll open a DataReader from the StreamSocket’s inputstream. From this datareader we can first read the length of the message and after that we can read the message itself. Now we’re all done in receiving the message through bluetooth.

   1: async void PeerFinder_ConnectionRequested(object sender, ConnectionRequestedEventArgs args)

   2: {

   3:     MessageBox.Show("Connected");

   4:     _ss = await PeerFinder.ConnectAsync(args.PeerInformation);

   5:     string message = await WaitForMessage();

   6: }

   7:  

   8: private async Task<string> WaitForMessage()

   9: {

  10:     DataReader dr = null;

  11:     while (true)

  12:     {

  13:         if (dr == null)

  14:             dr = new DataReader(_ss.InputStream);

  15:  

  16:         await dr.LoadAsync(4);

  17:         uint messageLen = (uint)dr.ReadInt32();

  18:         await dr.LoadAsync(messageLen);

  19:         return dr.ReadString(messageLen);

  20:     }

  21: }

NFC

The other Proximity capability in Windows Phone is NFC. With NFC it’s possible to read NFC tags or to communicate from phone to phone. In this post we’ll dive deeper in how to connect from one phone to another using NFC. To send and receive messages using NFC we’ll add 2 buttons again to our MainPage.xaml

   1: <Button x:Name="NfcSendButton" Click="NfcSendButton_Click_1"  Content="nfc send"></Button>

   2: <Button x:Name="NfcReceiveButton" Click="NfcReceiveButton_Click_1"   Content="nfc receive"></Button>

At the click event of the Send button we’ll add the following code. We’ll create an instance of a ProximityDevice and the only thing we’ll have to do is call the PublishMessage method on this ProximityDevice. In this example we’re sending a string but it’s also possible to send binary data.