wake-up-neo.com

Wie versende und empfange ich SMS von Android App?

Ich möchte meiner App eine SMS-Sendefunktion hinzufügen und möchte auch eine Option, bei der der Benutzer die Kontakte aus der Kontaktliste direkt aus der Anwendung auswählen kann. Gibt es eine Möglichkeit, die Kontaktliste in meine Anwendung zu integrieren.

Vielen Dank

35
kaibuki

Und hier ist ein Tutorial, das Schritt für Schritt zeigt, wie SMS von einer Android App gesendet wird.

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

Hoffe Androiders und meine Antwort vervollständigen deine Antwort!

UPDATE: Da der Link oben jetzt tot ist:

Disclaimer: Ich habe den Originalartikel nicht geschrieben. Ich kopiere es nur hier. Der ursprüngliche Autor laut Artikel war weimenglee. Ich kopiere den Artikel hierher, weil der Link nach dem Posten des ursprünglichen Links vor einigen Jahren nun tot ist.

So senden Sie SMS

Starten Sie zunächst Eclipse und erstellen Sie ein neues Android Projekt. Nennen Sie das Projekt wie in Abbildung 1 dargestellt.

Figure 1

Android verwendet eine berechtigungsbasierte Richtlinie, bei der alle von einer Anwendung benötigten Berechtigungen in der Datei AndroidManifest.xml Angegeben werden müssen. Auf diese Weise wird dem Benutzer bei der Installation der Anwendung klar, welche spezifischen Zugriffsberechtigungen für die Anwendung erforderlich sind. Da das Senden von SMS Nachrichten möglicherweise zusätzliche Kosten für den Benutzer verursacht, kann der Benutzer entscheiden, ob die Berechtigung SMS in der Datei AndroidManifest.xml Zugelassen wird die Anwendung zu installieren oder nicht.

Fügen Sie in der Datei AndroidManifest.xml Die beiden Berechtigungen SEND_SMS Und RECEIVE_SMS Hinzu:

<?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>

Fügen Sie in der Datei main.xml Im Ordner res/layout Den folgenden Code hinzu, damit der Benutzer eine Telefonnummer sowie eine zu sendende Nachricht eingeben kann:

<?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>

Der obige Code erstellt die in Abbildung 2 gezeigte Benutzeroberfläche.

enter image description here

Als Nächstes verbinden wir in der Aktivität SMS die Schaltflächenansicht, sodass der Benutzer beim Klicken darauf überprüft, ob die Telefonnummer des Empfängers und die Nachricht eingegeben wurden, bevor wir die Nachricht senden mit der Funktion sendSMS(), die wir in Kürze definieren werden:

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();
            }
        });        
    }    
}

Die Funktion sendSMS() ist wie folgt definiert:

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);        
    }    
}

Um eine SMS Nachricht zu senden, verwenden Sie die Klasse SmsManager. Im Gegensatz zu anderen Klassen instanziieren Sie diese Klasse nicht direkt. Stattdessen rufen Sie die statische Methode getDefault() auf, um ein Objekt SmsManager zu erhalten. Die Methode sendTextMessage() sendet die Nachricht SMS mit einem PendingIntent.

Das Objekt PendingIntent wird verwendet, um ein Ziel zu identifizieren, das zu einem späteren Zeitpunkt aufgerufen werden soll. Beispielsweise können Sie nach dem Senden der Nachricht ein PendingIntent -Objekt verwenden, um eine andere Aktivität anzuzeigen. In diesem Fall zeigt das Objekt PendingIntent (pi) einfach auf dieselbe Aktivität (SMS.Java). Wenn also SMS gesendet wird, geschieht nichts.

Wenn Sie den Status des Sendeprozesses für SMS -Nachrichten überwachen müssen, können Sie zwei PendingIntent-Objekte zusammen mit zwei BroadcastReceiver -Objekten wie folgt verwenden:

// --- sendet eine SMS Nachricht an ein anderes Gerät --- private void sendSMS (String phoneNumber, String message) {
String 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);        

}

Der obige Code verwendet ein PendingIntent -Objekt (sentPI), um den Sendevorgang zu überwachen. Wenn eine SMS -Nachricht gesendet wird, wird das Ereignis onReceive des ersten BroadcastReceiver ausgelöst. Hier überprüfen Sie den Status des Sendevorgangs. Das zweite PendingIntent-Objekt (deliverPI) überwacht den Übermittlungsprozess. Das onReceive -Ereignis des zweiten BroadcastReceiver wird ausgelöst, wenn ein SMS erfolgreich übermittelt wurde.

Sie können die Anwendung jetzt testen, indem Sie in Eclipse die Taste F11 drücken. Um eine SMS Nachricht von einer Emulatorinstanz zu einer anderen zu senden, starten Sie einfach eine andere Instanz des Android Emulators, indem Sie zum Ordner Tools des SDK gehen und Emulator.exe Ausführen.

enter image description here

Abbildung 3 zeigt, wie Sie eine SMS -Nachricht von einem Emulator an einen anderen senden können. Verwenden Sie einfach die Portnummer des Zielemulators (in der oberen linken Ecke des Fensters) als Telefonnummer. Wenn eine SMS erfolgreich gesendet wurde, wird eine "SMS gesendet" -Nachricht angezeigt. Nach erfolgreicher Zustellung wird eine SMS-Nachricht angezeigt. Beachten Sie, dass zu Testzwecken mit dem Emulator nach erfolgreicher Zustellung einer SMS die Meldung "SMS zugestellt" nicht angezeigt wird. Dies funktioniert nur für echte Geräte.

Abbildung 4 zeigt die auf dem Empfängeremulator empfangene Nachricht SMS. Die Nachricht wurde zuerst in der Benachrichtigungsleiste (oben auf dem Bildschirm) angezeigt. Wenn Sie die Benachrichtigungsleiste nach unten ziehen, wird die empfangene Nachricht angezeigt. Um die gesamte Nachricht anzuzeigen, klicken Sie auf die Nachricht.

enter image description here

Wenn Sie sich nicht die Mühe machen möchten, die Nachricht SMS selbst zu senden, können Sie mithilfe eines Intent-Objekts eine Nachricht SMS senden. Der folgende Code zeigt, wie Sie die integrierte Anwendung SMS aufrufen können, um eine SMS -Nachricht zu senden:

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);

Abbildung 5 zeigt die integrierte Anwendung SMS, die zum Senden der Nachricht SMS aufgerufen wurde.

enter image description here

Empfangen von SMS Nachrichten

Neben dem programmgesteuerten Senden von SMS Nachrichten können Sie auch eingehende SMS Nachrichten mit einem BroadcastReceiver Objekt abfangen.

Um zu sehen, wie SMS Nachrichten aus Ihrer Android Anwendung empfangen werden, fügen Sie in der Datei AndroidManifest.xml Das Element hinzu, damit eingehende SMS Nachrichten empfangen werden können abgefangen von der Klasse 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>

Fügen Sie Ihrem Projekt eine neue Klassendatei hinzu und nennen Sie sie SmsReceiver.Java (siehe Abbildung 6).

enter image description here

Erweitern Sie in der SmsReceiver-Klasse die BroadcastReceiver-Klasse und überschreiben Sie die onReceive () -Methode:

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) 
       {    
    }
}

Wenn SMS Nachrichten empfangen werden, wird die onCreate() Methode aufgerufen. Die SMS -Nachricht ist enthalten und über ein Bundle -Objekt an das Intent-Objekt (intent - der zweite Parameter in der onReceive() -Methode) angehängt. Die Nachrichten werden in einem Objektarray im PDU-Format gespeichert. Um jede Nachricht zu extrahieren, verwenden Sie die statische Methode createFromPdu() aus der Klasse SmsMessage. Die Nachricht SMS wird dann mit der Klasse Toast angezeigt:

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();
        }                         
    }
}

Das ist es! Drücken Sie in Eclipse die Taste F11, um die Anwendung zu testen. Stellen Sie die Anwendung auf jedem Android Emulator bereit. Abbildung 7 zeigt Eclipse mit den derzeit ausgeführten Emulatoren. Alles, was Sie tun müssen, ist, jeden Emulator auszuwählen und die Anwendung auf jedem einzelnen bereitzustellen.

enter image description here

Abbildung 8 zeigt, dass beim Senden einer SMS -Nachricht an eine andere Emulatorinstanz (Portnummer 5556) die Nachricht vom Zielemulator empfangen und über die Toast-Klasse angezeigt wird.

enter image description here

44
Shaunak

Hier ist ein Link mit Informationen, wie Sie die Kontakte in Ihre App laden können: http://developer.Android.com/guide/topics/providers/content-providers.html

Hoffe, das ist was Sie suchen.

13
Androider

Versuchen Sie dieses Tutorial, um SMS zu senden. Hoffe das hilft.

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

Fügen Sie Ihrer Aktivitätsdatei die folgende Methode hinzu, in der Sie die Funktion "SMS senden" implementieren müssen.

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();
  }
}

Sie müssen Android.telephony.SmsManager importieren , um die sendSMSMessage-Methode zu implementieren.

Fügen Sie dem XML-Layout Ihrer Aktivität eine Schaltfläche hinzu, und rufen Sie die sendSMSMessage-Methode für das Ereignis "Schaltfläche anklicken" auf.

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

Fügen Sie in Ihrer Manifest.xml die folgende Berechtigung hinzu.

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