Import Gmail Contact Programmatically in Java

Google’s Gmail is among the most popular and commonly used email services. Gmail provides a range of features along with just sending and receiving emails, such as calendars, chats, etc. In certain cases, you may need to connect to Gmail and import contacts programmatically from within your applications. To achieve that, this article shows how to import Gmail contacts using Java. Also, we will cover how to access contacts in a specific email group.

Java API to Import Gmail Contacts

Aspose.Email for Java is a powerful API to create email client applications. Moreover, it supports working with Gmail such as accessing contacts, calendars, appointments, etc. We will use this API to access and import contacts from Gmail accounts. You can either download the API or install it using the following Maven configurations.

Repository:

<repository>
    <id>AsposeJavaAPI</id>
    <name>Aspose Java API</name>
    <url>http://repository.aspose.com/repo/</url>
</repository>

Dependency:

<dependency>
    <groupId>com.aspose</groupId>
    <artifactId>aspose-email</artifactId>
    <version>22.2</version>
    <classifier>jdk16</classifier>
</dependency>

Import Contacts from Gmail in Java

Before you start, you need to create a project on the Google Developer Console, which will allow you to execute the code. To create one, you can follow this guide.

Now, create a helper class named GoogleOAuthHelper to take care of the authentication of a Gmail account. Also, create a class named OAuthUser to store user information. The following is the complete implementation of both classes.

public class OAuthUser {
String email;
String clientId;
String clientSecret;
String refreshToken;
}
view raw OAuthUser.java hosted with ❤ by GitHub
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import javax.xml.bind.DatatypeConverter;
/**
* <p>
* Developers console https://console.developers.google.com/projectselector/apis/credentials?pli=1
* Documentation https://developers.google.com/identity/protocols/OAuth2InstalledApp
* </p>
*/
class GoogleOAuthHelper {
public static final String AUTHORIZATION_URL = "https://accounts.google.com/o/oauth2/v2/auth";
public static final String TOKEN_REQUEST_URL = "https://oauth2.googleapis.com/token";
public static final String REDIRECT_URI = "urn:ietf:wg:oauth:2.0:oob";
public static final String REDIRECT_TYPE = "code";
public static final String SCOPE = "https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fcalendar" // Calendar
+ "+https%3A%2F%2Fwww.google.com%2Fm8%2Ffeeds%2F" // Contacts
+ "+https%3A%2F%2Fmail.google.com%2F"; // IMAP & SMTP
static String createCodeChalange() {
String verifierStr = UUID.randomUUID().toString() + "-" + UUID.randomUUID().toString();
System.out.println("Code Verifier: " + verifierStr);
MessageDigest digest;
try {
digest = MessageDigest.getInstance("SHA-256");
} catch (NoSuchAlgorithmException e) {
throw new IllegalAccessError(e.getMessage());
}
byte[] hash = digest.digest(verifierStr.getBytes(StandardCharsets.UTF_8));
String base64Hash = DatatypeConverter.printBase64Binary(hash);
base64Hash = base64Hash.split("=")[0];
base64Hash = base64Hash.replace('+', '-').replace('/', '_');
return base64Hash;
}
static String getAuthorizationCodeUrl(OAuthUser acc) {
return getAuthorizationCodeUrl(acc, SCOPE, REDIRECT_URI, REDIRECT_TYPE);
}
static String getAuthorizationCodeUrl(OAuthUser acc, String scope, String redirectUri, String responseType) {
System.out.println("---------------------------------------------------------");
System.out.println("------------- OAuth 2.0 AuthorizationCodeUrl -------------");
System.out.println("---------------------------------------------------------");
System.out.println("Login: " + acc.email);
String codeChallenge = createCodeChalange();
String state = urlEncode(UUID.randomUUID().toString());
String approveUrl = AUTHORIZATION_URL + "?client_id=" + acc.clientId + "&redirect_uri=" + redirectUri + "&response_type=" + responseType + "&scope=" + scope
+ "&code_challenge=" + codeChallenge + "&code_challenge_method=S256&state=" + state;
System.out.println("Approve Url: " + approveUrl);
return approveUrl;
}
static String urlEncode(String value) {
try {
return URLEncoder.encode(value, StandardCharsets.UTF_8.toString());
} catch (UnsupportedEncodingException e) {
throw new IllegalAccessError(e.getMessage());
}
}
static String urlDecode(String value) {
try {
return URLDecoder.decode(value, StandardCharsets.UTF_8.toString());
} catch (UnsupportedEncodingException e) {
throw new IllegalAccessError(e.getMessage());
}
}
static String getAccessTokenByAuthCode(String authorizationCode, String codeVerifier, OAuthUser user) {
String encodedParameters = "client_id=" + urlEncode(user.clientId) + "&client_secret=" + urlEncode(user.clientSecret) + "&code=" + urlEncode(authorizationCode)
+ "&code_verifier=" + codeVerifier + "&redirect_uri=" + urlEncode(REDIRECT_URI) + "&grant_type=authorization_code";
System.out.println("---------------------------------------------------------");
System.out.println("------------- OAuth 2.0 AccessTokenByAuthCode -------------");
System.out.println("---------------------------------------------------------");
System.out.println("Authorization code: " + authorizationCode);
String result = "";
Map<String, String> token = geToken(encodedParameters);
for (String key : token.keySet()) {
System.out.println(key + ": " + token.get(key));
if (key.equals("refresh_token")) {
result = token.get(key);
}
}
System.out.println("---------------------------------------------------------");
return result;
}
static String getAccessTokenByRefreshToken(OAuthUser user) {
String encodedParameters = "client_id=" + urlEncode(user.clientId) + "&client_secret=" + urlEncode(user.clientSecret) + "&refresh_token=" + urlEncode(user.refreshToken)
+ "&grant_type=refresh_token";
System.out.println("---------------------------------------------------------");
System.out.println("----------- OAuth 2.0 AccessTokenByRefreshToken -----------");
System.out.println("---------------------------------------------------------");
System.out.println("Login: " + user.email);
String result = "";
Map<String, String> token = geToken(encodedParameters);
for (String key : token.keySet()) {
System.out.println(key + ": " + token.get(key));
if (key.equals("access_token")) {
result = token.get(key);
}
}
System.out.println("---------------------------------------------------------");
return result;
}
static Map<String, String> geToken(String encodedParameters) {
try {
HttpURLConnection connection = (HttpURLConnection) new URL(TOKEN_REQUEST_URL).openConnection();
connection.setRequestMethod("POST");
byte[] requestData = encodedParameters.getBytes(StandardCharsets.UTF_8);
connection.setUseCaches(false);
connection.setDoInput(true);
connection.setDoOutput(true);
connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
connection.setRequestProperty("Content-Length", "" + requestData.length);
final OutputStream st = connection.getOutputStream();
try {
st.write(requestData, 0, requestData.length);
} finally {
st.flush();
st.close();
}
connection.connect();
if (connection.getResponseCode() >= HttpURLConnection.HTTP_BAD_REQUEST) {
throw new IllegalAccessError("Operation failed: " + connection.getResponseCode() + "/" + connection.getResponseMessage() + "\r\nDetails:\r\n{2}"
+ readInputStream(connection.getErrorStream()));
}
String responseText = readInputStream(connection.getInputStream());
Map<String, String> result = new HashMap<String, String>();
System.out.println(responseText);
String[] strs = responseText.replace("{", "").replace("}", "").replace("\"", "").replace("\r", "").replace("\n", "").split(",");
for (String sPair : strs) {
String[] pair = sPair.split(":");
String name = pair[0].trim().toLowerCase();
String value = urlDecode(pair[1].trim());
result.put(name, value);
}
return result;
} catch (IOException e) {
throw new IllegalAccessError(e.getMessage());
}
}
static String readInputStream(InputStream is) {
if (is == null)
return "";
BufferedReader reader = new BufferedReader(new InputStreamReader(is));
StringBuilder result = new StringBuilder();
String line;
try {
while ((line = reader.readLine()) != null) {
result.append(line);
}
} catch (IOException e) {
// ignore
}
return result.toString();
}
}
view raw GoogleOAuthHelper.java hosted with ❤ by GitHub

Import Contacts from a Gmail Account

The following are the steps to import contacts from a Gmail account in Java.

  • Create an object of OAuthUser class and initialize it with email, client ID and client secret.
  • Create two string objects to store authorization code and code verifier.
  • Get refresh token and access token.
  • Get an instance of GmailClient class into an IGmailClient object using GmailClient.getInstance(String, String) method.
  • Read contacts into an array using IGmailClient.getAllContacts() method.
  • Loop through array to access each contact.

The following code sample shows how to import Gmail contacts from an account in Java.

OAuthUser user = new OAuthUser();
// Set clientId, clientSecret and email
user.clientId = "<<clientID>>";
user.clientSecret = "<<clientSecret>>";
user.email = "<<email>>";
// You have to retrieve AuthorizationCode manually with generated AuthorizationCodeUrl
// Set authorizationCode
String authorizationCode = "<<authCode>>";
// Copy Code Verifier from the previous step output
// Set codeVerifier
String codeVerifier = "<<codeVerifier>>";
// Get Refresh Token
String refreshToken = GoogleOAuthHelper.getAccessTokenByAuthCode(authorizationCode, codeVerifier, user);
user.refreshToken = refreshToken;
// Get Access Token
String accessToken = GoogleOAuthHelper.getAccessTokenByRefreshToken(user);
// Use Access Token in API
IGmailClient client = GmailClient.getInstance(accessToken, user.email);
Contact[] contacts = client.getAllContacts();
for (Contact contact : contacts)
System.out.println(contact.getDisplayName() + ", " + contact.getEmailAddresses().get_Item(0));
view raw Import-Gmail-Contacts.java hosted with ❤ by GitHub

Import Gmail Contacts from a Group

You can also access contacts from a specific email group in Gmail following the steps below.

  • Follow the steps mentioned in previous section to initialize the IGmailClient.
  • Call IGmailClient.getAllGroups() to get groups into a ContactGroupCollection object.
  • Filter the required group(s) based on the title.
  • Access contacts from a group using IGmailClient.getContactsFromGroup(String) method.
  • Loop through array to access each contact.

The following code sample shows how to import contacts from a specific Gmail group in Java.

OAuthUser user = new OAuthUser();
// Set clientId, clientSecret and email
user.clientId = "<<clientID>>";
user.clientSecret = "<<clientSecret>>";
user.email = "<<email>>";
// You have to retrieve AuthorizationCode manually with generated AuthorizationCodeUrl
// Set authorizationCode
String authorizationCode = "<<authCode>>";
// Copy Code Verifier from the previous step output
// Set codeVerifier
String codeVerifier = "<<codeVerifier>>";
// Get Refresh Token
String refreshToken = GoogleOAuthHelper.getAccessTokenByAuthCode(authorizationCode, codeVerifier, user);
user.refreshToken = refreshToken;
// Get Access Token
String accessToken = GoogleOAuthHelper.getAccessTokenByRefreshToken(user);
// Use Access Token in API
IGmailClient client = GmailClient.getInstance(accessToken, user.email);
// Fetch contacts from a specific group
ContactGroupCollection groups = client.getAllGroups();
GoogleContactGroup group = null;
for (GoogleContactGroup g : groups) {
if ("TestGroup".equals(g.getTitle())) {
group = g;
}
}
// Retrieve contacts from the Group
if (group != null) {
Contact[] contacts2 = client.getContactsFromGroup(group.getId());
for (Contact con : contacts2)
System.out.println(con.getDisplayName() + "," + con.getEmailAddresses().get_Item(0).toString());
}
view raw Import-Gmail-Contacts-From-Group.java hosted with ❤ by GitHub

Get a Free API License

You can get a free temporary license to use Aspose.Email for Java without evaluation limitations.

Conclusion

In this article, you have learned how to import Gmail contacts from an account programmatically in Java. Moreover, you have seen how to access contacts from a particular email group in Gmail. Apart from that, you can explore the documentation to read more about Aspose.Email for Java. Also, you can ask your questions via our forum.

See Also