Envoi de message via WhatsApp

Depuis que j'ai trouvé des messages plus anciens, qui disent que WhatsApp ne prend pas en charge cela, je me demandais si quelque chose avait changé et s'il y avait un moyen d'ouvrir un `` chat '' WhatsApp avec un numéro que j'envoie via une intention?

MISE À JOUR Veuillez vous référer à https://faq.whatsapp.com/en/android/26000030/?category=5245251

La fonction Click to Chat de WhatsApp vous permet de commencer une conversation avec quelqu'un sans enregistrer son numéro de téléphone dans le carnet d'adresses de votre téléphone. Tant que vous connaissez le numéro de téléphone de cette personne, vous pouvez créer un lien qui vous permettra de démarrer une discussion avec elle.

Utilisez: https://wa.me/15551234567

N'utilisez pas: https://wa.me/+001-(555)1234567

Exemple: https://wa.me/15551234567?text=I 'm% 20interested% 20in% 20your% 20car% 20for% 20sale

Réponse originale Voici la solution

public void onClickWhatsApp(View view) {

    PackageManager pm=getPackageManager();
    try {

        Intent waIntent = new Intent(Intent.ACTION_SEND);
        waIntent.setType("text/plain");
        String text = "YOUR TEXT HERE";

        PackageInfo info=pm.getPackageInfo("com.whatsapp", PackageManager.GET_META_DATA);
        //Check if package exists or not. If not then code 
        //in catch block will be called
        waIntent.setPackage("com.whatsapp");

        waIntent.putExtra(Intent.EXTRA_TEXT, text);
        startActivity(Intent.createChooser(waIntent, "Share with"));

   } catch (NameNotFoundException e) {
        Toast.makeText(this, "WhatsApp not Installed", Toast.LENGTH_SHORT)
                .show();
   }  

}

Voir également http://www.whatsapp.com/faq/en/android/28000012

Avec ce code, vous pouvez ouvrir le chat WhatsApp avec le numéro donné.

void openWhatsappContact(String number) {
    Uri uri = Uri.parse("smsto:" + number);
    Intent i = new Intent(Intent.ACTION_SENDTO, uri);
    i.setPackage("com.whatsapp");  
    startActivity(Intent.createChooser(i, ""));
}

J'ai trouvé la solution suivante, vous aurez d'abord besoin de l'identifiant WhatsApp:

Correspondant aux rapports de certains autres fils ici et dans d'autres forums, le nom de connexion que j'ai trouvé était une sorte de: indicatif régional international sans les 0 ou + au début + numéro de téléphone sans le premier 0 + @ s.whatsapp.net

Par exemple, si vous habitez aux Pays-Bas et que vous avez le numéro de téléphone 0612325032, ce serait 31612325023@s.whatsapp.net -> +31 pour les Pays-Bas sans les 0 ou + et le numéro de téléphone sans le 0.

public void sendWhatsAppMessageTo(String whatsappid) {

Cursor c = getSherlockActivity().getContentResolver().query(ContactsContract.Data.CONTENT_URI,
        new String[] { ContactsContract.Contacts.Data._ID }, ContactsContract.Data.DATA1 + "=?",
        new String[] { whatsappid }, null);
c.moveToFirst();

Intent whatsapp = new Intent(Intent.ACTION_VIEW, Uri.parse("content://com.android.contacts/data/" + c.getString(0)));
c.close();

 if (whatsapp != null) {

startActivity(whatsapp);      

} else {
        Toast.makeText(this, "WhatsApp not Installed", Toast.LENGTH_SHORT)
                .show();
//download for example after dialog
                Uri uri = Uri.parse("market://details?id=com.whatsapp");
                Intent goToMarket = new Intent(Intent.ACTION_VIEW, uri);
    }

}

Cela devrait fonctionner que Whatsapp soit installé ou non.

boolean isWhatsappInstalled = whatsappInstalledOrNot("com.whatsapp");
if (isWhatsappInstalled) {
    Uri uri = Uri.parse("smsto:" + "98*********7")
    Intent sendIntent = new Intent(Intent.ACTION_SENDTO, uri);
    sendIntent.putExtra(Intent.EXTRA_TEXT, "Hai Good Morning");
    sendIntent.setPackage("com.whatsapp");
    startActivity(sendIntent);
} else {
    Toast.makeText(this, "WhatsApp not Installed", Toast.LENGTH_SHORT).show();
    Uri uri = Uri.parse("market://details?id=com.whatsapp");
    Intent goToMarket = new Intent(Intent.ACTION_VIEW, uri);
    startActivity(goToMarket);

}

private boolean whatsappInstalledOrNot(String uri) {
    PackageManager pm = getPackageManager();
    boolean app_installed = false;
    try {
        pm.getPackageInfo(uri, PackageManager.GET_ACTIVITIES);
        app_installed = true;
    } catch (PackageManager.NameNotFoundException e) {
        app_installed = false;
    }
    return app_installed;
}

Solution simple, essayez ceci.

String phoneNumberWithCountryCode = "+62820000000";
String message = "Hallo";

startActivity(
    new Intent(Intent.ACTION_VIEW,
        Uri.parse(
            String.format("https://api.whatsapp.com/send?phone=%s&text=%s", phoneNumberWithCountryCode, message)
        )
    )
);

Testé sur Marshmallow S5 et ça marche!

    Uri uri = Uri.parse("smsto:" + "phone number with country code");
    Intent sendIntent = new Intent(Intent.ACTION_SENDTO, uri);
    sendIntent.setPackage("com.whatsapp");
    startActivity(sendIntent); 

Cela ouvrira une discussion directe avec une personne, si WhatsApp n'est pas installé, cela lèvera une exception , si le numéro de téléphone n'est pas connu de WhatsApp, ils proposeront d'envoyer une invitation par sms ou un simple message SMS

Le code suivant est utilisé par l'application Google Now et ne fonctionnera PAS pour aucune autre application.

J'écris ce post parce que cela me met en colère, que WhatsApp n'autorise aucun autre développeur à envoyer des messages directement à l'exception de Google.

Et je veux que les autres développeurs indépendants sachent que ce type de coopération est en cours, alors que Google continue de parler de "ouvert à tout le monde" et que WhatsApp dit qu'ils ne veulent pas donner accès aux développeurs.

Récemment, WhatsApp a ajouté une intention spécialement pour Google Now, qui devrait ressembler à ceci:

Intent intent = new Intent("com.google.android.voicesearch.SEND_MESSAGE_TO_CONTACTS");
intent.setPackage("com.whatsapp");
intent.setComponent(new ComponentName("com.whatsapp", "com.whatsapp.VoiceMessagingActivity"));

intent.putExtra("com.google.android.voicesearch.extra.RECIPIENT_CONTACT_CHAT_ID", number);
intent.putExtra("android.intent.extra.TEXT", text);
intent.putExtra("search_action_token", ?????);

Je pourrais également découvrir que "search_action_token" est un PendingIntent qui contient un IBinder-Object, qui est renvoyé à Google App et vérifié, s'il a été créé par Google Now.

Sinon, WhatsApp n'acceptera pas le message.

Actuellement, la seule API officielle à laquelle vous pouvez faire une GETdemande:

https://api.whatsapp.com/send?phone=919773207706&text=Hello

Quoi qu'il en soit, il existe déjà un programme d'API secret exécuté par WhatsApp

utilisez ce code unique pour envoyer un message via WhatsApp

//NOTE : please use with country code first 2digits without plus signed
try {
      String mobile = "911234567890";
      String msg = "Its Working";
      startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse("https://api.whatsapp.com/send?phone=" + mobile + "&text=" + msg)));
      }catch (Exception e){
        //whatsapp app not install
     }

Cela fonctionne pour moi:

PackageManager pm = context.getPackageManager();
try {
    pm.getPackageInfo("com.whatsapp", PackageManager.GET_ACTIVITIES);
    Intent intent = new Intent();
            intent.setComponent(new ComponentName(packageName,
                    ri.activityInfo.name));
            intent.setType("text/plain");
            intent.putExtra(Intent.EXTRA_TEXT, element);

} catch (NameNotFoundException e) {
    ToastHelper.MakeShortText("Whatsapp have not been installed.");
}

C'est ce qui a fonctionné pour moi :

        Uri uri = Uri.parse("https://api.whatsapp.com/send?phone=" + "<number>" + "&text=" + "Hello WhatsApp!!");
        Intent sendIntent = new Intent(Intent.ACTION_VIEW, uri);
        startActivity(sendIntent);

Utilisez l'URL directe de WhatsApp

String url = "https://api.whatsapp.com/send?phone="+number;
Intent i = new Intent(Intent.ACTION_VIEW);
i.setData(Uri.parse(url));
startActivity(i);

c'est beaucoup de travail mais dur. profitez de votre code :)

 //method used to show IMs
private void show_custom_chooser(String value) {
    List<ResolveInfo> list = null;
    final Intent email = new Intent(Intent.ACTION_SEND);
    email.setData(Uri.parse("sms:"));
    email.putExtra(Intent.EXTRA_TEXT, "" + value);
    email.setType("text/plain"); // vnd.android-dir/mms-sms

    WindowManager.LayoutParams WMLP = dialogCustomChooser.getWindow()
            .getAttributes();
    WMLP.gravity = Gravity.CENTER;
    dialogCustomChooser.getWindow().setAttributes(WMLP);
    dialogCustomChooser.getWindow().setBackgroundDrawable(
            new ColorDrawable(android.graphics.Color.TRANSPARENT));
    dialogCustomChooser.setCanceledOnTouchOutside(true);
    dialogCustomChooser.setContentView(R.layout.about_dialog);
    dialogCustomChooser.setCancelable(true);
    ListView lvOfIms = (ListView) dialogCustomChooser
            .findViewById(R.id.listView1);
    PackageManager pm = getPackageManager();
    List<ResolveInfo> launchables = pm.queryIntentActivities(email, 0);
    // ////////////new
    list = new ArrayList<ResolveInfo>();
    for (int i = 0; i < launchables.size(); i++) {
        String string = launchables.get(i).toString();
        Log.d("heh", string);
//check only messangers
        if (string.contains("whatsapp")) {
            list.add(launchables.get(i));
        }
    }
    Collections.sort(list, new ResolveInfo.DisplayNameComparator(pm));
    int size = launchables.size();
    adapter = new AppAdapter(pm, list, MainActivity.this);
    lvOfIms.setAdapter(adapter);
    lvOfIms.setOnItemClickListener(new OnItemClickListener() {
        @Override
        public void onItemClick(AdapterView<?> arg0, View arg1,
                int position, long arg3) {
            ResolveInfo launchable = adapter.getItem(position);
            ActivityInfo activity = launchable.activityInfo;
            ComponentName name = new ComponentName(
                    activity.applicationInfo.packageName, activity.name);
            email.addCategory(Intent.CATEGORY_LAUNCHER);
            email.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK
                    | Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED);
            email.setComponent(name);
            startActivity(email);
            dialogCustomChooser.dismiss();
        }
    });
    dialogCustomChooser.show();

}

Je suis vraiment en retard ici mais je crois que de nos jours, nous avons des solutions plus courtes et meilleures pour envoyer des messages via WhatsApp.

Vous pouvez utiliser ce qui suit pour appeler le sélecteur de système, puis choisir quelle application vous utiliserez pour partager ce que vous voulez.

Intent sendIntent = new Intent();
sendIntent.setAction(Intent.ACTION_SEND);
sendIntent.putExtra(Intent.EXTRA_TEXT, "This is my text to send.");
sendIntent.setType("text/plain");
startActivity(sendIntent);

Si vous avez vraiment besoin d'envoyer via WhatsApp, tout ce que vous avez à faire est ce qui suit (vous sauterez le sélecteur de système)

 Intent sendIntent = new Intent();
    sendIntent.setAction(Intent.ACTION_SEND);
    sendIntent.putExtra(Intent.EXTRA_TEXT, "This is my text to send.");
    sendIntent.setType("text/plain");
    // Put this line here
    sendIntent.setPackage("com.whatsapp");
    //
    startActivity(sendIntent);

Si vous avez besoin de plus d'informations, vous pouvez les trouver ici: FAQ WhatsApp

Comme le dit la documentation , vous pouvez simplement utiliser une URL comme:

https://wa.me/15551234567

Où le dernier segment est le nombre au format E164

Uri uri = Uri.parse("https://wa.me/15551234567");
Intent intent = new Intent(Intent.ACTION_VIEW, uri);
startActivity(intent);

private fun sendWhatsappMessage(phoneNumber:String, text:String) {        
  val url = if (Intent().setPackage("com.whatsapp").resolveActivity(packageManager) != null) {
        "whatsapp://send?text=Hello&phone=$phoneNumber"
    } else {
        "https://api.whatsapp.com/send?phone=$phoneNumber&text=$text"
    }

    val browserIntent = Intent(Intent.ACTION_VIEW, Uri.parse(url))
    startActivity(browserIntent)
}

C'est un moyen beaucoup plus simple d'y parvenir. Ce code vérifie si WhatsApp est installé sur l'appareil. S'il est installé, il contourne le sélecteur système et va au contact sur WhatsApp et pré-champ le texte dans le chat. S'il n'est pas installé, il ouvre le lien WhatsApp sur votre navigateur Web.

Vous voudrez utiliser une URL au format suivant ...

https://api.whatsapp.com/send?text=text

Ensuite, vous pouvez lui envoyer le texte de votre choix. Vous avez également la possibilité de spécifier un numéro de téléphone ...

https://api.whatsapp.com/send?text=text&phone=1234

Ce que vous NE POUVEZ PAS FAIRE, c'est utiliser ce qui suit:

https://wa.me/send?text=text

Tu auras...

Nous n'avons pas trouvé la page que vous recherchiez

wa.me, cependant, fonctionnera si vous fournissez à la fois un numéro de téléphone et un texte. Mais, pour la plupart, si vous essayez de créer un lien de partage, vous ne voulez vraiment pas indiquer le numéro de téléphone, car vous voulez que l'utilisateur sélectionne quelqu'un. Dans ce cas, si vous ne fournissez pas le numéro et ne l'utilisez pas wa.mecomme URL, tous vos liens de partage échoueront. Veuillez utiliser app.whatsapp.com.

Vérifiez ce code,

    public void share(String subject,String text) {
     final Intent intent = new Intent(Intent.ACTION_SEND);

String score=1000;
     intent.setType("text/plain");
     intent.putExtra(Intent.EXTRA_SUBJECT, score);
     intent.putExtra(Intent.EXTRA_TEXT, text);

     startActivity(Intent.createChooser(intent, getString(R.string.share)));
}

Cela fonctionne pour moi:

public static void shareWhatsApp(Activity appActivity, String texto) {

    Intent sendIntent = new Intent(Intent.ACTION_SEND);     
    sendIntent.setType("text/plain");
    sendIntent.putExtra(android.content.Intent.EXTRA_TEXT, texto);

    PackageManager pm = appActivity.getApplicationContext().getPackageManager();
    final List<ResolveInfo> matches = pm.queryIntentActivities(sendIntent, 0);
    boolean temWhatsApp = false;
    for (final ResolveInfo info : matches) {
      if (info.activityInfo.packageName.startsWith("com.whatsapp"))  {
          final ComponentName name = new ComponentName(info.activityInfo.applicationInfo.packageName, info.activityInfo.name);
          sendIntent.addCategory(Intent.CATEGORY_LAUNCHER);
          sendIntent.setFlags(Intent.FLAG_ACTIVITY_NO_HISTORY | Intent.FLAG_ACTIVITY_NEW_TASK);
          sendIntent.setComponent(name);
          temWhatsApp = true;
          break;
      }
    }               

    if(temWhatsApp) {
        //abre whatsapp
        appActivity.startActivity(sendIntent);
    } else {
        //alerta - você deve ter o whatsapp instalado
        Toast.makeText(appActivity, appActivity.getString(R.string.share_whatsapp), Toast.LENGTH_SHORT).show();
    }
}

obtenez le numéro de contact à qui vous souhaitez envoyer le message et créez un uri pour WhatsApp, ici c est un curseur renvoyant le contact sélectionné.

Uri.parse("content://com.android.contacts/data/" + c.getString(0)));
i.setType("text/plain");
i.setPackage("com.whatsapp");           // so that only Whatsapp reacts and not the chooser
i.putExtra(Intent.EXTRA_SUBJECT, "Subject");
i.putExtra(Intent.EXTRA_TEXT, "I'm the body.");
startActivity(i);

De la documentation

Pour créer votre propre lien avec un message pré-rempli qui apparaîtra automatiquement dans le champ de texte d'un chat, utilisez https://wa.me/whatsappphonenumber/?text=urlencodedtext où whatsappphonenumber est un numéro de téléphone complet au format international et URL -encodedtext est le message prérempli encodé en URL.

Exemple: https://wa.me/15551234567?text=I 'm% 20interested% 20in% 20your% 20car% 20for% 20sale

Exemple de code

val phoneNumber = "13492838472"
    val text = "Hey, you know... I love StackOverflow :)"
    val uri = Uri.parse("https://wa.me/$phoneNumber/?text=$text")
    val sendIntent = Intent(Intent.ACTION_VIEW, uri)
    startActivity(sendIntent)

L'API suivante peut être utilisée en c ++ comme indiqué dans mon article .

Vous devez définir plusieurs constantes:

//
#define    GroupAdmin                <YOUR GROUP ADMIN MOBILE PHONE>
#define GroupName                <YOUR GROUP NAME>
#define CLIENT_ID                <YOUR CLIENT ID>
#define CLIENT_SECRET            <YOUR CLIENT SECRET>

#define GROUP_API_SERVER        L"api.whatsmate.net"
#define GROUP_API_PATH          L"/v3/whatsapp/group/text/message/12"
#define IMAGE_SINGLE_API_URL    L"http://api.whatsmate.net/v3/whatsapp/group/image/message/12"

//

Ensuite, vous vous connectez au point de terminaison de l'API.

hOpenHandle = InternetOpen(_T("HTTP"), INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0);
if (hOpenHandle == NULL)
{
    return false;
}

hConnectHandle = InternetConnect(hOpenHandle,
    GROUP_API_SERVER,
    INTERNET_DEFAULT_HTTP_PORT,
    NULL, NULL, INTERNET_SERVICE_HTTP,
    0, 1);

if (hConnectHandle == NULL)
{
    InternetCloseHandle(hOpenHandle);
    return false;
}

Envoyez ensuite à la fois l'en-tête et le corps et attendez le résultat qui doit être «OK».

Étape 1 - Ouvrez une requête HTTP:

const wchar_t *AcceptTypes[] = { _T("application/json"),NULL };
HINTERNET hRequest = HttpOpenRequest(hConnectHandle, _T("POST"), GROUP_API_PATH, NULL, NULL, AcceptTypes, 0, 0);

if (hRequest == NULL)
{
    InternetCloseHandle(hConnectHandle);
    InternetCloseHandle(hOpenHandle);
    return false;
}

Étape 2 - Envoyez l'en-tête:

std::wstring HeaderData;

HeaderData += _T("X-WM-CLIENT-ID: ");
HeaderData += _T(CLIENT_ID);
HeaderData += _T("\r\nX-WM-CLIENT-SECRET: ");
HeaderData += _T(CLIENT_SECRET);
HeaderData += _T("\r\n");
HttpAddRequestHeaders(hRequest, HeaderData.c_str(), HeaderData.size(), NULL);

Étape 3 - Envoyez le message:

std::wstring WJsonData;
WJsonData += _T("{");
WJsonData += _T("\"group_admin\":\"");
WJsonData += groupAdmin;
WJsonData += _T("\",");
WJsonData += _T("\"group_name\":\"");
WJsonData += groupName;
WJsonData += _T("\",");
WJsonData += _T("\"message\":\"");
WJsonData += message;
WJsonData += _T("\"");
WJsonData += _T("}");

const std::string JsonData(WJsonData.begin(), WJsonData.end());

bResults = HttpSendRequest(hRequest, NULL, 0, (LPVOID)(JsonData.c_str()), JsonData.size());

Maintenant, vérifiez simplement le résultat:

TCHAR StatusText[BUFFER_LENGTH] = { 0 };
DWORD StatusTextLen = BUFFER_LENGTH;
HttpQueryInfo(hRequest, HTTP_QUERY_STATUS_TEXT, &StatusText, &StatusTextLen, NULL);
bResults = (StatusTextLen && wcscmp(StatusText, L"OK")==FALSE);