Invio di messaggi tramite WhatsApp

Dato che ho trovato alcuni post più vecchi, che dicono che whatsapp non lo supporta, mi chiedevo se qualcosa fosse cambiato e se c'è un modo per aprire una "chat" di whatsapp con un numero che sto inviando attraverso un intento?

AGGIORNAMENTO Fare riferimento a https://faq.whatsapp.com/en/android/26000030/?category=5245251

La funzione Click to Chat di WhatsApp ti consente di iniziare una chat con qualcuno senza che il suo numero di telefono sia salvato nella rubrica del telefono. Finché conosci il numero di telefono di questa persona, puoi creare un collegamento che ti consentirà di avviare una chat con loro.

Usa: https://wa.me/15551234567

Non utilizzare: https://wa.me/+001-(555)1234567

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

Risposta originale Ecco la soluzione

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

}

Vedi anche http://www.whatsapp.com/faq/en/android/28000012

Con questo codice puoi aprire la chat di whatsapp con il numero indicato.

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

Ho trovato la seguente soluzione, per prima cosa avrai bisogno dell'ID whatsapp:

Corrispondendo ai rapporti di alcuni altri thread qui e in altri forum, il nome di accesso che ho trovato era una sorta di: prefisso internazionale senza 0 o + all'inizio + numero di telefono senza il primo 0 + @ s.whatsapp.net

Ad esempio, se vivi nei Paesi Bassi e hai il numero di telefono 0612325032, sarebbe 31612325023@s.whatsapp.net -> +31 per i Paesi Bassi senza 0 o + e il numero di telefono senza 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);
    }

}

Questo dovrebbe funzionare indipendentemente dal fatto che Whatsapp sia installato o meno.

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

Soluzione semplice, prova questo.

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

Testato su Marshmallow S5 e funziona!

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

Questo aprirà una chat diretta con una persona, se whatsapp non è installato genererà un'eccezione , se il numero di telefono non è noto a whatsapp si offrirà di inviare un invito tramite sms o semplice messaggio sms

Il codice seguente viene utilizzato dall'app Google Now e NON funzionerà per altre applicazioni.

Sto scrivendo questo post perché mi fa arrabbiare il fatto che WhatsApp non consenta ad altri sviluppatori di inviare messaggi direttamente ad eccezione di Google.

E voglio che altri sviluppatori freelance sappiano che questo tipo di collaborazione è in corso, mentre Google continua a parlare di "aperto a chiunque" e WhatsApp dice che non vogliono fornire alcun accesso agli sviluppatori.

Recentemente WhatsApp ha aggiunto un Intent appositamente per Google Now, che dovrebbe essere simile al seguente:

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

Potrei anche scoprire che "search_action_token" è un PendingIntent che contiene un IBinder-Object, che viene rimandato a Google App e controllato, se è stato creato da Google Now.

Altrimenti WhatsApp non accetterà il messaggio.

Attualmente, l'unica API ufficiale a cui puoi GETrichiedere:

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

Ad ogni modo, c'è un programma API segreto già eseguito da WhatsApp

usa questo codice a riga singola per inviare messaggi tramite 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
     }

Questo funziona per me:

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

Questo è ciò che ha funzionato per me :

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

Usa l'URL diretto di whatsapp

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

questo è un lavoro molto lungo ma scontroso. goditi il ​​tuo codice :)

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

}

Sono davvero in ritardo qui ma credo che oggigiorno abbiamo soluzioni più brevi e migliori per inviare messaggi tramite WhatsApp.

Puoi utilizzare quanto segue per chiamare il selettore di sistema, quindi scegliere quale app utilizzare per condividere ciò che desideri.

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

Se hai davvero bisogno di inviare tramite WhatsApp, tutto ciò che devi fare è quanto segue (salterai il selettore di sistema)

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

Se hai bisogno di maggiori informazioni puoi trovarle qui: FAQ di WhatsApp

Come dice la documentazione , puoi semplicemente usare un URL come:

https://wa.me/15551234567

Dove l'ultimo segmento è il numero nel formato 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)
}

Questo è un modo molto più semplice per ottenere ciò. Questo codice controlla se whatsapp è installato sul dispositivo. Se è installato, ignora il selettore di sistema e va al contatto su whatsapp e precampita il testo nella chat. Se non è installato, apre il collegamento whatsapp sul tuo browser web.

Ti consigliamo di utilizzare un URL nel seguente formato ...

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

Quindi puoi fare in modo che invii il testo che desideri. Hai anche la possibilità di specificare un numero di telefono ...

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

Quello che NON PUOI FARE è usare quanto segue:

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

Otterrete...

Non siamo riusciti a trovare la pagina che stavi cercando

wa.me, tuttavia, funzionerà se fornisci sia un numero di telefono che un testo. Ma, per la maggior parte, se stai cercando di creare un collegamento di condivisione, non vuoi davvero indicare il numero di telefono, perché vuoi che l'utente selezioni qualcuno. In tal caso, se non fornisci il numero e non lo usi wa.mecome URL, tutti i tuoi link di condivisione falliranno. Si prega di utilizzare app.whatsapp.com.

Controlla questo codice,

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

Questo funziona per me:

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

ottenere il numero di contatto a cui si desidera inviare il messaggio e creare uri per whatsapp, qui c è un cursore che restituisce il contatto selezionato.

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

Dalla documentazione

Per creare il tuo collegamento con un messaggio precompilato che apparirà automaticamente nel campo di testo di una chat, usa https://wa.me/whatsappphonenumber/?text=urlencodedtext dove whatsappphonenumber è un numero di telefono completo in formato internazionale e URL -encodedtext è il messaggio precompilato con codifica URL.

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

Esempio di codice

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)

La seguente API può essere utilizzata in c ++ come mostrato nel mio articolo .

È necessario definire diverse costanti:

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

//

Quindi ti connetti all'endpoint dell'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;
}

Quindi inviare sia l'intestazione che il corpo e attendere il risultato che deve essere "OK".

Passaggio 1: apri una richiesta 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;
}

Passaggio 2: invia l'intestazione:

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

Passaggio 3: inviare il messaggio:

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

Ora controlla il risultato:

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