Envoyer un sms depuis son application windows mobile

Soyez le premier à donner votre avis sur cette source.

Vue 28 186 fois - Téléchargée 1 216 fois

Description

Bonjour
L'envoi d'sms est maintenant simple depuis une application windows mobile,
Il suffit d'ajouter le code de la classe SMSSender pour simplifier l'opération
La fonction a utiliser pour l'envoi est SendSMS
Elle reçoit comme paramètre le texte du message et le numéros de téléphone (et son type) du destinataire.

Le code utilisé pour l'envoi du message est inspiré du livre Programming Microsoft Windows CE 3rd edition.

Source bien commenté pour les débutants.

Attention, l'application fonctionne avec toutes les versions windows mobile a condition que le simulateur doit supporter la fonctionalité de téléphonie
Windows Mobile 2003 : Marche tres bien
Windows Mobile 5 : Marche qu'avec smartphone
Windows Mobile 6 : On peut envoyer des sms vers le Cellular Emulator inclus dans l'SDK.

En plus, elle nécessite des droits d'administration, donc l'application doit être signer par un certificat pour exécuter le code.

Bien sur elle marche en pratique avec tout device possédant la fonctionnalité de téléphonie.

Source / Exemple :


//'=====================================================================================
//'                           #  #                                                     '
//'                 ##        #  #         # #      @ @ @                              '
//'    ###    "    #####       #  #          # #      " "      #                       '
//'   ##  #     ##    #####    #  #   ####    # #        #  #   #                      '
//'  ########### #######     ##   #  #    ##   # #    #   #  #   #                     '
//' ##                      #            ####  # #   ##    #  #   #                #   '
//'        ## ## @           #  #    #####      # #  #  #   #  #  #                ##  '
//'      #        "        ##    #### #       ##  # #### ######  #                  ## '
//'       #          #####  ##  #   ##   @  #                           #  #  #      # '
//'        #                   #          " #     #                     #  #  #     #  '
//'         #                ##            #    #  #################################   '
//'          #####      #####           ###    # ##                                    '
//'               ######                      #                                ##      '
//'=====================================================================================
// Utilisation Libre
// Auteur: Boutemine Oualid
// Juste une méthode pour les puristes.
// il faut utiliser les classes du compact framework pour
// l'envoi d'sms (voir frmMain).

using System;
using System.Runtime.InteropServices;
using System.Text;

namespace EnvoyerSMS
{
    public static class SMSSender
    {
        // Informations des numéros de tél du destinataire.
        public enum AddressType
        {
            Unknown,
            International,
            National,
            NetworkSpecific,
            Subscriber,
            Alphanumeric,
            Abbreviated
        }
        public struct PhoneAddress
        {
            public AddressType AddressType;
            public string PhoneNumber;
        }

        // Méthode de communication
        public static string SMS_MSGTYPE_TEXT = "Microsoft Text SMS Protocol"; // Protocol d'envoi
        public static long SMS_MODE_SEND = 0x00000002; // Mode d'envoi
        public static long SMS_OPTION_DELIVERY_NONE = 0x00000000;  // Pas d'options speciales
        public static long SMS_OPTION_DELIVERY_NO_RETRY = 0x00000001;  // le message ne sera pas reporté 
        // pour la livraison selon les politiques du routeur.
        // ans cette option, le SMS sera de nouveau 
        // envoyé jusqu'à ce que le routeur le passe
        public static long PS_MESSAGE_OPTION_NONE = 0x00000000;//aucune notification sera renvoyé à la demande

        // Méthode d'encodage du texte d'sms.
        public enum SMS_DATA_ENCODING
        {
            SMSDE_OPTIMAL = 0,  // la bonne méthode de codage des données pour optimizer la bande passance lors d'envoi.
            SMSDE_GSM,          // forcer un encodage 7-bit spécifié dans la spécification GSM.
            SMSDE_UCS2,         // utilise la methode UCS2 pour l'encodage des données.
        }

        // Méthode de communication avec le centre de services et le destinataire.
        public enum PROVIDER_SPECIFIC_MESSAGE_CLASS
        {
            PS_MESSAGE_CLASS0 = 0, //indique que le message doit être affiché immédiatement mais ne soit pas 
            // stockés sur la carte SIM.
            PS_MESSAGE_CLASS1,  // indique que le centre de service traitant le message doit être notifié
            // lorsque le message passe à travers son réseaux et il sera sauvegardé. 
            PS_MESSAGE_CLASS2,  // Indique que le méssage doit etre passer d'abord vers le destinataire avant 
            // que la notification sera envoyer vers le centre de service traitant le message
            // Si la carte SIM est pleine, un message d'erreur est 
            // envoyé au centre de service.
            PS_MESSAGE_CLASS3,  // lorsque le message a été envoyé avec succès à la destination 
            // et peut être stockés sur la carte SIM, le centre de service recevra une notification.
        }

        // Ces options sert a préciser qui (le cas échéant) des précédentes notifications 
        // envoyées au centre de service devrait être remplacé par le message en cours. 
        // Le type spécifié par l'option assure que toutes les précédentes notifications de ce type se remplacée 
        // par la présente notification. Par exemple, si PSRO_REPLACE_TYPE3 est fixé, 
        // toutes les notifications de type 3 seront déplacées avec la notification en cours. 
        public enum PROVIDER_SPECIFIC_REPLACE_OPTION
        {
            PSRO_NONE = 0,
            PSRO_REPLACE_TYPE1,
            PSRO_REPLACE_TYPE2,
            PSRO_REPLACE_TYPE3,
            PSRO_REPLACE_TYPE4,
            PSRO_REPLACE_TYPE5,
            PSRO_REPLACE_TYPE6,
            PSRO_REPLACE_TYPE7,
            PSRO_RETURN_CALL,
            PSRO_DEPERSONALIZATION,
        }
        // Ces champs de cette structure utilisent toutes les énumérations que
        // nous avons défini ci-dessus et sont transmises lors de l'envoi / réception 
        // de l'SMS sous forme de chaîne. 
        // dwMessageOptions, s'encode dans un entier, et spécifie autres détails énoncés dans la spécification GSM 3,40. 

        public struct TEXT_PROVIDER_SPECIFIC_DATA
        {
            public IntPtr dwMessageOptions;
            public PROVIDER_SPECIFIC_MESSAGE_CLASS psMessageClass;
            public PROVIDER_SPECIFIC_REPLACE_OPTION psReplaceOption;
        }

        // Fonctions native d'envoi d'sms.
        [DllImport("sms.dll")]
        private static extern IntPtr SmsOpen(String ptsMessageProtocol,
                IntPtr dwMessageModes, ref IntPtr psmshHandle, IntPtr phMessageAvailableEvent);

        [DllImport("sms.dll")]
        private static extern IntPtr SmsSendMessage(IntPtr smshHandle, IntPtr psmsaSMSCAddress, IntPtr psmsaDestinationAddress,
            IntPtr pstValidityPeriod, byte[] pbData, IntPtr dwDataSize, byte[] pbProviderSpecificData, IntPtr dwProviderSpecificDataSize,
            SMS_DATA_ENCODING smsdeDataEncoding, IntPtr dwOptions, IntPtr psmsmidMessageID);
        // Résultat de la fonction
        private const long S_OK = 0; // IntPrt.Zero
        private const long E_FAIL = 0x80004005;
        private const long E_OUTOFMEMORY = 0x8007000E;
        private const long E_INVALIDARG = 0x80070057;
        private const long E_UNEXPECTED = 0x8000FFFF;

        [DllImport("sms.dll")]
        private static extern IntPtr SmsClose(IntPtr smshHandle);

        public unsafe static void SendSMS(PhoneAddress destAddress, string smsMessage)
        {
            // Pointeur pour le sms.
            IntPtr hSms = IntPtr.Zero;

            try
            {
                // Informe le SE qu'on va faire une opération d'acces vers la carte SIM pour l'envoi d'sms (SMS_MODE_SEND)
                IntPtr res = SmsOpen(SMS_MSGTYPE_TEXT, (IntPtr)SMS_MODE_SEND, ref hSms, IntPtr.Zero);

                if (res != IntPtr.Zero)
                    throw new Exception("Carte SIM inaccessible.");
                Byte[] bDest = new Byte[516];
                fixed (byte* pAddr = bDest)
                {
                    // Ecriture du type du numéros de téléphone dans le premier bloc de memoire
                    byte* pCurrent = pAddr; // Pointeur de déplacement.
                    // 4 premiers octets: Type du numéros du destinataire.
                    Marshal.WriteInt32((IntPtr)pCurrent, (int)destAddress.AddressType);
                    pCurrent += 4; // se déplace 4 octet et prépare l'opération d'écriture suivante.
                    // Ecriture du numéros du destinataire.
                    foreach (byte b in Encoding.Unicode.GetBytes(destAddress.PhoneNumber))
                    {
                        Marshal.WriteByte((IntPtr)pCurrent, b);
                        pCurrent++; // se déplace 1 octet.
                    }
                    // On place quelques options pour le message(TEXT_PROVIDER_SPECIFIC_DATA).
                    TEXT_PROVIDER_SPECIFIC_DATA tpsd = new TEXT_PROVIDER_SPECIFIC_DATA();
                    tpsd.dwMessageOptions = (IntPtr)PS_MESSAGE_OPTION_NONE;
                    tpsd.psMessageClass = PROVIDER_SPECIFIC_MESSAGE_CLASS.PS_MESSAGE_CLASS0;
                    tpsd.psReplaceOption = PROVIDER_SPECIFIC_REPLACE_OPTION.PSRO_NONE;

                    // Transfromation de la structure vers un buffer.
                    IntPtr pTpsd = Marshal.AllocHGlobal(Marshal.SizeOf(tpsd));
                    Marshal.StructureToPtr(tpsd, pTpsd, true);

                    // buffer des options.
                    Byte[] bufProvData = new Byte[12]; // 4 Octets (Int) * 3 options = 12 octet.
                    Marshal.Copy(pTpsd, bufProvData, 0, 12);

                    // buffer du Message
                    byte[] bMessage = Encoding.Unicode.GetBytes(smsMessage);
                    int nMsgSize = bMessage.Length;

                    // Envoi de message
                    res = SmsSendMessage(hSms, IntPtr.Zero, (IntPtr)pAddr, IntPtr.Zero,
                              bMessage, (IntPtr)nMsgSize, bufProvData, (IntPtr)bufProvData.Length,
                              SMS_DATA_ENCODING.SMSDE_OPTIMAL, (IntPtr)SMS_OPTION_DELIVERY_NONE,
                              IntPtr.Zero);
                    // les parametres de la fonction:
                    /* - smshHandle : pointeur du sms obtenu apres l'appel a la fonction SmsOpen

  • - psmsaSMSCAddress : parameter indiquant quel fournisseur de service
  • (Short Message Service Center -SMSC-) le message sera lui passé pour etre routé.
  • null est recommandé.
  • - psmsaDestinationAddress: pointeur vers l'adresse du destinataire (Numéros de tel et son type) (pAddr dans notre exemple)
  • - pstValidityPeriod : Durée pandant laquelle l'sms est valide, null est recommandé.
  • - pbData : Le texte de l'sms (pointeur vers la tete du texte).
  • - dwDataSize: Taille du message (en octet).
  • - pbProviderSpecificData : infos spécifique du provider(TEXT_PROVIDER_SPECIFIC_DATA), spécifique pour certain opérateurs.
  • - dwProviderSpecificDataSize: Taille du buffer.
  • - smsdeDataEncoding : Méthode d'encodage du SMS.
  • - dwOptions : Options d'envoi.
  • - psmsmidMessageID : Utilisé avec la fonction SmsGetMessageStatus.
  • /
if (res != IntPtr.Zero) throw new Exception("Impossible d'envoyer le message."); } } finally { // Fin d'opération d'utilisation de la carte sim. // Libération des ressources mémoire. SmsClose(hSms); } } } }

Conclusion :


Le code source précédent est une implémentation non sophistiqué pour les puristes

Mais le compact framework contient une autre méthode plus simple

Il suffit d'ajouter une référence vers l'assembly
Microsoft.WindowsMobile.PocketOutlook

On ajoute un import du namespace dans notre code et colle ce bout de code
using Microsoft.WindowsMobile.PocketOutlook;

SmsMessage sms = new SmsMessage(txtDestNbr.Text, txtMessage.Text);
sms.Send();

Plus simple nespa !!

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

mhidou91
Messages postés
8
Date d'inscription
vendredi 14 mai 2010
Statut
Membre
Dernière intervention
12 juillet 2012
-
merci pour ce tuoto
alors si vous voulez m'aider moi je veux utiliser cette application dans mon terminal
mais je veux que ce dernier soit ecoute recoit des message de la part d'un serveur comme un systeme de push
je l ai trouvé avec windows Phone mais moi je le veux avec Windows Mobile 6.5

merci j'aimerais bien que vous m'aidiez .. ;)
lassad_haddaji
Messages postés
142
Date d'inscription
mardi 24 avril 2007
Statut
Membre
Dernière intervention
6 avril 2012
-
est ce que possible de le tester avec sdk, parce que chaque fois me dis message non envoyer, ou bien il faut le tester sur ppc? merci de me repondre

bon continuation boutmine :)
spilz
Messages postés
8
Date d'inscription
jeudi 21 avril 2005
Statut
Membre
Dernière intervention
14 janvier 2010
-
bonjour, très pratique ton code, merci

les sms partent bien

j'ai une question tout de meme, est-il possible que le sms envoyé soit enregistré après dans les messages envoyés sur le téléphone, et avoir l'accusé de réception ?

merci
loulou2893
Messages postés
1
Date d'inscription
dimanche 19 juillet 2009
Statut
Membre
Dernière intervention
19 juillet 2009
-
Bonjour

Je ne comprend pas comment faire pour installer le logiciel ZIP sur mon pc vista

Merci de votre aide

Thibault
myk68
Messages postés
1
Date d'inscription
jeudi 22 janvier 2009
Statut
Membre
Dernière intervention
21 avril 2009
-
Bonjour Boutemine, j'aimerais savoir si il y a aussi un moyen de receptionné les sms et les afficher dans une application?
L'envoi d'sms fonctionne parfaitement avec l'assembly Microsoft.WindowsMobile.PocketOutlook et son objet SmsMessage mais je n'ai trouvé aucune info sur la réception.

Merci d'avance pour votre aide

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.