Mostrar la vista de componer SMS en Android


167

Quiero enviar un sms con Android.

¿Cuál es la intención del envío de SMS?

Quiero mostrar la vista de componer sms con mi texto predefinido pasando en el campo de mensaje.


1
Deberías leer este artículo para la historia completa.
Nguyen Minh Binh

¡Estoy haciendo algo similar AQUÍ! stackoverflow.com/questions/14452808/…
toobsco42

@ toobsco42: No, estás haciendo exactamente lo contrario. Usted está enviando SMS usted mismo y esta pregunta lo requiere a través de la aplicación estándar de SMS .
Jan Hudec

También puede admitir dispositivos Dual-Sim, consulte esto: stackoverflow.com/a/30677542/2267723
Maher Abuthraa

Este artículo explica fácilmente SMS / MMS en Android, proporciona simplemente un ejemplo de código para enviar SMS y recibir SMS: codeproject.com/Articles/1044639/…
Rou1997

Respuestas:


199

Puedes usar el siguiente código:

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

Asegúrese de establecer phoneNumberel número de teléfono al que desea enviar el mensaje

Puede agregar un mensaje al SMS con (de comentarios):

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

87
Gracias por tu código. y quiero agregar, ya que necesito poner mi texto predefinido. Obtuve esta solución Intent intent = new Intent (Intent.ACTION_VIEW, Uri.parse ("sms:" + phoneNumber)); intent.putExtra ("sms_body", mensaje); startActivity (intento);
DJ

1
¿Cómo configurar "phoneNumber" de la lista de contactos?
Saeed M.

@djk gracias quiero leer todos los contactos y quiero una página propia para enviar sms con autocompletar pero no puedo leer los contactos ¿algún buen tutorial?
Guru el

Usaría el widget de composición de sms predeterminado para hacerlo. solo deje el número de teléfono vacío (es opcional)
shem

1
Hola. Quiero enviar SMS a granel. como 10,000 sms enviados con un solo clic. Es posible ? Escuché que Android envía 30 sms cada 30 minutos. por
favor

151

Esto funcionó para mí.

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

Puede agregar esta línea en AndroidManifest.xml

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

Mira esto

Esto puede ser útil para usted.


11
La pregunta pide mostrar el SMS en la vista de redacción estándar. Esto es exactamente lo contrario, enviar SMS a espaldas del usuario, ¿no?
Jan Hudec

No puede enviar un mensaje si hay un apóstrofe en él.
loco

39

Pruebe el siguiente código y luego llame sendSMS("99999999999", "message");para enviar sms en el número deseado.

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

Coloque el siguiente permiso en el AndroidManifest.xmlarchivo.

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

Espero que esto pueda ayudar.

Actualización del comentario: DummyClasshere.class es una actividad sin hacer ningún proceso o la clase en la que necesita navegar.

Puede usar Object.class en lugar de DummyClasshere.class.


algo una actividad sin hacer ningún proceso. de lo contrario, la clase en la que necesita navegar ..
Senthil Mg

Solo uso new Intent()y eso lo hace.
Osmium USA

¿Cómo sabes si se envió un mensaje (sms)?
Ninja Coding

28

Esto definitivamente funcionará. En esto, envíe un mensaje sin usar ninguna intención.

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

Este código se utiliza para enviar mensajes en segundo plano (sin mostrar el compositor de mensajes) . También puede funcionar dentro del receptor de difusión . Si desea enviar un mensaje desde el receptor Broadcast.

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

1
+1. Trabajó para mi requerimiento. Pero me falta una cosa. Este mensaje no aparece en mis artículos enviados. ¿Por qué es así?
Tahir Akram

No hemos usado el proceso Inten predeterminado para el envío de SMS, solo estamos usando el Administrador de SMS. La intención se reunirá para mantener el registro del SmsManager.
Dwivedi Ji

Si. Esto es muy útil para mi. Pero el mensaje de confirmación dado después de enviar sms significa que podría ser mejor.
Gunaseelan

3
Solo recomendaría agregar este bloque en try-catch.
Tanveer Shaikh


10

Espero que este código te ayude :)

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

7

Agrego mi método de SMS si puede ayudar a alguien. Tenga cuidado con smsManager.sendTextMessage, si el texto es demasiado largo, el mensaje no desaparece. Debes respetar la longitud máxima dependiendo de la codificación. Más información aquí SMS Manager envía un mensaje mutlipart cuando hay menos de 160 caracteres

// PARA USAR EveryWhere

SMSUtils.sendSMS(context, phoneNumber, message);

//Manifiesto

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

    }
}

5
String phoneNumber = "0123456789";
String message = "Hello World!";

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

Incluya el siguiente permiso en su archivo AndroidManifest.xml

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

4

Parte de lo que se explica anteriormente está destinado solo para colocar un SMS en un estado 'listo para lanzar'. como dijo Senthil Mg, puede usar el administrador de sms para enviar el sms directamente, pero SMSManagerse ha movido aandroid.telephony.SmsManager

Sé que no es mucha más información, pero podría ayudar a alguien algún día.


La pregunta pide explícitamente NO enviar el SMS usted mismo.
Jan Hudec

3

Espero que esto pueda ayudarte ...

Nombre de archivo = 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;
  }

}

agregue esta línea en AndroidManifest.xml

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

ingrese la descripción de la imagen aquí


3

Esto permite enviar mensajes de texto a través de la aplicación existente. phoneNumber: es String. Si no desea especificar el número de teléfono, use la cadena vacía "".

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

2

Enviar SMS desde KitKat y superior: - AGREGAR este permiso en su AndroidManifest.xml

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

Debería tener que implementar también el permiso de tiempo de ejecución para Marshmallow y la versión anterior.

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>

El código que será el siguiente:

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

Este es el código para el diseño de sms y para enviar 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;
        }
    }
}

Eso es.


0

Puede usar esto para enviar sms a cualquier número:

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

1
Actualización: si usa Intent para enviar sms, no necesita el permiso android.permission.SEND_SMS.
Nafis Ahmad

0

Puede omitir el número de teléfono para permitir que el usuario solo elija entre los contactos, pero inserte su texto sms en el cuerpo. El código es para Xamarin Android:

    var uri = Uri.Parse("smsto:"); //append your number here for explicit nb
    var intent = new Intent(Intent.ActionSendto, uri);
    intent.PutExtra("sms_body", text);
    Context.StartActivity(intent);

dónde

El contexto es Xamarin.Essentials.Platform.CurrentActivity ?? Application.Context

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.