Windows Phone 7

Windows Phone und die Cloud – eine Einführung

Ramon Arjona

Ich lerne Lesen und Schreiben in Spanisch. Wo ich lebe, kann ich mein Spanisch üben, indem ich die zweisprachigen Schilder zu lesen versuche, die an vielen öffentlichen Orten aufgestellt sind. Es kommt vor, dass ich ein bestimmtes Wort oder auch einen ganzen Satz nicht richtig verstehe und einfach nicht weiterkomme. Und nicht immer bin ich mir sicher, ohne Übersetzung in meiner Muttersprache das Gelesene richtig verstanden zu haben. Ich könnte natürlich ein entsprechendes Wörterbuch mit mir herumtragen, aber das Nachschlagen darin ist mir einfach zu analog.

Was ich mir wünsche, schließlich sieht man mich kaum ohne mein Telefon, ist eine einfache Methode, per Telefon Hilfe bei der Übersetzung zu bekommen. Ich kann zwar mit meinem Telefon auf Bing den cloudbasierten Microsoft Translator verwenden, aber dazu muss ich schon einige Tasten drücken, bis ich endlich auf dem richtigen Bildschirm gelandet bin. Gäbe es doch nur eine Möglichkeit, und zwar eine einfache, dieses Übersetzungsprogramm auf meinem Telefon nutzen zu können. Die gibt es tatsächlich, dank Windows Phone 7.

Dieser Artikel dient als Einführung in die Entwicklung von Windows Phone-Anwendungen, und Sie erfahren, wie Sie derartige Apps in einen Webdienst in der Cloud einbinden. Sie sollten bereits über grundlegende Kenntnisse in C# und Visual Studio verfügen, und Erfahrung in der Anwendungsentwicklung mit XAML (Extensible Application Markup Language) wäre hilfreich, ist aber nicht unbedingt erforderlich. Ich habe die im April aktualisierte CTP-Version (Community Technology Preview) der Windows Phone-Tools verwendet. Wenn Sie diesen Artikel lesen, hat sich möglicherweise schon wieder einiges geändert, also besuchen Sie developer.windowsphone.com, wo Sie die aktuellste Dokumentation lesen und die neuesten Tools herunterladen können.

Schritt für Schritt: Erhalten einer AppID

Für die Interaktion mit Translator oder einem anderen Bing-Webdienst benötigen Sie als Erstes eine Anwendungs-ID (AppID). Diese wird von der Dienst-API verwendet, um Anforderungen von registrierten Bing-Anwendungsentwicklern zu überprüfen.

Navigieren Sie zu bing.com/developers/createapp.aspx, und melden Sie sich mit Ihrer Windows Live ID an. Füllen Sie dann das Formular aus, in dem Sie nach einem Namen und einer Beschreibung Ihrer Anwendung gefragt werden sowie nach Details wie Firmenname und E-Mail-Adresse. Die E-Mail-Adresse dient dazu, Sie bei einer Änderung der APIs zu benachrichtigen, wozu es kommen kann, wenn neue Versionen eingeführt oder alte Versionen nicht mehr unterstützt werden. Für die Translator-API insbesondere gilt zum Zeitpunkt der Dokumentationserstellung, dass alte Versionen nur 90 Tage nach der Veröffentlichung einer neuen Version online verfügbar bleiben.

Lesen Sie dann die Nutzungsbedingungen, und markieren Sie zur Bestätigung das Kontrollkästchen. Klicken Sie auf die Schaltfläche zum Akzeptieren, und Sie werden zu einer Seite weitergeleitet, auf der Ihre neue AppID bereits eingetragen ist. Zu Referenzzwecken können Sie jederzeit zurück auf diese Seite kommen, aber ich kopiere meine AppID in der Regel bei der Erstellung und füge sie in die Quelldatei meiner Anwendung ein.

Sie sollten die Nutzungsbedingungen für Webdienste, die Sie in einer Anwendung einsetzen wollen, immer lesen. Es ist wirklich nicht ratsam, diese nur zu überfliegen, insbesondere, wenn Sie Anwendungen über Marketplace auch für andere Nutzer verfügbar machen möchten. Sie schulden es Ihren Kunden, die Ziele in Bezug auf den Servicelevel und andere Bedingungen von Partnern zu verstehen, die den Dienst für Ihre Apps bereitstellen. Stellen Sie also sicher, dass Sie die Nutzungsbedingungen gelesen und verstanden haben, egal, ob Ihre App einen Dienst von Microsoft oder anderen Anbietern nutzt.

Nun, da Sie über eine AppID verfügen, können wir mit dem Erstellen unserer mobilen Übersetzungsanwendung beginnen.

Definieren des Szenarios

Vor der Erstellung meiner ersten App habe ich mir einige erfolgreiche mobile Anwendungen auf dem Markt angesehen. So habe ich beispielsweise Anwendungen für Windows Phones und andere Smartphones unter die Lupe genommen, um herauszufinden, was die wirklich erfolgreichen mobilen Apps ausmacht. Ich habe Produktbesprechungen gelesen, viele Interviews geführt und meinen Freunden den letzten Nerv geraubt, damit sie mich mit ihren Telefonen spielen ließen.

Nach meinen Recherchen bin ich zu dem Schluss gekommen, dass der Schlüssel zu einer erfolgreichen mobilen App in der Einfachheit liegt. Jede beliebte App spricht ein oder zwei grundlegende Benutzerszenarien an und wird diesen ideal gerecht. So bin ich auf eine ganze Klasse von Apps gestoßen, deren Zweck einfach darin besteht, unanständige Geräusche zu machen. Quasi die Wiederauferstehung des Furzkissens als Telefonanwendung. Das scheinen die Leute lustig zu finden, und zwar so lustig, dass sie Geld dafür bezahlen, sie auf ihr Telefon zu laden.

Ähnlich gibt es Apps für simulierte Würfelspiele oder Apps, die Restaurants empfehlen und sogar vorab das Trinkgeld für ein bestimmtes Essen berechnen. Alle konzentrieren sich auf ein Benutzerszenario, das auf einfache und intuitive Weise umgesetzt wird. Dieser Ansatz ist nicht nur bei einer bestimmten Smartphone-Marke zu finden. Die Vorstellung von einer ausgefeilten und intuitiven Benutzererfahrung wird noch verstärkt im „Windows Phone UI Design and Interaction Guide“, der unter developer.windowsphone.com/windows-phone-7 veröffentlicht ist.

Als ich also mit meiner Übersetzungsanwendung ganz am Anfang stand, war es wichtig, dass ich mich ausschließlich auf das Ziel dieser App konzentrierte und auf nichts anderes. Dazu musste ich mir zuerst ein klares Bild von meinen Zielen machen. Damit konnte ich der Versuchung widerstehen, andere coole Features hinzuzufügen, die zwar interessant gewesen wären, aber nicht meinem Hauptzweck gedient hätten. Meine App sollte vom Englischen ins Spanische und umgekehrt übersetzen können. Die Übersetzungsrichtung sollte leicht umgekehrt werden können, und es sollten sowohl einzelne Wörter als auch ganze Sätze übersetzt werden. Und ich entschied mich, bei Spanisch und Englisch zu bleiben und keine anderen Sprachen zu integrieren.

Erstellen der App

Öffnen Sie Visual Studio Express 2010 for Windows Phone, um mit dem Erstellen der Übersetzungsanwendung zu beginnen. Klicken Sie auf New project... (Neues Projekt), und wählen Sie Windows Phone Application (Windows Phone-Anwendung) aus. Daraufhin wird das standardmäßige Windows Phone-Projekt mit einem zweigeteilten Bildschirm geöffnet: Titel und Inhalt. Die Abschnitte sind durch ein XAML-Rasterobjekt getrennt, wodurch wir eine Reihe von Zeilen und Spalten definieren können, in denen wir untergeordnete Benutzeroberflächenelemente positionieren können, beispielsweise Schaltflächen und Textblöcke (siehe Abbildung 1).

Abbildung 1 Standardmäßiges Windows Phone-Projekt mit Anzeige und Codeansichten

Zuerst bearbeiten wir den Anwendungsnamen und Seitentitel, indem wir diese Elemente im Designer auswählen. Dadurch wird der zugehörige XAML-Code im Codeansichtsfenster des Designers markiert, und Sie sehen, welche Elemente bearbeitet werden müssen. Öffnen Sie dann die Toolbox, und ziehen Sie einige Benutzeroberflächenelemente in den unteren Seitenbereich, das Inhaltsraster. Wählen Sie ein Textfeld zum Einfügen der zu übersetzenden Wörter sowie einen Textblock, in dem die Übersetzung erscheint. Zum Schluss fügen Sie zwei Schaltflächen hinzu (siehe Abbildung 2).

Abbildung 2 Hinzufügen von Benutzeroberflächenelementen (Textfeld, Textblock und Schaltfläche)

Mit einer Schaltfläche wird die Übersetzung ausgeführt, und mit der zweiten wird die Übersetzungsrichtung umgekehrt.

XAML: die moderne Benutzeroberfläche

Den Kern der Windows Phone 7-Benutzererfahrung bildet der Code für das Entwurfssystem, „Metro“ genannt, und XAML ist das zentrale Element bei Metro, wenn es um die Implementierung von Benutzeroberflächen geht. Wenn Sie schon mit Silverlight oder Windows Presentation Foundation (WPF) gearbeitet haben, ist Ihnen XAML möglicherweise ein Begriff. Wenn nicht, erhalten Sie in diesem Abschnitt eine kurze Einführung.

Mit XAML können Sie Benutzeroberflächen deklarativ strukturieren, indem Sie die Logik Ihrer App strikt von ihrem Aussehen trennen. Sie werden sehen, dass sich der Code für die Hauptseite Ihrer App in der Datei „Mainpage.xaml.cs“ befindet, das grundlegende Layout aber in „Mainpage.xaml“ gespeichert ist. Anders als bei der herkömmlichen Entwicklung mit Windows Forms, ist der Anwendungscode nicht mit dem Benutzeroberflächenlayout verbunden. Jedes Benutzeroberflächenelement in Ihrer Anwendung wurde als ein XML-Element in einer XAML-Datei erstellt.

Das ist insofern ein Vorteil, als dass Aussehen und Verhalten der Anwendung getrennt von der Logik bearbeitet werden kann. Dadurch können wir beispielsweise, nachdem wir die grundlegende Benutzeroberfläche für unsere Übersetzungsanwendung erstellt haben, die XAML an einen Experten weiterleiten, während wir uns weiter um den Code kümmern. Der Designer braucht nicht über die Implementierung der App Bescheid zu wissen, und uns kann es egal sein, für welche Farbpalette er sich entschieden hat.

Zwar habe ich kein Budget für einen Benutzeroberflächendesigner, aber ich habe MS Paint, und das reicht schon aus, um zu zeigen, wie einfach es ist, die grafischen Ressourcen für meine App zu aktualisieren.

Neues Symbol für den Übersetzer

Ich doppelklicke auf die Datei „ApplicationIcon.png“, die beim Erstellen standardmäßig zum Projekt hinzugefügt wurde. Daraufhin wird meine Bildbearbeitungssoftware geöffnet, auf meinem Entwicklungscomputer ist das MS Paint. Ich ersetze das langweilige Getriebesymbol durch den Großbuchstaben T, lösche den schwarzen Hintergrund, und fülle ihn mit monochrom pink. Bestimmt werde ich für die Grafik keinen Preis gewinnen, aber mir gefällt es so (siehe Abbildung 3).

Abbildung 3 Neues Projektsymbol, erstellt mit MS Paint

Um die Änderung zu überprüfen, klicke ich auf die Startschaltfläche, um die Anwendung für den Windows Phone 7-Emulator bereitzustellen. Falls Sie schon mit früheren Versionen des Windows Phone-Emulators gearbeitet haben, werden Sie gleich bemerken, wie sehr sich die Benutzerfreundlichkeit bei der Entwicklung verbessert hat. Der Emulator für Windows Phone 6.5 kann eine Qual sein und erfordert einige manuelle Konfigurationsschritte, um den Debugger zu starten und mit dem Emulator zu verbinden. Hier in der Entwicklungsumgebung von Windows Phone 7 funktioniert alles reibungslos durch Klicken auf die grüne Startschaltfläche. Ich freue mich sogar schon über die schnellen Ladezeiten und das schnelle Anzeigen der Hauptbenutzeroberfläche der App (siehe Abbildung 4).

Abbildung 4 Die App, angezeigt vom Windows Phone 7-Emulator

Zum Anzeigen des Anwendungssymbols schließe ich die Benutzeroberfläche und navigiere zum Hauptbildschirm des Emulators. Die Translator-Grafik wird angezeigt und sieht gut aus (siehe Abbildung 5).

Abbildung 5 Überprüfen des neuen App-Symbols im Emulator

Das App-Manifest

Das Anwendungssymbol wird in der Datei „WMAppManifest.xml“ definiert, die im Ordner mit den Projekteigenschaften gespeichert ist. Zum Ändern des Anwendungssymbols ändern Sie den Namen der Datei „ApplicationIcon.png“ im Projekt und überprüfen, ob die Änderung hier im IconPath-Element angezeigt wird:

<IconPath IsRelative="true"
   IsResource="false">myicon.png
   </IconPath>

Findet die Anwendung das Symbol nicht, wird der Laufzeitstandard zugewiesen, eine Art weißer Kreis auf schwarzem Hintergrund.

Ein weiteres Element dieser Datei, das eine genauere Betrachtung verdient, ist das Capabilities-Element, das die Funktionen enthält, die Ihre Anwendung verwenden möchte. Es empfiehlt sich, nur das anzufordern, was die Anwendung auch benötigt, und nicht mehr. Wenn Sie einen Blick auf die Datei werfen, sehen Sie eine Reihe von Funktionen, die wir wahrscheinlich nicht in unserer Übersetzungsanwendung verwenden werden.

Mit ID_CAP_GAMERSERVICES wird zum Beispiel deklariert, dass Ihre App mit der XBox-API kommunizieren muss. ID_CAP_LOCATION gibt an, dass die App die Standortfunktion des Geräts verwenden will, und ID_CAP_PUSH_­NOTIFICATION bedeutet, dass eine Interaktion zwischen der App und der Pushbenachrichtigung von Windows Phone 7 besteht. Alles beeindruckende Features, die wir aber für unsere App nicht brauchen, also weg damit. Tatsächlich benötigen wir wohl nur die ID_CAP_NETWORKING-Funktion, die besagt, dass unsere App über das Netzwerk Daten senden und empfangen möchte.

Die Microsoft Translator-API

Microsoft Translator macht drei Arten von APIs verfügbar. Die SOAP-API bietet dem Benutzer eine starke Typisierung und einfache Bedienung. Die AJAX-API ist in erster Linie hilfreich für Webseitenentwickler, die Übersetzung in ihre Benutzeroberfläche einbetten wollen. Die HTTP-API ist hilfreich, wenn weder die SOAP- noch die AJAX-API passend ist.

Wir wählen die SOAP-Schnittstelle, da sie für unsere Zwecke am besten geeignet ist. Wechseln Sie zum Projektmappen-Explorer, und klicken Sie mit der rechten Maustaste auf Verweise. Wählen Sie dann Dienstverweis hinzufügen, und geben Sie den Endpunkt für die SOAP-Schnittstelle in die Translator-API ein:  http://api.microsofttranslator.com/V2/Soap.svc. Tragen Sie für den Dienstendpunkt den NamenTranslatorService im Feld Namespace ein, und klicken Sie auf OK (siehe Abbildung 6).

Abbildung 6. Hinzufügen eines SOAP-Dienstverweises

Visual Studio erledigt den Rest und erstellt für Sie den Clientcode für die SOAP-Schnittstelle.

Nun fügen wir Code zur Anwendung hinzu. Fügen Sie zur Deklaration der MainPage-Klasse Ihrer App die App-ID und einen Verweis auf den TranslatorService-Client hinzu:

string appID = <<your appID>>;
  TranslationService.LanguageServiceClient client = 
    new TranslationService.LanguageServiceClient();

IntelliSense zeigt uns, dass der Übersetzungsdienst einige interessante Methoden bietet. Zuerst fällt auf, dass alle Methoden asynchron sind. Das ist sinnvoll, da es keinen triftigen Grund gibt, die Clientanwendung zu blockieren, während wir darauf warten, dass ein Netzwerkvorgang abgeschlossen wird. Wir müssen also für jeden Vorgang, den wir ausführen, einen Delegaten registrieren. In diesem Fall interessiert uns nur die TranslateAsync-Methode und das vom LanguageServiceClient verfügbar gemachte TranslateAsyncComplete-Ereignis. Aber die anderen Methoden sind sicherlich auch interessant. Wir wollen sie uns genauer daraufhin ansehen, ob sie in unser Benutzerszenario passen.

Die zwei herausstehenden Methoden sind GetLanguagesForTranslateAsync und GetLanguageNamesAsync. Mit der ersten Methode erhalten wir eine Liste mit Sprachcodes, die der Übersetzungsdienst unterstützt. Wenn wir diese Methode aufrufen, sehen wir, dass der Sprachcode für Spanisch „es“ lautet. Mit der GetLanguageNamesAsync-Methode wird eine Liste mit Sprachnamen für bestimmte Sprachcodes zurückgegeben, die für ein gegebenes Gebietsschema lokalisiert wurden. Wenn Sie also „es“ als Gebietsschema und Sprachcode in diese Methode übergeben, erhalten Sie die Zeichenfolge „Español“. Für eine Übersetzung in mehrere Sprachen wäre beides sinnvoll.

Auch interessant ist die SpeakAsync-Methode. Sie akzeptiert eine Zeichenfolge und ein Gebietsschema und gibt eine URL in eine WAV-Datei aus, mit der ein Wort richtig ausgesprochen wird. Dies ist ein großartiges Feature. Ich könnte beispielsweise eine Zeichenfolge eingeben, die Übersetzung abrufen und diese Zeichenfolge dann an die SpeakAsync-Methode übergeben, um eine WAV-Datei zu erhalten, die mir eine Kommunikation auf Spanisch ermöglicht.  Oder wenn ich unsicher bin, wie ein Wort ausgesprochen wird, könnte ich es mir mithilfe der SpeakAsync-Methode anhören.

Ziemlich coole Features, und es ist nicht leicht, der Versuchung zu widerstehen, sie in die App zu integrieren, nur weil sie cool sind. Jetzt bleiben wir jedenfalls hart und konzentrieren uns darauf, das zu Beginn definierte Benutzerszenario umzusetzen. Mit dieser klaren Vorgabe ist es leichter, darauf zu verzichten, „nur noch dieses eine Feature“ hinzuzufügen.

Den Code für unsere Übersetzungsanwendung haben wir schnell geschrieben. Als Erstes registrieren wir die Delegaten für TranslateCompleted:

client.TranslateCompleted += new
  EventHandler<TranslationService.TranslateCompletedEventArgs>
  
(client_TranslateCompleted);

Dann implementieren wir den Ereignishandler für TranslateCompleted, womit der Text unseres TextBlock-Elements als übersetzter Text festgelegt wird:

void client_TranslateCompleted(object sender,
   TranslationService.TranslateCompletedEventArgs e)
 {
   TranslatedTextBlock.Text = e.Result;
 }
We wire up the button to submit the text we’ve entered for translation:
 private void TranslateButton_Click(object sender, 
   RoutedEventArgs e)
 {
   client.TranslateAsync(appID, TranslateTextBox.Text, fromLanguage,
     toLanguage);             
 }

Wir fügen einfachen Code für die zweite Schaltfläche hinzu, damit zwischen den Übersetzungsrichtungen gewechselt wird, von Spanisch in Englisch zu Englisch in Spanisch. Mit dieser Schaltfläche wird eine globale Statusvariable verwaltet, und der Text unserer Schaltfläche wird entsprechend geändert.

Schließlich stellen wir die App auf dem Emulator bereit, um sie zu testen. Wir verfügen jetzt über eine voll funktionsfähige Übersetzungsanwendung, die aus nur wenigen Codezeilen besteht und uns nur ca. eine Stunde Entwicklungszeit gekostet hat.

Erweitern der Übersetzungsanwendung

Die einfache Übersetzungsanwendung ist ganz nett, aber wir könnten mehr daraus machen, indem wir unser Benutzerszenario erweitern. Es wäre gut, wenn wir mehr Sprachen der Translator-API in unsere App einbinden könnten, ohne die Metro-Entwurfsrichtlinien zu verletzen. Und noch besser wäre es, wir kämen ohne die Schaltfläche für die Übersetzungsrichtung aus und könnten diese auf einfachere, intuitivere Weise ändern. Wie auch immer wir vorgehen, wir müssen an den Benutzer denken, der das Gerät mit seinen Fingern bedient und dabei schnell sein möchte.

Was also können wir tun? Wir erstellen eine Anwendung mit dem Standardlistenprojekt. Starten ein neues Projekt und wählen Windows Phone List Application (Windows Phone-Listenanwendung) aus. Daraufhin wird ein Standardbildschirm mit einem ListBox-Steuerelement im ContentGrid-Element aufgerufen. Das ListBox-Element enthält sechs Sprachen, in die wir Text übersetzen möchten, wodurch dann der Blindtext ersetzt wird (siehe Abbildung 7).

Abbildung 7 Die standardmäßige Windows Phone-Listenanwendung

Wir bearbeiten die Datei „MainViewModelSampleData.xaml“, die im Ordner „SampleData“ des Projekts enthalten ist. Wir erhalten ungefähr folgende XML-Ausgabe:

<local:ItemViewModel LineOne="design one" LineTwo="Maecenas praesent accumsan bibendum" LineThree="Maecenas praesent accumsan bibendum dictumst eleifend facilisi faucibus habitant inceptos interdum lobortis nascetur"/>

Indem wir den XML-Code bearbeiten, können wir die Ansicht des ListBox-Elements zur Entwurfszeit ändern, um alle Sprachen einzuschließen, mit denen wir arbeiten möchten: Spanisch, Deutsch, Englisch, Portugiesisch, Italienisch und Französisch. Beachten Sie, dass nach dem Speichern der Datei die Änderungen in der Entwurfszeitansicht zu sehen sind. Das liegt daran, dass das ListBox-Steuerelement über eine Datenbindung an das in „MainViewModelSampleData.xaml“ definierte Items-Element verfügt. Dies wird vom ItemsSource-Attribut des ListBox-Steuerelements gesteuert.

Sie können auch den Inhalt des ListBox-Elements zur Laufzeit aktualisieren. Wenn Sie sich die von Visual Studio erstellte Datei ansehen, fällt auf, dass eine ObservableCollection<ItemViewCollection> mit Platzhalterdaten aufgefüllt wird, die den Daten aus der Datei „MainViewModelSampleData.xaml“ ähneln. Angenommen, ich möchte die Liste der Sprachen für die Benutzeroberfläche dynamisch auf Basis der Sprachen generieren, die von der GetLanguageNamesAsync-Methode zurückgegeben werden, dann würde ich die Datei „MainViewModel.cs“ dahingehend ändern, dass die Items-Auflistung gefüllt wird. Ich ziehe es hier vor, eine statische Liste mit Sprachen anzugeben und die Auflistung der ItemViewModel-Objekten einfach direkt zu bearbeiten. Wenn wir jetzt die Listenanwendung ausführen, sollte eine Benutzeroberfläche ähnlich wie in Abbildung 8 angezeigt werden.

Abbildung 8 Benutzeroberfläche der Listenanwendung

Wenn der Benutzer eine dieser Schaltflächen berührt, gelangt er auf eine Detailseite, die im Wesentlichen der Benutzeroberfläche unserer einfachen Übersetzungsanwendung entspricht. Es gibt ein Textfeld zum Einfügen der zu übersetzenden Wörter, einen Textblock für den übersetzten Text und eine Schaltfläche zum Übergeben der Übersetzung. Statt nun eine weitere Schaltfläche für die Übersetzungsrichtung hinzuzufügen, verlassen wir uns auf die Translator-API. Die bidirektionale Übersetzung unserer einfachen Übersetzungsanwendung macht in unserem Szenario mit mehreren Sprachen keinen Sinn, und durch das Hinzufügen weiterer Benutzeroberflächenebenen würden wir die App überfrachten. Glücklicherweise bietet die Translator-API eine Methode, die eingegebenen Sprachen automatisch zu erkennen.

Wir fügen Code hinzu, um zuerst die DetectAsync-Methode des Übersetzungsclients aufzurufen, übergeben den zu übersetzenden Text, und rufen dann TranslateAsync über den DetectAsyncComplete-Ereignishandler auf. Der Ereignishandler sieht nun folgendermaßen aus:

void client_DetectCompleted(object sender, 
  TranslationService.DetectCompletedEventArgs e)
{
  string languageCode = e.Result;
  client.TranslateAsync(appID, TranslateTextBox.Text, fromLanguage, tolanguage);
}

Wegen der vom Benutzer ausgewählten Schaltfläche wissen wir, in welche Sprache übersetzt werden soll. Wir wissen, aus welcher Sprache übersetzt werden soll, da dies von der Translator-API automatisch erkannt wurde. Wir haben einen einfachen mehrsprachigen Übersetzer erstellt, der nur zwei Berührungen durch den Benutzer erfordert, Tippen nicht eingerechnet, und wir haben nicht einmal eine Stunde dafür codieren müssen.

Einfachheit

Einfachheit ist die Grundlage der Entwicklung für Windows Phone 7. Eine App sollte sich auf ein Benutzerszenario konzentrieren und dieses optimal umsetzen. Die mit Windows Phone 7 SDK CTP ausgelieferten Tools ermöglichen eine unkomplizierte Bereitstellung von gleichzeitig einfachen und leistungsstarken Apps. Wir haben außerdem festgestellt, dass die Interaktion mit der Cloud problemlos möglich ist und dass der Microsoft Translator-Webdienst mit nur geringem Entwicklungsaufwand in eine Windows Phone-App integriert werden kann. Mit bekannten Tools wie Visual Studio und klaren Richtlinien wie Metro lassen sich Windows Phone und die Cloud kombinieren, sodass sich Entwicklern und Benutzern ganz neue Möglichkeiten bieten.

Ramon Arjona arbeitet als Senior Test Lead im Windows-Team bei Microsoft.

Unser Dank gilt den folgenden technischen Experten für die Durchsicht dieses Artikels: Vikram Dendi und Sandor Maurice