Guía de recuperación de datos de dispositivos
Singular requiere que se incluyan identificadores de dispositivo específicos en todas las solicitudes de API para una atribución precisa. Estos identificadores incluyen:
- Google Advertising ID (GAID) y Google App Set ID (ASID) para dispositivos Google Play
- Amazon Advertising ID para dispositivos Amazon que no sean de Google Play
- Open Advertising ID (OAID) para dispositivos Android fabricados en China
- Y si ninguno de los anteriores está disponible, el Android ID (ANDI) para dispositivos que no sean de Google Play
- Identificador para anunciantes (IDFA) e Identificador para vendedores (IDFV) para dispositivos iOS
Singular también requiere algunos Parámetros del dispositivo móvil:
- Configuración regional (por ejemplo, en_US)
- Marca del dispositivo (por ejemplo, Samsung)
- Modelo del dispositivo (por ejemplo, iPhone 12, Samsung Galaxy S21)
- Compilación (por ejemplo, Build/13D15)
Singular proporciona ejemplos de fragmentos de código para ayudarle a obtener estos identificadores, que puede encontrar a continuación.
Ejemplo de clase Device Info
Identificadores
Identificadores necesarios para iOS
- El IDFV es obligatorio en todas las solicitudes S2S
- Se debe proporcionar el IDFA si el usuario proporcionó el Consentimiento de transparencia de seguimiento de aplicaciones.
- También se requiere el Estado de Autorización ATT.
Recuperación del Identificador para Anunciantes (IDFA)
El Identificador para Anunciantes (IDFA) ayuda a los anunciantes a rastrear y atribuir las acciones de los usuarios (por ejemplo, clics en anuncios, instalaciones de aplicaciones) a campañas específicas, lo que permite una orientación precisa de los anuncios y la optimización de las campañas.
A partir de iOS 14.5, los usuarios deben optar por el marco App Tracking Transparency (ATT) antes de que las aplicaciones puedan acceder a su IDFA. Si los usuarios no lo hacen, el IDFA no estará disponible, lo que limitará las capacidades de seguimiento.
Recuperación del identificador para proveedores (IDFV)
El identificador para proveedores (IDFV) es un identificador único asignado por Apple a un dispositivo, que es específico de un proveedor o desarrollador concreto. Permanece constante en todas las aplicaciones del mismo proveedor en un dispositivo determinado, lo que permite al proveedor realizar un seguimiento del comportamiento y las interacciones del usuario en todo su ecosistema de aplicaciones sin identificar al usuario personalmente.
- Asegúrese de que se muestra y gestiona la solicitud de ATT antes de intentar acceder al IDFA.
- Si utiliza ATT, capture el IDFA y páselo a su servidor para utilizarlo en solicitudes de API Singular.
- Capture el IDFV y devuélvalo a su servidor para utilizarlo en solicitudes de API Singular.
Ejemplo: Solicitud de estado de autorización ATT para recuperar IDFA e IDFV con registros de consola
Aquí están los fragmentos de código Objective-C y Swift para recuperar tanto el IDFA (Identificador para Anunciantes) como el IDFV (Identificador para Vendedor) con registros de consola. Este código incluye la gestión de los permisos de App Tracking Transparency (ATT), necesarios para acceder al IDFA a partir de iOS 14.5.
#import <AdSupport/AdSupport.h>
#import <AppTrackingTransparency/AppTrackingTransparency.h>
#import <UIKit/UIKit.h>
- (void)retrieveIdentifiers {
// Request ATT authorization (iOS 14.5+)
[ATTrackingManager requestTrackingAuthorizationWithCompletionHandler:^(ATTrackingManagerAuthorizationStatus status) {
dispatch_async(dispatch_get_main_queue(), ^{
switch (status) {
case ATTrackingManagerAuthorizationStatusAuthorized: {
// ATT authorized, retrieve IDFA
NSUUID *idfa = [[ASIdentifierManager sharedManager] advertisingIdentifier];
NSLog(@"IDFA: %@", [idfa UUIDString]);
break;
}
case ATTrackingManagerAuthorizationStatusDenied:
case ATTrackingManagerAuthorizationStatusRestricted:
case ATTrackingManagerAuthorizationStatusNotDetermined:
// ATT not authorized or not determined
NSLog(@"Tracking not authorized or not determined.");
break;
default:
NSLog(@"Unknown ATT status.");
break;
}
// Retrieve IDFV (always available)
NSUUID *idfv = [[UIDevice currentDevice] identifierForVendor];
if (idfv != nil) {
NSLog(@"IDFV: %@", [idfv UUIDString]);
} else {
NSLog(@"Unable to retrieve IDFV.");
}
});
}];
}
// Call the method to retrieve identifiers
[self retrieveIdentifiers];
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)")
case .denied, .restricted, .notDetermined:
// ATT not authorized or not determined
print("Tracking not authorized or not determined.")
@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()
- IDFA: Requiere autorización ATT a partir de iOS 14.5. Sin el consentimiento del usuario, el IDFA devolverá todos ceros.
- IDFV: Siempre disponible y debe proporcionarse siempre en las solicitudes de API singulares.
Identificadores Android requeridos (dispositivos Google Play)
- El ASID es obligatorio en todas las solicitudes S2S
- El AIFA (GAID) debe proporcionarse si está disponible.
Recuperación del identificador de publicidad de Google (GAID)
El identificador de publicidad de Google (GAID), también conocido como AIFA en singular o ID de publicidad de Android (AAID), es un identificador único y reajustable por el usuario que se asigna a los dispositivos Android. Ayuda a los anunciantes y a los desarrolladores de aplicaciones a rastrear y atribuir las acciones de los usuarios (por ejemplo, clics en anuncios, instalaciones de aplicaciones) a través de aplicaciones a campañas específicas, lo que permite una orientación precisa de los anuncios y la optimización de las campañas, al tiempo que se mantiene la privacidad del usuario.
Asegúrate de haber añadido la dependencia necesaria para Google Play Services en tu archivo build.gradle:
dependencies {
implementation 'com.google.android.gms:play-services-ads-identifier:17.0.0'
}
Si la compilación de tu aplicación está orientada a Android 12/API nivel 31 o superior, añade permisos en AndroidManifest.xml para acceder al ID de publicidad de Google:
<uses-permission android:name="com.google.android.gms.permission.AD_ID" />
Para utilizar este método, simplemente llámalo desde tu actividad o clase de aplicación:
AdIdUtils.getGoogleAdId(getApplicationContext());
Código Java para recuperar el ID de publicidad de Google (GAID)
import android.content.Context;
import android.os.AsyncTask;
import android.util.Log;
import com.google.android.gms.ads.identifier.AdvertisingIdClient;
import com.google.android.gms.ads.identifier.AdvertisingIdClient.Info;
public class AdIdUtils {
// Method to retrieve the Google Advertising ID (GAID)
public static void getGoogleAdId(Context context) {
// Running the task in a background thread
AsyncTask.execute(new Runnable() {
@Override
public void run() {
try {
// Retrieve the Advertising ID info
Info adInfo = AdvertisingIdClient.getAdvertisingIdInfo(context);
// Get the GAID (Google Advertising ID)
String adId = adInfo.getId();
// Check if "Limit Ad Tracking" is enabled by the user
boolean isLimitAdTrackingEnabled = adInfo.isLimitAdTrackingEnabled();
// Log the results
Log.d("GoogleAdID", "Advertising ID: " + adId);
Log.d("GoogleAdID", "Limit Ad Tracking Enabled: " + isLimitAdTrackingEnabled);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}
}
Asegúrate de haber añadido la dependencia necesaria para Google Play Services en tu archivo build.gradle:
dependencies {
implementation 'com.google.android.gms:play-services-ads-identifier:17.0.0'
}
Si la compilación de tu aplicación está orientada a Android 12/API nivel 31 o superior, añade permisos en AndroidManifest.xml para acceder al ID de publicidad de Google:
<uses-permission android:name="com.google.android.gms.permission.AD_ID" />
Uso
Para utilizar esta función, es necesario llamarla desde un ámbito de coroutine, como dentro de un ViewModel o una actividad utilizando lifecycleScope. Aquí tienes un ejemplo de cómo podrías llamarla en una actividad:
import androidx.lifecycle.lifecycleScope
import kotlinx.coroutines.launch
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
// Launch a coroutine to fetch the Google Ad ID
lifecycleScope.launch {
val googleAdId = AdIdUtils.getGoogleAdId(applicationContext)
Log.d("MainActivity", "Retrieved Google Ad ID: $googleAdId")
}
}
}
Código Java para Recuperar el ID de Publicidad de Google (GAID)
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 {
// Function to retrieve Google Advertising ID (GAID) using coroutines
suspend fun getGoogleAdId(context: Context): String? {
return withContext(Dispatchers.IO) {
try {
// Retrieve the Advertising ID info
val adInfo = AdvertisingIdClient.getAdvertisingIdInfo(context)
// Get the GAID (Google Advertising ID)
val adId = adInfo.id
// Check if "Limit Ad Tracking" is enabled by the user
val isLimitAdTrackingEnabled = adInfo.isLimitAdTrackingEnabled
// Log the results
Log.d("GoogleAdID", "Advertising ID: $adId")
Log.d("GoogleAdID", "Limit Ad Tracking Enabled: $isLimitAdTrackingEnabled")
adId
} catch (e: Exception) {
e.printStackTrace()
null
}
}
}
}
Recuperación del App Set ID (ASID)
El App Set ID de Android permite a los desarrolladores realizar un seguimiento de los usuarios a través de sus propias aplicaciones de una manera respetuosa con la privacidad. Resulta especialmente útil para el análisis y la prevención del fraude, pero no puede utilizarse con fines publicitarios, como los anuncios personalizados o la medición.
Asegúrese de haber añadido la dependencia necesaria para Google Play Services en su archivo build.gradle:
dependencies {
implementation 'com.google.android.gms:play-services-appset:16.1.0'
}
Uso
Para utilizar esta función, simplemente llámala desde tu actividad o clase de aplicación:
AppSetIdUtils.getAppSetId(getApplicationContext());
Código Java para Recuperar App Set ID
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;
import com.google.android.gms.tasks.OnSuccessListener;
import com.google.android.gms.tasks.Task;
public class AppSetIdUtils {
// Method to retrieve the App Set ID
public static void getAppSetId(Context context) {
// Get the AppSetIdClient instance
AppSetIdClient client = AppSet.getClient(context);
// Retrieve the App Set ID information asynchronously
Task<AppSetIdInfo> task = client.getAppSetIdInfo();
task.addOnSuccessListener(new OnSuccessListener<AppSetIdInfo>() {
@Override
public void onSuccess(AppSetIdInfo info) {
// Get the App Set ID and its scope
String appSetId = info.getId();
int scope = info.getScope();
// Log the results
Log.d("AppSetID", "App Set ID: " + appSetId);
Log.d("AppSetID", "Scope: " + (scope == AppSetIdInfo.SCOPE_DEVELOPER ? "Developer" : "App"));
}
}).addOnFailureListener(e -> {
// Handle any errors that occur during retrieval
Log.e("AppSetID", "Failed to retrieve App Set ID", e);
});
}
}
Asegúrese de que ha añadido la dependencia necesaria para los servicios de Google Play en su archivo build.gradle:
dependencies {
implementation 'com.google.android.gms:play-services-appset:16.1.0'
}
Uso
Para utilizar esta función, simplemente llámala desde tu actividad o clase de aplicación:
AppSetIdUtils.getAppSetId(applicationContext)
Código Kotlin para Recuperar App Set ID
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.tasks.Task
object AppSetIdUtils {
// Function to retrieve the App Set ID
fun getAppSetId(context: Context) {
// Get the AppSetIdClient instance
val client: AppSetIdClient = AppSet.getClient(context)
// Retrieve the App Set ID information asynchronously
val task: Task<AppSetIdInfo> = client.appSetIdInfo
task.addOnSuccessListener { info ->
// Get the App Set ID and its scope
val appSetId: String = info.id
val scope: Int = info.scope
// Log the results
Log.d("AppSetID", "App Set ID: $appSetId")
Log.d("AppSetID", "Scope: ${if (scope == AppSetIdInfo.SCOPE_DEVELOPER) "Developer" else "App"}")
}.addOnFailureListener { exception ->
// Handle any errors that occur during retrieval
Log.e("AppSetID", "Failed to retrieve App Set ID", exception)
}
}
}
Identificadores de Android necesarios (dispositivos que no sean de Google Play)
Si no hay ASID o AIFA disponibles:
- Se debe proporcionar el AMID (Identificador de Amazon). Sólo dispositivos Amazon.
Cómo recuperar el identificador de Amazon (AMID)
Para capturar el identificador de publicidad de Amazon en tu aplicación Android, puedes utilizar la clase Settings.Secure para recuperar el identificador y comprobar las preferencias de seguimiento de anuncios del usuario. Aquí tienes un ejemplo de código limpio y sencillo basado en la información proporcionada por la documentación de Amazon:
Asegúrate de manejar escenarios en los que el identificador de publicidad podría no estar disponible (por ejemplo, en dispositivos que no sean Fire OS o en versiones antiguas de Fire OS).
Respete siempre la preferencia de Limitar seguimiento de anuncios del usuario cuando utilice este identificador con fines publicitarios o analíticos. Este código debería funcionar en dispositivos Amazon Fire con Fire OS 5.1 o posterior, según las directrices de Amazon.
Puede llamar a este método desde su actividad o servicio pasando el identificador ContentResolver:
// Example usage in an Activity
AdvertisingIdHelper.getAmazonAdvertisingId(getContentResolver());
Código Java para Recuperar el ID de Publicidad de Amazon (AMID)
import android.content.ContentResolver;
import android.provider.Settings;
import android.provider.Settings.SettingNotFoundException;
import android.util.Log;
public class AdvertisingIdHelper {
public static void getAmazonAdvertisingId(ContentResolver contentResolver) {
String advertisingID = "";
boolean limitAdTracking = false;
try {
// Get user's ad tracking preference
limitAdTracking = (Settings.Secure.getInt(contentResolver, "limit_ad_tracking") == 0) ? false : true;
// Get the Amazon Advertising ID
advertisingID = Settings.Secure.getString(contentResolver, "advertising_id");
// Log the values for demonstration purposes
Log.d("AdvertisingID", "Amazon Advertising ID: " + advertisingID);
Log.d("LimitAdTracking", "Limit Ad Tracking: " + limitAdTracking);
} catch (SettingNotFoundException e) {
// Handle case where settings are not available (e.g., non-Fire OS devices)
Log.e("AdvertisingID", "Advertising ID not supported on this device", e);
}
}
}
Puedes llamar a este método desde una Actividad o Servicio pasando el ContentResolver:
// Example usage in an Activity
AdvertisingIdHelper.getAmazonAdvertisingId(contentResolver)
Código Kotlin para recuperar el ID de publicidad de Amazon (AMID)
import android.content.ContentResolver
import android.provider.Settings
import android.util.Log
object AdvertisingIdHelper {
fun getAmazonAdvertisingId(contentResolver: ContentResolver) {
try {
// Get user's ad tracking preference
val limitAdTracking = Settings.Secure.getInt(contentResolver, "limit_ad_tracking") != 0
// Get the Amazon Advertising ID
val advertisingID = Settings.Secure.getString(contentResolver, "advertising_id")
// Log the values for demonstration purposes
Log.d("AdvertisingID", "Amazon Advertising ID: $advertisingID")
Log.d("LimitAdTracking", "Limit Ad Tracking: $limitAdTracking")
} catch (e: Settings.SettingNotFoundException) {
// Handle case where settings are not available (e.g., non-Fire OS devices)
Log.e("AdvertisingID", "Advertising ID not supported on this device", e)
}
}
}
- Se debe proporcionar el OAID (Open Advertising Identifier). Dispositivos nacionales de China.
Cómo recuperar el identificador de publicidad abierta (OAID)
El Open Advertising Identifier (OAID) es un identificador único y anónimo utilizado con fines publicitarios en dispositivos Android, especialmente los fabricados en China. Fue introducido por la Mobile Security Alliance (MSA) como alternativa al identificador de publicidad de Google (GAID) para dispositivos en los que Google Play Services no está disponible o no es compatible, como en el mercado chino.
El OAID se utiliza principalmente para la atribución de publicidad y el seguimiento de usuarios en entornos en los que los servicios de Google Play están restringidos, lo que permite a los anunciantes y desarrolladores realizar un seguimiento del comportamiento de los usuarios manteniendo el anonimato.
El OAID está disponible en la mayoría de los dispositivos Android fabricados en China, incluidos los de marcas como Huawei, Xiaomi y otras. Se puede acceder a él mediante el SDK MSA o Huawei Mobile Services (HMS).
Asegúrese de que su archivo build.gradle incluye las dependencias necesarias para el SDK MSA.
dependencies {
implementation 'com.bun.msa.sdk:msa:1.0.26' // Example version; check for the latest one
}
Código Java para recuperar el OAID
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;
public class MainActivity extends AppCompatActivity {
private static final String TAG = "OAIDExample";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
// Initialize and request OAID
getOAID();
}
private void getOAID() {
try {
// Create a DeviceId instance and request OAID asynchronously
DeviceId deviceId = new DeviceId(this);
deviceId.getDeviceIds(new IIdentifierListener() {
@Override
public void onSupport(boolean isSupport, DeviceIdSupplier supplier) {
if (isSupport && supplier != null) {
// Retrieve OAID from supplier
String oaid = supplier.getOAID();
Log.d(TAG, "OAID: " + oaid);
} else {
Log.e(TAG, "OAID not supported on this device");
}
}
});
} catch (Exception e) {
Log.e(TAG, "Error retrieving OAID", e);
}
}
}
Añade el SDK MSA a tu proyecto: Similar a la versión Java, necesitas integrar el SDK MSA a tu proyecto. Asegúrate de tener la dependencia correcta en tu archivo build.gradle:
dependencies {
implementation 'com.bun.msa.sdk:msa:1.0.26' // Example version; check for the latest one
}
Código Kotlin para recuperar el OAID
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)
// Initialize and request OAID
getOAID()
}
private fun getOAID() {
try {
val deviceId = DeviceId(this)
deviceId.getDeviceIds(object : IIdentifierListener {
override fun onSupport(isSupport: Boolean, supplier: DeviceIdSupplier?) {
if (isSupport && supplier != null) {
// Retrieve OAID from supplier
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)
}
}
}
- Si no existe ningún otro identificador de dispositivo, entonces puedes proporcionar el ANDI (Android ID).
Cómo recuperar el Android ID (ANDI)
El Android ID es un identificador único de 64 bits generado por el sistema operativo Android cuando se configura un dispositivo por primera vez. Está diseñado para ser persistente durante toda la vida útil del dispositivo, pero se puede restablecer en determinadas condiciones, como un restablecimiento de fábrica.
El Android ID es único para cada dispositivo y, a partir de Android 8.0 (Oreo), tiene un alcance por app y por usuario. Esto significa que diferentes apps en el mismo dispositivo recibirán diferentes Android ID a menos que compartan la misma clave de firma.
El Android ID permanece constante a menos que el dispositivo se someta a un restablecimiento de fábrica o si una app se desinstala y se vuelve a instalar después de una actualización OTA (over-the-air).
Para recuperar el Android ID en una aplicación Android, puede utilizar el siguiente fragmento de código:
import android.provider.Settings;
import android.content.Context;
String androidId = Settings.Secure.getString(context.getContentResolver(), Settings.Secure.ANDROID_ID);
Puede llamar a este método desde una Actividad o Servicio pasando el ContentResolver:
import android.os.Bundle
import android.provider.Settings
import android.widget.TextView
import androidx.appcompat.app.AppCompatActivity
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
// Find the TextView in the layout to display the Android ID
val textView: TextView = findViewById(R.id.textView)
// Retrieve the Android ID
val androidId: String = Settings.Secure.getString(contentResolver, Settings.Secure.ANDROID_ID)
}
}
Identificadores Web Requeridos
- El SDID es requerido en todas las peticiones S2S
Cómo recuperar el identificador de dispositivo (SDID) de Singular Web SDK
Descripción
Debe tener implementado el SDK de Singular Web.
UsoPara utilizar este método, simplemente llámelo desde el código de su sitio web después de que Singular SDK se haya inicializado:
window.singularSdk.getSingularDeviceId()
Parámetros necesarios del dispositivo móvil
- La configuración regional, la marca del dispositivo, el modelo del dispositivo y la construcción son obligatorios en todas las solicitudes S2S.
Recuperación de la configuración regional, la marca, el modelo y la compilación del dispositivo
#import <Foundation/Foundation.h>
#import <UIKit/UIKit.h>
#import <sys/sysctl.h>
// Retrieve the Locale
NSString *retrieveLocale() {
NSString *locale = [[NSLocale currentLocale] localeIdentifier];
NSLog(@"Locale: %@", locale);
return locale;
}
// Retrieve the Manufacturer
NSString *retrieveManufacturer() {
// Set the Device Make to Apple
return @"Apple";
}
// Retrieve the Device Model
NSString *deviceModel() {
size_t bufferSize = 64;
char model[bufferSize];
int status = sysctlbyname("hw.machine", model, &bufferSize, NULL, 0);
if (status == 0) {
NSString *deviceModel = [NSString stringWithCString:model encoding:NSUTF8StringEncoding];
NSLog(@"Device Model: %@", deviceModel);
return deviceModel;
} else {
NSLog(@"Unable to retrieve device model.");
return nil;
}
}
// Retrieve the Build Version
NSString *buildVersion() {
size_t bufferSize = 64;
char build[bufferSize];
int status = sysctlbyname("kern.osversion", build, &bufferSize, NULL, 0);
if (status == 0) {
NSString *buildVersion = [NSString stringWithCString:build encoding:NSUTF8StringEncoding];
NSLog(@"Build Version: %@", buildVersion);
return buildVersion;
} else {
NSLog(@"Unable to retrieve build version.");
return nil;
}
}
// Example usage
int main(int argc, const char * argv[]) {
@autoreleasepool {
// Retrieve Locale
NSString *locale = retrieveLocale();
// Retrieve Device Make
NSString *make = retrieveManufacturer();
// Retrieve Device Model
NSString *model = deviceModel();
// Retrieve Build Version
NSString *build = buildVersion();
// Log results
if (locale) {
NSLog(@"Locale: %@", locale);
}
if (make) {
NSLog(@"Device Make: %@", make);
}
if (model) {
NSLog(@"Device Model: %@", model);
}
if (build) {
NSLog(@"Build Version: %@", build);
}
}
return 0;
}
import Foundation
// Retrieve the Locale
func retrieveLocale() -> String {
let locale = Locale.current.identifier
print("Locale: \(locale)")
return locale
}
// Retrieve the Device Model
import UIKit
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 the 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
}
// Example usage:
let locale = retrieveLocale()
print("Locale: \(locale)")
let deviceMake = "Apple"
print("Device Make: \(deviceMake)")
if let model = deviceModel() {
print("Device Model: \(model)")
}
if let build = buildVersion() {
print("Build Version: \(build)")
}
// Locale - lc= query parameter
String locale = Locale.getDefault().toString(); // Converts Locale object to string
// Make - ma= query parameter
String deviceMake = Build.MANUFACTURER; // Gets the device manufacturer name
// Model - mo= query parameter
String deviceModel = Build.MODEL; // Gets the device model
// Build - bd= query parameter
String build = "Build/" + Build.ID; // Gets the build ID and appends it to "Build/"
// Locale - lc= query parameter
val locale: String = Locale.getDefault().toString() // Converts Locale object to string
// Make - ma= query parameter
val deviceMake: String = Build.MANUFACTURER // Gets the device manufacturer name
// Model - mo= query parameter
val deviceModel: String = Build.MODEL // Gets the device model
// Build - bd= query parameter
val build: String = "Build/" + Build.ID // Gets the build ID and appends it to "Build/"