Pour revoir la liste des critères selon lesquels votre application va être évaluée : Windows Phone Certification Requirements.

Edition du Manifest de l’application

Avant de soumettre, vérifiez bien ces 2 points :

• Tous vos assets sont bien remplis dans le Manifest de votre application, la base !
• Les « Capabilities » mentionnées dans le Manifest correspondent bien aux besoins de votre application. Par exemple, une application de radio n’a pas besoin de la capability « ID_CAP_MEDIALIB_AUDIO » si elle utilise des flux streaming en ligne, à moins qu’elle n’ait besoin d’accéder à la bibliothèque media de l’utilisateur.

Soumettre votre application pour Windows Phone 8

Ca y est, vous êtes prêts !

Important pour les jeux : il faut impérativement avoir un certificat pour soumettre vos jeux sur le Windows Store, donc voici quelques sites qui vont vous permettre de générer ces certificats en ligne :

• Pour soumettre en Europe, les certificats PEGI : https://wp-rating.pegi.eu/Games/Submit
• Pour soumettre aux Etats-Unis / Canda, les certificats ESRB : https://www.mobileratings.org/CTIA_Microsoft/Home.aspx

Vous trouverez sur MSDN la liste de tous les organismes de certification pour les jeux en fonction des pays pour lesquels vous souhaitez soumettre.

• App Info :

Dans cette section, choisissez le nom de votre application, sa catégorie, son prix, etc.

Petit conseil, dans le choix des pays, optez pour l’option “Distribute to all markets except those with stricter content rules”. Cela vous évitera des refus

Pour soumettre une version Beta, il faut aller dans “More Options”, idem pour désactiver la publication automatique de votre application suite à sa certification.

• Upload and describe your XAP :

Point très important : Une soumission doit contenir tous les .xap de votre application. Je m’explique : même si vous ne voulez soumettre qu’une mise à jour pour Windows Phone 8, il faut continuer d’inclure les .xap des versions précédentes dans la soumission si vous souhaitez que les utilisateurs qui n’ont pas encore Windows Phone 8 puissent continuer à utiliser votre application. Des développeurs se sont fait avoir en ne soumettant que le xap de la version 8, et ont fait disparaitre leur application 7.5 du Store.

Dans la liste déroulante, vous voyez la liste de vos XAP existants. Pour ajouter un XAP pour Windows Phone 8, il faut utiliser le bouton “Add New”.

Pensez bien après le téléchargement à décrire votre application dans tous les langages pour lesquels elle est disponible.

Petite astuce pour l’upload des images, cliquez sur le bouton “Upload All” qui vous permet de choisir toutes les images à télécharger en une seule fois. Automatiquement, vos assets vous être répartis dans les bonnes catégories.

Cliquez sur “Save”, puis “Submit” si vous n’avez pas d’autres changements à apporter.

Et Voilà ! Contemplez le résultat, et attendez patiemment les retours, qui se font sous environ une semaine.

Soumission des produits pour l’ In-App Purchase

La liste des produits disponibles à l’achat depuis votre application se trouve dans l’onglet « Products ». Sachez que vous pouvez soumettre des produits pour votre application même si celle-ci n’est pas encore validée. La certification d’un produit par le Store n’est pas très longue (dans mon cas, une journée) donc ne tardez pas, même si votre application n’est pas encore tout à fait terminée.

Tax Profile

Voici les différentes étapes à remplir pour le Tax Profile. Un peu d’aide ne fait jamais de mal avec les formulaires américains

1/ Choisir le pays :

2/ Remplir les informations de base : nom, prénom, adresse, etc. Suite à cette étape, un code PIN vous est envoyé sur votre email (à bien garder sous la main).

3/ Sélectionner le type de bénéficiaire des revenus

4/ Choisir le type de formulaire, W8-BEN étant celui qui s’applique dans la plupart des cas.

5/ Remplir ce fameux formulaire et le « signer » avec votre nom complet et le code PIN reçu de l’adresse “admin@cticompliance.com” :

Exemple d’email :

6/ et voilà, c’est fini :

Merci à la communauté Windows Phone pour ses petits conseils !

Les API Proximity et NFC permettent à deux Windows ou Windows Phone d’échanger des données lorsqu’ils sont à proximité.

Comment ça marche ? Un message NFC est utilisé pour configurer une connexion qui va ensuite permettre aux 2 périphériques de communiquer via un socket en Bluetooth ou TCP/IP (Wifi).

Pourquoi c’est bien ? Cela vous évite de perdre du temps sur la configuration de la connexion (et c’est quoi ton mot de passe, etc.). Un seul « tap » vers l’autre téléphone ou PC, et hop la connexion est configurée. En effet, comme on considère que le tap a été volontaire, on se passe des protocoles usuels d’authentification.

Si vous voulez tester, c’est ce que fait votre Windows Phone 8 lorsque vous voulez partager une photo avec un autre téléphone en utilisant la fonction « Tap + Share » (ou « Toucher + Envoyer » en français).

Quand vous souhaitez utiliser ce scénario, le mieux est donc d’avoir le Bluetooth activé :) Si vous préférez passer par le Wifi en TCP/IP, il faudra que les téléphones soient sur le même réseau ou routeur (pas de conflits d’IP, etc.).

Remarque importante : Wi-Fi Direct est supporté sur Windows 8, mais pas sur Windows Phone 8.

N’oubliez pas que vous pouvez appeler le Launcher connectionSettingsTask pour que votre utilisateur puisse aller activer le Bluetooth depuis votre application Windows Phone.

ConnectionSettingsTask connectionSettingsTask = new ConnectionSettingsTask();
connectionSettingsTask.ConnectionSettingsType = ConnectionSettingsType.Bluetooth;
connectionSettingsTask.Show();

Voyons comment créer une petite application qui communique avec d’autres instances, au travers de 3 étapes :

• Rechercher les autres instances de l’application et établir la communication
• Envoyer un message
• Recevoir un message

Le sample est téléchargeable ici : PeerCommunications.zip 

Etape 1 – Rechercher des Peers

Comme dans l’article précédent, vous initialisez le ProximityDevice au lancement de l’application (ou au moment opportun), et en plus, vous allez rechercher d’autres instances de votre application avec le PeerFinder :

        private void InitializeProximityDevice()
        {
            if (this.device == null)
            {
                this.device = ProximityDevice.GetDefault();
            }

            if (this.device != null)
            {
                this.device.DeviceArrived += ProximityDeviceArrived;
                this.device.DeviceDeparted += ProximityDeviceDeparted;
                lblStatus.Text = MSG_NFC_ACTIVE;

                PeerFinder.TriggeredConnectionStateChanged += OnTriggeredConnectionStateChanged;

                // Start finding peer apps, while making this app discoverable by peers
                PeerFinder.Start();
            }
            else
            {
                lblStatus.Text = MSG_NFC_NOT_FOUND;
            }
        }

Le PeerFinder va rechercher pour vous les autres instances de votre application, et rendre la vôtre trouvable par les autres. Automatiquement quand un autre Windows Phone va s’approcher de votre téléphone, ce dernier va lui proposer de lancer une instance de l’application :

Cela fonctionne aussi de Windows Phone vers Windows 8 et inversement. Pour vous connecter à Windows 8 depuis Windows Phone par exemple, vous allez juste spécifier l’identité de l’application à rechercher avec AlternateIdentities :

if (device != null)
{
PeerFinder.AlternateIdentities.Add("Windows", "my Win8 appID");
PeerFinder.TriggeredConnectionStateChanged += OnTriggeredConnectionStateChanged;
PeerFinder.Start();
}

Ensuite, vous allez pouvoir récupérer les infos concernant la connexion ad-hoc créée par le PeerFinder en vous abonnant à l’événement TriggeredConnectionStateChanged :

        private void OnTriggeredConnectionStateChanged(object sender, TriggeredConnectionStateChangedEventArgs args)
        {
            switch (args.State)
            {
                case TriggeredConnectState.Listening:
                    lblStatus.Text = "Listening";
                    break;
                // Connecting as hostbreak;
                case TriggeredConnectState.PeerFound:
                    lblStatus.Text = "Peer Found";
                    break;
                // Proximity gesture is complete and user can pull their devices away. Remaining work is to // establish the connection using a different transport, like TCP/IP or Bluetoothbreak;
                case TriggeredConnectState.Connecting:
                    lblStatus.Text = "Connecting";
                    break;
                // Connecting as a clientbreak;
                case TriggeredConnectState.Completed:
                    // Connection completed, retrieve the socket over which to communicate
                    streamSocket = args.Socket;
                    lblStatus.Text = "Connection completed";
                    break;
                case TriggeredConnectState.Canceled:
                    lblStatus.Text = "Connection canceled";
                    break;
                case TriggeredConnectState.Failed:
                    lblStatus.Text = "Connection canceled";
                    break;
            }
        }

Cette fonction vous renvoie notamment dans ses arguments le socket initialisé pour la connexion entre les deux périphériques. C’est ensuite ce socket que vous allez utiliser pour échanger les données.

Vous êtes complètement libres d’utiliser le protocole de votre choix pour la communication une fois le socket initialisé. Dans la suite de l’article, je vais juste échanger une chaine de caractères entre les deux pour vous donner un exemple.

Etape 2 : Envoyer un message

J’ajoute un bouton à mon interface pour déclencher l’envoi du message :

        private void SendMessageButton_Click(object sender, RoutedEventArgs e)
        {
            SendMessage("YATTTA!");
        }

Pour envoyer un message, il suffit de créer un DataWriter à partir du socket que vous avez récupéré et d’y ajouter les données à transmettre :

        private async void SendMessage(string message)
        {
            if (streamSocket != null)
            {
                if (dataWriter == null)
                    dataWriter = new DataWriter(streamSocket.OutputStream);

                dataWriter.WriteInt32(message.Length);
                await dataWriter.StoreAsync();

                dataWriter.WriteString(message);
                await dataWriter.StoreAsync();
            }
        }

Etape 3 : Recevoir un message

De la même façon, j’attends la réception d’un message avec ma fonction asynchrone GetMessage. Celle-ci sera complétée quand elle aura un message à lire.

    private async void GetMessageButton_Click(object sender, RoutedEventArgs e)
    {
            string s = await GetMessage();
            lblMsg.Text = s;
    }

Pour recevoir un message, il suffit de créer un DataReader à partir du socket que vous avez récupéré:

        private async Task<string> GetMessage()
        {
            if (streamSocket != null)
            {
                if (dataReader == null) dataReader = new DataReader(streamSocket.InputStream);
                await dataReader.LoadAsync(4);
                uint messageLen = (uint)dataReader.ReadInt32();
                await dataReader.LoadAsync(messageLen);
                return dataReader.ReadString(messageLen);
            }
            else return null;
        }

N’oubliez pas de faire le ménage derrière vous en partant :

        protected override void OnNavigatingFrom(NavigatingCancelEventArgs e)
        {
            PeerFinder.Stop();
            CloseSocket();
        }

        private void CloseSocket()
        {
            if (streamSocket != null)
            {
                streamSocket.Dispose();
            }

            if (dataWriter != null)
            {
                dataWriter.Dispose();
            }

            if (dataReader != null)
            {
                dataReader.Dispose();
            }
        }

Vous pouvez télécharger le code source correspondant à cet exemple ici : PeerCommunications.zip

Je vous conseille aussi de jeter un coup d’œil aux samples Windows 8 sur ce sujet, notamment pour ceux qui voudraient voir comment cela fonctionne en JavaScript. Petit indice, ce sont les mêmes API, juste pas le même langage, donc pas de surprises

Quid de l’interop avec un device Android ou autre ? Pour l’instant, il n’y a pas de standard pour la communication NFC en Peer-to-Peer. Du coup, Android, Windows/Windows Phone et Meego ont tous leurs propres implémentations, et ne peuvent communiquer entre eux.

Comme ce serait bien trop facile, nous allons en écrire une nous-même. Pour cela, il faut utiliser l’API Windows Proximity. Vous avez de la chance, grâce au noyau partagé entre Windows et Windows Phone, cette Proximity API fonctionne exactement de la même façon depuis les deux OS. J’ai écrit l’exemple qui suit pour Windows Phone 8, mais sachez que le même code fonctionnerait pour Windows 8.

Dans cet article, je vais supposer que vous connaissez bien les bases du développement pour Windows Phone. Si ce n’est pas le cas, vous trouverez une série de tutoriels pour vous former sur MSDN et vous pouvez suivre l’actu sur le blog de Pierre Cauchois.

Pour démarrer, créez un nouveau projet Windows Phone 8 (ou Windows 8) dans Visual Studio. Parmi les modèles, prenez le plus simple « Windows Phone App », et choisissez bien sûr Windows Phone 8.0 pour la version de l’OS. Vous pouvez télécharger l’exemple de code ici : ReadWriteNFCTags.zip

Avant de commencer le développement, 2 choses :

- précisez dans le manifeste de l’application – fichier WMAppManifest.xml - que vous allez utiliser du NFC en ajoutant la capability « ID_CAP_PROXIMITY ». Sans cette précision, votre application ne pourra pas être déployée.

- Vous pouvez aussi ajouter dans l’onglet « Requirements » du manifeste que vous ne souhaitez installer l’application que sur des téléphones équipés de NFC avec « ID_REQ_NFC ».

Etape 1 : Initialiser la connexion au NFC

Pour que votre application soit « NFC » aware, c’est-à-dire qu’elle entende si on lui envoie des infos via NFC et qu’elle puisse en émettre, il va falloir initialiser un ProximityDevice au chargement de votre page principale. Pour écrire du code bien propre, je vous conseille de mettre toutes les fonctions spécifiques NFC dans un helper dédié. Ici, je vais au plus simple :

        ProximityDevice device { get; set; }
        long PublishedMessageID = -1;
        long SubscribedMessageID = -1;

        // Constructor
        public MainPage()
        {
            InitializeComponent();
            
            this.Loaded += MainPage_Loaded;

        }

        void MainPage_Loaded(object sender, RoutedEventArgs e)
        {
            this.InitializeProximityDevice();
        }

Pour initialiser votre ProximityDevice, une fonction toute simple : GetDefault, qui vous retourne l’instance du ProximityDevice utilisé par défaut. Dans mon application, je vais juste afficher dans un TextBlock baptisé « lblTagStatus » l’état de mon device.

        private void InitializeProximityDevice() 
        {
                if (this.device == null) {
                    this.device = ProximityDevice.GetDefault();
                }

                if (this.device != null)
                {
                    this.device.DeviceArrived += ProximityDeviceArrived;
                    this.device.DeviceDeparted += ProximityDeviceDeparted;
                    lblTagStatus.Text = MSG_NFC_ACTIVE;
                } 
                else 
                { 
                    lblTagStatus.Text = MSG_NFC_NOT_FOUND; 
                }
        }

Etape 2 : Ecrire un message sur un tag NFC

Chose à savoir, il existe un format standard pour les messages échangés en NFC appelé NDEF, pour NFC Data Exchange Format. Vous n’êtes pas obligés de l’utiliser, mais c’est toujours mieux si vous envisagez des développements multiplateformes.

Bonne nouvelle, il existe une librairie NDEF pour Windows 8 sur CodePlex que vous pouvez récupérer, et qui fonctionne très bien aussi sur Windows Phone (c’est ça, la magie des API en commun). Pour l’ajouter à votre application, un clic-droit sur le projet dans Visual Studio, lancer NuGet, rechercher NDEF, installer et hop c’est terminé.

Pour plus de détails sur cette librairie, https://ndef.codeplex.com/

Voici la structure d’un message NDEF. Comme vous le voyez, il peut contenir plusieurs enregistrements.

Pour construire un message NDEF avec cette librairie, je vais avoir besoin des using suivants dans ma classe :

using NdefLibrary.Ndef;
using System.Runtime.InteropServices.WindowsRuntime;

Et voici la fonction que j’appelle pour écrire sur un tag (que vous pouvez appeler au clic sur un bouton) :

  private void WriteNDEFToNfc() 
        {
            // Initialize Smart Poster record with URI, Action + 1 Title
            var spRecord = new NdefSpRecord
            {
                Uri = "https://msdn.microsoft.com/windows",
                NfcAction = NdefSpActRecord.NfcActionType.DoAction
            };

            spRecord.AddTitle(new NdefTextRecord
            {
                Text = "Windows Dev Center",
                LanguageCode = "en"
            });

            // Add record to NDEF message
            var msg = new NdefMessage { spRecord };

            // Publish NDEF message to a tag
            if (device != null)
            {
                PublishedMessageID = device.PublishBinaryMessage("NDEF:WriteTag", msg.ToByteArray().AsBuffer());
                Debug.WriteLine("Published Message. ID is {0}", PublishedMessageID);

                lblSender.Text = "Published Message. ID is: " + PublishedMessageID.ToString();
                lblMessageContent.Text = "Content: " + spRecord.Uri.ToString();
                lblMessageType.Text = "Type: " + spRecord.Type.ToString();
            }

            // Alternative: send NDEF message to another NFC device
            //device.PublishBinaryMessage("NDEF", msg.ToByteArray().AsBuffer());
        }

J’ai créé un enregistrement (NdefTextRecord), que j’ai ajouté au message (NdefMessage). Ensuite, si mon device NFC est bien initialisé, j’envoie ce message et je récupère son ID (PublishedMessageID). Cette fonction marche très bien, à condition que vos tags soient bien formatés avant.

Une fois que mon tag contient le message, je n’ai plus qu’à le passer près du téléphone pour qu’il soit reconnu. Aucune application à lancer, NFC le reconnait directement.

Petite remarque, Windows Phone étant un OS à la sécurité bien pensée, il y aura toujours un prompt demandant l’approbation de l’utilisateur à la lecture d’un tag. Voilà à quoi ce prompt ressemble :

Etape 3 : Lire un message depuis un tag NFC

Pour lire un message depuis un tag, il va falloir dire au ProximityDevice de votre application qu’il faut qu’il s’intéresse à un certain type de messages, ici NDEF, en appelant la fonction SubscribeForMessage, et lui préciser quoi faire en cas de réception, ici appeler la fonction messageReceived.

Dans mon exemple, j’ai ajouté un bouton Read dans ma page principale qui m’abonne à un type de message (et me désabonne des anciens si besoin) :

        private void btnReadNFC_Click(object sender, RoutedEventArgs e)
        {
            InitLabels();

            // Make sure NFC is supported
            if (device != null)
            {
                if (SubscribedMessageID != -1)
                {
                    device.StopSubscribingForMessage(SubscribedMessageID);
                }
                //Suscribe to NDEF new message
                SubscribedMessageID = device.SubscribeForMessage("NDEF", messageReceived);
                Debug.WriteLine("Subscribed Message. ID is {0}", SubscribedMessageID);
            }
        }

Si je passe mon tag avec un message NDEF près de mon téléphone, la fonction suivante messageReceived sera appelée. Celle-ci va récupérer le message et l’analyser en fonction de son type : SpRecord, UriRecord, ou TextRecord.

 private void messageReceived(ProximityDevice sender, ProximityMessage message)
        {
            var rawMsg = message.Data.ToArray();
            var ndefMessage = NdefMessage.FromByteArray(rawMsg);
            SubscribedMessageID = -1;

            // Loop over all records contained in the NDEF message
            foreach (NdefRecord record in ndefMessage)
            {
                // Check the type of each record - handling a Smart Poster, URI and Text record in this example
                var specializedType = record.CheckSpecializedType(false);
                if (specializedType == typeof(NdefSpRecord))
                {
                    // Convert and extract Smart Poster info
                    var spRecord = new NdefSpRecord(record);

                    Dispatcher.BeginInvoke(() => {
                        lblSender.Text = "Message received from: " + sender.DeviceId;
                        lblMessageContent.Text = "Content: " + spRecord.Uri;
                        lblMessageType.Text = "Type: " + spRecord.Type.ToString();
                    });
                }
                else if (specializedType == typeof(NdefUriRecord))
                {
                    // Convert and extract Smart Poster info
                    var uriRecord = new NdefUriRecord(record);
                    Dispatcher.BeginInvoke(() =>
                    {
                        lblSender.Text = "Message received from: " + sender.DeviceId;
                        lblMessageContent.Text = "Content: " + uriRecord.Uri;
                        lblMessageType.Text = "Type: " + uriRecord.Type.ToString();
                    });
                }
                else if (specializedType == typeof(NdefTextRecord))
                {
                    // Convert and extract Smart Poster info
                    var textRecord = new NdefTextRecord(record);
                    Dispatcher.BeginInvoke(() =>
                    {
                        lblSender.Text = "Message received from: " + sender.DeviceId;
                        lblMessageContent.Text = "Content: " + textRecord.Text;
                        lblMessageType.Text = "Type: " + textRecord.Type.ToString();
                    });
                }
            }
        }

Tada ! Maintenant, vous savez lire des tags, et même modifier leurs contenus.

Vous pouvez télécharger le code source correspondant à cet exemple ici : ReadWriteNFCTags.zip

Dans le prochain article, nous verrons comment communiquer avec une autre instance de votre application, pratique pour des jeux par exemple.

Liens utiles

• Application NFC Interactor pour Windows Phone 8: https://www.nfcinteractor.com/download-nfc-interactor-for-windows-phone-8/
• Proximity API for Windows Phone : https://msdn.microsoft.com/en-US/library/windowsphone/develop/jj207060(v=vs.105).aspx
• Understanding NFC Data Exchange Format (NDEF) messages : https://www.developer.nokia.com/Community/Wiki/Understanding_NFC_Data_Exchange_Format_(NDEF)_messages
• Blog de Pierre Cauchois sur Windows Phone 8 : https://blogs.msdn.com/b/pierreca/

« Après l'avènement des smartphones et de l'internet mobile, qui ont déjà transformé le téléphone portable en outil du quotidien, la technologie sans contact ou NFC ajoute une nouvelle dimension à la mobilité grâce à cette technologie, les français pourront bientôt utiliser leur mobile Cityzi pour payer chez les commerçants, prendre les transports en commun, cumuler des points de fidélité ou lire des informations contextuelles grâce à des étiquettes intelligentes Les applications permises par cette technologie sont extrêmement variées, et la plupart restent à inventer. » Laurent Jullien, Président de l’Association Française du Sans Contact Mobile (AFSCM)

En effet, NFC (Near Field Communications) est une technologie qui, comme son nom l’indique, permet l'échange d'informations sans contact entre des périphériques à faible distance, de l’ordre de 3 ou 4 cm.

Microsoft, en équipant Windows Phone 8 et Windows 8 de contrôleurs NFC, ouvre la porte de ces nouveaux scénarios aux développeurs :

- Partager du contenu entre 2 périphériques comme des contacts, urls, informations de connexion, etc. Si vous voulez tester, c’est ce que fait votre Windows Phone 8 lorsque vous voulez partager une photo à un autre téléphone en utilisant la fonction « Tap + Share » ou « Toucher + Envoyer » en français.

- Acquérir du contenu : lire des données depuis un tag NFC. Par exemple, partager votre localisation sur un réseau social grâce au tag situé dans votre restaurant, récupérer une url, connaître l’état du stock disponible d’un article, etc. Vous pouvez avoir de l’imagination ! NFC possède aussi un mode write. Ainsi, vous allez pouvoir écrire vous-même des infos dans vos tags.

- Emettre du contenu : votre puce NFC vous permet aussi l’émulation de cartes, et là on arrive à un scénario possible bien connu, celui du portefeuille électronique. L’application Windows Phone 8 Wallet, ou Portefeuille en français, stocke vos moyens de paiement, cartes de membres, cartes de fidélité et bons de réductions et surtout, vous permet de les utiliser par simple contact grâce au NFC. Je vous entends déjà poser la question de la sécurité, oui, il y a bien un code PIN spécifique pour le Wallet. Personne ne pourra utiliser vos moyens de paiement par simple contact sans votre consentement. Imaginez sinon le nombre de transactions possibles dans le métro !

Quand on sait que RFID permet aussi d’échanger des données ou de lire des tags, on est en droit se demander quelles sont les différences avec NFC ? En résumé :

• RFID et NFC utilisent tous 2 les radiofréquences pour communiquer, et en cela, on peut voir NFC comme une extension des technologies RFID.
• RFID peut être utilisé avec n’importe quelle fréquence ou standard, alors que NFC requiert du 13.56 MHz.
• RFID fonctionne à longue distance (par longue, j’entends jusqu’à une centaine de mètres, pas 3km) et c’est là la principale différence. Le fait que NFC fonctionne à très courte distance permet de supposer que l’action a été voulue (e.g. scanner un tag, « tap » pour communiquer avec un autre téléphone, effectuer un paiement). Je schématise mais vous voyez le principe. A l’inverse, RFID ne conviendrait pas des scénarios type m-commerce, pour des raisons évidentes de sécurité (eavesdropping, man-in-the-middle attacks), alors que c’est une techno très pratique pour le tracking.

Et si maintenant on commençait à jouer un peu avec ? Avant toute chose, équipez-vous du matériel nécessaire :

• Un bon PC équipé de Windows 8 et Visual Studio 2012. Il existe des versions gratuites, appelées « express », de nos outils pour le développement d’applications Windows 8 et Windows Phone 8.
• Un Windows Phone 8 ou Windows 8 équipé d’un contrôleur NFC – de très beaux modèles sont sortis !
• En option : des SmartTags NFC, si vous voulez tester. Vous en trouverez facilement sur Amazon, mais pensez à les prendre déjà formatés, ça vous fera gagner du temps (conseil d’amie).

Je vous ai écrit quelques articles pour débuter avec NFC pour Windows:

• Lire/Ecrire des tags NFC depuis Windows 8 ou Windows Phone 8
• NFC : Comment faire communiquer vos applications Windows Phone 8 et Windows 8

En savoir plus :

• Association Française du Sans Contact Mobile : https://www.afscm.org/
• Initiative Cityzi : https://www.cityzi.fr/
• NFC chez Nokia : https://www.nokia.com/global/products/nfc/
• Proximité et NFC dans Windows 8 : https://msdn.microsoft.com/en-us/library/windows/apps/hh465229.aspx
• Proximity API pour Windows Phone : https://msdn.microsoft.com/en-US/library/windowsphone/develop/jj207060(v=vs.105).aspx
• Communiqué de presse de NXP : https://www.nxp.com/news/press-releases/2012/10/nxp-delivers-nfc-to-microsofts-windows-phone-8-devices.html