Detecting Changes in Android Contacts

Introduction

In this post, we'll explore how to detect changes in Android contacts. Android OS provides a mechanism for contact storage known as the Contacts Provider. This provider offers a structured set of data and a standard interface that connects data across different processes.

Structure of Android Contacts

ContactsRaw Table

  • _id: RAW_CONTACT_ID
  • account_name: e.g., email address
  • account_type: e.g., com.google.com
  • deleted: Indicates if the contact is deleted

The ContactsContract.RawContacts.CONTENT_URI table contains original contacts, mainly storing RAW_CONTACT_ID. Contact details are stored in the ContactsContract.Data table.

Contacts Table

  • _id: CONTACT_ID (refers to a group of RAW_CONTACT_IDs)
  • lookup: Provides a link to all contact details in this table

The Contacts.CONTENT_URI table groups RawContacts based on merging rules. If a raw contact can't be grouped with an existing contact, a new contact is created. The LOOKUP_KEY is a permanent link to a contact, remaining consistent even if CONTACT_ID changes due to merging.

ContactContract Table

  • _id: CONTACT_DETAIL_ID
  • lookup: Permanent link to contact
  • raw_contact_id: Refers to RAW_CONTACT_ID in the ContactsRaw table
  • contact_id: Refers to CONTACT_ID in the Contacts table
  • version: Reflects updates to contact records
  • data1 to data16: Data content (e.g., email, phone number, address)
  • mime_type: Type of record (e.g., email, number, address)
  • is_primary: Indicates if there are multiple instances of contact information (e.g., primary phone number)

The ContactsContract.Data.CONTENT_URI table contains contact details. Each contact may have multiple records here (e.g., one for name, one for phone number, one for email). contact_id is a reference to the Contacts table, and raw_contact_id references the original contact.

AggregationException Table

  • RAW_CONTACT_ID1: First raw contact ID
  • RAW_CONTACT_ID2: Second raw contact ID
  • AggregationExceptions.TYPE: Type of exception (e.g., automatic merging, keeping separate, keeping together)

The AggregationException table specifies pairs of raw contacts that should not be grouped. The type can be:

  • TYPE_AUTOMATIC: Automatic merging by the content provider
  • TYPE_KEEP_SEPARATE: Contacts remain separate
  • TYPE_KEEP_TOGETHER: Contacts are merged until explicitly separated by the user

Automatic Merging Rules

Contacts are merged automatically based on:

  • Matching name and surname
  • Matching name and surname in different orders
  • Matching surname and a short first name
  • Matching name or surname with one phone/email
  • One contact lacking a name/surname but sharing a phone/email

Detecting Changes

Using ContentObserver

To detect contact changes, you can use ContentObserver, which provides two methods:

  • onChange(boolean selfChange): Triggers when something changes
  • onChange(boolean selfChange, Uri uri): Provides the URI of the changed contact (available since API 16)

Version Number

Each contact record includes a version number. By maintaining a local database of stored versions, you can compare version numbers to detect changes.

Timestamp

You can track the last change using a timestamp (available since API 18). By querying with this timestamp, you can identify which contacts have been modified.

Detecting New Contacts

To detect new contacts, save the last RAW_CONTACT_ID and query for contacts with higher IDs. When a significant change occurs, a new RAW_CONTACT_ID is generated. Check

for changes in the LOOKUP_KEY to ensure you’re capturing all updates accurately.

Detecting Removed Contacts

To determine if a contact has been removed, query the database for the contact using the LOOKUP_KEY. This process might be resource-intensive as it involves checking each contact of interest.

SyncAdapter and Server Synchronization

The Contacts Provider is designed to handle synchronization between a device and an online service. A SyncAdapter can be used to manage contact synchronization with your custom account and server. This component handles tasks such as checking network availability, scheduling, and restarting synchronization, which can be useful for applications involving contact management.

Issues Encountered

During synchronization, I encountered an issue where updating a contact (replacing its content) led to the contact being removed and a new one being created with a different RAW_CONTACT_ID. According to the documentation, this happens if the raw contact changes significantly. Despite attempts to reproduce this issue through both simple queries and batch operations, I couldn't replicate it consistently.

What Would Be Great?

A feature that would significantly enhance contact management would be a listener that notifies which contacts (including third-party accounts) are new, deleted, or changed. Additionally, a history feature that allows querying changes since a specific timestamp would be very beneficial.

Helpful Links

This article was written to help me remember the details of working with Android contacts. If you find any inaccuracies or have additional insights, please leave a comment below.

Comments

Post a Comment

Popular posts from this blog

Skate Tricks Recognition Using Gyroscope

Image
In this article, we’ll describe how to recognize skateboard tricks using a gyroscope. This sensor is already present in most smartphones, but if you’re not familiar with it, here is a description . Before we dive in, a small disclaimer: This project originated as part of a Slido hackathon with the goal of demonstrating that it’s possible to recognize skateboard tricks using a gyroscope. For simplicity, we’ll focus on recognizing just two basic tricks and won’t consider the skater’s stance on the board. We’ll break down the problem into several smaller tasks: recording the trick, storing the data, describing the trick, analyzing it, and, finally, recognizing it. Recording the Trick Let’s start with trick recording. To obtain precise data, the device with the gyroscope needs to be attached directly to the skateboard. Place it on the bottom of the board to avoid interfering with the execution of the trick. The device should also be compact and lightweight to avoid altering the board’s cen...
Read more

Play table

Image
Using proximity sensors for playing midi tones combined with LED visualization Description The goal of this project was to create a table-sized device equipped with multiple proximity sensors capable of playing MIDI tones. Each sensor is accompanied by LEDs that indicate the distance of the user's hand above the table. This interactive table can be used by one or more people simultaneously. Hardware Setup I began with a cardboard prototype to test the sensors and the underlying logic. Afterward, I ordered a custom plottered sticker with a design which was painted with bare conductive paint. I drilled holes and connected the touchboard to seven Arduino Nanos, each controlling 13 LEDs. Additionally, I incorporated two potentiometers: one for volume control and another for changing the note setup. Programming The programming task was divided into two parts: Master Program (Touchboard): Reads values from the proximity sensors and sends messages to the slave Arduinos. Sl...
Read more

Counting dice and train wagons using computer vision

Image
Computer vision exercises with preprocessing Before starting my next project, I decided to work on some computer vision exercises. Each example is based on straightforward image preprocessing techniques. No complex data structures or machine learning are involved. Dice Detection I got this idea while browsing the net and became curious about how challenging it would be to write such a script. Here’s a step-by-step breakdown of the algorithm: Movement Detection : By comparing several frames with thresholds, we can determine if there is any movement in the frame. Adding a small time buffer after the movement stops gives us more accurate information. Removing the Background : Thresholding the grayscale frame helps to remove the background, leaving us with a binary image that highlights the objects. Cropping the Objects : Using contours, we can detect and isolate the objects by cropping them. Detecting Dots : By inverting the image, the dots on the dice become more distinguish...
Read more