Senden einer Nachricht über WhatsApp

Da ich einige ältere Beiträge gefunden habe, die besagen, dass WhatsApp dies nicht unterstützt, habe ich mich gefragt, ob sich etwas geändert hat und ob es eine Möglichkeit gibt, einen WhatsApp-Chat mit einer Nummer zu öffnen, die ich absichtlich sende.

UPDATE Weitere Informationen finden Sie unter https://faq.whatsapp.com/de/android/26000030/?category=5245251

Mit der Click-to-Chat-Funktion von WhatsApp können Sie einen Chat mit jemandem beginnen, ohne dessen Telefonnummer im Adressbuch Ihres Telefons gespeichert zu haben. Solange Sie die Telefonnummer dieser Person kennen, können Sie einen Link erstellen, über den Sie einen Chat mit dieser Person starten können.

Verwenden Sie: https://wa.me/15551234567

Verwenden Sie nicht: https://wa.me/+001-(555)1234567

Beispiel: https://wa.me/15551234567?text=Ich bin% 20interessiert% 20in% 20your% 20car% 20for% 20sale

Ursprüngliche Antwort Hier ist die Lösung

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

}

Siehe auch http://www.whatsapp.com/faq/en/android/28000012

Mit diesem Code können Sie den WhatsApp-Chat mit der angegebenen Nummer öffnen.

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

Ich habe die folgende Lösung gefunden. Zuerst benötigen Sie die WhatsApp-ID:

Passend zu Berichten aus einigen anderen Threads hier und in anderen Foren war der Anmeldename, den ich gefunden habe, eine Art: internationale Vorwahl ohne die Nullen oder + am Anfang + Telefonnummer ohne die ersten 0 + @ s.whatsapp.net

Wenn Sie beispielsweise in den Niederlanden leben und die Telefonnummer 0612325032 haben, wäre dies 31612325023@s.whatsapp.net -> +31 für die Niederlande ohne die Nullen oder + und die Telefonnummer ohne die 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);
    }

}

Dies sollte funktionieren, unabhängig davon, ob Whatsapp installiert ist oder nicht.

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

Einfache Lösung, versuchen Sie dies.

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

Getestet auf Marshmallow S5 und es funktioniert!

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

Dadurch wird ein direkter Chat mit einer Person geöffnet. Wenn WhatsApp nicht installiert ist, wird eine Ausnahme ausgelöst. Wenn WhatsApp die Telefonnummer nicht kennt, bietet sie an, eine Einladung per SMS oder einfacher SMS-Nachricht zu senden

Der folgende Code wird von der Google Now App verwendet und funktioniert NICHT für andere Anwendungen.

Ich schreibe diesen Beitrag, weil es mich wütend macht, dass WhatsApp keinem anderen Entwickler erlaubt, Nachrichten direkt zu senden, außer Google.

Und ich möchte, dass andere freiberufliche Entwickler wissen, dass diese Art der Zusammenarbeit stattfindet, während Google immer wieder von "Offen für jedermann" spricht und WhatsApp sagt, dass sie Entwicklern keinen Zugriff gewähren möchten.

Vor kurzem hat WhatsApp eine Absicht speziell für Google Now hinzugefügt, die wie folgt aussehen sollte:

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", ?????);

Ich konnte auch herausfinden, dass "search_action_token" ein PendingIntent ist, der ein IBinder-Objekt enthält, das an Google App zurückgesendet und überprüft wird, ob es von Google Now erstellt wurde.

Andernfalls akzeptiert WhatsApp die Nachricht nicht.

Derzeit ist die einzige offizielle API , an die Sie eine GETAnfrage stellen können:

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

Wie auch immer, es gibt bereits ein geheimes API-Programm, das von WhatsApp ausgeführt wird

Verwenden Sie diesen Singleline-Code, um Nachrichten über WhatsApp zu senden

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

Das funktioniert bei mir:

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

Das hat bei mir funktioniert:

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

Verwenden Sie die direkte URL von WhatsApp

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

Das ist viel langwierig, funktioniert aber mürrisch. Viel Spaß mit deinem 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();

}

Ich bin sehr spät hier, aber ich glaube, dass wir heutzutage kürzere und bessere Lösungen haben, um Nachrichten über WhatsApp zu senden.

Sie können die Systemauswahl wie folgt aufrufen und dann auswählen, mit welcher App Sie alles teilen möchten, was Sie möchten.

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

Wenn Sie wirklich über WhatsApp senden müssen, müssen Sie nur Folgendes tun (Sie überspringen die Systemauswahl).

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

Wenn Sie weitere Informationen benötigen, finden Sie diese hier: WhatsApp-FAQ

Wie in der Dokumentation angegeben , können Sie einfach eine URL verwenden wie:

https://wa.me/15551234567

Wobei das letzte Segment die Nummer im E164-Format ist

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

Dies ist ein viel einfacherer Weg, um dies zu erreichen. Dieser Code prüft, ob WhatsApp auf dem Gerät installiert ist. Wenn es installiert ist, umgeht es die Systemauswahl und geht zum Kontakt auf WhatsApp und füllt den Text im Chat vor. Wenn nicht installiert, wird der WhatsApp-Link in Ihrem Webbrowser geöffnet.

Sie möchten eine URL im folgenden Format verwenden ...

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

Dann können Sie den gewünschten Text senden lassen. Sie haben auch die Möglichkeit, eine Telefonnummer anzugeben ...

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

Was Sie nicht tun können, ist Folgendes zu verwenden:

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

Sie erhalten...

Wir konnten die gesuchte Seite nicht finden

wa.meDies funktioniert jedoch, wenn Sie sowohl eine Telefonnummer als auch einen Text angeben. Wenn Sie jedoch versuchen, einen Freigabelink zu erstellen, möchten Sie zum größten Teil die Telefonnummer nicht angeben, da der Benutzer jemanden auswählen soll. Wenn Sie in diesem Fall die Nummer nicht angeben und wa.meals URL verwenden, schlagen alle Ihre Freigabelinks fehl. Bitte benutzen app.whatsapp.com.

Überprüfen Sie diesen 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)));
}

Das funktioniert bei mir:

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

Rufen Sie die Kontaktnummer ab, an die Sie die Nachricht senden möchten, und erstellen Sie eine URL für WhatsApp. Hier ist c ein Cursor, der den ausgewählten Kontakt zurückgibt.

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

Aus der Dokumentation

Verwenden Sie https://wa.me/whatsappphonenumber/?text=urlencodedtext, um einen eigenen Link mit einer vorab ausgefüllten Nachricht zu erstellen, die automatisch im Textfeld eines Chats angezeigt wird. Dabei handelt es sich bei whatsappphonenumber um eine vollständige Telefonnummer im internationalen Format und mit der URL -encodedtext ist die URL-codierte vorgefüllte Nachricht.

Beispiel: https://wa.me/15551234567?text=Ich bin% 20interessiert% 20in% 20your% 20car% 20for% 20sale

Codebeispiel

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)

Die folgende API kann in c ++ verwendet werden, wie in meinem Artikel gezeigt .

Sie müssen mehrere Konstanten definieren:

//
#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"

//

Anschließend stellen Sie eine Verbindung zum Endpunkt der API her.

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

Senden Sie dann sowohl den Header als auch den Body und warten Sie auf das Ergebnis, das "OK" sein muss.

Schritt 1 - Öffnen Sie eine HTTP-Anfrage:

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

Schritt 2 - Senden Sie den Header:

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

Schritt 3 - Senden Sie die Nachricht:

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

Überprüfen Sie jetzt einfach das Ergebnis:

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