web-dev-qa-db-fra.com

Comment envoyer et recevoir SMS de Android app?

Je veux ajouter la fonction d'envoi de sms dans mon application et je veux également une option dans laquelle l'utilisateur peut sélectionner les contacts dans la liste de contacts directement depuis l'application. Existe-t-il un moyen d'intégrer cette liste de contacts à mon application?.

Merci

androidsmsandroid-contacts
35
kaibuki

Et voici un tutoriel montrant étape par étape comment envoyer SMS à partir d'une application Android.

http://mobiforge.com/developing/story/sms-messaging-Android

J'espère que Androider et ma réponse complètent votre réponse!

MISE À JOUR: Puisque le lien ci-dessus est maintenant mort:

Disclaimer: Je n'ai pas écrit l'article original. Je le copie juste ici. L'auteur d'origine selon l'article était weimenglee. Je copie l'article ici car après avoir publié le lien d'origine il y a quelques années, le lien est maintenant mort.

Comment envoyer des SMS

Pour commencer, lancez d'abord Eclipse et créez un nouveau projet Android. Nommez le projet comme indiqué dans la figure 1.

Figure 1

Android utilise une stratégie basée sur les autorisations dans laquelle toutes les autorisations nécessaires à une application doivent être spécifiées dans le fichier AndroidManifest.xml. Ce faisant, lorsque l'application est installée, il sera clair pour l'utilisateur quelles autorisations d'accès spécifiques sont requises par l'application. Par exemple, l'envoi de messages SMS entraînera potentiellement des frais supplémentaires de la part de l'utilisateur, indiquant que les autorisations SMS dans le fichier AndroidManifest.xml Permettront l'utilisateur décide d'autoriser ou non l'installation de l'application.

Dans le fichier AndroidManifest.xml, Ajoutez les deux autorisations - SEND_SMS Et RECEIVE_SMS:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:Android="http://schemas.Android.com/apk/res/Android"
      package="net.learn2develop.SMSMessaging"
      Android:versionCode="1"
      Android:versionName="1.0.0">
    <application Android:icon="@drawable/icon" Android:label="@string/app_name">
        <activity Android:name=".SMS"
                  Android:label="@string/app_name">
            <intent-filter>
                <action Android:name="Android.intent.action.MAIN" />
                <category Android:name="Android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
    <uses-permission Android:name="Android.permission.SEND_SMS">
    </uses-permission>
    <uses-permission Android:name="Android.permission.RECEIVE_SMS">
    </uses-permission>
</manifest>

Dans le fichier main.xml Situé dans le dossier res/layout, Ajoutez le code suivant afin que l'utilisateur puisse entrer un numéro de téléphone ainsi qu'un message à envoyer:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:Android="http://schemas.Android.com/apk/res/Android"
    Android:orientation="vertical"
    Android:layout_width="fill_parent"
    Android:layout_height="fill_parent"
    >
    <TextView  
        Android:layout_width="fill_parent" 
        Android:layout_height="wrap_content" 
        Android:text="Enter the phone number of recipient"
        />     
    <EditText 
        Android:id="@+id/txtPhoneNo"  
        Android:layout_width="fill_parent" 
        Android:layout_height="wrap_content"        
        />
    <TextView  
        Android:layout_width="fill_parent" 
        Android:layout_height="wrap_content"         
        Android:text="Message"
        />     
    <EditText 
        Android:id="@+id/txtMessage"  
        Android:layout_width="fill_parent" 
        Android:layout_height="150px"
        Android:gravity="top"         
        />          
    <Button 
        Android:id="@+id/btnSendSMS"  
        Android:layout_width="fill_parent" 
        Android:layout_height="wrap_content"
        Android:text="Send SMS"
        />    
</LinearLayout>

Le code ci-dessus crée l'interface utilisateur illustrée à la figure 2.

enter image description here

Ensuite, dans l'activité SMS, nous câblons la vue Bouton afin que lorsque l'utilisateur clique dessus, nous vérifions que le numéro de téléphone du destinataire et le message sont entrés avant de envoyer le message en utilisant la fonction sendSMS(), que nous définirons prochainement:

package net.learn2develop.SMSMessaging;

import Android.app.Activity;
import Android.app.PendingIntent;
import Android.content.Intent;
import Android.os.Bundle;
import Android.telephony.gsm.SmsManager;
import Android.view.View;
import Android.widget.Button;
import Android.widget.EditText;
import Android.widget.Toast;

public class SMS extends Activity 
{
    Button btnSendSMS;
    EditText txtPhoneNo;
    EditText txtMessage;

    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) 
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);        

        btnSendSMS = (Button) findViewById(R.id.btnSendSMS);
        txtPhoneNo = (EditText) findViewById(R.id.txtPhoneNo);
        txtMessage = (EditText) findViewById(R.id.txtMessage);

        btnSendSMS.setOnClickListener(new View.OnClickListener() 
        {
            public void onClick(View v) 
            {                
                String phoneNo = txtPhoneNo.getText().toString();
                String message = txtMessage.getText().toString();                 
                if (phoneNo.length()>0 && message.length()>0)                
                    sendSMS(phoneNo, message);                
                else
                    Toast.makeText(getBaseContext(), 
                        "Please enter both phone number and message.", 
                        Toast.LENGTH_SHORT).show();
            }
        });        
    }    
}

La fonction sendSMS() est définie comme suit:

public class SMS extends Activity 
{
    //...

    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) 
    {
        //...
    }

    //---sends an SMS message to another device---
    private void sendSMS(String phoneNumber, String message)
    {        
        PendingIntent pi = PendingIntent.getActivity(this, 0,
            new Intent(this, SMS.class), 0);                
        SmsManager sms = SmsManager.getDefault();
        sms.sendTextMessage(phoneNumber, null, message, pi, null);        
    }    
}

Pour envoyer un message SMS, vous utilisez la classe SmsManager. Contrairement aux autres classes, vous n'instanciez pas directement cette classe; à la place, vous appellerez la getDefault() méthode statique pour obtenir un objet SmsManager. La méthode sendTextMessage() envoie le message SMS avec un PendingIntent.

L'objet PendingIntent est utilisé pour identifier une cible à invoquer ultérieurement. Par exemple, après l'envoi du message, vous pouvez utiliser un objet PendingIntent pour afficher une autre activité. Dans ce cas, l'objet PendingIntent (pi) pointe simplement vers la même activité (SMS.Java), Donc quand le SMS est envoyé, rien ne se passera .

Si vous devez surveiller l'état du processus d'envoi de messages SMS SMS, vous pouvez réellement utiliser deux objets PendingIntent avec deux objets BroadcastReceiver, comme ceci:

// --- envoie un SMS message à un autre appareil --- private void sendSMS (String phoneNumber, String message) {
Chaîne SENT = "SMS_SENT"; String DELIVERED = "SMS_DELIVERED";

PendingIntent sentPI = PendingIntent.getBroadcast(this, 0,
    new Intent(SENT), 0);

PendingIntent deliveredPI = PendingIntent.getBroadcast(this, 0,
    new Intent(DELIVERED), 0);

//---when the SMS has been sent---
registerReceiver(new BroadcastReceiver(){
    @Override
    public void onReceive(Context arg0, Intent arg1) {
        switch (getResultCode())
        {
            case Activity.RESULT_OK:
                Toast.makeText(getBaseContext(), "SMS sent", 
                        Toast.LENGTH_SHORT).show();
                break;
            case SmsManager.RESULT_ERROR_GENERIC_FAILURE:
                Toast.makeText(getBaseContext(), "Generic failure", 
                        Toast.LENGTH_SHORT).show();
                break;
            case SmsManager.RESULT_ERROR_NO_SERVICE:
                Toast.makeText(getBaseContext(), "No service", 
                        Toast.LENGTH_SHORT).show();
                break;
            case SmsManager.RESULT_ERROR_NULL_PDU:
                Toast.makeText(getBaseContext(), "Null PDU", 
                        Toast.LENGTH_SHORT).show();
                break;
            case SmsManager.RESULT_ERROR_RADIO_OFF:
                Toast.makeText(getBaseContext(), "Radio off", 
                        Toast.LENGTH_SHORT).show();
                break;
        }
    }
}, new IntentFilter(SENT));

//---when the SMS has been delivered---
registerReceiver(new BroadcastReceiver(){
    @Override
    public void onReceive(Context arg0, Intent arg1) {
        switch (getResultCode())
        {
            case Activity.RESULT_OK:
                Toast.makeText(getBaseContext(), "SMS delivered", 
                        Toast.LENGTH_SHORT).show();
                break;
            case Activity.RESULT_CANCELED:
                Toast.makeText(getBaseContext(), "SMS not delivered", 
                        Toast.LENGTH_SHORT).show();
                break;                        
        }
    }
}, new IntentFilter(DELIVERED));        

SmsManager sms = SmsManager.getDefault();
sms.sendTextMessage(phoneNumber, null, message, sentPI, deliveredPI);

}

Le code ci-dessus utilise un objet PendingIntent (sentPI) pour surveiller le processus d'envoi. Lorsqu'un message SMS est envoyé, le premier événement onReceive de BroadcastReceiver se déclenche. C'est là que vous vérifiez l'état du processus d'envoi. Le deuxième objet PendingIntent (deliveryPI) surveille le processus de livraison. Le deuxième événement onReceive du BroadcastReceiver se déclenchera lorsqu'un SMS sera livré avec succès.

Vous pouvez maintenant tester l'application en appuyant sur F11 dans Eclipse. Pour envoyer un message SMS d'une instance d'émulateur à une autre, lancez simplement une autre instance de l'émulateur Android en accédant au dossier Tools du SDK et en exécutant Emulator.exe.

enter image description here

La figure 3 montre comment envoyer un message SMS d'un émulateur à un autre; utilisez simplement le numéro de port de l'émulateur cible (indiqué dans le coin supérieur gauche de la fenêtre) comme numéro de téléphone. SMS est envoyé avec succès, il affichera un message "SMS envoyé". Quand il sera livré avec succès, il affichera un message "SMS livré". Notez que pour tester à l'aide de l'émulateur, lorsqu'un SMS est livré avec succès, le message "SMS livré" n'apparaît pas; cela ne fonctionne que pour les appareils réels.

La figure 4 montre le message SMS reçu sur l'émulateur du destinataire. Le message est apparu pour la première fois dans la barre de notification (en haut de l'écran). Faire glisser la barre de notification vers le bas révèle le message reçu. Pour afficher l'intégralité du message message, cliquez sur le message.

enter image description here

Si vous ne souhaitez pas passer tous les problèmes d'envoi du message SMS vous-même, vous pouvez utiliser un objet Intent pour vous aider à envoyer un message SMS. Le code suivant montre comment vous pouvez appeler l'application intégrée SMS pour vous aider à envoyer un message SMS:

Intent sendIntent = new Intent(Intent.ACTION_VIEW);
sendIntent.putExtra("sms_body", "Content of the SMS goes here..."); 
sendIntent.setType("vnd.Android-dir/mms-sms");
startActivity(sendIntent);

La figure 5 montre l'application intégrée SMS invoquée pour envoyer le message SMS.

enter image description here

Réception de messages SMS

Outre l'envoi par programmation de messages SMS, vous pouvez également intercepter les messages SMS SMS) entrants à l'aide d'un objet BroadcastReceiver.

Pour voir comment recevoir des messages SMS depuis votre Android, dans le fichier AndroidManifest.xml, Ajoutez l'élément de sorte que SMS peuvent être interceptés par la classe SmsReceiver:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:Android="http://schemas.Android.com/apk/res/Android"
      package="net.learn2develop.SMSMessaging"
      Android:versionCode="1"
      Android:versionName="1.0.0">
    <application Android:icon="@drawable/icon" Android:label="@string/app_name">
        <activity Android:name=".SMS"
                  Android:label="@string/app_name">
            <intent-filter>
                <action Android:name="Android.intent.action.MAIN" />
                <category Android:name="Android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>        

        <receiver Android:name=".SmsReceiver"> 
            <intent-filter> 
                <action Android:name=
                    "Android.provider.Telephony.SMS_RECEIVED" /> 
            </intent-filter> 
        </receiver>

    </application>
    <uses-permission Android:name="Android.permission.SEND_SMS">
    </uses-permission>
    <uses-permission Android:name="Android.permission.RECEIVE_SMS">
    </uses-permission>
</manifest>

Ajoutez un nouveau fichier de classe à votre projet et nommez-le SmsReceiver.Java (voir la figure 6).

enter image description here

Dans la classe SmsReceiver, étendez la classe BroadcastReceiver et remplacez la méthode onReceive ():

package net.learn2develop.SMSMessaging;

import Android.content.BroadcastReceiver;
import Android.content.Context;
import Android.content.Intent;

public class SmsReceiver extends BroadcastReceiver
{
    @Override
    public void onReceive(Context context, Intent intent) 
       {    
    }
}

Lorsque SMS messages sont reçus, la méthode onCreate() sera invoquée. Le message SMS est contenu et attaché à l'objet Intent (intention - le deuxième paramètre de la méthode onReceive()) via un objet Bundle. Les messages sont stockés dans un tableau Object au format PDU. Pour extraire chaque message, vous utilisez la fonction statique createFromPdu() méthode de la classe SmsMessage. Le message SMS est ensuite affiché en utilisant la classe Toast:

package net.learn2develop.SMSMessaging;

import Android.content.BroadcastReceiver;
import Android.content.Context;
import Android.content.Intent;
import Android.os.Bundle;
import Android.telephony.gsm.SmsMessage;
import Android.widget.Toast;

public class SmsReceiver extends BroadcastReceiver
{
    @Override
    public void onReceive(Context context, Intent intent) 
    {
        //---get the SMS message passed in---
        Bundle bundle = intent.getExtras();        
        SmsMessage[] msgs = null;
        String str = "";            
        if (bundle != null)
        {
            //---retrieve the SMS message received---
            Object[] pdus = (Object[]) bundle.get("pdus");
            msgs = new SmsMessage[pdus.length];            
            for (int i=0; i<msgs.length; i++){
                msgs[i] = SmsMessage.createFromPdu((byte[])pdus[i]);                
                str += "SMS from " + msgs[i].getOriginatingAddress();                     
                str += " :";
                str += msgs[i].getMessageBody().toString();
                str += "n";        
            }
            //---display the new SMS message---
            Toast.makeText(context, str, Toast.LENGTH_SHORT).show();
        }                         
    }
}

C'est ça! Pour tester l'application, appuyez sur F11 dans Eclipse. Déployez l'application sur chaque Android. La figure 7 montre Eclipse montrant les émulateurs en cours d'exécution. Tout ce que vous avez à faire est de sélectionner chaque émulateur et de déployer l'application sur chacun d'eux.

enter image description here

La figure 8 montre que lorsque vous envoyez un message SMS à une autre instance d'émulateur (numéro de port 5556), le message est reçu par l'émulateur cible et affiché via la classe Toast.

enter image description here

44
Shaunak

Voici un lien avec des informations sur la façon de charger les contacts dans votre application: http://developer.Android.com/guide/topics/providers/content-providers.html

J'espère que c'est ce que vous recherchez.

13
Androider

Essayez ce tutoriel pour envoyer des SMS. J'espère que cela t'aides.

http://www.tutorialspoint.com/Android/android_sending_sms.htm

Ajoutez la méthode suivante dans votre fichier d'activité dans laquelle vous devez implémenter la fonctionnalité "envoyer des SMS".

protected void sendSMSMessage() {

  String phoneNo = txtphoneNo.getText().toString();
  String message = txtMessage.getText().toString();

  try {
     SmsManager smsManager = SmsManager.getDefault();
     smsManager.sendTextMessage(phoneNo, null, message, null, null);
     Toast.makeText(getApplicationContext(), "SMS sent.",
     Toast.LENGTH_LONG).show();
  } catch (Exception e) {
     Toast.makeText(getApplicationContext(),
     "SMS faild, please try again.",
     Toast.LENGTH_LONG).show();
     e.printStackTrace();
  }
}

Vous devrez importer Android.telephony.SmsManager pour implémenter la méthode sendSMSMessage.

Ajoutez un bouton à la disposition xml de votre activité et appelez la méthode sendSMSMessage sur l'événement Click de bouton.

Button.setOnClickListener(new View.OnClickListener() {
  public void onClick(View view) {
    sendSMSMessage();
   }
 });

Dans votre Manifest.xml, ajoutez l'autorisation suivante.

<uses-permission Android:name="Android.permission.SEND_SMS"/>
7
Ishara Amarasekera