wake-up-neo.com

Zeige verfassen SMS Ansicht in Android

Ich möchte eine SMS mit Android senden.

Was ist die Absicht für SMS senden?

Ich möchte die Ansicht zum Verfassen von SMS mit meinem vordefinierten Text im Nachrichtenfeld anzeigen.

163
djk

Sie können den folgenden Code verwenden:

startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse("sms:"
                        + phoneNumber)));

Stellen Sie sicher, dass Sie phoneNumber auf die Telefonnummer setzen, an die Sie die Nachricht senden möchten

Sie können eine Nachricht zu SMS mit (aus Kommentaren) hinzufügen:

Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse("sms:" + phoneNumber));     
intent.putExtra("sms_body", message); 
startActivity(intent);
193
Ads

Das hat bei mir funktioniert.

public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);
    Button btnSendSMS = (Button) findViewById(R.id.btnSendSMS);
    btnSendSMS.setOnClickListener(new View.OnClickListener() {
        public void onClick(View v) {
            sendSMS("5556", "Hi You got a message!");
           /*here i can send message to emulator 5556. In Real device 
            *you can change number*/
        }
    });
}

//Sends an SMS message to another device

private void sendSMS(String phoneNumber, String message) {
    SmsManager sms = SmsManager.getDefault();
    sms.sendTextMessage(phoneNumber, null, message, null, null);
}

Sie können diese Zeile in AndroidManifest.xml hinzufügen

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

Schauen Sie sich this an

Dies kann für Sie hilfreich sein.

151
selva_pollachi

Probieren Sie den folgenden Code aus und rufen Sie dann sendSMS("99999999999", "message"); an, um eine SMS mit der gewünschten Nummer zu senden.

//---sends an SMS message to another device---
@SuppressWarnings("deprecation")
private void sendSMS(String phoneNumber, String message)
{        
    Log.v("phoneNumber",phoneNumber);
    Log.v("MEssage",message);
    PendingIntent pi = PendingIntent.getActivity(this, 0,
    new Intent(this, **DummyClasshere.class**), 0);                
    SmsManager sms = SmsManager.getDefault();
    sms.sendTextMessage(phoneNumber, null, message, pi, null);        
}

Bitte geben Sie die folgende Berechtigung in die Datei AndroidManifest.xml Ein.

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

Hoffe das könnte helfen.

pdate Aus dem Kommentar: DummyClasshere.class ist eine Aktivität ohne Prozess oder die Klasse, in der Sie navigieren müssen.

Sie können Object.class anstelle von DummyClasshere.class verwenden.

39
Senthil Mg

Dies wird auf jeden Fall funktionieren. Senden Sie eine Nachricht, ohne eine Absicht zu verwenden.

SmsManager smsManager =     SmsManager.getDefault();
smsManager.sendTextMessage("Phone Number", null, "Message", null, null);

Dieser Code wird für Nachricht im Hintergrund senden (Nachrichtenkomponist wird nicht angezeigt) verwendet. Er kann auch im Rundfunkempfänger verwendet werden. Wenn Sie eine Nachricht vom Rundfunkempfänger senden möchten.

   <uses-permission Android:name="Android.permission.SEND_SMS"/>
28
Dwivedi Ji

Hoffe dieser Code hilft dir :)

public class MainActivity extends Activity {
    private int mMessageSentParts;
    private int mMessageSentTotalParts;
    private int mMessageSentCount;
     String SENT = "SMS_SENT";
     String DELIVERED = "SMS_DELIVERED";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Button button=(Button)findViewById(R.id.button1);
        button.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                String phoneNumber = "0000000000";
                String message = "Hello World!";
                sendSMS(phoneNumber,message);


            }
        });



    }


    public void sendSMS(String phoneNumber,String message) {
        SmsManager smsManager = SmsManager.getDefault();


         String SENT = "SMS_SENT";
            String DELIVERED = "SMS_DELIVERED";

            SmsManager sms = SmsManager.getDefault();
            ArrayList<String> parts = sms.divideMessage(message);
            int messageCount = parts.size();

            Log.i("Message Count", "Message Count: " + messageCount);

            ArrayList<PendingIntent> deliveryIntents = new ArrayList<PendingIntent>();
            ArrayList<PendingIntent> sentIntents = new ArrayList<PendingIntent>();

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

            for (int j = 0; j < messageCount; j++) {
                sentIntents.add(sentPI);
                deliveryIntents.add(deliveredPI);
            }

            // ---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.sendTextMessage(phoneNumber, null, message, sentPI, deliveredPI);
           /* sms.sendMultipartTextMessage(phoneNumber, null, parts, sentIntents, deliveryIntents); */
    }
}
10
Harshal Benake

In Android, wir haben die Klasse SmsManager , die SMS) Operationen wie verwaltet Senden von Daten, Text und pdu SMS Nachrichten. Rufen Sie dieses Objekt mit der statischen Methode SmsManager.getDefault () ab.

SmsManager Javadoc

Überprüfen Sie den folgenden Link, um den Beispielcode zum Senden von SMS zu erhalten:

Artikel zum Senden und Empfangen von SMS Nachrichten in Android

10
chiranjib

Ich füge meine SMS Methode hinzu, wenn es jemandem helfen kann. Sei vorsichtig mit smsManager.sendTextMessage. Wenn der Text zu lang ist, verschwindet die Nachricht nicht Weitere Informationen finden Sie hier SMS Manager sendet eine mehrteilige Nachricht, wenn weniger als 160 Zeichen vorhanden sind

// ÜBERALL VERWENDEN

SMSUtils.sendSMS(context, phoneNumber, message);

//Manifest

<!-- SMS -->
<uses-permission Android:name="Android.permission.SEND_SMS"/>
<uses-permission Android:name="Android.permission.READ_PHONE_STATE"/>

 <receiver
     Android:name=".SMSUtils"
     Android:enabled="true"
     Android:exported="true">
     <intent-filter>
         <action Android:name="SMS_SENT"/>
         <action Android:name="SMS_DELIVERED"/>
      </intent-filter>
 </receiver>

//Java

public class SMSUtils extends BroadcastReceiver {

    public static final String SENT_SMS_ACTION_NAME = "SMS_SENT";
    public static final String DELIVERED_SMS_ACTION_NAME = "SMS_DELIVERED";

    @Override
    public void onReceive(Context context, Intent intent) {
        //Detect l'envoie de sms
        if (intent.getAction().equals(SENT_SMS_ACTION_NAME)) {
            switch (getResultCode()) {
                case Activity.RESULT_OK: // Sms sent
                    Toast.makeText(context, context.getString(R.string.sms_send), Toast.LENGTH_LONG).show();
                    break;
                case SmsManager.RESULT_ERROR_GENERIC_FAILURE: // generic failure
                    Toast.makeText(context, context.getString(R.string.sms_not_send), Toast.LENGTH_LONG).show();
                    break;
                case SmsManager.RESULT_ERROR_NO_SERVICE: // No service
                    Toast.makeText(context, context.getString(R.string.sms_not_send_no_service), Toast.LENGTH_LONG).show();
                    break;
                case SmsManager.RESULT_ERROR_NULL_PDU: // null pdu
                    Toast.makeText(context, context.getString(R.string.sms_not_send), Toast.LENGTH_LONG).show();
                    break;
                case SmsManager.RESULT_ERROR_RADIO_OFF: //Radio off
                    Toast.makeText(context, context.getString(R.string.sms_not_send_no_radio), Toast.LENGTH_LONG).show();
                    break;
            }
        }
        //detect la reception d'un sms
        else if (intent.getAction().equals(DELIVERED_SMS_ACTION_NAME)) {
            switch (getResultCode()) {
                case Activity.RESULT_OK:
                    Toast.makeText(context, context.getString(R.string.sms_receive), Toast.LENGTH_LONG).show();
                    break;
                case Activity.RESULT_CANCELED:
                    Toast.makeText(context, context.getString(R.string.sms_not_receive), Toast.LENGTH_LONG).show();
                    break;
            }
        }
    }

    /**
     * Test if device can send SMS
     * @param context
     * @return
     */
    public static boolean canSendSMS(Context context) {
        return context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_TELEPHONY);
    }

    public static void sendSMS(final Context context, String phoneNumber, String message) {

        if (!canSendSMS(context)) {
            Toast.makeText(context, context.getString(R.string.cannot_send_sms), Toast.LENGTH_LONG).show();
            return;
        }

        PendingIntent sentPI = PendingIntent.getBroadcast(context, 0, new Intent(SENT_SMS_ACTION_NAME), 0);
        PendingIntent deliveredPI = PendingIntent.getBroadcast(context, 0, new Intent(DELIVERED_SMS_ACTION_NAME), 0);

        final SMSUtils smsUtils = new SMSUtils();
        //register for sending and delivery
        context.registerReceiver(smsUtils, new IntentFilter(SMSUtils.SENT_SMS_ACTION_NAME));
        context.registerReceiver(smsUtils, new IntentFilter(DELIVERED_SMS_ACTION_NAME));

        SmsManager sms = SmsManager.getDefault();
        ArrayList<String> parts = sms.divideMessage(message);

        ArrayList<PendingIntent> sendList = new ArrayList<>();
        sendList.add(sentPI);

        ArrayList<PendingIntent> deliverList = new ArrayList<>();
        deliverList.add(deliveredPI);

        sms.sendMultipartTextMessage(phoneNumber, null, parts, sendList, deliverList);

        //we unsubscribed in 10 seconds 
        new Handler().postDelayed(new Runnable() {
            @Override
            public void run() {
                context.unregisterReceiver(smsUtils);
            }
        }, 10000);

    }
}
6
Anthone
String phoneNumber = "0123456789";
String message = "Hello World!";

SmsManager smsManager = SmsManager.getDefault();
smsManager.sendTextMessage(phoneNumber, null, message, null, null);

Fügen Sie die folgende Berechtigung in Ihre AndroidManifest.xml-Datei ein

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

Einige der oben erläuterten Funktionen dienen nur dazu, eine SMS in den Status 'Bereit zum Starten' zu versetzen. Wie Senthil Mg sagte, können Sie den SMS-Manager verwenden, um die SMS direkt zu senden, aber SMSManager wurde nach Android.telephony.SmsManager verschoben

Ich weiß, es ist nicht viel von mehr Informationen, aber es könnte eines Tages jemandem helfen.

4
Eitan Schwartz

Hoffe das kann dir helfen ...

Dateiname = MainActivity.Java

import Android.os.Bundle;
import Android.app.Activity;
import Android.telephony.SmsManager;
import Android.view.Menu;
import Android.view.inputmethod.InputMethodManager;
import Android.widget.*;
import Android.view.View.OnClickListener;
import Android.view.*;


public class MainActivity extends Activity implements OnClickListener{


  Button click;
  EditText txt;
  TextView txtvw;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    click = (Button)findViewById(R.id.button);
    txt = (EditText)findViewById(R.id.editText);
    txtvw = (TextView)findViewById(R.id.textView1);

    click.setOnClickListener(this);
}

@Override
public void onClick(View v){


    txt.setText("");
    v = this.getCurrentFocus();

    try{
        SmsManager sms = SmsManager.getDefault();
        sms.sendTextMessage("8017891398",null,"Sent from Android",null,null);
    }
    catch(Exception e){
        txtvw.setText("Message not sent!");
    }
    if(v != null){
        InputMethodManager imm = (InputMethodManager)getSystemService(INPUT_METHOD_SERVICE);
        imm.hideSoftInputFromWindow(v.getWindowToken(),0);
    }

}

@Override
public boolean onCreateOptionsMenu(Menu menu) {
    // Inflate the menu; this adds items to the action bar if it is present.
    getMenuInflater().inflate(R.menu.main, menu);
    return true;
  }

}

fügen Sie diese Zeile in AndroidManifest.xml hinzu

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

enter image description here

3
Sudip Das

Dies ermöglicht das Senden von Kurzmitteilungen über eine vorhandene App. phoneNumber - ist String. Wenn Sie keine Telefonnummer angeben möchten, verwenden Sie die leere Zeichenfolge "".

Intent sendIntent = new Intent(Intent.ACTION_SENDTO, Uri.fromParts("smsto", phoneNumber, null));
sendIntent.putExtra("sms_body", "text message");
startActivity(sendIntent);
3
divonas

Senden SMS von KitKat und höher: - Fügen Sie diese Berechtigung in Ihr AndroidManifest.xml hinzu

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

Sie sollten auch die Laufzeitberechtigung für Marshmallow und Above Version implementieren müssen.

AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:Android="http://schemas.Android.com/apk/res/Android"
    package="com.defaultmessanginggit">

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

    <application
        Android:allowBackup="true"
        Android:icon="@mipmap/ic_launcher"
        Android:label="@string/app_name"
        Android:roundIcon="@mipmap/ic_launcher_round"
        Android:supportsRtl="true"
        Android:theme="@style/AppTheme">
        <activity
            Android:name=".ConversationListActivity"
            Android:label="@string/app_name" >
            <intent-filter>
                <action Android:name="Android.intent.action.MAIN" />

                <category Android:name="Android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <activity
            Android:name=".ComposeSMSActivity"
            Android:label="@string/title_activity_compose_sms" >
        </activity>
    </application>

</manifest>

Der Code, der unten angegeben wird: -

activity_conversation_list.xml

<LinearLayout xmlns:Android="http://schemas.Android.com/apk/res/Android"
    Android:layout_width="match_parent"
    Android:layout_height="match_parent"
    xmlns:tools="http://schemas.Android.com/tools"
    Android:orientation="vertical">

    <Button
        Android:id="@+id/btn_send_msg"
        Android:layout_width="wrap_content"
        Android:layout_height="wrap_content"
        Android:text="Message" />
</LinearLayout> 

ConversationListActivity.Java

public class ConversationListActivity extends FragmentActivity {

    /**
     * Whether or not the activity is in two-pane mode, i.e. running on a tablet
     * device.
     */
    private int PERMISSIONS_REQUEST_RECEIVE_SMS = 130;
    private Button btn_send_sms;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_conversation_list);

        btn_send_sms = (Button) findViewById(R.id.btn_send_msg);

        btn_send_sms.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {

                int hasSendSMSPermission = 0;
                if (Android.os.Build.VERSION.SDK_INT >= Android.os.Build.VERSION_CODES.M) {
                    hasSendSMSPermission = checkSelfPermission(Manifest.permission.SEND_SMS);
                    if (hasSendSMSPermission != PackageManager.PERMISSION_GRANTED) {
                        requestPermissions(new String[]{Manifest.permission.SEND_SMS},
                                PERMISSIONS_REQUEST_RECEIVE_SMS);
                    } else if (hasSendSMSPermission == PackageManager.PERMISSION_GRANTED) {
                        Intent intent = new Intent(ConversationListActivity.this, ComposeSMSActivity.class);
                        startActivity(intent);
                    }
                }else{
                    Intent intent = new Intent(ConversationListActivity.this, ComposeSMSActivity.class);
                    startActivity(intent);
                }
            }
        });
    }
}

Dies ist der Code für das SMS-Layout und zum Senden von SMS: -

activity_compose_sms.xml

<LinearLayout xmlns:Android="http://schemas.Android.com/apk/res/Android"
    Android:layout_width="match_parent"
    Android:layout_height="match_parent"
    Android:orientation="vertical">

    <FrameLayout xmlns:Android="http://schemas.Android.com/apk/res/Android"
        xmlns:tools="http://schemas.Android.com/tools"
        Android:id="@+id/container"
        Android:layout_width="match_parent"
        Android:layout_height="match_parent"
        tools:ignore="MergeRootFrame" />
</LinearLayout>

fragment_compose_sms.xml

<RelativeLayout xmlns:Android="http://schemas.Android.com/apk/res/Android"
    xmlns:tools="http://schemas.Android.com/tools"
    Android:layout_width="match_parent"
    Android:layout_height="match_parent"
    Android:paddingLeft="16dp"
    Android:paddingRight="16dp"
    Android:paddingTop="16dp"
    Android:paddingBottom="16dp">

    <LinearLayout
        Android:orientation="vertical"
        Android:layout_width="fill_parent"
        Android:layout_height="fill_parent"
        Android:layout_alignParentTop="true"
        Android:layout_alignParentStart="true">

        <LinearLayout
            Android:orientation="horizontal"
            Android:layout_width="match_parent"
            Android:layout_height="wrap_content">

            <TextView
                Android:layout_width="wrap_content"
                Android:layout_height="wrap_content"
                Android:text="@string/compose_to"
                Android:id="@+id/textView"
                Android:layout_gravity="center_vertical" />

            <EditText
                Android:layout_width="wrap_content"
                Android:layout_height="wrap_content"
                Android:inputType="phone"
                Android:ems="10"
                Android:id="@+id/composeEditTextTo" />
        </LinearLayout>

        <LinearLayout
            Android:orientation="horizontal"
            Android:layout_width="match_parent"
            Android:layout_height="wrap_content">
            <TextView
                Android:layout_width="wrap_content"
                Android:layout_height="wrap_content"
                Android:text="@string/compose_message"
                Android:id="@+id/textView2"
                Android:layout_gravity="center_vertical" />

            <EditText
                Android:layout_width="wrap_content"
                Android:layout_height="wrap_content"
                Android:inputType="textMultiLine"
                Android:ems="10"
                Android:id="@+id/composeEditTextMessage"
                Android:layout_weight="1" />

        </LinearLayout>

        <LinearLayout
            Android:orientation="horizontal"
            Android:layout_width="match_parent"
            Android:layout_height="wrap_content">

            <Button
                Android:layout_width="wrap_content"
                Android:layout_height="wrap_content"
                Android:text="@string/compose_cancel"
                Android:id="@+id/composeButtonCancel" />

            <Button
                Android:layout_width="wrap_content"
                Android:layout_height="wrap_content"
                Android:text="@string/compose_send"
                Android:id="@+id/composeButtonSend" />
        </LinearLayout>

        <LinearLayout
            Android:orientation="vertical"
            Android:layout_width="match_parent"
            Android:layout_height="wrap_content"
            Android:paddingTop="10dp"
            Android:id="@+id/composeNotDefault"
            Android:visibility="invisible">

            <TextView
                Android:layout_width="wrap_content"
                Android:layout_height="wrap_content"
                Android:textAppearance="?android:attr/textAppearanceMedium"
                Android:text="@string/compose_not_default"
                Android:id="@id/composeNotDefault" />

            <Button
                Android:layout_width="wrap_content"
                Android:layout_height="wrap_content"
                Android:text="@string/compose_set_default"
                Android:id="@+id/composeButtonSetDefault" />
        </LinearLayout>


    </LinearLayout>
</RelativeLayout>

ComposeSMSActivity.Java

public class ComposeSMSActivity extends Activity {

    Activity mActivity;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_compose_sms);

        mActivity = this;

        if (savedInstanceState == null) {
            getFragmentManager().beginTransaction()
                    .add(R.id.container, new PlaceholderFragment())
                    .commit();
        }

        getActionBar().setDisplayHomeAsUpEnabled(true);

    }

    public static class PlaceholderFragment extends Fragment {

        public PlaceholderFragment() {
        }

        @Override
        public View onCreateView(LayoutInflater inflater, ViewGroup container,
                                 Bundle savedInstanceState) {
            final View rootView = inflater.inflate(R.layout.fragment_compose_sms, container, false);

            rootView.findViewById(R.id.composeButtonCancel).setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    NavUtils.navigateUpTo(getActivity(), new Intent(getActivity(), ConversationListActivity.class));
                }
            });

            rootView.findViewById(R.id.composeButtonSend).setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    String recipient = ((TextView) rootView.findViewById(R.id.composeEditTextTo)).getText().toString();
                    String message = ((TextView) rootView.findViewById(R.id.composeEditTextMessage)).getText().toString();

                    SmsManager smsManager = SmsManager.getDefault();
                    smsManager.sendTextMessage(recipient, "ME", message, null, null);
                }
            });

            return rootView;
        }
    }
}

Das ist es.

2
Shubham Sejpal

Das einzige, was bei mir funktioniert hat, ist:

Intent sendIntent = new Intent(Intent.ACTION_SENDTO, Uri.parse("smsto:"+phone_number));
sendIntent.putExtra("sms_body", message);
startActivity(sendIntent);
0
Manav Patadia

Sie können dies verwenden, um eine SMS an eine beliebige Nummer zu senden:

 public void sendsms(View view) {
        String phoneNumber = "+880xxxxxxxxxx";
        String message = "Welcome to sms";
        Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse("sms:" + phoneNumber));
        intent.putExtra("sms_body", message);
        startActivity(intent);
    }
0
Selim Raza