Exporter (0) Imprimer
Développer tout
Ce sujet n'a pas encore été évalué - Évaluez ce sujet

Pas à pas : Introduction aux nouvelles API natives de Windows Mobile

Microsoft Corporation

Novembre 2005

S'applique à :
Microsoft .NET Compact Framework version 1.0
Microsoft Visual C++
Microsoft Visual Studio 2005
Windows Mobile 5.0 pour Pocket PC
Windows Mobile 5.0 pour Smartphones

Résumé : Découvrez les nouvelles API natives de Windows Mobile dans cet atelier pratique. Vous allez améliorer une application existante en utilisant ces nouvelles interfaces. À la fin de cet atelier, vous serez prêt à utiliser ces API pour simplifier votre code existant ou pour étendre vos applications afin d’utiliser les nombreuses nouvelles fonctionnalités de Windows Mobile 5.0. Il s’agit d’un atelier de niveau 300. (35 pages imprimées)

Consultez l'article en anglais  Aa454896.us(fr-fr,MSDN.10).gif

Téléchargez MED307_Intro_New_WM5_Native API.msi à partir du Centre de téléchargement Microsoft.

Aa454896.3squares(fr-fr,MSDN.10).gif
Sur cette page

Introduction
Exercice 1 : Utilisation du Sélecteur de contact pour permettre la recherche
Exercice 2 : Utilisation de la messagerie et du Sélecteur d’images pour envoyer du courrier électronique avec des pièces jointes
Exercice 3 : Utilisation de l’API broker État et notification pour extraire des informations sur l’état du système
Exercice 4 : Utilisation de l’API Broker État et notification pour recevoir des notifications des changements d’état du système
Exercice 5 : Utilisation de l’API de capture (facultatif)
Annexe A : Arrêt de l’exécution d’une application sur un périphérique ou un émulateur
Résumé

Pour effectuer cet exercice, vous avez besoin des éléments suivants :

  • Windows XP Professionnel.
    Cet atelier nécessite Windows XP Professionnel.

  • Visual Studio 2005.
    Cet atelier nécessite Visual Studio 2005 Standard, Professionnel ou Team System. Il ne fonctionnera pas avec les éditions Express. Si vous ne disposez pas de la version correcte de Visual Studio 2005, déterminez comment l’obtenir en consultant le site Centre de développement Visual Studio 2005.

  • ActiveSync 4.0.
    ActiveSync 4.0 permet la connectivité entre un périphérique utilisant Windows Mobile et votre ordinateur.

  • Kits SDK Windows Mobile 5.0.
    Les kits SDK Windows Mobile 5.0 pour Pocket PC et Smartphone permettent le développement pour les périphériques Windows Mobile dans Visual Studio 2005.

Téléchargez et installez le kit SDK Windows Mobile 5.0 pour Pocket PC.

Téléchargez et installez le kit SDK Windows Mobile 5.0 pour Smartphone.

Remarque : Si vous avez utilisé un émulateur dans un atelier précédent, vous devez procéder à une réinitialisation matérielle de l’émulateur avant de commencer cet atelier. Sur l’émulateur, cliquez sur Fichier, pointez sur Réinitialisation, puis cliquez sur Matérielle.

Remarque : Si vous recevez une erreur au cours du déploiement, indiquant que le processus ou le fichier est en cours d’utilisation, cela signifie que le programme est toujours en cours d’exécution sur l’émulateur et qu’il doit être arrêté avant le déploiement et l’exécution d’une nouvelle copie. Cette erreur peut apparaître chaque fois que vous déployez l’émulateur. Reportez-vous à la dernière tâche de cet atelier pour savoir comment quitter une application en cours d’exécution.

Introduction

Cet atelier présente nombre des nouvelles API (Application Programming Interfaces) de Windows Mobile, telles que le Sélecteur de contact, le Sélecteur d’images, l’API d’application de messagerie, l’API de capture photo et l’API Broker État et notification. Pour comprendre ces API et la façon dont elles peuvent s’intégrer à une application, utilisez ces nouvelles API pour ajouter des fonctionnalités à une application existante, écrite avec Visual C++. L’application existante fournit la gestion élémentaire des menus et l’affichage à l’écran, mais elle ne contient pas de fonctionnalités qui soient fonctionnelles.

L’application que vous allez modifier est une application de Smartphone, utilisée par les commerciaux sur le terrain d’un revendeur de produits d’art et de photographie. Les commerciaux passent beaucoup de temps sur la route afin de travailler en étroite collaboration avec chaque client. Ces commerciaux doivent toujours avoir un accès facile aux informations relatives aux clients et doivent pouvoir travailler efficacement lorsqu’ils ne sont pas au bureau.

L’application est un gestionnaire de contacts qui permet le suivi des noms des contacts, des numéros de téléphone au travail, des numéros de téléphone portable et des informations sur le client. Dans cet atelier, vous allez intégrer l’application à Microsoft Pocket Outlook en fournissant les fonctionnalités de recherche de contact. Vous allez utiliser les autres API pour intégrer étroitement l’application aux fonctionnalités du téléphone, telles que la localisation d’images dans l’inventaire et l’envoi automatique de messages électroniques. Vous allez également mettre à jour l’application afin de surveiller les appels entrants ou manuels d’un client, afin que les informations relatives au client s’affichent automatiquement. L’atelier comprend également un exercice facultatif pour ajouter la prise en charge des photos à partir de l’application.

L’objectif de cet atelier est de présenter les API gérées disponibles dans le cadre de la plate-forme Windows Mobile et de démontrer leur efficacité pour améliorer la productivité des utilisateurs. Dans cet atelier, vous allez effectuer les exercices suivants :

  • Utilisation du Sélecteur de contact pour permettre la recherche

  • Utilisation de la messagerie et du Sélecteur d’images pour envoyer du courrier électronique avec des pièces jointes

  • Utilisation de l’API broker État et notification pour extraire des informations sur l’état du système

  • Utilisation de l’API Broker État et notification pour recevoir des notifications des changements d’état du système

  • Utilisation de l’API de capture (facultatif)

Exercice 1 : Utilisation du Sélecteur de contact pour permettre la recherche

Dans cet exercice, vous allez ajouter à l’application une fonctionnalité de recherche permettant à l’utilisateur de rechercher un contact spécifique. Pour cela, vous allez utiliser la fonction ChooseContact du Sélecteur de contact.

Avant de commencer l’atelier, vous devez exécuter une application afin d’ajouter à l’émulateur les contacts et fichiers image Pocket Outlook nécessaires.

Remarque : Ne vous inquiétez pas du fait que le programme d’initialisation est écrit avec Microsoft .NET Compact Framework. Cette application a été choisie pour sa simplicité pour produire ce type de programme. Tout le codage effectué dans cet atelier est en langage C++.

Pour alimenter l’émulateur avec des données de test

  1. Si Microsoft Visual Studio 2005 n’est pas déjà ouvert, lancez-le en cliquant sur Démarrer | Tous les programmes | Microsoft Visual Studio 2005 | Microsoft Visual Studio 2005.

  2. Dans Visual Studio 2005, cliquez sur Fichier | Ouvrir | Projet/Solution.

  3. Dans la boîte de dialogue Ouvrir un projet, accédez à l’unité sur laquelle vous avez téléchargé le fichier .msi, puis accédez à C:\Program Files\Windows Mobile Developer Samples\HOLs\MED307 Intro New WM5 Native API\Setup Files\InitializeLab.sln.

  4. Cliquez sur Ouvrir. La solution InitializeLab s’ouvre.

  5. Dans la barre de menus de Visual Studio 2005, vérifiez que Windows Mobile 5.0 Smartphone Emulator est sélectionné dans la liste déroulante Périphérique cible, comme illustré dans la figure suivante.

    Figure 1

  6. Dans le menu Déboguer, cliquez sur Démarrer le débogage afin de lancer l’application.

  7. Si vous y êtes invité par la boîte de dialogue Déployer InitializeLab, vérifiez que Windows Mobile 5.0 Smartphone Emulator est sélectionné, puis cliquez sur Déployer.

    Remarque : Si l’émulateur n’apparaît pas, recherchez un bouton dans la barre des tâches Windows et cliquez dessus afin de mettre l’émulateur au premier plan. N’oubliez pas que le premier démarrage de l’émulateur peut prendre plusieurs minutes.

    Important : Si vous recevez une erreur au cours du déploiement, indiquant que le processus ou le fichier est en cours d’utilisation, cela signifie que le programme est toujours en cours d’exécution sur l’émulateur et qu’il doit être arrêté avant le déploiement et l’exécution d’une nouvelle copie. Cette erreur peut apparaître chaque fois que vous déployez l’émulateur. Reportez-vous à la dernière tâche de cet atelier pour savoir comment quitter une application en cours d’exécution.

  8. Lorsque l’application apparaît sur l’émulateur, cliquez sur Touche programmable 1, le bouton gris situé sous le mot Démarrer, comme illustré dans la figure suivante. L’application affiche un curseur d’attente et indique que les contacts, puis les images, sont ajoutés.

    Figure 2

  9. Lorsque l’application affiche Initialisation terminée, cliquez sur Touche programmable 2, le bouton gris situé sous le mot Quitter, afin de quitter l’application.

  10. Dans le menu Fichier de Visual Studio, cliquez sur Fermer le projet.

  11. Si Visual Studio vous invite à enregistrer, cliquez sur Oui. Remarque : Si vous quittez l’émulateur, prenez soin d’enregistrer l’état de l’émulateur.

Avant de modifier l’application, vous devez vous familiariser avec son implémentation.

Pour vous familiariser avec l’application existante

  1. Si Visual Studio 2005 n’est pas déjà ouvert, lancez-le en cliquant sur Démarrer | Tous les programmes | Microsoft Visual Studio 2005 | Microsoft Visual Studio 2005.

  2. Dans Visual Studio 2005, cliquez sur Fichier | Ouvrir | Projet/Solution.

  3. Dans la boîte de dialogue Ouvrir un projet, accédez à l’unité sur laquelle vous avez téléchargé le fichier .msi, puis accédez à C:\Program Files\Windows Mobile Developer Samples\HOLs\MED307 Intro New WM5 Native API\Exercises\NewNativeAPIs.

  4. Sélectionnez NewNativeAPIs.sln, puis cliquez sur Ouvrir.

    La solution NewNativeAPIs s’ouvre.

    Remarque : Une fois la solution ouverte, la solution, le projet et les fichiers source doivent être visibles dans l’Explorateur de solutions de Visual Studio 2005. Si l’Explorateur de solutions ne s’affiche pas automatiquement, cliquez sur Affichage | Explorateur de solutions afin de le rendre visible.

  5. Dans l’Explorateur de solutions, développez NewNativeAPIs, développez Fichiers source, puis double-cliquez sur NewNativeAPIs.cpp afin d’ouvrir le fichier source NewNativeAPIs.cpp.

    Notez que près du bas du fichier, quatre fonctions permettent l’administration de base de Pocket Outlook. Examinez ces fonctions afin de comprendre leur implémentation:

    - PocketOutlookLogon : ouvre une session sur Microsoft Pocket Outlook en stockant le pointeur de l’interface de l’application Pocket Outlook dans une variable globale, nommée g_polApp.
    - GetContact : localise un contact en utilisant l’identificateur d’objet (OID) du contact. Cette fonction renvoie le pointeur d’interface du contact et le stocke dans la variable globale g_pContact.
    - DisplayContact : la première version de cette fonction accepte un pointeur d’interface de contact affichant les informations importantes concernant le contact. En utilisant le contact référencé par le pointeur d’interface, les champs FileAs, BusinessTelephoneNumber, MobileTelephoneNumber et Body sont extraits du contact et copiés vers les variables globales utilisées pour afficher les valeurs. Cette fonction invalide également la zone d’affichage de l’application afin de forcer un réaffichage.
    - DisplayContact : La deuxième version de cette fonction associe la fonctionnalité de GetContact et l’autre version de DisplayContact. Elle accepte un OID de contact, puis localise et affiche le contact.

  6. Localisez l’instruction case WM_COMMAND dans la fonction WndProc. Notez que le programme comporte deux options de menu : IDM_EXIT et IDM_SELECT. Le code de IDM_EXIT est déjà fourni et gère les détails du nettoyage et de l’arrêt de l’application. IDM_SELECT appelle la fonction OnCOMMAND_SELECT.

  7. Localisez la fonction OnCOMMAND_SELECT vers le haut du fichier source. Rappelez-vous que cette fonction est appelée lorsque l’utilisateur choisit l’option de menu Sélectionner. Cette fonction appelle la majeure partie du nouveau code que vous ajoutez.

Vous êtes désormais prêt à ajouter la fonctionnalité permettant à l’utilisateur de choisir un contact spécifique. Pour cela, utilisez la nouvelle fonction ChooseContact.

Pour ajouter la fonctionnalité de sélection de contact

  1. Dans NewNativeAPIs.cpp, ajoutez une nouvelle fonction nommée SelectContact, qui renvoie une valeur bool. Cette fonction doit apparaître dans le fichier source avant la fonction OnCOMMAND_SELECT.

  2. Dans la méthode, déclarez une variable HRESULT nommée hr avec la valeur initiale E_ABORT.

    bool SelectContact()
    {
    	HRESULT hr = E_ABORT;
    }
  3. La structure CHOOSECONTACT contrôle le comportement de la fonction ChooseContact et contient la sélection utilisateur à la fin de la fonction ChooseContact. Déclarez une instance de la structure CHOOSECONTACT nommée cc et définissez le membre cbSize sur la taille de la structure.

    CHOOSECONTACT cc = {0};
    cc.cbSize = sizeof(cc);
  4. Le Sélecteur de contact offre un certain nombre d’options et de comportements, dont bon nombre sont activés et désactivés via l’utilisation du membre dwFlags de CHOOSECONTACT. Normalement, le Sélecteur de contact permet à l’utilisateur d’ajouter un nouveau contact. Cette fonctionnalité est désactivée via l’indicateur CCF_HIDENEW. Le Sélecteur de contact permet de sélectionner simplement un contact, ou un contact et une propriété spécifique du contact. L’indicateur CCF_CHOOSECONTACTONLY indique que seul le contact doit être choisi. Effectuez un OU au niveau bit afin de combiner ces indicateurs, de sorte que l’application sélectionne uniquement un contact et n’autorise pas l’utilisateur à créer un nouveau contact.

    cc.dwFlags = CCF_HIDENEW | CCF_CHOOSECONTACTONLY;
  5. En utilisant le membre rgpropidRequiredProperties de CHOOSECONTACT, le Sélecteur de contact peut limiter la liste des contacts affichés aux seuls contacts pour lesquels des propriétés spécifiques sont alimentées. Étant donné que votre application prendra bientôt en charge l’envoi de messages électroniques, utilisez PIMPR_ALL_EMAIL pour limiter la liste des contacts affichés aux seuls contacts pour lesquels au moins un jeu de propriétés de message électronique est défini. Le membre rgpropidRequiredProperties est un tableau, de sorte que vous devez d’abord déclarer un tableau de type CEPROPID qui initialise ce tableau avec la valeur PIMPR_ALL_EMAIL. Ensuite, affectez le tableau au membre rgpropidRequiredProperties de CHOOSECONTACT. Vous devez également définir le membre cRequiredProperties de CHOOSECONTACT sur le nombre d’éléments du tableau.

    CEPROPID rgProperties[] = {PIMPR_ALL_EMAIL};
    cc.rgpropidRequiredProperties = rgProperties;
    cc.cRequiredProperties = 1;
  6. Vous êtes maintenant prêt à afficher le Sélecteur de contact. Pour cela, appelez la fonction ChooseContact en passant un pointeur à l’instance de CHOOSECONTACT que vous avez initialisée. Affectez la valeur renvoyée par ChooseContact à la variable hr.

    hr = ChooseContact(&cc);
  7. Après l’appel de ChooseContact, utilisez la macro SUCCEEDED afin de vérifier que l’utilisateur a fait une sélection. Si tel est le cas, le membre oidContactID de CHOOSECONTACT contient l’OID des contacts sélectionnés. Affichez le contact sélectionné à l’aide de la méthode DisplayContact.

    if (SUCCEEDED(hr))
    DisplayContact(cc.oidContactID);
  8. Avec la macro SUCCEEDED, ajoutez le code à SelectContact afin de renvoyer true si ChooseContact a renvoyé un code de réussite.

    return SUCCEEDED(hr);
  9. Vous avez ajouté tout le code nécessaire à la méthode SelectContact. Il doit à présenter se présenter comme suit :

    bool SelectContact()
    {
    	HRESULT hr = E_ABORT;
    	CEPROPID rgProperties[] = {PIMPR_ALL_EMAIL};
    	
    	CHOOSECONTACT cc = {0};
    	cc.cbSize = sizeof (cc);
    	cc.dwFlags = CCF_HIDENEW | CCF_CHOOSECONTACTONLY;
    	cc.rgpropidRequiredProperties = rgProperties;
    	cc.cRequiredProperties = 1;
    	
    	hr = ChooseContact(&cc);
    	
    	if (SUCCEEDED(hr))
    	  DisplayContact(cc.oidContactID);
    	
    	return SUCCEEDED(hr);
    }

    La dernière chose à faire avant de tester la nouvelle fonctionnalité de recherche de contact consiste à appeler la fonction SelectContact à partir de OnCOMMAND_SELECT.

  10. Localisez la méthode OnCOMMAND_SELECT.

  11. Supprimez la ligne contenant l’appel de MessageBox.

    MessageBox(g_hWnd, _T("Select Clicked"), _T("Handle_IDM_SELECT"), MB_OK);
  12. Remplacez cette ligne par un appel de SelectContact. Affectez la valeur renvoyée par SelectContact à une variable bool nommée bSuccess. La méthode OnCOMMAND_SELECT doit à présent ressembler à ce qui suit.

    void OnCOMMAND_SELECT()
    {
    	bool bSuccess = SelectContact();
    }

Vous êtes maintenant prêt à tester la nouvelle fonctionnalité de l’application.

Pour tester la nouvelle fonctionnalité

  1. Dans le menu Générer, cliquez sur Générer NewNativeAPIs. Corrigez les éventuelles erreurs de compilation avant de continuer.

  2. Vérifiez que Windows Mobile 5.0 Smartphone Emulator est toujours sélectionné dans la liste déroulante, comme illustré dans la figure 1.

  3. Démarrez l’application en cliquant sur Déboguer | Démarrer le débogage

  4. Si vous y êtes invité par la boîte de dialogue Déployer NewNativeAPIs, vérifiez que Windows Mobile 5.0 Smartphone Emulator est sélectionné, puis cliquez sur Déployer. Si l’émulateur n’apparaît pas, recherchez un bouton dans la barre des tâches Windows et cliquez dessus afin de mettre l’émulateur au premier plan.

  5. Cliquez sur Touche programmable 1 sous le mot Sélectionner afin d’afficher le Sélecteur de contact. L’affichage de l’émulateur doit à présent se présenter comme sur la figure suivante.

    Figure 3

  6. Cliquez sur l’un des contacts. L’application affiche les informations appropriées, comme illustré dans la figure suivante pour Brown, Jo.

    Figure 4

  7. Une fois que vous vous êtes assuré que la nouvelle fonctionnalité fonctionne correctement, quittez l’application en cliquant sur Touche programmable 2 sous le mot Exit.

Exercice 2 : Utilisation de la messagerie et du Sélecteur d’images pour envoyer du courrier électronique avec des pièces jointes

Dans cet exercice, vous allez utiliser la nouvelle API Sélecteur d’images et application de messagerie pour permettre à l’utilisateur d’envoyer au contact sélectionné un message électronique avec une image comme pièce jointe.

Dans cette tâche, vous allez utiliser le Sélecteur d’images pour permettre aux utilisateurs de sélectionner les photos à envoyer à leurs clients.

Pour utiliser le Sélecteur d’images

  1. Localisez les déclarations de variables globales en haut du fichier NewNativeAPIs.cpp. Sous les autres variables globales, ajoutez une déclaration pour un tableau TCHAR nommé g_tszSelectedPicture avec une taille de 260. Cette variable sera utilisée pour stocker le chemin du fichier d’image sélectionné par l’utilisateur.

    TCHAR        g_tszSelectedPicture[260];
  2. Ajoutez une nouvelle fonction nommée SelectPicture, qui renvoie une valeur bool. Cette fonction doit apparaître dans le fichier source avant la fonction OnCOMMAND_SELECT et après la fonction SelectContact ajoutée dans l’exercice 1. Dans la méthode, déclarez une variable bool nommée bSuccess avec la valeur initiale FALSE.

    bool SelectPicture()
    {    
    	bool bSuccess = false;
    } 
  3. Les développeurs natifs accèdent au Sélecteur d’images via la fonction GetOpenFileNameEx. La structure OPENFILENAMEEX contrôle le comportement de GetOpenFileNameEx et contient le chemin vers le fichier image que l’utilisateur a sélectionné via la fonction GetOpenFileNameEx. Déclarez une instance de la structure OPENFILENAMEEX nommée ofnex. Définissez le membre lStructSize sur la taille de la structure. Définissez les membres hInstance et hwndOwner respectivement sur les variables globales g_hInst et g_hWnd.

    OPENFILENAMEEX ofnex = {0};
    ofnex.lStructSize = sizeof(ofnex);
    ofnex.hInstance = g_hInst;
    ofnex.hwndOwner = g_hWnd;
  4. Pour afficher le Sélecteur d’images, vous devez configurer le membre ExFlags sur OFN_EXFLAG_THUMBNAILVIEW. Dans de nombreux cas, les images stockées sur un périphérique peuvent être protégées par DRM (Digital Rights Management), de sorte que vous devez également envisager le traitement des problèmes DRM. Les images spécialement protégées contre l’envoi ne doivent pas être affichées, car toute tentative de les envoyer échouera ; l’indicateur OFN_EXFLAG_HIDEDRMFORWARDLOCKED doit également être défini.

    ofnex.ExFlags = 
    OFN_EXFLAG_THUMBNAILVIEW | OFN_EXFLAG_HIDEDRMFORWARDLOCKED;

    Remarque : Si vous souhaitiez masquer toutes les images protégées par DRM, vous devriez définir l’indicateur OFN_EXFLAG_HIDEDRMPROTECTED.

  5. Par défaut, le Sélecteur d’images affiche initialement les fichiers dans \Mes documents\Mes images. Pour démarrer dans un répertoire initial différent, affectez le nom du répertoire au membre lpstrInitialDir. Dans votre application, définissez le répertoire initial sur \Images.

    ofnex.lpstrInitialDir = _T("\\Images");

    Remarque : Normalement, le Sélecteur d’images permet à l’utilisateur de parcourir les répertoires autres que le répertoire initial. Si vous souhaitez empêcher l’utilisateur d’explorer d’autres répertoires, configurez l’indicateur étendu OFN_EXFLAG_LOCKDIRECTORY (membre ExFlag).

  6. Vous devez fournir une mémoire tampon pour recevoir le nom de fichier sélectionné. Déclarez un tableau TCHAR avec une taille de 260, puis affectez-le au membre lpstrFile. Le membre nMaxFileSize doit être défini à la taille du membre lpstrFile.

    TCHAR tszFile[260];
    
    ofnex.lpstrFile = tszFile;
    ofnex.nMaxFile = 260;
  7. Vous êtes maintenant prêt à afficher le Sélecteur d’images. Appelez GetOpenFileNameEx en passant l’adresse de la structure OPENFILENAMEEX. Affectez la valeur de retour GetOpenFileNameEx à bSuccess.

    bSuccess = GetOpenFileNameEx(&ofnex);
  8. Si GetOpenFileNameEx renvoie true, copiez le nom de fichier sélectionné dans la variable globale déclarée à l’étape 1.

    if (bSuccess)
    _tcscpy(g_tszSelectedPicture, ofnex.lpstrFile);
  9. SelectPicture doit renvoyer la valeur de bSuccess.

    return bSuccess;
  10. Vous avez ajouté tout le code nécessaire à la méthode SelectPicture. Vérifiez que le code ressemble à ce qui suit.

    bool SelectPicture()
    {
      bool bSuccess = false;
      TCHAR tszFile[260] ;
      
      OPENFILENAMEEX ofnex = {0};
      ofnex.lStructSize = sizeof(ofnex);
      ofnex.hInstance = g_hInst;
      ofnex.hwndOwner = g_hWnd;
      ofnex.ExFlags = 
    	OFN_EXFLAG_THUMBNAILVIEW | OFN_EXFLAG_HIDEDRMFORWARDLOCKED ;
      ofnex.lpstrInitialDir = _T("\\Images");
      ofnex.lpstrFile = tszFile;
      ofnex.nMaxFile = 260;
      
      bSuccess = GetOpenFileNameEx(&ofnex);
      
      if (bSuccess)
        _tcscpy(g_tszSelectedPicture, ofnex.lpstrFile);
      
      return bSuccess;
    }

    Ajoutez à présent l’appel de la fonction SelectPicture à partir de OnCOMMAND_SELECT. La fonction SelectPicture doit uniquement être appelée si la fonction SelectContact a indiqué une réussite.

  11. Localisez la méthode OnCOMMAND_SELECT.

  12. Immédiatement après l’appel de SelectContact, ajoutez une instruction IF afin de vérifier la réussite de l’appel. Dans l’instruction IF, appelez SelectPicture en affectant la valeur renvoyée à bSuccess.

    if (bSuccess)
    {
    	bSuccess = SelectPicture();
    }
  13. La méthode OnCOMMAND_SELECT doit à présent ressembler à ce qui suit.

    void OnCOMMAND_SELECT()
    {
    bool bSuccess = SelectContact();
    if (bSuccess)
    {
    	bSuccess = SelectPicture();
    }
    }

Dans cette tâche, vous allez ajouter l’instruction d’inclusion du fichier d’en-tête et la référence de la bibliothèque à utiliser dans l’application de messagerie.

Pour ajouter l’en-tête et la bibliothèque d’une API d’application de messagerie

  1. Ajoutez l’instruction #include pour cemapi.h au fichier NewNativeAPIs.cpp.

    #include ‹cemapi.h›
  2. Pour ajouter la référence à la bibliothèque cemapi.lib, vous devez modifier les propriétés du projet. Dans le menu de Visual Studio, enregistrez le projet. Ensuite, cliquez sur Projet, puis cliquez sur Propriétés de NewNativeAPIs.

  3. À gauche de la boîte de dialogue Pages de Propriétés, développez Propriétés de la configuration, comme illustré dans la figure suivante.

    Figure 5

  4. Développez Éditeur de liens.

  5. Sous Éditeur de liens, sélectionnez le nœud Entrée.

  6. Dans la partie droite de la boîte de dialogue, localisez le champ Dépendances supplémentaires.

  7. Tapez un espace, puis cemapi.lib après pimstore.lib dans le champ Dépendances supplémentaires, comme illustré dans la figure ci-dessous.

    Figure 6

  8. Cliquez sur OK.

Dans cette tâche, vous allez utiliser l’API Application de messagerie pour créer un message électronique, joindre l’image sélectionnée, puis afficher le message pour l’utilisateur avant l’envoi. Pour faciliter autant que possible la communication avec les clients pour l’utilisateur, le message électronique définit automatiquement le destinataire du message, un objet, un corps pour le message et inclut l’image sélectionnée en pièce jointe.

Pour utiliser l’API Application de messagerie pour envoyer l’image

  1. Commencez par ajouter une nouvelle fonction nommée SendEmailMessage avec une valeur de retour VOID. Cette fonction doit apparaître dans le fichier source avant la fonction OnCOMMAND_SELECT.

    void SendEmailMessage()
    {
    }
    
  2. Avant d’envoyer le message, vous devez disposer de l’adresse électronique du destinataire. Le contact actuellement sélectionné est stocké dans la variable globale g_pContact ; utilisez la fonction get_Email1Address pour extraire l’adresse électronique du contact. Déclarez une variable BSTR contenant l’adresse électronique. Nommez la variable bstrEmailAddress.

    BSTR bstrEmailAddress;
    g_pContact->get_Email1Address(&bstrEmailAddress);

    Remarque : Dans la mesure où, dans l’exercice 1, la liste des contacts a été filtrée par PIMPR_ALL_EMAIL, rien ne garantit qu’une adresse électronique est stockée dans le champ Email1Address du contact, mais seulement que l’une des adresses électroniques du contact est remplie. Dans cet atelier, cette hypothèse ne pose pas de problème, car tous les contacts ont une adresse Email1Address. Dans un scénario réel, vous avez deux options : écrivez le code afin de vérifier chacun des champs d’adresse électronique du contact, jusqu’à ce qu’une adresse soit trouvée, ou filtrez les contacts avec l’indicateur PIMPR_EMAIL1_ADDRESS plutôt que d’utiliser l’indicateur PIMPR_ALL_EMAIL. En général, il est préférable de rechercher parmi les adresses électroniques disponibles plutôt que d’imposer qu’une adresse spécifique soit remplie.

  3. La fonction MailComposeMessage affiche un message électronique en utilisant le formulaire standard de composition d’un message. La structure MAILCOMPOSEFIELDS contient les champs requis pour initialiser MailComposeMessage. Déclarez une instance de la structure MAILCOMPOSEFIELDS nommée mailFields. Définissez le membre cbSize sur la taille de la structure.

    MAILCOMPOSEFIELDS mailFields = {0};
    mailFields.cbSize = sizeof(mailFields);
  4. Définissez à présent les valeurs du sujet et du corps du message. Définissez le membre pszSubject sur la chaîne « La photo dont nous avons parlé ». Par commodité, une constante nommée tszBaseMessage a été déclarée, contenant le texte du corps du message. Affectez cette constante au membre pszBody.

    mailFields.pszSubject = _T("The picture we discussed");
    //message.pszBody = tszBaseMessage;
  5. Adressez le message électronique en affectant au membre pszTo l’adresse électronique extraite du contact.

    mailFields.pszTo = bstrEmailAddress;

    Remarque : Pour adresser le message électronique à plusieurs destinataires, répertoriez toutes les adresses électroniques dans une même chaîne, les adresses étant séparées par un point-virgule.

  6. Joignez la photo sélectionnée par l’utilisateur au message. Pour cela, affectez le nom de fichier stocké dans la variable g_tszSelectedPicture au membre pszAttachments. Vous devez également affecter le nombre de pièces jointes au membre cAttachments.

    mailFields.pszAttachments = g_tszSelectedPicture;
    mailFields.cAttachments = 1;

    Remarque : Pour inclure plusieurs pièces jointes, répertoriez les noms des fichiers dans une même chaîne, les noms des pièces jointes étant séparés par \0. Prenez soin de spécifier le nombre approprié de pièces jointes dans cAttachments.

  7. Les périphériques incluent souvent plusieurs comptes de messagerie ; vous devez donc spécifier le compte à utiliser pour l’envoi du message. Lors de l’identification du compte, vous pouvez spécifier le nom du compte ou le protocole de transport du message. Dans les deux cas, la valeur est affectée au membre pszAccount. La signification de la valeur pszAccount, qui détermine si la valeur pszAccount est interprétée comme nom de compte ou comme nom de transport, est contrôlée par l’indicateur MCF_ACCOUNT_IS_NAME ou MCF_ACCOUNT_IS_TRANSPORT. Dans votre application, utilisez le nom de compte « ActiveSync » et affectez l’indicateur MCF_ACCOUNT_IS_NAME au membre dwFlags.

    mailFields.pszAccount = _T("ActiveSync");
    mailFields.dwFlags = MCF_ACCOUNT_IS_NAME;
  8. Affichez à présent le message pour l’utilisateur en appelant MailComposeMessage et en passant l’adresse de la structure MAILCOMPOSEFIELDS. Une fois le message affiché, l’utilisateur peut consulter, modifier, envoyer ou annuler le message.

    MailComposeMessage(&mailFields);
  9. Lorsque l’exécution de MailComposeMessage est terminée, libérez la mémoire associée à bstrEmailAddress avec SysFreeString.

    SysFreeString(bstrEmailAddress);
  10. Vous avez ajouté tout le code nécessaire à la méthode SendEmailMessage. Il doit à présent se présenter comme suit :

    void SendEmailMessage()
    {
    	BSTR bstrEmailAddress;
    	g_pContact->get_Email1Address(&bstrEmailAddress);
    	
    	MAILCOMPOSEFIELDS mailFields = {0};
    	mailFields.cbSize = sizeof(mailFields);
    	mailFields.pszSubject = _T("The picture we discussed");
    	//mailFields.pszBody = tszBaseMessage;
    	mailFields.pszTo = bstrEmailAddress;
    	mailFields.pszAttachments = g_tszSelectedPicture;
    	mailFields.cAttachments = 1;
    	mailFields.pszAccount = _T("ActiveSync");
    	mailFields.dwFlags = MCF_ACCOUNT_IS_NAME;
    	
    	MailComposeMessage(&mailFields);
    	
    	SysFreeString(bstrEmailAddress);
    }

    La dernière chose à faire avant de tester l’application consiste à appeler la fonction SendEmailMessage à partir de OnCOMMAND_SELECT. La fonction SendEmailMessage doit uniquement être appelée si l’utilisateur a sélectionné une image.

  11. Localisez la méthode OnCOMMAND_SELECT.

  12. Immédiatement après l’appel de SelectPicture, ajoutez une instruction IF afin de vérifier la réussite de l’appel. Dans l’instruction IF, appelez SendEmailMessage.

    if (bSuccess)
    {
    	SendEmailMessage();
    }
  13. La méthode OnCOMMAND_SELECT doit à présent ressembler à ce qui suit.

    void OnCOMMAND_SELECT()
    {
    	bool bSuccess = SelectContact();
    	if (bSuccess)
    	{
    	bSuccess = SelectPicture();
    	if (bSuccess)
    	{
    	SendEmailMessage();
    	}
      }
    }

Vous êtes maintenant prêt à tester la nouvelle fonctionnalité de l’application.

Pour tester la nouvelle fonctionnalité

  1. Dans le menu Générer, cliquez sur Générer NewNativeAPIs. Corrigez les éventuelles erreurs de compilation avant de continuer.

  2. Vérifiez que Windows Mobile 5.0 Smartphone Emulator est toujours sélectionné dans la liste déroulante.

  3. Démarrez l’application en cliquant sur Déboguer | Démarrer sans débogage. Soyez conscient que le démarrage de l’émulateur peut prendre plusieurs secondes.

    Important : Vous ne pouvez pas utiliser le débogueur lorsque l’application affiche le Sélecteur d’images. Si vous lancez l’application avec le débogueur, l’émulateur se bloque lorsque vous tentez de sélectionner une image avec le Sélecteur d’images. Si vous devez lancer l’application avec le débogueur afin de déboguer d’autres aspects de votre programme, mettez en commentaire la ligne de OnCOMMAND_SELECT qui appelle SelectPicture et remplacez-la par la ligne suivante, qui copie un chemin de fichier dans la même variable globale que celle alimentée par SelectPicture.

    // bSuccess = SelectPicture();
    _tcscpy(g_tszSelectedPicture, _T("\\Images\\eek.jpg"));
  4. Si nécessaire, placez l’émulateur au premier plan, puis cliquez sur Touche programmable 1 sous le mot Sélectionner.

  5. Cliquez sur Adams, Jay dans le Sélecteur de contact.

  6. Le Sélecteur d’images doit à présent se présenter comme sur la figure suivante.

    Figure 7

  7. Avec le pavé de navigation, accédez à une photo, puis cliquez sur Touche programmable 1 sous le mot Sélectionner afin de sélectionner la photo.

  8. Le formulaire de courrier électronique s’affiche et est alimenté avec l’adresse électronique, l’objet, le corps et la pièce jointe. Le formulaire de courrier électronique doit à présent se présenter comme sur la figure suivante.

    Figure 8

  9. Si vous le souhaitez, vous pouvez modifier n'importe quelle partie du message. Envoyez le message en cliquant sur Touche programmable 1 sous le mot Envoyer.

  10. Quittez l’application en cliquant sur Touche programmable 2 sous le mot Quitter.

    Pour vérifier que le message a bien été envoyé au système de messagerie électronique, examinez le dossier Boîte d’envoi Pocket Outlook.

  11. Affichez l’écran d’accueil du Smartphone en cliquant sur le bouton Accueil (celui immédiatement sous Touche programmable 1, représentant une maison).

  12. Cliquez sur Touche programmable 1 sous le mot Démarrer. Avec le pavé de navigation, accédez à l’icône Messagerie, sélectionnez-la, puis cliquez sur Entrée.

  13. Cliquez sur Entrée sur le pavé directionnel afin de sélectionner Courrier Outlook.

  14. Cliquez sur Touche programmable 2 sous le mot Menu.

  15. Sélectionnez Dossiers, comme illustré dans la figure suivante, puis cliquez sur Entrée.

    Figure 9

  16. Sélectionnez Outbox, puis cliquez sur Entrée sur le pavé directionnel de l’émulateur.

  17. Vous devez voir le message suivant : La photo dont nous avons parlé. Si vous avez sélectionné Adams, Jay, le message est adressé à jadams@wingtiptoys.com. Il s’agit du message envoyé par l’application.

Exercice 3 : Utilisation de l’API broker État et notification pour extraire des informations sur l’état du système

Dans cet exercice, vous allez utiliser la nouvelle API Broker État et notification. L’API Broker État et notification est une API très complète permettant l’accès à plus d’une centaine de valeurs d’état de périphérique et notifications de changement de valeurs d’état. Toutes les valeurs d’état sont extraites du registre. Dans cet exercice, vous allez l’utiliser pour extraire le nom et le numéro de téléphone du propriétaire du périphérique.

Comme nous l’avons vu au début de cet exercice, l’API Broker État et notification permet l’accès à plus d’une centaine de valeurs d’état de périphérique. Dans cet exercice, vous allez utiliser l’API Broker État et notification pour extraire le nom et le numéro de téléphone du propriétaire du périphérique. Vous allez ensuite utiliser ces informations pour mettre à jour le message électronique ajouté lors de l’exercice précédent, afin de proposer une formule de fin plus professionnelle.

Avant d’effectuer cette tâche, vous devez renseigner les informations relatives au propriétaire du périphérique.

Pour utiliser l’API Broker État et notification pour extraire des informations relatives au périphérique

  1. Sur l’émulateur, affichez l’écran d’accueil du Smartphone en cliquant sur le bouton Accueil.

  2. Cliquez sur Touche programmable 1 sous le mot Démarrer. Accédez à l’icône Paramètres, puis cliquez sur Entrée sur le pavé directionnel de l’émulateur.

  3. Accédez à l’option 9 Plus, puis cliquez sur Entrée.

  4. Accédez à l’option 4 Info. du propriétaire, puis cliquez sur Entrée.

  5. Tapez Judy Lew pour la valeur de Nom.

  6. Accédez au champ Numéro de téléphone, puis tapez la valeur 603.555.9999.

  7. Cliquez sur Touche programmable 1 sous le mot Terminé.

  8. Revenez à l’écran d’accueil du Smartphone en cliquant sur le bouton Accueil.

    L’API Broker État et notification offre deux fonctions pour l’extraction des informations sur l’état du périphérique : la fonction RegistryGetString pour les valeurs d’état des chaînes et la fonction RegistryGetDWORD pour les valeurs DWORD. L’emplacement dans le registre et le type de données des valeurs d’état disponibles se trouvent dans la documentation du kit SDK de Windows Mobile. Dans cette partie de la tâche, vous utilisez RegistryGetString pour extraire le nom et le numéro de téléphone du propriétaire du périphérique afin de créer un message électronique plus personnel en incluant cette information dans la phrase de fin du message.

  9. Pour utiliser l’API Broker État et notification, vous devez inclure le fichier d’en-tête RegExt.h.

    #include ‹RegExt.h›
  10. Ajoutez une nouvelle fonction GetMessageClosing. Cette fonction doit apparaître dans le fichier source avant la fonction SendEmailMessage. La fonction doit accepter un seul paramètre TCHAR * nommé tszMessageClosing, et doit renvoyer un paramètre TCHAR *. Dans la fonction, déclarez une variable HRESULT nommée hr avec la valeur initiale S_OK.

    TCHAR *GetMessageClosing(TCHAR * tszMessageClosing)
    {
    	HRESULT hr = S_OK;
    }
  11. Dans la fonction, déclarez deux tableaux TCHAR : tszOwnerName et tszOwnerPhone. Leur taille doit être respectivement de 128 et 32. Ces tableaux seront utilisés pour stocker les valeurs extraites de l’API Broker État et notification.

    TCHAR tszOwnerName[128];
    TCHAR tszOwnerPhone[32];
  12. Comme nous l’avons précisé dans l’introduction de l’exercice, toutes les valeurs de l’API Broker État et notification sont stockées dans le registre. Dans le cas des informations relatives au propriétaire, les valeurs sont stockées sous HKEY_CURRENT_USER\ControlPanel\Owner. Étant donné que vous allez accéder à deux valeurs sous la même clé, déclarez une variable TCHAR * tszOwnerKey avec la valeur ControlPanel\Owner.

    TCHAR *tszOwnerKey = _T("ControlPanel\\Owner");
  13. Avec RegistryGetString, extrayez le nom du propriétaire à partir de la valeur Name sous tszOwnerKey. Stockez la valeur dans tszOwnerName.

    hr = RegistryGetString(HKEY_CURRENT_USER, tszOwnerKey, _T("Name"),
    tszOwnerName, sizeof(tszOwnerName));
  14. À présent, extrayez le numéro de téléphone du propriétaire en utilisant la valeur nommée Telephone. Stockez la valeur dans tszOwnerPhone.

     hr = RegistryGetString(HKEY_CURRENT_USER, tszOwnerKey, _T("Telephone"),
    tszOwnerPhone, sizeof(tszOwnerPhone));
  15. Générez à présent une phrase de fin pour le message électronique, de la forme "\n\nCordialement, \n nom\n téléphone". Stockez la phrase dans tszMessageClosing.

    _tcscpy(tszMessageClosing, _T("\n\nSincerely,\n"));
    _tcscat(tszMessageClosing, tszOwnerName);
    _tcscat(tszMessageClosing, _T("\n"));
    _tcscat(tszMessageClosing, tszOwnerPhone);
  16. Renvoyez tszMessageClosing comme valeur de retour de GetMessageClosing.

    return tszMessageClosing;
  17. La fonction GetMessageClosing complète doit à présent ressembler à ce qui suit.

    TCHAR *GetMessageClosing(TCHAR *tszMessageClosing)
    {
    	HRESULT hr = S_OK;
    	TCHAR tszOwnerName[128];
    	TCHAR tszOwnerPhone[32];
    	TCHAR *tszOwnerKey = _T("ControlPanel\\Owner");
    	
    	hr = RegistryGetString(HKEY_CURRENT_USER, tszOwnerKey, 
    		_T("Name"), tszOwnerName, sizeof(tszOwnerName));
    		
    	hr = RegistryGetString(HKEY_CURRENT_USER, tszOwnerKey,
    		_T("Telephone"), tszOwnerPhone, sizeof(tszOwnerPhone));
    	
    	_tcscpy(tszMessageClosing, _T("\n\nSincerely,\n"));
    	_tcscat(tszMessageClosing, tszOwnerName);
    	_tcscat(tszMessageClosing, _T("\n"));
    	_tcscat(tszMessageClosing, tszOwnerPhone);
    	
    	return tszMessageClosing;
    }

    La dernière étape consiste à concaténer la phrase de fin avec le message électronique.

  18. Dans la fonction SendEmailMessage, immédiatement après l’appel de get_Email1Address, déclarez deux variables de type tableau TCHAR nommées tszMessageBody et tszMessageClosing. Affectez-leur respectivement une taille de 1024 et 512.

    TCHAR tszMessageBody[1024];
    TCHAR tszMessageClosing[512];
  19. Appelez GetClosing en passant tszMessageClosing. Copiez la constante tszMessageBase dans tszMessageBody, puis concaténez tszMessageClosing à la fin de tszMessageBody.

    GetMessageClosing(tszMessageClosing);
    _tcscpy(tszMessageBody, tszBaseMessage);
    _tcscat(tszMessageBody, tszMessageClosing);
  20. Modifiez à présent l’affectation au membre pszBody de la structure MAILCOMPOSEFIELDS afin d’utiliser tszMessageBody au lieu de tszBaseMessage.

    mailFields.pszBody = tszMessageBody;
  21. La fonction SendEmailMessage mise à jour doit à présent ressembler à ce qui suit.

    void SendEmailMessage()
    {
    	BSTR bstrEmailAddress;
    	g_pContact->get_Email1Address(&bstrEmailAddress);
    	
    	TCHAR tszMessageBody[1024];
    	TCHAR tszMessageClosing[512];
    	GetMessageClosing(tszMessageClosing);
    	_tcscpy(tszMessageBody, tszBaseMessage);
    	_tcscat(tszMessageBody, tszMessageClosing);
    	
    	MAILCOMPOSEFIELDS mailFields = {0};
    	mailFields.cbSize = sizeof(mailFields);
    	mailFields.pszSubject = _T("The picture we discussed");
    	//message.pszBody = tszBaseMessage;
    	
    	mailFields.pszBody = tszMessageBody;
    	
    	mailFields.pszTo = bstrEmailAddress;
    	mailFields.pszAttachments = g_tszSelectedPicture;
    	mailFields.cAttachments = 1;
    	mailFields.pszAccount = _T("ActiveSync");
    	mailFields.dwFlags = MCF_ACCOUNT_IS_NAME;
    	
    	HRESULT hr = MailComposeMessage(&mailFields);
    	
    	SysFreeString(bstrEmailAddress);
    }

Pour vérifier que le message contient à présent la phrase de fin, suivez les étapes de la section Pour tester la nouvelle fonctionnalité de l’exercice 2. Vous devez voir que le message électronique se termine à présent par Cordialement Judy Lew, suivi de 603.555.9999 sur la ligne suivante.

Exercice 4 : Utilisation de l’API Broker État et notification pour recevoir des notifications des changements d’état du système

Outre l’accès aux nombreuses valeurs d’état du périphérique, l’API Broker État et notification prend également en charge la notification d’une application des changements d’une valeur. Dans cet exercice, nous allons mettre à jour l’application afin d’afficher automatiquement les informations relatives à un contact lorsque celui-ci appelle un utilisateur et lorsqu’un utilisateur l’appelle. Vous allez pour cela surveiller la valeur d’état OID de l’appelant. Cette valeur contient l’OID d’un contact Pocket Outlook lorsque le Smartphone appelle un numéro de téléphone contenant dans la liste des contacts.

L’API Broker État et notification offre un certain nombre de moyens permettant de recevoir des notifications, notamment les fonctions de rappel, les files d'attente de messages et les messages de fenêtre. Dans cet exercice, vous allez utiliser la fonction RegistryNotifyWindow qui enregistre l’application afin qu’elle reçoive un message défini par l'utilisateur envoyé à une fenêtre de l’application, indiquant qu’une valeur a changé.

Dans cette tâche, vous allez ajouter le code nécessaire pour l’enregistrement auprès de l’API Broker État et notification afin qu’elle soit informée chaque fois que l’OID du contact appelant change. Grâce à cette notification, l’application peut facilement localiser le contact correspondant à l’appelant lorsque celui-ci appelle l’utilisateur du Smartphone, ou lorsque ce dernier appelle le contact.

Pour s’enregistrer pour la notification

  1. La première étape consiste à définir l’identificateur de message à envoyer à l’application. Vers le haut du fichier source NewNativeAPIs.cpp, localisez la déclaration de la constante tszBaseMessage. Immédiatement après la déclaration de tszBaseMessage, déclarez une valeur DWORD constante nommée WM_CALLEROIDCHANGED. Définissez la valeur sur WM_USER + 1.

    const DWORD WM_CALLEROIDCHANGED = WM_USER + 1;
  2. Les déclarations globales se trouvent au-dessus des déclarations des constantes. Ajoutez une déclaration globale pour un pointeur HREGNOTIFY nommé g_hNotify, initialisé à la valeur NULL.

    HREGNOTIFY g_hNotify = NULL;
  3. Ajoutez à présent l’enregistrement de notification à la fonction InitInstance, juste avant l’instruction de retour de la fonction. Utilisez RegistryNotifyWindow. Comme pour l’extraction de valeurs, vous devez spécifier la clé de registre et le nom de la valeur correspondant à la valeur qui vous intéresse. Dans le cas de l’OID appelant, la valeur d’état se trouve sous HKEY_LOCAL_MACHINE\System\State\Phone dans la valeur nommée CALLER OID. Passez g_hWnd comme fenêtre pour la notification, WM_CALLEROIDCHANGED comme message à envoyer et l’adresse de hNotify pour recevoir le pointeur d’enregistrement.

    HRESULT hr = RegistryNotifyWindow(HKEY_LOCAL_MACHINE,
    				_T("System\\State\\Phone"), _T("Caller OID"), g_hWnd,
    				WM_CALLEROIDCHANGED, 0, NULL, &g_hNotify);
  4. Outre l’enregistrement pour la notification, l’application est responsable de la fermeture du pointeur de notification lorsque l’application n’a plus besoin de recevoir la notification. Pour fermer le pointeur de notification, utilisez RegistryCloseNotification. Localisez l’instruction case IDM_EXIT dans WndProc. Ajoutez l’appel de la fonction afin de fermer g_hNotify immédiatement avant l’appel de DestroyWindow. Fermez le pointeur de notification uniquement s’il n’est pas NULL.

    if (g_hNotify)
    RegistryCloseNotification(g_hNotify);

Vous avez terminé l’enregistrement de notification. La fenêtre principale de l’application recevra désormais un message WM_CALLEROIDCHANGED chaque fois qu’un appel sera reçu ou émis vers une personne de la liste des contacts de l’utilisateur du Smartphone.

Dans cette tâche, vous allez ajouter le code nécessaire pour permettre à l’application de gérer le message WM_CALLEROIDCHANGED. Pour cela, commencez par ajouter une fonction afin de traiter le message. Vous allez ensuite modifier la fonction WndProc afin d’appeler la fonction lorsque le message est reçu.

Pour gérer les notifications de changement d’état

  1. Ajoutez une nouvelle fonction à NewNativeAPIs.cpp, nommée OnCALLEROIDCHANGED. Cette fonction doit apparaître dans le fichier source avant la fonction WndProc. La fonction doit présenter un type de retour void.

    void OnCALLEROIDCHANGED()
    {
    }
  2. Dans la fonction WndProc, modifiez l’instruction MESSAGE SWITCH afin d’inclure un cas pour traiter WM_CALLEROIDCHANGED.

    case WM_CALLEROIDCHANGED:
  3. Dans le nouveau cas ajouté, ajoutez un appel de la fonction OnCALLEROIDCHANGED, suivi d’une instruction BREAK.

    OnCALLEROIDCHANGED();
    
    break;
  4. La fonction WndProc doit à présent se présenter comme suit.

    LRESULT CALLBACK WndProc(HWND hWnd, UINT message, 
    WPARAM wParam, LPARAM lParam)
    {
    	int wmId, wmEvent;
    	
    	switch (message) 
    	{
    	case WM_CALLEROIDCHANGED:
    		OnCALLEROIDCHANGED();
    		break;
    	case WM_COMMAND:
    		// Code to handle WM_COMMAND ...
    	case WM_CREATE:
    		// Code to handle WM_CREATE ...
    	case WM_PAINT:
    		// Code to handle WM_PAINT ...
    	case WM_DESTROY:
    		// Code to handle WM_DESTROY ...
    	default:
    		return DefWindowProc(hWnd, message, wParam, lParam);
    	}
    	return 0;
    }

À ce stade, la fonction OnCALLEROIDCHANGED est appelée chaque fois que l’utilisateur est en conversation téléphonique avec quelqu’un de la liste de contacts. La seule chose qui reste à faire est de modifier la fonction OnCALLEROIDCHANGED de sorte que les informations de contact correctes soient affichées.

Pour afficher les informations de contact de l’appelant

  1. Dans le corps de la fonction OnCALLEROIDCHANGED, déclarez une variable DWORD nommée dwOID avec une valeur initiale de -1 et une variable HRESULT nommée hr avec une valeur initiale de S_OK.

    DWORD dwOID = -1;
    HRESULT hr = S_OK;
  2. Extrayez à présent la valeur de l’OID appelant dans dwOID avec la fonction RegistryGetDWORD. Utilisez la même clé de registre et le même nom de valeur que ceux spécifiés dans la tâche 1 lors de l’enregistrement afin d’être informé d’un changement de la valeur OID appelant. Affectez la valeur de retour de la fonction à hr.

    hr = RegistryGetDWORD(HKEY_LOCAL_MACHINE, _T("System\\State\\Phone"),
    _T("Caller OID"), &dwOID);
  3. Vous êtes désormais prêt à afficher le contact avec DisplayContact. Il est important de se rappeler que chaque appel ne correspond pas nécessairement à quelqu’un stocké dans la liste de contacts. Ainsi, affichez uniquement le contact si l’appel de RegistryGetDWORD a extrait avec succès une valeur.

    if (SUCCEEDED(hr))
    {
    	DisplayContact(dwOID);
    }
  4. Il est très probable que votre application s’exécute en arrière-plan lorsque l’appel téléphonique se produit. Pour vous assurer que l’application s’exécute au premier plan, appelez la fonction SetForegroundWindow et passez le pointeur de la fenêtre principale. Ajoutez l’appel de SetForegroundWindow immédiatement après l’appel de DisplayContact.

    SetForegroundWindow(g_hWnd);
  5. La fonction OnCALLEROIDCHANGED complète doit à présent ressembler à ce qui suit.

    void OnCALLEROIDCHANGED()
    {
    	DWORD dwOID = -1;
    	HRESULT hr = S_OK;
    	
    	hr = RegistryGetDWORD(HKEY_LOCAL_MACHINE, _T("System\\State\\Phone"),
    		_T("Caller OID"), &dwOID);
    if (SUCCEEDED(hr))
    {
    	DisplayContact(dwOID);
    	SetForegroundWindow(g_hWnd);
    }
    }

Vous êtes maintenant prêt à tester la nouvelle fonctionnalité de l’application. Celle-ci affiche automatiquement les informations d’un contact si ce dernier appelle le Smartphone ou si l’utilisateur du Smartphone appelle un contact. La réception d’appels par l’émulateur n’est pas prise en charge, donc vous testerez la fonctionnalité en appelant manuellement l’un des contacts.

Pour tester la nouvelle fonctionnalité

  1. Dans le menu Générer, cliquez sur Générer la solution. Corrigez les éventuelles erreurs de compilation avant de continuer.

  2. Vérifiez que Windows Mobile 5.0 Smartphone Emulator est sélectionné dans la liste déroulante.

  3. Démarrez l’application en cliquant sur Déboguer | Démarrer sans débogage.

  4. Revenez à l’écran d’accueil du périphérique en cliquant sur le bouton Accueil. L’application continue de s’exécuter en arrière-plan.

  5. En utilisant le pavé numérique de l’émulateur, composez le numéro de téléphone 60 35 55 28 64.

  6. Cliquez sur le bouton Parler (situé juste au-dessous du bouton Accueil avec l’image d’un récepteur téléphonique vert). Le téléphone compose le numéro et connecte l’appel. Immédiatement après, les informations de contact de Jim Wilson apparaissent automatiquement.

  7. Terminez l’appel en cliquant sur le bouton Fin (le bouton avec une image représentant un récepteur téléphonique rouge). Essayez de répéter les étapes 4 à 6 en utilisant un numéro de téléphone qui ne correspond pas à un contact, par exemple 21 22 22 55 55. L’application reste en arrière-plan.

  8. Terminez l’appel, puis essayez un autre numéro de téléphone correspondant à un contact, par exemple 31 05 55 36 62. Immédiatement après l’établissement de la communication, les informations de contact de Jane Clayton apparaissent automatiquement. Terminez l’appel.

  9. Lorsque vous êtes satisfait du fonctionnement de l’application, dans le menu Fichier, cliquez sur Quitter afin d’arrêter l’application. Prenez soin d’enregistrer l’état de l’émulateur.

Exercice 5 : Utilisation de l’API de capture (facultatif)

Cet exercice illustre la nouvelle API de capture photo. Comme vous pouvez l’imaginer, cette API nécessite qu’un appareil photo soit connecté au périphérique. Les émulateurs Windows Mobile 5.0 ne prennent pas en charge les appareils photo ; ils ne sont donc pas compatibles avec l’API de capture photo. En revanche, si un Smartphone physique est connecté à votre poste de travail, vous pouvez l’utiliser comme appareil photo pour effectuer cet exercice facultatif.

L’API de capture photo est exposée aux développeurs natifs via la fonction SHCameraCapture. Elle offre une fenêtre permettant d’afficher et de capturer les photos et les vidéos de façon indépendante du périphérique. Dans cet exercice, vous allez utiliser l’API de capture photo pour modifier l’application afin de permettre à l’utilisateur de prendre une photo et de l’envoyer à un contact, plutôt que d’envoyer l’une des images stockées à partir du périphérique.

Dans cette tâche, vous allez utiliser l’API de capture photo afin de permettre à l’utilisateur de prendre une photo, plutôt que de sélectionner une photo existante stockée sur le périphérique.

Pour ajouter la prise en charge de la capture photo

  1. Ajoutez une nouvelle fonction nommée TakePicture, qui renvoie une valeur bool. Dans la méthode, déclarez une variable HRESULT nommée hr avec la valeur initiale S_OK.

    bool TakePicture()
    {
    	HRESULT hr = S_OK;
    } 
  2. Les développeurs natifs accèdent à l’API de capture photo via la fonction SHCameraCapture. La structure SHCAMERACAPTURE contrôle le comportement de SHCameraCapture et contient le chemin vers le fichier image créé lors du retour de la fonction SHCameraCapture. Déclarez une instance de la structure SHCAMERACAPTURE nommée shcc. Définissez le membre cbSize sur la taille de la structure. Définissez le membre hwndOwner sur la variable globale g_hWnd.

    SHCAMERACAPTURE shcc = {0};
    shcc.cbSize = sizeof(shcc);
    shcc.hwndOwner = g_hWnd;
  3. L’API de capture photo prend en charge la capture de photos fixes, la vidéo, ainsi que la vidéo avec du son. Le membre Indicateurs de SHCAMERACAPTURE contrôle lequel de ces modes est utilisé. Dans votre application, vous allez capturer une photo fixe ; affectez CAMERA_CAPTURE_STILL au membre Flags.

    shcc.Flags = CAMERACAPTURE_FLAGS_STILL;
  4. Le membre Quality indique le niveau de compression de la photo capturée et affecte donc la qualité de l’image. La valeur CAMERACAPTURE_QUALITY_LOW indique que le taux maximal de compression pris en charge doit être utilisé, afin de créer la taille de fichier image la plus petite parmi les options disponibles, entraînant la qualité d’image la plus faible. CAMERACAPTURE_QUALITY_HIGH indique que la compression minimale doit être utilisée. Cette option génère les fichiers les plus volumineux avec la qualité d’image la plus élevée. Dans votre application, définissez la qualité sur CAMERACAPTURE_QUALITY_NORMAL, ce qui génère des images avec une taille et une qualité comprises entre CAMERACAPTURE_QUALITY_LOW et CAMERACAPTURE_QUALITY_HIGH.

    shcc.StillQuality = CAMERACAPTURE_STILLQUALITY_NORMAL;

    Remarque : Le niveau exact de compression utilisé dans chaque cas dépend des possibilités de l’appareil photo et des pilotes.

  5. Le membre pszInitialDir indique où les fichiers photo doivent être stockés. Définissez cet emplacement sur \Mes documents\Mes photos.

    shcc.pszInitialDir = _T("\\My Documents\\My Photos");
  6. Vous êtes désormais prêt à appeler SHCameraCapture. Appelez SHCameraCapture en passant l’adresse de la structure SHCAMERACAPTURE. Affectez la valeur de retour SHCameraCapture à hr.

    hr = SHCameraCapture(&shcc);
  7. Si SHCameraCapture renvoie un code de réussite, copiez le nom du fichier généré (szFile) dans la même variable globale que celle utilisée dans votre implémentation de la méthode SelectPicture, à savoir g_tszSelectedPicture.

    if (SUCCEEDED(hr))
    _tcscpy(g_tszSelectedPicture, shcc.szFile);
  8. Utilisez la macro SUCCEEDED pour que la méthode TakePicture renvoie true si SHCameraCapture a renvoyé un code de réussite.

    return SUCCEEDED(hr);
  9. Vous avez ajouté tout le code nécessaire à la méthode TakePicture. Vérifiez que le code ressemble à ce qui suit.

    bool TakePicture()
    {
    	HRESULT hr = S_OK;
    	
    	SHCAMERACAPTURE shcc = {0};
    	shcc.cbSize = sizeof(shcc);
    	shcc.hwndOwner = g_hWnd;
    	shcc.StillQuality = CAMERACAPTURE_STILLQUALITY_NORMAL;
    	shcc.pszInitialDir = _T("\\My Documents\\My Photos");
    	
    	hr = SHCameraCapture(&shcc);
    	
    	if (SUCCEEDED(hr))
    _tcscpy(g_tszSelectedPicture, shcc.szFile);
    
    	return SUCCEEDED(hr);
    }

    La dernière chose à faire avant de tester la nouvelle fonctionnalité consiste à placer en commentaire l’appel de la fonction SelectPicture dans OnCOMMAND_SELECT.

    //bSuccess = SelectPicture();
  10. Remplacez l’appel de la fonction SelectPicture par un appel de TakePicture. Tout comme l’appel de SelectPicture, TakePicture doit uniquement être appelé si la fonction SelectContact a renvoyé une indication de réussite.

    _tcscpy(g_tszSelectedPicture, _T("\\Images\\eek.jpg")); 
  11. La fonction OnCOMMAND_SELECT doit à présent ressembler à ce qui suit.

    void OnCOMMAND_SELECT()
    {
    	bool bSuccess = SelectContact();
    	if (bSuccess)
    	{
    	// bSuccess = SelectPicture();
    	_tcscpy(g_tszSelectedPicture, _T("\\Images\\eek.jpg")); 
    	if (bSuccess)
    	{
    		SendEmailMessage();
    	}
      }
    }

Vous êtes maintenant prêt à tester la nouvelle fonctionnalité de l’application.

Pour tester la nouvelle fonctionnalité

  1. Dans le menu Générer, cliquez sur Générer la solution. Corrigez les éventuelles erreurs de compilation avant de continuer.

  2. Vérifiez que Windows Mobile 5.0 Smartphone Device est sélectionné dans la liste déroulante.

  3. Démarrez l’application en cliquant sur Déboguer | Démarrer sans débogage.

  4. Cliquez sur Touche programmable 1 sous le mot Sélectionner.

  5. Sélectionnez Adams, Jay dans le Sélecteur de contact.

  6. La fenêtre Capture photo apparaît. Pointez le Smartphone sur une personne ou un objet que vous souhaitez photographier, puis appuyez sur Touche programmable 1 afin de prendre la photo.

  7. Le formulaire de courrier électronique s’affiche et est alimenté avec l’adresse électronique, l’objet, le corps et la photo en tant que pièce jointe. Envoyez le message électronique.

  8. Quittez le programme.

    Vous pouvez à présent vérifier que la photo a réellement été capturée.

  9. Ouvrez l’écran d’accueil du Smartphone en appuyant sur le bouton Accueil.

  10. Appuyez sur Touche programmable 1 afin d’afficher le menu Démarrer.

  11. Appuyez de nouveau sur Touche programmable 1 pour afficher davantage de programmes.

  12. Sélectionnez Photos et vidéos.

  13. Vous devez à présent voir les miniatures de plusieurs photos, notamment celle que vous venez de prendre. Sélectionnez la photo afin de l’agrandir. Si vous ne voyez pas la photo, appuyez sur Touche programmable 2 afin d’afficher le menu, puis sélectionnez l’option 7 afin d’accéder à Mes documents\Mes images.

Annexe A : Arrêt de l’exécution d’une application sur un périphérique ou un émulateur

Cette tâche décrit comment arrêter une application qui s’exécute sur un périphérique ou un émulateur. Cela s’avère utile lorsqu’une application a été démarrée sans le débogueur et doit être arrêtée de sorte qu’une nouvelle copie de l’installation puisse être déployée. Vous allez arrêter l’application en utilisant l’outil distant Remote Process Viewer de Visual Studio.

Pour arrêter un processus, vous devez connaître le nom du fichier exécutable. Dans la plupart des cas, il s’agit du même nom que le projet Visual Studio. Si vous n’êtes pas certain du nom du fichier exécutable, vous pouvez le trouver dans les propriétés du projet.

Pour terminer un processus

  1. Dans Visual Studio, sélectionnez Projet, puis Propriétés xxx, où xxx représente le nom du projet en cours.

  2. Notez la valeur dans le champ Nom de l’assembly. Il s’agit du nom sous lequel le fichier exécutable s’exécutera sur le périphérique ou l’émulateur.

  3. Fermez la boîte de dialogue Propriétés.

    Vous pouvez à présent arrêter le processus.

  4. Dans le menu Démarrer, cliquez sur Démarrer > Microsoft Visual Studio 2005 > Outils distants Visual Studio > Remote Process Viewer.

  5. Lorsque vous y êtes invité par la boîte de dialogue Sélectionner un périphérique Windows CE, sélectionnez l’émulateur ou le périphérique sur lequel l’application s’exécute, comme illustré dans la figure suivante, puis cliquez sur OK.

    Figure 10

  6. Une fois la connexion à l’émulateur ou au périphérique établie, localisez l’application que vous souhaitez arrêter dans le volet supérieur de Remote Process Viewer, comme illustré dans la figure suivante.

    Figure 11

    Vous pouvez être amené à agrandir la colonne Processus (la colonne la plus à gauche) afin de voir le nom complet des processus.

  7. Cliquez sur le nom du processus afin de le sélectionner.

  8. Pour arrêter le processus, sélectionnez Fichier > Terminer le processus dans le menu Remote Process Viewer.

    Remarque : Soyez certain que le processus correct est sélectionné avant de cliquer sur Terminer le processus. L’arrêt d’un processus incorrect risque de rendre le périphérique ou l’émulateur inutilisable, nécessitant une réinitialisation avant de pouvoir le réutiliser.

  9. Vérifiez que le processus est arrêté en sélectionnant Cible > Actualiser dans le menu Remote Process Viewer, puis en faisant de nouveau défiler dans le volet supérieur. Si le nom de l’application apparaît toujours, cela signifie que le processus n’est pas arrêté et que vous devez recommencer.

    Remarque : La plupart des processus sont arrêtés en une seule fois. Cependant, en fonction de l’état de l’application, deux tentatives peuvent être nécessaires.

Résumé

Dans cet atelier, vous avez effectué les exercices suivants :

  • Utilisation du Sélecteur de contact pour permettre la recherche

  • Utilisation de la messagerie et du Sélecteur d’images pour envoyer du courrier électronique avec des pièces jointes

  • Utilisation de l’API broker État et notification pour extraire des informations sur l’état du système

  • Utilisation de l’API Broker État et notification pour recevoir des notifications des changements d’état du système

  • Utilisation de l’API de capture (facultatif)

Dans cet atelier, vous avez utilisé les nouvelles API Windows Mobile afin d’utiliser le Sélecteur de contact pour fournir des fonctionnalités de recherche des contacts Pocket Outlook. Le Sélecteur de contact permet à l’utilisateur de localiser des photos en utilisant des vues miniatures. Avec l’API Application de messagerie, l’application a généré un message électronique avec la photo comme pièce jointe et a présenté le message électronique à l’utilisateur en vue de sa vérification. Le message s’est affiché avec le formulaire standard de composition de message électronique.

En utilisant la nouvelle API Broker État et notification, vous avez extrait les informations relatives au propriétaire du Smartphone et vous avez utilisé ces informations pour définir une fin personnalisée du message électronique, avec le nom et le numéro de téléphone du propriétaire du Smartphone. Avec l’API Broker État et notification, vous avez également ajouté une fonction permettant à l’application d’être informée lorsque l’utilisateur du Smartphone communique avec une personne dont le numéro de téléphone est stocké dans la liste des contacts Pocket Outlook. Lorsqu’un tel appel se produit, l’application localise automatiquement les informations du contact et les affiche pour l’utilisateur. Si vous avez effectué l’exercice facultatif, vous avez créé une prise en charge intégrée pour la prise d’une photo et son envoi en tant que pièce jointe au message électronique.

Cela vous a-t-il été utile ?
(1500 caractères restants)
Merci pour vos suggestions.
Afficher:
© 2014 Microsoft. Tous droits réservés.