Dieser Artikel ist Tag #7 der Serie 8 Tage Windows Phone 8 von Geert van der Cruijsen.
Der Originalartikel befindet sich hier: 8 days of Windows Phone 8 — Day 7: Proximity Capabilities.
Willkommen zurück zu meiner Blog-Serie 8 Tage Windows Phone 8. Heute, im vorletzten Artikel, befassen wir uns mit den Nahfeldsensoren, namentlich Bluetooth und NFC. Wichtig bei diesem Artikel ist, dass ich den Code mit dem Emulator nicht testen konnte, da Bluetooth und NFC nur mit einem richtigen Gerät getestet werden können. Da ich beim Schreiben dieser Artikel kein Gerät zur Verfügung hatte, kann es sein, dass die Beispiele nicht hundertprozentig funktionieren.
- Tag 0: Einleitung zu den 8 Tagen Windows Phone 8
- Tag 1: Überblick über das SDK
- Tag 2: Live Tiles und Sperrbildschirm
- Tag 3: Der Emulator & das Simulation Dashboard
- Tag 4: Die neuen Bildschirmauflösungen
- Tag 5: .NET 4.5 & C# 5.0
- Tag 6: Die API zur Sprachsteuerung
- Tag 7: NFC und Bluetooth
- Tag 8: Brieftasche und In-App Käufe
Bluetooth
Um Bluetooth oder NFC zu nutzen, müssen Sie als erstes eine entsprechende Fähigkeit im WMAppManifest.xml hinzufügen.
Nachdem wir das getan haben, sind wir bereit, eine Anwendung zu bauen, welche mit einem anderen Gerät über Bluetooth kommuniziert. Die Kommunikation über Bluetooth funktioniert durch eine Art Client/Server Verbindung. Ein Telefon wird der Server, zu welchem sich das andere Telefon verbinden kann. Damit können beide Telefone kommunizieren.
Um den Server und den Client aufzusetzen, fügen wir zwei Buttons hinzu — einem zum Start des Servers und einen für den Client.
<StackPanel x:Name="ContentPanel" Grid.Row="1" Margin="12,0,12,0"> <Button x:Name="ServerButton" Click="ServerButton_Click_1" Content="server"></Button> <Button x:Name="ClientButton" Click="ClientButton_Click_1" Content="client"></Button> </StackPanel>
Im Click Event des Buttons für den Server fügen wir den folgenden Code hinzu, um ein PeerFinder Objekt zu erstellen, welches auf eingehende Verbindungsversuche hört. Wenn sich ein anderes Gerät mit unserem Telefon verbindet, wird ein ConnectionRequested Event gefeuert. Im EventHandler zeigen wir einfach eine MessageBox, um zu bestätigen, dass sich das andere Gerät verbunden hat.
private void ServerButton_Click_1(object sender, RoutedEventArgs e)
{
PeerFinder.Start();
PeerFinder.ConnectionRequested += PeerFinder_ConnectionRequested;
}
async void PeerFinder_ConnectionRequested(object sender, ConnectionRequestedEventArgs args)
{
MessageBox.Show("Connected");
_ss = await PeerFinder.ConnectAsync(args.PeerInformation);
}
Um die Verbindung mit dem Server herzustellen, müssen wir die Client-Seite implementieren. Im entsprechenden Click Event fügen wir den folgenden Code hinzu, um nach Server-Telefonen zu suchen und uns zu verbinden, wenn wir eins gefunden haben. Wir verwenden wieder den PeerFinder, um nach Verbindungspartnern zu suchen. Wenn die Methode FindAllPeers zurück kommt, prüfen wir, ob es einen aktiven Server gibt, indem wir mit der Eigenschaft Count die Anzahl der Ergebnisse abfragen. Wenn Count größer 0 ist, verbinden wir uns mit diesem Partner und prüfen seinen DisplayName.
protected async void ClientButton_Click_1(object sender, RoutedEventArgs e)
{
PeerFinder.Start();
var p = await PeerFinder.FindAllPeersAsync();
if (p.Count > 0)
{
_ss = await PeerFinder.ConnectAsync(p[0]);
string phoneName = p[0].DisplayName;
}
}
Nun, da wir zwei Telefone verbunden haben, können wir eine Nachricht von einem Telefon zum anderen schicken. Wir fügen der MainPage einen weiteren Button und den folgenden Code im Click Event hinzu. Damit schicken wir eine Nachricht von einem Telefon zum anderen.
private async void SendMessageButton_Click_1(object sender, RoutedEventArgs e)
{
if (_ss == null)
throw new Exception("Socket not initialized");
DataWriter dw = new DataWriter(ss.OutputStream);
dw.WriteString("Hello Windows Phone 8");
await dw.StoreAsync();
}
Wir verwenden den StreamSocket, welchen wir bei Herstellung der Verbindung initialisiert hatten, um die Nachricht zu schicken. Wenn der StreamSocket nicht initialisiert ist, feuern wir eine Exception. Andernfalls können wir weitermachen. Wir erstellen einen DataWriter basierend auf dem OutputStream des StreamSocket und verwenden die Methode WriteString, um die Nachricht über den DataWriter zu schicken. Jetzt können wir die Methode StoreAsync aufrufen, um die Daten tatsächlich an das verbundene Telefon zu senden.
Als letztes müssen wir die Nachricht auf dem Telefon noch empfangen. Wir verbinden den StreamSocket des PeerFinder und rufen eine neue private Methode WaitForMessage.
In dieser asynchronen Methode öffnen wir einen DataReader basierend auf dem InputStream des StreamSocket. Aus dem DataReader können wir zunächst die Länge der zu empfangenden Nachricht abfragen und anschließend die Nachricht selbst auslesen. Damit sind wir fertig mit der Übertragung einer Nachricht über Bluetooth.
async void PeerFinder_ConnectionRequested(object sender, ConnectionRequestedEventArgs args)
{
MessageBox.Show("Connected");
_ss = await PeerFinder.ConnectAsync(args.PeerInformation);
string message = await WaitForMessage();
}
private async Task<string> WaitForMessage()
{
DataReader dr = null;
while (true)
{
if (dr == null)
dr = new DataReader(_ss.InputStream);
await dr.LoadAsync(4);
uint messageLen = (uint)dr.ReadInt32();
await dr.LoadAsync(messageLen);
return dr.ReadString(messageLen);
}
}
NFC
Der zweite Nahfeldsensor in Windows Phone ist NFC. Mit NFC ist es möglich, NFC Tags zu lesen oder zwischen Telefonen zu kommunizieren. In folgenden Abschnitt wollen wir uns näher damit befassen, wie man per NFC zwischen Telefonen kommunizieren kann. Um Nachrichten per NFC zu senden und zu empfangen, fügen wir wieder mal zwei Buttons zu unserer MainPage.xaml hinzu.
<Button x:Name="NfcSendButton" Click="NfcSendButton_Click_1" Content="nfc send"></Button> <Button x:Name="NfcReceiveButton" Click="NfcReceiveButton_Click_1" Content="nfc receive"></Button>
Im Click Event des Send Buttons fügen wir den folgenden Code hinzu. Wir erstellen eine Instanz der Klasse ProximityDevice. Dann müssen wir nur noch die Methode PublishMessage auf diesem Objekt aufrufen. Im Beispiel senden wir einen String. Es ist aber auch möglich, binäre Daten zu übertragen.
private void NfcSendButton_Click_1(object sender, RoutedEventArgs e)
{
ProximityDevice pd = ProximityDevice.GetDefault();
if (pd != null)
{
pd.PublishMessage("8days", "Hello World!");
}
}
Nachdem wir die Nachricht gesendet haben, müssen wir als letztes für heute nur noch die Nachricht empfangen. Fügen Sie den folgenden Code zum Click Event des Receive Buttons hinzu. Wir erstellen wieder eine Instanz der Klasse ProximityDevice und registrieren uns für eingehende Nachrichten. Das war’s. Wenn jetzt eine Nachricht eintrifft, wird die Methode NfcReceive aufgerufen und wir können die Nachricht auslesen.
private void NfcReceiveButton_Click_1(object sender, RoutedEventArgs e)
{
ProximityDevice pd = ProximityDevice.GetDefault();
if (pd != null)
{
long Id = pd.SubscribeForMessage("8days", NfcReceive);
}
}
private void NfcReceive(ProximityDevice sender, ProximityMessage message)
{
var m = message.DataAsString;
}
Wie Sie sehen, ist die Umsetzung von NFC in Windows Phone 8 wirklich einfach. Ich kann es nicht erwarten, bis Entwickler anfangen, diese Features in ihren Anwendungen zu nutzen. Alle momentan angekündigten Windows Phone 8 Geräte haben NFC Fähigkeiten — die Voraussetzungen sind also gelegt.
Morgen, am letzten Tag der Serie, werden wir uns mit den Features zur Brieftasche beschäftigen und wie man In-App Käufe realisiert.
Das Beispielprojekt zum heutigen Artikel können Sie hier herunterladen: http://sdrv.ms/QSJ2yx.