Guia de recuperação de dados do dispositivo
A Singular exige que identificadores de dispositivos específicos sejam incluídos em todas as solicitações de API para uma atribuição precisa. Esses identificadores incluem:
- Google Advertising ID (GAID) e Google App Set ID (ASID) para dispositivos Google Play
- ID de publicidade da Amazon para dispositivos Amazon que não sejam do Google Play
- Open Advertising ID (OAID) para dispositivos Android fabricados na China
- E se nenhuma das opções acima estiver disponível, o Android ID (ANDI) para dispositivos que não sejam do Google Play
- Identificador para anunciantes (IDFA) e Identificador para fornecedores (IDFV) para dispositivos iOS
A Singular também requer alguns parâmetros do dispositivo móvel:
- Localidade (por exemplo, en_US)
- Marca do dispositivo (por exemplo, Samsung)
- Modelo do dispositivo (por exemplo, iPhone 12, Samsung Galaxy S21)
- Compilação (por exemplo, Build/13D15)
O Singular fornece exemplos de trechos de código para ajudá-lo a obter esses identificadores, que podem ser encontrados abaixo.
Exemplo de classe de informações do dispositivo
Identificadores
Identificadores iOS necessários
- O IDFV é necessário em todos os pedidos S2S
- O IDFA deve ser fornecido se o consentimento de transparência do rastreio da aplicação tiver sido fornecido pelo utilizador.
- O Estado de Autorização ATT também é necessário.
Recuperar o Identificador para Anunciantes (IDFA)
O Identificador para Anunciantes (IDFA) ajuda os anunciantes a controlar e atribuir acções dos utilizadores (por exemplo, cliques em anúncios, instalações de aplicações) a campanhas específicas, permitindo uma segmentação precisa dos anúncios e a otimização das campanhas.
A partir do iOS 14.5, os utilizadores têm de aderir através da estrutura App Tracking Transparency (ATT) para que as aplicações possam aceder ao seu IDFA. Se os utilizadores não optarem por aderir, o IDFA não estará disponível, limitando as capacidades de rastreio.
Recuperação do identificador para fornecedores (IDFV)
O IDFV (Identifier for Vendors) é um identificador único atribuído pela Apple a um dispositivo, que é específico de um determinado fornecedor ou programador. Permanece consistente em todas as aplicações do mesmo fornecedor num determinado dispositivo, permitindo ao fornecedor seguir o comportamento e as interações do utilizador no seu ecossistema de aplicações sem identificar o utilizador pessoalmente.
- Certifique-se de que a solicitação ATT é apresentada e tratada antes de tentar aceder ao IDFA.
- Se estiver a utilizar ATT, capture o IDFA e transmita-o de volta ao seu servidor para utilização em pedidos de API Singular.
- Capture o IDFV e transmita-o de volta ao seu servidor para utilização em pedidos de API Singular.
Exemplo: Solicitação de status de autorização ATT para recuperar IDFA e IDFV com logs do console
Aqui estão os trechos de código Objective-C e Swift para recuperar o IDFA (Identificador para anunciantes) e o IDFV (Identificador para fornecedor) com logs do console. Este código inclui a manipulação das permissões de App Tracking Transparency (ATT), que são necessárias para aceder ao IDFA a partir do 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: Requer autorização ATT a partir do iOS 14.5+. Sem o consentimento do utilizador, o IDFA devolverá todos os zeros.
- IDFV: sempre disponível e deve ser sempre fornecido em solicitações de API singulares.
Identificadores Android necessários (dispositivos Google Play)
- O ASID é necessário em todos os pedidos S2S
- O AIFA (GAID) deve ser fornecido se estiver disponível.
Recuperar o identificador de publicidade do Google (GAID)
O Identificador de publicidade do Google (GAID), também conhecido como AIFA no singular ou ID de publicidade do Android (AAID), é um identificador exclusivo e redefinível pelo utilizador atribuído a dispositivos Android. Ajuda os anunciantes e os programadores de aplicações a rastrear e atribuir acções de utilizadores (por exemplo, cliques em anúncios, instalações de aplicações) em aplicações a campanhas específicas, permitindo uma segmentação precisa de anúncios e a otimização de campanhas, mantendo a privacidade do utilizador.
Certifique-se de que adicionou a dependência necessária para o Google Play Services no seu ficheiro build.gradle:
dependencies {
implementation 'com.google.android.gms:play-services-ads-identifier:17.0.0'
}
Se a compilação da aplicação tiver como alvo o Android 12/API nível 31 ou superior, adicione permissões no AndroidManifest.xml para aceder ao ID de publicidade do Google:
<uses-permission android:name="com.google.android.gms.permission.AD_ID" />
Para utilizar este método, basta chamá-lo a partir da sua atividade ou classe de aplicação:
AdIdUtils.getGoogleAdId(getApplicationContext());
Código Java para recuperar o ID de publicidade do 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();
}
}
});
}
}
Certifique-se de ter adicionado a dependência necessária para o Google Play Services no arquivo build.gradle:
dependencies {
implementation 'com.google.android.gms:play-services-ads-identifier:17.0.0'
}
Se a compilação da aplicação tiver como alvo o Android 12/API nível 31 ou superior, adicione permissões no AndroidManifest.xml para aceder ao ID de publicidade do Google:
<uses-permission android:name="com.google.android.gms.permission.AD_ID" />
Utilização
Para usar essa função, é necessário chamá-la de um escopo de corrotina, como em um ViewModel ou uma atividade usando lifecycleScope. Aqui está um exemplo de como você pode chamá-la em uma atividade:
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 o ID de publicidade do 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
}
}
}
}
Recuperar a ID do conjunto de aplicações (ASID)
O ID do conjunto de aplicações do Android fornece uma forma de os programadores acompanharem os utilizadores nas suas próprias aplicações de uma forma consciente da privacidade. É particularmente útil para análises e prevenção de fraudes, mas não pode ser utilizado para fins publicitários, como anúncios personalizados ou medições.
Certifique-se de que adicionou a dependência necessária para o Google Play Services no seu ficheiro build.gradle:
dependencies {
implementation 'com.google.android.gms:play-services-appset:16.1.0'
}
Utilização
Para utilizar esta função, basta chamá-la a partir da sua atividade ou classe de aplicação:
AppSetIdUtils.getAppSetId(getApplicationContext());
Código Java para recuperar o ID do App Set
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);
});
}
}
Certifique-se de que adicionou a dependência necessária para os serviços do Google Play no seu ficheiro build.gradle:
dependencies {
implementation 'com.google.android.gms:play-services-appset:16.1.0'
}
Utilização
Para utilizar esta função, basta chamá-la a partir da sua atividade ou classe de aplicação:
AppSetIdUtils.getAppSetId(applicationContext)
Código Kotlin para recuperar o ID do App Set
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 Android necessários (dispositivos que não são do Google Play)
Se não houver ASID ou AIFA disponíveis:
- O AMID (Amazon Identifier) deve ser fornecido. Apenas dispositivos Amazon.
Recuperar o Amazon ID (AMID)
Para capturar o identificador de publicidade da Amazon na sua aplicação Android, pode utilizar a classe Settings.Secure para recuperar o identificador e verificar as preferências de monitorização de anúncios do utilizador. Aqui está um exemplo de código simples e limpo com base nas informações fornecidas pela documentação da Amazon:
Certifique-se de que lida com cenários em que o ID de publicidade pode não estar disponível (por exemplo, em dispositivos não Fire OS ou versões mais antigas do Fire OS).
Respeite sempre a preferência do utilizador de Limitar o rastreio de anúncios quando utilizar este identificador para fins publicitários ou analíticos. Este código deve funcionar em dispositivos Amazon Fire com Fire OS 5.1 ou posterior, de acordo com as diretrizes da Amazon
Pode chamar este método a partir da sua atividade ou serviço, passando o ContentResolver:
// Example usage in an Activity
AdvertisingIdHelper.getAmazonAdvertisingId(getContentResolver());
Código Java para recuperar o Amazon Advertising ID (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);
}
}
}
Pode chamar este método a partir de uma atividade ou serviço, passando o ContentResolver:
// Example usage in an Activity
AdvertisingIdHelper.getAmazonAdvertisingId(contentResolver)
Código Kotlin para recuperar o Amazon Advertising ID (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)
}
}
}
- O OAID (Open Advertising Identifier) deve ser fornecido. Dispositivos domésticos da China.
Recuperar o Open Advertising ID (OAID)
O Open Advertising Identifier (OAID) é um identificador único e anónimo utilizado para fins publicitários em dispositivos Android, especialmente os fabricados na China. Foi introduzido pela Mobile Security Alliance (MSA) como uma alternativa ao GAID (Advertising ID) da Google para dispositivos em que o Google Play Services não está disponível ou não é suportado, como no mercado chinês.
O OAID é utilizado principalmente para atribuição de publicidade e rastreio de utilizadores em ambientes onde o Google Play Services é restrito, permitindo aos anunciantes e programadores rastrear o comportamento dos utilizadores mantendo o anonimato.
O OAID está disponível na maioria dos dispositivos Android fabricados na China, incluindo os de marcas como a Huawei, a Xiaomi e outras. Pode ser acedido através do MSA SDK ou dos Huawei Mobile Services (HMS).
Certifique-se de que o seu ficheiro build.gradle inclui as dependências necessárias para o SDK MSA.
dependencies {
implementation 'com.bun.msa.sdk:msa:1.0.26' // Example version; check for the latest one
}
Código Java para recuperar o 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);
}
}
}
Adicione o SDK do MSA ao seu projeto: Semelhante à versão Java, é necessário integrar o SDK do MSA no seu projeto. Certifique-se de ter a dependência correta no arquivo build.gradle:
dependencies {
implementation 'com.bun.msa.sdk:msa:1.0.26' // Example version; check for the latest one
}
Código Kotlin para recuperar o 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)
}
}
}
- Se não existir outro identificador de dispositivo, então pode fornecer o ANDI (Android ID).
Recuperar o ID do Android (ANDI)
O ID do Android é um identificador único de 64 bits gerado pelo sistema operativo Android quando um dispositivo é configurado pela primeira vez. Foi concebido para ser persistente ao longo da vida útil do dispositivo, mas pode ser reposto em determinadas condições, como uma reposição de fábrica.
O ID Android é único para cada dispositivo e, a partir do Android 8.0 (Oreo), tem um âmbito por aplicação e por utilizador. Isto significa que diferentes aplicações no mesmo dispositivo receberão diferentes IDs Android, a menos que partilhem a mesma chave de assinatura.
O ID Android permanece constante, a menos que o dispositivo seja reiniciado de fábrica ou se uma aplicação for desinstalada e reinstalada após uma atualização OTA (over-the-air).
Para recuperar o ID Android numa aplicação Android, pode utilizar o seguinte fragmento de código:
import android.provider.Settings;
import android.content.Context;
String androidId = Settings.Secure.getString(context.getContentResolver(), Settings.Secure.ANDROID_ID);
Pode chamar este método a partir de uma Activity ou Service, passando o 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 necessários
- O SDID é necessário em todos os pedidos S2S
Recuperar o ID do dispositivo do Singular Web SDK (SDID)
Descrição
É necessário ter o Singular Web SDK implementado.
UtilizaçãoPara utilizar este método, basta chamá-lo a partir do código do seu web site após a inicialização do Singular SDK:
window.singularSdk.getSingularDeviceId()
Parâmetros necessários do dispositivo móvel
- Locale, Device Make, Device Model e Build são necessários em todas as solicitações S2S
Recuperação de Localidade, Marca do Dispositivo, Modelo e Construção
#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/"