सेवा में ईमेल भेजें (उपयोगकर्ता को संकेत दिए बिना)

Question

क्या यह संभव है कि मैं सेवा का उपयोग करके पृष्ठभूमि में ईमेल भेजूं .. सेवा में जैसे मैं ACTION_SENDTO के साथ इरारी डेटा mailto: recipient_email के साथ इरादा का उपयोग करता हूं और इसे किसी भी उपयोगकर्ता हस्तक्षेप के बिना पृष्ठभूमि में भेजा जाता है .. या उपयोगकर्ता को संकेत दिए बिना डिफ़ॉल्ट ईमेल ऐप के माध्यम से ...

Answer 1

के लिए एक ट्यूटोरियल है सबसे अच्छा समाधान ईमेल भेजने के लिए जीमेल खाते का उपयोग कर रहा है।

सामान्यतया:

1. डाउनलोड mail.jar और activation.jar एंड्रॉयड https://code.google.com/p/javamail-android/
2. कनेक्ट के लिए जीमेल के लिए OAuth टोकन
3. ईमेल

यहाँ

पाने के लिए भेजें कोड है

import java.util.Properties; 

import javax.activation.DataHandler; 
import javax.mail.Message; 
import javax.mail.Session; 
import javax.mail.URLName; 
import javax.mail.internet.InternetAddress; 
import javax.mail.internet.MimeMessage; 
import javax.mail.util.ByteArrayDataSource; 

import android.accounts.Account; 
import android.accounts.AccountManager; 
import android.accounts.AccountManagerCallback; 
import android.accounts.AccountManagerFuture; 
import android.app.Activity; 
import android.os.Bundle; 
import android.os.StrictMode; 
import android.util.Log; 

import com.sun.mail.smtp.SMTPTransport; 
import com.sun.mail.util.BASE64EncoderStream; 

public class GMailSender { 
    private Session session; 
    private String token; 


    public String getToken() { 
     return token; 
    } 

    public GMailSender(Activity ctx) { 
     super(); 
     initToken(ctx); 
    } 

    public void initToken(Activity ctx) { 

     AccountManager am = AccountManager.get(ctx); 

     Account[] accounts = am.getAccountsByType("com.google"); 
     for (Account account : accounts) { 
      Log.d("getToken", "account="+account); 
     } 

     Account me = accounts[0]; //You need to get a google account on the device, it changes if you have more than one 


     am.getAuthToken(me, "oauth2:https://mail.google.com/", null, ctx, new AccountManagerCallback<Bundle>(){ 
      @Override 
      public void run(AccountManagerFuture<Bundle> result){ 
       try{ 
        Bundle bundle = result.getResult(); 
        token = bundle.getString(AccountManager.KEY_AUTHTOKEN); 
        Log.d("initToken callback", "token="+token);  

       } catch (Exception e){ 
        Log.d("test", e.getMessage()); 
       } 
      } 
     }, null); 

     Log.d("getToken", "token="+token); 
    } 



    public SMTPTransport connectToSmtp(String host, int port, String userEmail, 
      String oauthToken, boolean debug) throws Exception { 

     Properties props = new Properties(); 
     props.put("mail.smtp.starttls.enable", "true"); 
     props.put("mail.smtp.starttls.required", "true"); 
     props.put("mail.smtp.sasl.enable", "false"); 

     session = Session.getInstance(props); 
     session.setDebug(debug); 

     final URLName unusedUrlName = null; 
     SMTPTransport transport = new SMTPTransport(session, unusedUrlName); 
     // If the password is non-null, SMTP tries to do AUTH LOGIN. 
     final String emptyPassword = null; 

     /* enable if you use this code on an Activity (just for test) or use the AsyncTask 
     StrictMode.ThreadPolicy policy = new StrictMode.ThreadPolicy.Builder().permitAll().build(); 
     StrictMode.setThreadPolicy(policy); 
     */ 

     transport.connect(host, port, userEmail, emptyPassword); 

     byte[] response = String.format("user=%s\1auth=Bearer %s\1\1", 
       userEmail, oauthToken).getBytes(); 
     response = BASE64EncoderStream.encode(response); 

     transport.issueCommand("AUTH XOAUTH2 " + new String(response), 235); 

     return transport; 
    } 

    public synchronized void sendMail(String subject, String body, String user, 
      String oauthToken, String recipients) { 
     try { 

      SMTPTransport smtpTransport = connectToSmtp("smtp.gmail.com", 587, 
        user, oauthToken, true); 

      MimeMessage message = new MimeMessage(session); 
      DataHandler handler = new DataHandler(new ByteArrayDataSource(
        body.getBytes(), "text/plain")); 
      message.setSender(new InternetAddress(user)); 
      message.setSubject(subject); 
      message.setDataHandler(handler); 
      if (recipients.indexOf(',') > 0) 
       message.setRecipients(Message.RecipientType.TO, 
         InternetAddress.parse(recipients)); 
      else 
       message.setRecipient(Message.RecipientType.TO, 
         new InternetAddress(recipients)); 
      smtpTransport.sendMessage(message, message.getAllRecipients()); 

     } catch (Exception e) { 
      Log.d("test", e.getMessage(), e); 
     } 
    } 

} 

यह कोड मूल रूप से यहां पोस्ट किया गया था Javamail api in android using XOauth।

कृपया ध्यान दें कि ओएथ टोकन आपको एक गतिविधि की आवश्यकता है और आपको उस उपयोगकर्ता से पूछना है कि किस खाते का उपयोग करना है। ऑनक्रेट चरण के दौरान टोकन को पुनर्प्राप्त किया जाना चाहिए और वरीयताओं में सहेजा जाना चाहिए। यह भी देखें How to get the Android device's primary e-mail address

वैकल्पिक रूप से आप mail.jar का उपयोग कर सकते हैं लेकिन आपको उपयोगकर्ता को अपना उपयोगकर्ता नाम और पासवर्ड के लिए पूछना है।

Answer 2

फिर आपको इसे प्रोग्रामेटिक रूप से करने की आवश्यकता है। यहां http://nilvec.com/sending-email-without-user-interaction-in-android/

Answer 3

एंड्रॉयड में

संदेश ई-मेल एक नमूना परियोजना बनाने के लिए जीमेल प्रमाणीकरण

कदम का उपयोग कर JavaMail एपीआई का उपयोग कर:

MailSenderActivity.java

YOUR PACKAGE; 

import android.app.Activity; 
import android.os.Bundle; 
import android.util.Log; 
import android.view.View; 
import android.widget.Button; 

public class MailSenderActivity extends Activity { 

    /** Called when the activity is first created. */ 
    @Override 
    public void onCreate(Bundle savedInstanceState) { 
     super.onCreate(savedInstanceState); 
     setContentView(R.layout.main); 

     final Button send = (Button) this.findViewById(R.id.send); 
     send.setOnClickListener(new View.OnClickListener() { 

      public void onClick(View v) { 
       // TODO Auto-generated method stub 

       try { 
        GMailSender sender = new GMailSender("username@gmail.com", "password"); 
        sender.sendMail("This is Subject", 
          "This is Body", 
          "user@gmail.com", 
          "user@yahoo.com"); 
       } catch (Exception e) { 
        Log.e("SendMail", e.getMessage(), e); 
       } 

      } 
     }); 

    } 
} 

GMailSender.java

YOUR PACKAGE; 

import javax.activation.DataHandler; 
import javax.activation.DataSource; 
import javax.mail.Message; 
import javax.mail.PasswordAuthentication; 
import javax.mail.Session; 
import javax.mail.Transport; 
import javax.mail.internet.InternetAddress; 
import javax.mail.internet.MimeMessage; 
import java.io.ByteArrayInputStream; 
import java.io.IOException; 
import java.io.InputStream; 
import java.io.OutputStream; 
import java.security.Security; 
import java.util.Properties; 

public class GMailSender extends javax.mail.Authenticator { 
    private String mailhost = "smtp.gmail.com"; 
    private String user; 
    private String password; 
    private Session session; 

    static { 
     Security.addProvider(new com.provider.JSSEProvider()); 
    } 

    public GMailSender(String user, String password) { 
     this.user = user; 
     this.password = password; 

     Properties props = new Properties(); 
     props.setProperty("mail.transport.protocol", "smtp"); 
     props.setProperty("mail.host", mailhost); 
     props.put("mail.smtp.auth", "true"); 
     props.put("mail.smtp.port", "465"); 
     props.put("mail.smtp.socketFactory.port", "465"); 
     props.put("mail.smtp.socketFactory.class", 
       "javax.net.ssl.SSLSocketFactory"); 
     props.put("mail.smtp.socketFactory.fallback", "false"); 
     props.setProperty("mail.smtp.quitwait", "false"); 

     session = Session.getDefaultInstance(props, this); 
    } 

    protected PasswordAuthentication getPasswordAuthentication() { 
     return new PasswordAuthentication(user, password); 
    } 

    public synchronized void sendMail(String subject, String body, String sender, String recipients) throws Exception { 
     try{ 
     MimeMessage message = new MimeMessage(session); 
     DataHandler handler = new DataHandler(new ByteArrayDataSource(body.getBytes(), "text/plain")); 
     message.setSender(new InternetAddress(sender)); 
     message.setSubject(subject); 
     message.setDataHandler(handler); 
     if (recipients.indexOf(',') > 0) 
      message.setRecipients(Message.RecipientType.TO, InternetAddress.parse(recipients)); 
     else 
      message.setRecipient(Message.RecipientType.TO, new InternetAddress(recipients)); 
     Transport.send(message); 
     }catch(Exception e){ 

     } 
    } 

    public class ByteArrayDataSource implements DataSource { 
     private byte[] data; 
     private String type; 

     public ByteArrayDataSource(byte[] data, String type) { 
      super(); 
      this.data = data; 
      this.type = type; 
     } 

     public ByteArrayDataSource(byte[] data) { 
      super(); 
      this.data = data; 
     } 

     public void setType(String type) { 
      this.type = type; 
     } 

     public String getContentType() { 
      if (type == null) 
       return "application/octet-stream"; 
      else 
       return type; 
     } 

     public InputStream getInputStream() throws IOException { 
      return new ByteArrayInputStream(data); 
     } 

     public String getName() { 
      return "ByteArrayDataSource"; 
     } 

     public OutputStream getOutputStream() throws IOException { 
      throw new IOException("Not Supported"); 
     } 
    } 
} 

जे एसएसई प्रदाता

JSSEProvider।जावा

/* 
* Licensed to the Apache Software Foundation (ASF) under one or more 
* contributor license agreements. See the NOTICE file distributed with 
* this work for additional information regarding copyright ownership. 
* The ASF licenses this file to You under the Apache License, Version 2.0 
* (the "License"); you may not use this file except in compliance with 
* the License. You may obtain a copy of the License at 
* 
*  http://www.apache.org/licenses/LICENSE-2.0 
* 
* Unless required by applicable law or agreed to in writing, software 
* distributed under the License is distributed on an "AS IS" BASIS, 
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
* See the License for the specific language governing permissions and 
* limitations under the License. 
*/ 

/** 
* @author Alexander Y. Kleymenov 
* @version $Revision$ 
*/ 


import java.security.AccessController; 
import java.security.Provider; 

public final class JSSEProvider extends Provider { 

    public JSSEProvider() { 
     super("HarmonyJSSE", 1.0, "Harmony JSSE Provider"); 
     AccessController.doPrivileged(new java.security.PrivilegedAction<Void>() { 
      public Void run() { 
       put("SSLContext.TLS", 
         "org.apache.harmony.xnet.provider.jsse.SSLContextImpl"); 
       put("Alg.Alias.SSLContext.TLSv1", "TLS"); 
       put("KeyManagerFactory.X509", 
         "org.apache.harmony.xnet.provider.jsse.KeyManagerFactoryImpl"); 
       put("TrustManagerFactory.X509", 
         "org.apache.harmony.xnet.provider.jsse.TrustManagerFactoryImpl"); 
       return null; 
      } 
     }); 
    } 
} 

जोड़ें 3 जार अपने Android परियोजना

• mail.jar
• activation.jar
• additional.jar

Click here - How to add External Jars

0 करने के लिए नीचे दिए गए लिंक में पाया

और भूल जाते हैं अपने मेनिफ़ेस्ट में इस लाइन को जोड़ने के लिए नहीं है:

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

परियोजना चलाने के लिए और मेल के लिए आपके प्राप्तकर्ता मेल खाते की जाँच करें। चीयर्स !!

उम्मीद है कि यह

पीएस में मदद करता है और यह न भूलें कि आप एंड्रॉइड में किसी भी गतिविधि से नेटवर्क ऑपरेशन नहीं कर सकते हैं। इसलिए मुख्य थ्रेड अपवाद पर नेटवर्क से बचने के लिए AsyncTask या IntentService का उपयोग करने की अनुशंसा की जाती है।

जार फाइलें: https://code.google.com/p/javamail-android/