Ignorar verificação de SSL no Android

O código abaixo gera um objeto do tipo HttpClient que irá ignorar as verificações de certificado digital.

Basta obter o objeto com a chamada do método getHttpClient. 

Exemplo: EscapeSSLSocketFactory.getHttpClient();

package com.example.escapesslcertificate;

import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;

import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

import org.apache.http.HttpVersion;
import org.apache.http.client.HttpClient;
import org.apache.http.conn.ClientConnectionManager;
import org.apache.http.conn.scheme.PlainSocketFactory;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.HttpParams;
import org.apache.http.params.HttpProtocolParams;
import org.apache.http.protocol.HTTP;

public class EscapeSSLSocketFactory extends SSLSocketFactory {
 
    SSLContext sslContext = SSLContext.getInstance("TLS");
 
    public EscapeSSLSocketFactory(KeyStore truststore) throws NoSuchAlgorithmException, KeyManagementException, KeyStoreException, UnrecoverableKeyException {
   
     super(truststore);
 
        TrustManager tm = new X509TrustManager() {
            public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
            }
 
            public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
            }
 
            public X509Certificate[] getAcceptedIssuers() {
                return null;
            }
        };
 
        sslContext.init(null, new TrustManager[] { tm }, null);
    }
 
    @Override
    public Socket createSocket(Socket socket, String host, int port, boolean autoClose) throws IOException, UnknownHostException {
        return sslContext.getSocketFactory().createSocket(socket, host, port, autoClose);
    }
 
    @Override
    public Socket createSocket() throws IOException {
        return sslContext.getSocketFactory().createSocket();
    }
    
    public static HttpClient getHttpClient() throws KeyStoreException, NoSuchAlgorithmException, CertificateException, IOException, KeyManagementException, UnrecoverableKeyException {
     
     KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
  trustStore.load(null, null);

  SSLSocketFactory sf = new EscapeSSLSocketFactory(trustStore);
  sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);

  HttpParams params = new BasicHttpParams();
  HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
  HttpProtocolParams.setContentCharset(params, HTTP.UTF_8);

  SchemeRegistry registry = new SchemeRegistry();
  registry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
  registry.register(new Scheme("https", sf, 443));

  ClientConnectionManager ccm = new ThreadSafeClientConnManager(params, registry);

  return new DefaultHttpClient(ccm, params);
    }
}

exemplo envio de email utilizando javamail

Arquivo com as propriedades de Email (mail.properties)

#Configuracao de Email
mail.transport.protocol=smtp
mail.debug=true
#
mail.smtp.auth=true
mail.smtp.host=smtp.gmail.com
mail.smtp.port=25
#
mail.smtp.from={usuario}@gmail.com
mail.smtp.user={usuario}
mail.smtp.password={senha}

Classe MailAutenticator que estende java.mail.Authenticator e precisa ser utilizada caso o servidor smtp exiga autenticação para o envio de emails.

import javax.mail.Authenticator;
import javax.mail.PasswordAuthentication;

/**
 * Classe de encapsulamento de informações para uso durante o processo de
 * autenticação no servidor de e-mail.
 */
public class MailAuthenticator extends Authenticator {

 private String username, password;

 public MailAuthenticator(String user, String pwd) {
  username = user;
  password = pwd;
 }

 /**
  * Retorna um elemento de autenticação para e-mail
  * a partir de usuário e senha pré-configurados
  */
 @Override
 public PasswordAuthentication getPasswordAuthentication() {
  return new PasswordAuthentication(username, password);
 }

}

Classe MailSender que é  responsável por estabelecer comunicação com o servidor e enviar os email.

import java.io.FileInputStream;
import java.util.Properties;

import javax.activation.CommandMap;
import javax.activation.DataHandler;
import javax.activation.FileDataSource;
import javax.activation.MailcapCommandMap;
import javax.mail.Message;
import javax.mail.Multipart;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeBodyPart;
import javax.mail.internet.MimeMessage;
import javax.mail.internet.MimeMultipart;

import android.util.Log;

public class MailSender {

 private static final String TAG = MailSender.class.getName();
 
 public MailSender() {
  
  MailcapCommandMap mc = (MailcapCommandMap)CommandMap.getDefaultCommandMap();
  mc.addMailcap("text/html;; x-java-content-handler=com.sun.mail.handlers.text_html");
  mc.addMailcap("text/xml;; x-java-content-handler=com.sun.mail.handlers.text_xml");
  mc.addMailcap("text/plain;; x-java-content-handler=com.sun.mail.handlers.text_plain");
  mc.addMailcap("multipart/*;; x-java-content-handler=com.sun.mail.handlers.multipart_mixed");
  mc.addMailcap("message/rfc822;; x-java-content-handler=com.sun.mail.handlers.message_rfc822");
  CommandMap.setDefaultCommandMap(mc);
 }

 /**
  * 
  * @param from
  * @param to
  * @param subject
  * @param message
  * @param file
  * @throws Exception
  */
 public boolean sendMail(String from, String[] to, String subject, String message) throws Exception {
  return sendMail(from, to, subject, message, new String[0]);
 }
 
 /**
  * 
  * @param from
  * @param to
  * @param subject
  * @param message
  * @param file
  * @throws Exception
  */
 public boolean sendMail(String from, String[] to, String subject, String message, String file) throws Exception {
  return sendMail(from, to, subject, message, new String[] { file });
 }

 /**
  * 
  * @param from
  * @param to
  * @param subject
  * @param message
  * @param files
  * @return 
  * @throws Exception
  */
 public boolean sendMail(String from, String[] to, String subject, String message, String[] files) throws Exception {

  Properties properties = new Properties();
  properties.load(new FileInputStream("mail.properties"));

  String user = properties.getProperty("mail.smtp.user");
  String pass = properties.getProperty("mail.smtp.password");

  Session session = Session.getInstance(properties, new MailAuthenticator(user, pass));
  session.setDebug(true);

  Message msg = new MimeMessage(session);

  try {

   // Setando o destinatário
   msg.setRecipient(Message.RecipientType.TO, new InternetAddress(to[0]));
   for (int count = 1; count < to.length; count++) {
    msg.addRecipient(Message.RecipientType.TO, new InternetAddress(to[count]));
   }   
   
   // Setando a origem do email
   if (from == null || from.isEmpty()) {
    from = properties.getProperty("mail.smtp.from");
   }
   //
   msg.setFrom(new InternetAddress(from));

   // Setando o assunto
   msg.setSubject(subject);

   if (files == null || files.length == 0) {

    /* Setando o content/type do email */
    msg.setContent(message, "text/html");

   } else {

    // Cria a primeira parte da mensagem
    MimeBodyPart mineBodyPart = new MimeBodyPart();
    mineBodyPart.setContent(message, "text/html");

    // Cria a Multipart
    Multipart multiPart = new MimeMultipart();
    multiPart.addBodyPart(mineBodyPart);

    for (String file : files) {

     // Cria partes dos arquivos em anexo
     MimeBodyPart mineBodyPartFiles = new MimeBodyPart();

     // Anexa o arquivo na mensagem
     FileDataSource fileDataSource = new FileDataSource(file);
     mineBodyPartFiles.setDataHandler(new DataHandler(fileDataSource));
     mineBodyPartFiles.setFileName(fileDataSource.getName());
     multiPart.addBodyPart(mineBodyPartFiles);
    }

    // adiciona a Multipart na mensagem
    msg.setContent(multiPart);
   }

  } catch (Exception e) {

   Log.e(TAG, e.getLocalizedMessage());
   
   throw new Exception(e.getLocalizedMessage(), e);
  }

  try {
   
   Transport transport = session.getTransport();
   transport.connect();

   transport.sendMessage(msg, msg.getAllRecipients());
   transport.close();
   
   return true;
   
  } catch (Exception e) {

   Log.e(TAG, e.getLocalizedMessage());
  }
  
  return false;
 }
}

otimizando conversão para valores numéricos

String para Inteiro

 
 /**
  * Método que retorna um Integer caso o parâmetro seja diferente de nulo e vazio
  * 
  * @param valor
  *            campo a ser convertido
  * @param defaultValue
  *            valor default caso ocorra erro
  * @return Integer
  *            valor convertido para Integer
  */
 public static Integer getInteger(String valor, Integer defaultValue) {
 try {
   
      int num  = 0;
      int sign = -1;
      final int len  = valor.length( );
      final char ch  = valor.charAt( 0 );
      if ( ch == '-' )
          sign = 1;
      else
          num = '0' - ch;

      int i = 1;
      while ( i < len )
          num = num*10 + '0' - valor.charAt( i++ );
 
      return sign * num;
      
 } catch (Exception e) {
      return defaultValue;
 }
 }

String para Long

 
/**
  * Método que retorna um Long caso o parâmetro seja diferente de nulo e vazio
  * 
  * @param valor
  *            campo a ser convertido
  * @param defaultValue
  *            valor default caso ocorra erro
  * @return Long
  *            valor convertido para Long
  */
 public static Long getLong(String valor, Long defaultValue) {
 try { 
      long num  = 0;
      long sign = -1;
      final long len  = valor.length( );
      final char ch   = valor.charAt( 0 );
      if ( ch == '-' )
          sign = 1;
      else
          num = '0' - ch;
 
      // Build the number.
      int i = 1;
      while ( i < len )
          num = num*10 + '0' - valor.charAt( i++ );
 
      return sign * num;
      
 } catch (Exception e) {
      return defaultValue;
 }
 }

String para Double

 
/**
  * Método que retorna um Double caso o parâmetro seja diferente de nulo e vazio
  * 
  * @param valor
  *            campo a ser convertido
  * @param defaultValue
  *            valor default caso ocorra erro
  * @return Double
  *            valor convertido para Double
  */
 public static Double getDouble(String valor, Double defaultValue) {
 try {

      double num  = 0;
      double sign = -1;
      final double len  = valor.length( );
      final char ch  = valor.charAt( 0 );
      if ( ch == '-' )
          sign = 1;
      else
          num = '0' - ch;
 
      // Build the number.
      int i = 1;
      while ( i < len )
          num = num*10 + '0' - valor.charAt( i++ );
 
      return sign * num;
      
} catch (Exception e) {
      return defaultValue;
}
}