import AdSupport
import AppTrackingTransparency
import UIKit

func retrieveIdentifiers() {
    // Request ATT authorization (iOS 14.5+)
    ATTrackingManager.requestTrackingAuthorization { status in
        DispatchQueue.main.async {
            switch status {
            case .authorized:
                // ATT authorized, retrieve IDFA
                let idfa = ASIdentifierManager.shared().advertisingIdentifier.uuidString
                print("IDFA: \(idfa)")
                print("ATT Status: \(status.rawValue)") // Status = 3
            case .denied:
                print("ATT Status: Denied (\(status.rawValue))") // Status = 2
            case .restricted:
                print("ATT Status: Restricted (\(status.rawValue))") // Status = 1
            case .notDetermined:
                print("ATT Status: Not Determined (\(status.rawValue))") // Status = 0
            @unknown default:
                print("Unknown ATT status.")
            }

            // Retrieve IDFV (always available)
            if let idfv = UIDevice.current.identifierForVendor?.uuidString {
                print("IDFV: \(idfv)")
            } else {
                print("Unable to retrieve IDFV.")
            }
        }
    }
}

// Call the function to retrieve identifiers
retrieveIdentifiers()

Dependencias

dependencies {
    implementation 'com.google.android.gms:play-services-ads-identifier:18.0.1'
}

Permisos

<uses-permission android:name="com.google.android.gms.permission.AD_ID" />

Uso

import androidx.lifecycle.lifecycleScope
import kotlinx.coroutines.launch

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        lifecycleScope.launch {
            val googleAdId = AdIdUtils.getGoogleAdId(applicationContext)
            Log.d("MainActivity", "Retrieved Google Ad ID: $googleAdId")
        }
    }
}

Implementación

import android.content.Context
import android.util.Log
import com.google.android.gms.ads.identifier.AdvertisingIdClient
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext

object AdIdUtils {
    suspend fun getGoogleAdId(context: Context): String? {
        return withContext(Dispatchers.IO) {
            try {
                val adInfo = AdvertisingIdClient.getAdvertisingIdInfo(context)
                val adId = adInfo.id
                val isLimitAdTrackingEnabled = adInfo.isLimitAdTrackingEnabled

                Log.d("GoogleAdID", "Advertising ID: $adId")
                Log.d("GoogleAdID", "Limit Ad Tracking: $isLimitAdTrackingEnabled")

                adId
            } catch (e: Exception) {
                Log.e("GoogleAdID", "Error retrieving GAID", e)
                null
            }
        }
    }
}

Dependencias

dependencies {
    implementation 'com.google.android.gms:play-services-appset:16.1.0'
}

Uso

AppSetIdUtils.getAppSetId(applicationContext)

Implementación

import android.content.Context
import android.util.Log
import com.google.android.gms.appset.AppSet
import com.google.android.gms.appset.AppSetIdClient
import com.google.android.gms.appset.AppSetIdInfo

object AppSetIdUtils {
    fun getAppSetId(context: Context) {
        val client: AppSetIdClient = AppSet.getClient(context)
        val task = client.appSetIdInfo

        task.addOnSuccessListener { info -
            val appSetId: String = info.id
            val scope: Int = info.scope

            Log.d("AppSetID", "App Set ID: $appSetId")
            Log.d("AppSetID", "Scope: ${if (scope == AppSetIdInfo.SCOPE_DEVELOPER) "Developer" else "App"}")
        }.addOnFailureListener { exception -
            Log.e("AppSetID", "Failed to retrieve App Set ID", exception)
        }
    }
}

Uso

AdvertisingIdHelper.getAmazonAdvertisingId(contentResolver)

Implementación

import android.content.ContentResolver
import android.provider.Settings
import android.util.Log

object AdvertisingIdHelper {

    fun getAmazonAdvertisingId(contentResolver: ContentResolver) {
        try {
            val limitAdTracking = Settings.Secure.getInt(contentResolver, "limit_ad_tracking") != 0
            val advertisingID = Settings.Secure.getString(contentResolver, "advertising_id")

            Log.d("AdvertisingID", "Amazon Advertising ID: $advertisingID")
            Log.d("LimitAdTracking", "Limit Ad Tracking: $limitAdTracking")

        } catch (e: Settings.SettingNotFoundException) {
            Log.e("AdvertisingID", "Advertising ID not supported on this device", e)
        }
    }
}

Dependencias

dependencies {
    implementation 'com.bun.msa.sdk:msa:1.0.26'
}

Implementación

import android.os.Bundle
import android.util.Log
import androidx.appcompat.app.AppCompatActivity
import com.bun.msa.sdk.DeviceId
import com.bun.msa.sdk.DeviceIdSupplier
import com.bun.msa.sdk.IIdentifierListener

class MainActivity : AppCompatActivity() {

    companion object {
        private const val TAG = "OAIDExample"
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        getOAID()
    }

    private fun getOAID() {
        try {
            val deviceId = DeviceId(this)
            deviceId.getDeviceIds(object : IIdentifierListener {
                override fun onSupport(isSupport: Boolean, supplier: DeviceIdSupplier?) {
                    if (isSupport && supplier != null) {
                        val oaid = supplier.oAID
                        Log.d(TAG, "OAID: $oaid")
                    } else {
                        Log.e(TAG, "OAID not supported on this device")
                    }
                }
            })
        } catch (e: Exception) {
            Log.e(TAG, "Error retrieving OAID", e)
        }
    }
}

import android.provider.Settings

val androidId: String = Settings.Secure.getString(
    contentResolver,
    Settings.Secure.ANDROID_ID
)

import Foundation
import UIKit

// Retrieve Locale
func retrieveLocale() - String {
    let locale = Locale.current.identifier
    print("Locale: \(locale)")
    return locale
}

// Retrieve Manufacturer (always Apple for iOS)
func retrieveManufacturer() - String {
    return "Apple"
}

// Retrieve Device Model
func deviceModel() - String? {
    var systemInfo = utsname()
    uname(&systemInfo)
    let machineMirror = Mirror(reflecting: systemInfo.machine)
    let identifier = machineMirror.children.reduce("") { identifier, element in
        guard let value = element.value as? Int8, value != 0 else { return identifier }
        return identifier + String(UnicodeScalar(UInt8(value)))
    }
    print("Device Model: \(identifier)")
    return identifier
}

// Retrieve Build Version
func buildVersion() - String? {
    var size: Int = 0
    sysctlbyname("kern.osversion", nil, &size, nil, 0)

    var build = [CChar](repeating: 0, count: size)
    sysctlbyname("kern.osversion", &build, &size, nil, 0)

    let buildVersion = String(cString: build)
    print("Build Version: \(buildVersion)")
    return buildVersion
}

import android.os.Build;
import java.util.Locale;

// Locale (lc parameter)
String locale = Locale.getDefault().toString();

// Device Make (ma parameter)
String deviceMake = Build.MANUFACTURER;

// Device Model (mo parameter)
String deviceModel = Build.MODEL;

// Build (bd parameter)
String build = "Build/" + Build.ID;

import android.os.Build
import java.util.Locale

// Locale (lc parameter)
val locale: String = Locale.getDefault().toString()

// Device Make (ma parameter)
val deviceMake: String = Build.MANUFACTURER

// Device Model (mo parameter)
val deviceModel: String = Build.MODEL

// Build (bd parameter)
val build: String = "Build/" + Build.ID

import Foundation

// install_time: creation date of the Documents directory (proxy)
let docs = FileManager.default
    .urls(for: .documentDirectory, in: .userDomainMask).first!
let attrs = try? FileManager.default.attributesOfItem(atPath: docs.path)
let created = attrs?[.creationDate] as? Date
let installTime = created.map { Int($0.timeIntervalSince1970) }

import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;

// install_time: PackageInfo.firstInstallTime is in milliseconds
long installTime = 0L;
try {
    PackageInfo info = getPackageManager().getPackageInfo(getPackageName(), 0);
    installTime = info.firstInstallTime / 1000L; // seconds
} catch (PackageManager.NameNotFoundException e) {
    e.printStackTrace();
}

import android.content.pm.PackageManager

// install_time: PackageInfo.firstInstallTime is in milliseconds
val installMillis = packageManager
    .getPackageInfo(packageName, 0)
    .firstInstallTime
val installTime = installMillis / 1000 // seconds

import Foundation

// update_time: creation date of the app bundle executable (proxy)
let execPath = Bundle.main.executablePath!
let attrs = try? FileManager.default.attributesOfItem(atPath: execPath)
let updated = attrs?[.creationDate] as? Date
let updateTime = updated.map { Int($0.timeIntervalSince1970) }

import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;

// update_time: PackageInfo.lastUpdateTime is in milliseconds
long updateTime = 0L;
try {
    PackageInfo info = getPackageManager().getPackageInfo(getPackageName(), 0);
    updateTime = info.lastUpdateTime / 1000L; // seconds
} catch (PackageManager.NameNotFoundException e) {
    e.printStackTrace();
}

import android.content.pm.PackageManager

// update_time: PackageInfo.lastUpdateTime is in milliseconds
val updateMillis = packageManager
    .getPackageInfo(packageName, 0)
    .lastUpdateTime
val updateTime = updateMillis / 1000 // seconds