por - ¿Cómo enviar y recibir mensajes de texto desde la aplicación de Android?

pagina para enviar mensajes de texto gratis a celulares

Question

Deseo agregar la función de envío de sms en mi aplicación y también quiero una opción en la que el usuario pueda seleccionar los contactos de la lista de contactos directamente desde la aplicación. ¿Hay alguna forma de que la lista de contactos se pueda integrar con mi aplicación?

Gracias

Answer 1

Aquí hay un enlace con información sobre cómo cargar los contactos en su aplicación: http://developer.android.com/guide/topics/providers/content-providers.html

Espero que esto es lo que estás buscando.

Answer 2

Pruebe este tutorial para enviar SMS. Espero que esto ayude.

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

Agregue el siguiente método en su archivo de actividad en el que debe implementar la funcionalidad "enviar 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();
}
}

Tendrá que importar android.telephony.SmsManager para implementar el método sendSMSMessage.

Agregue un botón al diseño xml de su actividad y llame al método sendSMSMessage en el evento Click del botón.

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

En su Manifest.xml, agregue el siguiente permiso.

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

Answer 3

Y aquí hay un tutorial que muestra paso a paso cómo enviar SMS desde una aplicación de Android.

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

¡La respuesta de Hope Androider y mi respuesta completa!

ACTUALIZACIÓN: dado que el enlace de arriba ahora se ha extinguido:

Descargo de responsabilidad: no he escrito el artículo original. Solo estoy copiando aquí. El autor original según el artículo era weimenglee . Estoy copiando el artículo aquí porque después de publicar el enlace original hace algunos años, el enlace ahora está muerto.

Cómo enviar SMS

Para comenzar, primero inicie Eclipse y cree un nuevo proyecto de Android. Nombre el proyecto como se muestra en la Figura 1.

Android usa una política basada en permisos donde todos los permisos necesarios para una aplicación deben especificarse en el archivo AndroidManifest.xml . Al hacerlo, cuando se instala la aplicación, será claro para el usuario qué permisos de acceso específicos requiere la aplicación. Por ejemplo, el envío de mensajes SMS puede generar un costo adicional para el usuario, lo que indica que los permisos de SMS en el archivo AndroidManifest.xml le permitirán al usuario decidir si permite la instalación de la aplicación o no.

En el archivo AndroidManifest.xml , agregue los dos permisos: SEND_SMS y 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>

En el archivo main.xml ubicado en la carpeta res/layout , agregue el siguiente código para que el usuario pueda ingresar un número de teléfono y un mensaje para enviar:

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

El código anterior crea la interfaz de usuario que se muestra en la Figura 2.

A continuación, en la actividad SMS, conectamos la vista Button para que cuando el usuario haga clic en ella, verifiquemos que se ingrese el número de teléfono del destinatario y el mensaje antes de enviar el mensaje usando la función sendSMS() , que definiremos en breve:

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 función sendSMS() se define de la siguiente manera:

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

Para enviar un mensaje SMS, usa la clase SmsManager . A diferencia de otras clases, no instancia directamente esta clase; en su lugar, llamará al método estático getDefault() para obtener un objeto SmsManager . El método sendTextMessage() envía el mensaje SMS con un PendingIntent .

El objeto PendingIntent se usa para identificar un objetivo para invocar en un momento posterior. Por ejemplo, después de enviar el mensaje, puede usar un objeto PendingIntent para mostrar otra actividad. En este caso, el objeto PendingIntent (pi) simplemente apunta a la misma actividad ( SMS.java ), por lo que cuando se envíe el SMS, no ocurrirá nada.

Si necesita supervisar el estado del proceso de envío de mensajes SMS, puede utilizar dos objetos PendingIntent junto con dos objetos BroadcastReceiver , como este:

// --- envía un mensaje SMS a otro dispositivo --- private void sendSMS (String phoneNumber, String message) {
String SENT = "SMS_SENT"; Cadena ENTREGADA = "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);

}

El código anterior usa un objeto PendingIntent (sentPI) para monitorear el proceso de envío. Cuando se envía un mensaje SMS, se activará el primer evento onReceive de BroadcastReceiver. Aquí es donde verifica el estado del proceso de envío. El segundo objeto PendingIntent (deliveredPI) supervisa el proceso de entrega. El segundo evento onReceive de BroadcastReceiver se onReceive cuando se entregue un SMS correctamente.

Ahora puede probar la aplicación presionando F11 en Eclipse. Para enviar un mensaje SMS de una instancia de emulador a otra, simplemente inicie otra instancia del emulador de Android yendo a la carpeta Herramientas del SDK y ejecutando Emulator.exe .

La Figura 3 muestra cómo puede enviar un mensaje SMS de un emulador a otro; simplemente use el número de puerto del emulador de destino (que se muestra en la esquina superior izquierda de la ventana) como su número de teléfono. Cuando un SMS se envía con éxito, mostrará un mensaje de "SMS enviado". Cuando se entregue con éxito, mostrará un mensaje de "SMS entregado". Tenga en cuenta que para las pruebas con el emulador, cuando un SMS se entrega correctamente, el mensaje "SMS entregado" no aparece; esto solo funciona para dispositivos reales.

La Figura 4 muestra el mensaje SMS recibido en el emulador de destinatarios. El mensaje apareció primero en la barra de notificaciones (parte superior de la pantalla). Al arrastrar hacia abajo la barra de notificaciones, se muestra el mensaje recibido. Para ver el mensaje completo, haga clic en el mensaje.

Si no quiere pasar por todas las molestias de enviar el mensaje SMS usted mismo, puede usar un objeto Intent para ayudarlo a enviar un mensaje SMS. El siguiente código muestra cómo puede invocar la aplicación de SMS integrada para ayudarlo a enviar un mensaje 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 Figura 5 muestra la aplicación de SMS incorporada invocada para enviar el mensaje SMS.

Recibir mensajes SMS

Además de enviar mensajes SMS mediante programación, también puede interceptar los mensajes SMS entrantes utilizando un objeto BroadcastReceiver .

Para ver cómo recibir mensajes SMS desde su aplicación Android, en el archivo AndroidManifest.xml agregue el elemento para que los mensajes SMS entrantes puedan ser interceptados por la clase 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>

Agregue un nuevo archivo de clase a su proyecto y asígnele el nombre SmsReceiver.java (consulte la Figura 6).

En la clase SmsReceiver, amplíe la clase BroadcastReceiver y anule el método 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)
{
}
}

Cuando se reciben mensajes SMS, se onCreate() método onCreate() . El mensaje SMS está contenido y se adjunta al objeto Intent (intención - el segundo parámetro en el método onReceive() ) a través de un objeto Bundle . Los mensajes se almacenan en una matriz de objetos en formato PDU. Para extraer cada mensaje, utiliza el createFromPdu() estático createFromPdu() de la clase SmsMessage . El mensaje SMS se muestra con la clase 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();
}
}
}

¡Eso es! Para probar la aplicación, presione F11 en Eclipse. Implementa la aplicación en cada emulador de Android. La Figura 7 muestra Eclipse que muestra los emuladores actualmente en ejecución. Todo lo que necesita hacer es seleccionar cada emulador e implementar la aplicación en cada uno.

La Figura 8 muestra que cuando envía un mensaje SMS a otra instancia de emulador (número de puerto 5556), el emulador de destino recibe el mensaje y se muestra a través de la clase Toast.