Complete Guide to Android Device Identifiers

Android devices have several unique identifiers that developers can access programmatically using Java, though the available methods have evolved significantly due to privacy concerns. The most common approaches include the Advertising ID (GAID), Android ID, hardware identifiers, and device serial number, each with different characteristics and privacy implications.

Contents

• Understanding Android Device Identifiers
• Advertising ID (GAID)
• Android ID
• Hardware Identifiers
• Device Serial Number
• Best Practices and Privacy Considerations
• Implementation Examples

Understanding Android Device Identifiers

Android devices provide multiple ways to identify devices programmatically, but the landscape has changed considerably with each Android version as Google has increasingly prioritized user privacy. Developers need to understand that not all identifiers are available or reliable across all devices and Android versions.

The availability of certain identifiers depends on factors like:

• Android version (especially targeting Android 10+ and 12+)
• Manufacturer implementation
• User privacy settings
• Required permissions in the app’s manifest

Modern Android development emphasizes contextual identifiers rather than permanent device-wide identifiers, reflecting Google’s shift toward privacy-first approaches.

Advertising ID (GAID)

The Google Advertising ID (GAID) is currently the most recommended approach for device identification in Android applications, particularly for advertising and analytics purposes.

Key characteristics:

• Available since Android 4.3 (API level 18)
• User-resettable through device settings
• Can be limited by users for personalized advertising
• Requires AD_ID permission in manifest (Android 12+)

Implementation:

// For Android 12 (API 31) and above
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
    AdvertisingIdClient.Info advertisingIdInfo;
    try {
        advertisingIdInfo = AdvertisingIdClient.getAdvertisingIdInfo(context);
        String advertisingId = advertisingIdInfo.getId();
        boolean isLimitAdTracking = advertisingIdInfo.isLimitAdTrackingEnabled();
        
        // Use the advertising ID
        Log.d("DeviceID", "Advertising ID: " + advertisingId);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

The Advertising ID is the preferred method because it respects user privacy while still providing a reasonably stable identifier for legitimate use cases.

Android ID

The Android ID is a 64-bit number (as a hex string) that is generated and stored when a device is first set up.

Characteristics:

• Available since early Android versions
• Reset when device is factory reset
• Can be null on some devices
• No special permissions required

Implementation:

String androidId = Settings.Secure.getString(
    context.getContentResolver(), 
    Settings.Secure.ANDROID_ID
);

Important considerations:

• The Android ID can change between device reboots
• On some devices, it may be null
• It’s not guaranteed to be unique across all devices
• Starting with Android 10, this identifier is scoped to each app by default

For these reasons, the Android ID is generally less reliable than other methods and should be used with caution.

Hardware Identifiers

Hardware identifiers include various device-specific numbers that can be accessed through Android APIs.

Telephony Manager Identifiers

IMEI (International Mobile Equipment Identity):

// Requires READ_PHONE_STATE permission
TelephonyManager telephonyManager = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
String imei = telephonyManager.getDeviceId();

MEID (Mobile Equipment Identifier):

String meid = telephonyManager.getDeviceId(); // Returns MEID on CDMA devices

Hardware Serial Number:

String serial = telephonyManager.getSimSerialNumber();

WiFi and Bluetooth MAC Addresses

WiFi MAC Address:

WifiManager wifi = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
String macAddress = wifi.getConnectionInfo().getMacAddress();

Bluetooth MAC Address:

BluetoothAdapter bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
String bluetoothMac = bluetoothAdapter.getAddress();

Important limitations:

• Hardware identifiers require READ_PHONE_STATE permission
• Starting with Android 10, access to hardware identifiers is restricted to system apps
• On devices with Android 10+, these return null or constant values for most apps
• The MAC address is randomized when WiFi is off (Android 10+ behavior)

Device Serial Number

Android devices typically have a serial number that can be accessed, though its availability varies.

Implementation:

String serialNumber = Build.SERIAL;

Usage considerations:

• Requires special permissions on newer Android versions
• May return ‘unknown’ on many devices
• Not reliable as a primary identifier
• Primarily useful for debugging purposes

Best Practices and Privacy Considerations

Privacy Requirements

Starting with Android 10, Google has implemented strict privacy protections:

• Android 10 (API 29): Apps cannot access non-resettable device identifiers without special permissions
• Android 12 (API 31): Hardware identifiers are restricted, Advertising ID requires AD_ID permission
• Play Store requirements: Apps must justify why they need device identifiers

Recommended Approach

For modern Android applications:

1. Use Advertising ID for most use cases requiring device identification
2. Implement proper permission handling with runtime checks
3. Provide user controls for resetting identifiers
4. Consider custom solutions like generating app-specific IDs

Permission Handling

// Check for Advertising ID permission (Android 12+)
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
    if (!context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_AUTOMOTIVE)) {
        if (checkSelfPermission(Manifest.permission.AD_ID) != PackageManager.PERMISSION_GRANTED) {
            // Request permission
        }
    }
}

Implementation Examples

Unified Device ID Provider

public class DeviceIdProvider {
    private Context context;
    
    public DeviceIdProvider(Context context) {
        this.context = context.getApplicationContext();
    }
    
    public String getDeviceId() {
        try {
            // Try Advertising ID first (Android 12+)
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
                AdvertisingIdClient.Info advertisingIdInfo = 
                    AdvertisingIdClient.getAdvertisingIdInfo(context);
                return advertisingIdInfo.getId();
            }
            
            // Fallback to Android ID
            String androidId = Settings.Secure.getString(
                context.getContentResolver(), 
                Settings.Secure.ANDROID_ID
            );
            
            if (!TextUtils.isEmpty(androidId) && !"9774d56d682e549c".equals(androidId)) {
                return androidId;
            }
            
            // Generate a random UUID as last resort
            return UUID.randomUUID().toString();
            
        } catch (Exception e) {
            // Generate random ID on error
            return UUID.randomUUID().toString();
        }
    }
}

User Privacy Options

public class PrivacyManager {
    public static boolean isAdPersonalizationEnabled(Context context) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
            try {
                AdvertisingIdClient.Info advertisingIdInfo = 
                    AdvertisingIdClient.getAdvertisingIdInfo(context);
                return !advertisingIdInfo.isLimitAdTrackingEnabled();
            } catch (Exception e) {
                return false;
            }
        }
        return true; // Default for older versions
    }
    
    public static void openPrivacySettings(Context context) {
        Intent intent = new Intent(Settings.ACTION_PRIVACY_SETTINGS);
        context.startActivity(intent);
    }
}

Usage Analytics with Device ID

public class AnalyticsHelper {
    private String getOrCreateDeviceId() {
        // Try to get existing ID from preferences
        SharedPreferences prefs = context.getSharedPreferences("app_prefs", Context.MODE_PRIVATE);
        String deviceId = prefs.getString("device_id", null);
        
        if (deviceId == null) {
            // Generate new ID
            DeviceIdProvider provider = new DeviceIdProvider(context);
            deviceId = provider.getDeviceId();
            
            // Store for future use
            prefs.edit().putString("device_id", deviceId).apply();
        }
        
        return deviceId;
    }
    
    public void trackEvent(String eventName, Map<String, Object> properties) {
        String deviceId = getOrCreateDeviceId();
        
        // Create analytics event with device ID
        Map<String, Object> event = new HashMap<>(properties);
        event.put("device_id", deviceId);
        event.put("timestamp", System.currentTimeMillis());
        
        // Send to analytics service
        AnalyticsService.track(eventName, event);
    }
}

Conclusion

Android devices do have unique identifiers that can be accessed programmatically, but the approaches have evolved significantly with increasing privacy protections. Key takeaways include:

1. Advertising ID (GAID) is the most reliable and privacy-compliant method for most use cases, requiring proper permission handling on Android 12+.

2. Android ID remains accessible but has limitations including potential null values and reset behavior, making it less reliable than other methods.

3. Hardware identifiers like IMEI and MAC addresses are increasingly restricted and should be avoided unless absolutely necessary with proper justification.

4. Modern Android development requires careful permission handling and respect for user privacy preferences, with proper fallback mechanisms when identifiers are unavailable.

5. Custom solutions like app-specific generated IDs may be the most appropriate approach for many applications, especially when combined with Advertising ID for cross-device consistency.

Developers should always consider their specific use case, implement proper error handling, and provide transparency to users about how device identifiers are being used in their applications.

Sources

1. [Android Developer Documentation - Advertising ID](https://developer.android.com/reference/com/google/android/gms/ads identifier/AdvertisingIdClient)
2. Google Play Console Policy Requirements
3. Android Privacy Changes - Google Developers Blog
4. Settings.Secure Reference - Android Developer Documentation
5. TelephonyManager Documentation - Android Developer