Afficher la vue composée SMS dans Android
Je veux envoyer un SMS avec Android.
Quelle est l'intention de SMS envoyer?
Je souhaite afficher la vue Composer SMS avec mon texte prédéfini en passant dans le champ du message.
Vous pouvez utiliser le code suivant:
startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse("sms:"
+ phoneNumber)));
Assurez-vous de définir phoneNumber sur le numéro de téléphone auquel vous souhaitez envoyer le message
Vous pouvez ajouter un message au SMS avec (à partir de commentaires):
Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse("sms:" + phoneNumber));
intent.putExtra("sms_body", message);
startActivity(intent);
Cela a fonctionné pour moi.
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);
}
Vous pouvez ajouter cette ligne dans AndroidManifest.xml
<uses-permission Android:name="Android.permission.SEND_SMS"/>
Jetez un oeil à this
Cela peut être utile pour vous.
Essayez le code ci-dessous puis appelez sendSMS("99999999999", "message"); pour envoyer un SMS au numéro souhaité.
//---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);
}
Veuillez placer l'autorisation suivante dans le fichier AndroidManifest.xml.
<uses-permission Android:name="Android.permission.SEND_SMS"/>
J'espère que cela pourrait aider.
Mise à jour Extrait du commentaire: DummyClasshere.class est une activité qui ne nécessite aucun processus ni la classe dans laquelle vous devez naviguer.
Vous pouvez utiliser Object.class à la place de DummyClasshere.class.
Cela fonctionnera certainement. En cela, envoyez un message sans utiliser d’intention.
SmsManager smsManager = SmsManager.getDefault();
smsManager.sendTextMessage("Phone Number", null, "Message", null, null);
Ce code est utilisé pour envoyer un message en arrière-plan (ne montrant pas le composeur de message), Il peut également fonctionner à l'intérieur du récepteur de diffusion . Si vous souhaitez envoyer un message à partir du récepteur de diffusion.
<uses-permission Android:name="Android.permission.SEND_SMS"/>
J'espère que ce code vous aide :)
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); */
}
}
Dans Android, nous avons la classe SmsManager qui gère SMS des opérations telles que l'envoi de données, le texte et pdu SMS messages. Obtenez cet objet en appelant la méthode statique SmsManager.getDefault ().
Consultez le lien suivant pour obtenir l'exemple de code d'envoi de SMS:
article sur l'envoi et la réception de SMS messages sous Android
J'ajoute ma méthode SMS si elle peut aider quelqu'un. Faites attention avec smsManager.sendTextMessage, si le texte est trop long, le message ne disparaît pas. Vous devez respecter la longueur maximale en fonction du codage. Plus d'informations ici SMS Manager envoie un message à plusieurs participants lorsqu'il y a moins de 160 caractères
// UTILISER EveryWhere
SMSUtils.sendSMS(context, phoneNumber, message);
//Manifeste
<!-- 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);
}
}
String phoneNumber = "0123456789";
String message = "Hello World!";
SmsManager smsManager = SmsManager.getDefault();
smsManager.sendTextMessage(phoneNumber, null, message, null, null);
Incluez l'autorisation suivante dans votre fichier AndroidManifest.xml
<uses-permission Android:name="Android.permission.SEND_SMS" />
Une partie de ce qui est expliqué ci-dessus est uniquement destinée à placer un SMS dans un état "prêt à être lancé". comme Senthil Mg a dit que vous pouvez utiliser sms manager pour envoyer le sms directement mais SMSManager a été déplacé vers Android.telephony.SmsManager
Je sais que ce n'est pas beaucoup de plus d'infos, mais cela pourrait aider quelqu'un un jour.
J'espère que cela peut vous aider ...
Nom de fichier = 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;
}
}
ajouter cette ligne dans AndroidManifest.xml
<uses-permission Android:name="Android.permission.SEND_SMS" />
Cela permet d'envoyer un message texte via l'application existante. Numéro de téléphone - est fort. Si vous ne souhaitez pas spécifier de numéro de téléphone, utilisez une chaîne vide "".
Intent sendIntent = new Intent(Intent.ACTION_SENDTO, Uri.fromParts("smsto", phoneNumber, null));
sendIntent.putExtra("sms_body", "text message");
startActivity(sendIntent);
Envoyez SMS à partir de KitKat et au-dessus: - Ajoutez cette permission dans votre AndroidManifest.xml
<uses-permission Android:name="Android.permission.SEND_SMS"/>
Vous devriez également avoir à implémenter le autorisation d'exécution pour Marshmallow et la version ci-dessus.
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>
Le code qui sera donné ci-dessous: -
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);
}
}
});
}
}
Ceci est le code pour la mise en page sms et pour l'envoi de 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;
}
}
}
C'est ça.
La seule chose qui a fonctionné pour moi est:
Intent sendIntent = new Intent(Intent.ACTION_SENDTO, Uri.parse("smsto:"+phone_number));
sendIntent.putExtra("sms_body", message);
startActivity(sendIntent);
Vous pouvez utiliser cela pour envoyer des sms à n’importe quel numéro:
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);
}