Suporte a SKAdNetwork

SKAdNetwork é a estrutura de atribuição focada na privacidade da Apple para campanhas de instalação de aplicativos iOS. A partir do SDK do Unreal Engine versão 2.0.11, o SKAdNetwork é ativado por padrão no Modo Gerenciado, em que o Singular atualiza automaticamente os valores de conversão com base no modelo de conversão configurado no painel.

Entendendo os modos SKAN

Modo gerenciado (padrão)

No Managed Mode, o Singular lida automaticamente com as atualizações do valor de conversão com base no modelo de conversão configurado no painel. Esta é a abordagem recomendada para a maioria das aplicações, uma vez que requer um código mínimo e fornece um rastreamento de conversão ideal.

• Atualizações automáticas: O Singular gerencia todas as atualizações de valores de conversão com base nos eventos do usuário e no seu modelo configurado.
• Configuração do painel: Projete seu modelo de conversão no dashboard do Singular sem alterações de código.
• Otimização: Beneficie-se da experiência da Singular em maximizar as atualizações do valor de conversão dentro das restrições da Apple.

Modo manual (avançado)

O Modo manual oferece controle total sobre as atualizações de valores de conversão, permitindo implementar uma lógica personalizada para determinar quando e como atualizar os valores de conversão do SKAN. Utilize este modo apenas se tiver requisitos específicos que o Modo Gerido não consegue satisfazer.

Opções de configuração

Configure o comportamento da SKAdNetwork no método USingularSDKBPLibrary::Initialize. A tabela seguinte mostra as opções disponíveis e as suas predefinições.

Versões antigas do SDK

Se estiver a utilizar uma versão do SDK do Unreal Engine anterior à 2.0.11, active manualmente o suporte de SKAdNetwork utilizando o método abaixo.

// Initialize with SKAdNetwork enabled
bool Success = USingularSDKBPLibrary::Initialize(
    TEXT("YOUR_SDK_KEY"),
    TEXT("YOUR_SDK_SECRET"),
    60,                      // Session timeout
    TEXT(""),                // Custom user ID
    true,                    // Enable SKAdNetwork
    false,                   // Manual SKAN management
    0,                       // Wait for tracking authorization
    false,                   // OAID collection
    true,                    // Enable logging
    3,                       // Log level
    false,                   // Clipboard attribution
    TEXT(""),                // Facebook App ID
    TEXT("")                 // Custom SDID
);

if (Success)
{
    UE_LOG(LogTemp, Log, TEXT("SDK initialized with SKAdNetwork enabled"));
}

// Register for SKAdNetwork attribution
USingularSDKBPLibrary::SkanRegisterAppForAdNetworkAttribution();
UE_LOG(LogTemp, Log, TEXT("Registered for SKAdNetwork attribution"));

Configuração do modo manual

Para implementar uma lógica de valor de conversão personalizada, active o Modo manual e utilize os métodos SDK fornecidos para atualizar e monitorizar os valores de conversão ao longo do ciclo de vida da aplicação.

// Initialize with Manual Mode enabled
bool Success = USingularSDKBPLibrary::Initialize(
    TEXT("YOUR_SDK_KEY"),
    TEXT("YOUR_SDK_SECRET"),
    60,                      // Session timeout
    TEXT(""),                // Custom user ID
    true,                    // Enable SKAdNetwork
    true,                    // Enable Manual SKAN management
    0,                       // Wait for tracking authorization
    false,                   // OAID collection
    true,                    // Enable logging
    3,                       // Log level
    false,                   // Clipboard attribution
    TEXT(""),                // Facebook App ID
    TEXT("")                 // Custom SDID
);

if (Success)
{
    UE_LOG(LogTemp, Log, TEXT("SDK initialized with Manual SKAN Mode"));
}

static bool SkanUpdateConversionValue(int conversionValue)

// Track a sign-up event
USingularSDKBPLibrary::SendEvent(TEXT("SignUp"));

// Update the conversion value to 7
bool Success = USingularSDKBPLibrary::SkanUpdateConversionValue(7);

if (Success)
{
    UE_LOG(LogTemp, Log, TEXT("Conversion value updated to 7"));
}
else
{
    UE_LOG(LogTemp, Warning, TEXT("Failed to update conversion value"));
}

// Example: Update based on purchase tier
void OnPurchaseComplete(float PurchaseAmount)
{
    // Track revenue event
    USingularSDKBPLibrary::SendRevenue(TEXT("purchase"), TEXT("USD"), PurchaseAmount);

    // Calculate conversion value based on amount
    int ConversionValue = 10; // Default
    if (PurchaseAmount >= 100.0f)
    {
        ConversionValue = 63; // High value
    }
    else if (PurchaseAmount >= 50.0f)
    {
        ConversionValue = 40; // Medium value
    }
    else if (PurchaseAmount >= 10.0f)
    {
        ConversionValue = 20; // Low value
    }

    USingularSDKBPLibrary::SkanUpdateConversionValue(ConversionValue);
}

static int SkanGetConversionValue()

// Get the current conversion value
int CurrentValue = USingularSDKBPLibrary::SkanGetConversionValue();
UE_LOG(LogTemp, Log, TEXT("Current conversion value: %d"), CurrentValue);

// Only update if current value is below threshold
if (CurrentValue < 30)
{
    USingularSDKBPLibrary::SkanUpdateConversionValue(30);
    UE_LOG(LogTemp, Log, TEXT("Conversion value updated from %d to 30"), CurrentValue);
}

Recursos adicionais

Para obter informações mais abrangentes sobre a implementação e as práticas recomendadas da SKAdNetwork, consulte o Guia de implementação da SKAdNetwork do SDK do iOS.

Suporte ao App Tracking Transparency (ATT)

A App Tracking Transparency (ATT) é a estrutura de privacidade da Apple que exige o consentimento do utilizador antes de aceder ao IDFA (Identificador para Anunciantes) do dispositivo e partilhar dados do utilizador. A implementação correta da ATT é fundamental para a atribuição do iOS e para maximizar a precisão das suas campanhas de aquisição de utilizadores.

Por que a ATT é importante para a atribuição

A partir do iOS 14.5, os aplicativos devem solicitar permissão do usuário por meio da estrutura ATT antes de acessar o IDFA. Embora a atribuição ainda seja possível sem o IDFA usando impressão digital e métodos probabilísticos, ter o IDFA melhora significativamente a precisão da atribuição e fornece correspondência determinística.

• Atribuição determinística: O IDFA permite uma atribuição precisa, ao nível do dispositivo, que liga as impressões de anúncios diretamente às instalações.
• Otimização da rede de anúncios: As redes de anúncios podem otimizar melhor as campanhas e fornecer relatórios mais precisos com o acesso ao IDFA.
• Informações ao nível do utilizador: O acesso ao IDFA permite uma análise mais granular do comportamento do utilizador e um acompanhamento de coortes.

Tempo de inicialização do SDK

O momento da inicialização do SDK em relação ao prompt ATT é fundamental. Se o SDK inicializar e enviar a primeira sessão antes que o usuário responda ao prompt ATT, o IDFA não será capturado, resultando em uma atribuição menos precisa.

Por que atrasar a inicialização?

Por padrão, o Singular SDK envia uma sessão imediatamente após a inicialização. Quando essa sessão vem de um novo dispositivo, ela aciona o processo de atribuição do Singular usando apenas os dados disponíveis naquele momento. Se o usuário ainda não tiver respondido ao prompt ATT, o IDFA não estará disponível e a atribuição será baseada em métodos menos precisos.

Configurar o tempo limite de espera do SDK

Configure o SDK para aguardar a resposta ATT do usuário antes de inicializar, definindo o parâmetro waitForTrackingAuthorizationWithTimeoutInterval. Esse atraso dá ao usuário tempo para responder ao prompt ATT, evitando atrasos indefinidos se o prompt não for exibido.

Como funciona o atraso ATT

1. O SDK inicializa e começa a gravar uma sessão e os eventos do utilizador, mas ainda não os envia para os servidores Singular.
2. Assim que o consentimento do App Tracking Transparency é concedido, negado ou o tempo limite expira, o SDK envia a sessão e os eventos em fila para a Singular (com ou sem IDFA).
3. A Singular inicia o processo de atribuição, aproveitando o IDFA, se disponível.

Implementação

Exemplo de configuração

Defina o parâmetro waitForTrackingAuthorizationWithTimeoutIntervalao inicializar o SDK. Este valor representa o número máximo de segundos a aguardar pela resposta ATT do utilizador.

// Initialize with ATT delay
bool Success = USingularSDKBPLibrary::Initialize(
    TEXT("YOUR_SDK_KEY"),
    TEXT("YOUR_SDK_SECRET"),
    60,                      // Session timeout
    TEXT(""),                // Custom user ID
    true,                    // Enable SKAdNetwork
    false,                   // Manual SKAN management
    300,                     // Wait up to 300 seconds (5 minutes) for ATT response
    false,                   // OAID collection
    true,                    // Enable logging
    3,                       // Log level
    false,                   // Clipboard attribution
    TEXT(""),                // Facebook App ID
    TEXT("")                 // Custom SDID
);

if (Success)
{
    UE_LOG(LogTemp, Log, TEXT("SDK initialized with ATT delay"));
}

Melhores práticas de ATT

• Mensagens de pré-prompt: Mostre aos utilizadores um ecrã pré-ATT que explique por que razão necessita de permissão de rastreio e como isso os beneficia (melhores anúncios, experiência melhorada). Isto pode aumentar significativamente as taxas de aceitação.
• O momento é importante: Mostre o aviso ATT num momento natural do fluxo da aplicação, e não imediatamente no primeiro lançamento. Deixe que os utilizadores experimentem primeiro a sua aplicação.
• Mensagens personalizadas: Personalize a mensagem de aviso da ATT no ficheiro Info.plist utilizando a tecla NSUserTrackingUsageDescription para explicar claramente o objetivo do rastreio.
• Teste exaustivamente: Teste cenários autorizados e negados para garantir que a sua aplicação funciona corretamente, independentemente da escolha do utilizador.
• Respeite a escolha do utilizador: Nunca solicite repetidamente aos utilizadores que tenham negado o rastreio nem mostre mensagens agressivas que os pressionem a aceitar.

Recursos adicionais

Para obter mais informações sobre as alterações e práticas recomendadas do iOS 14+, consulte os seguintes recursos:

• Preparação para o iOS 14
• Documentação da estrutura de transparência de rastreamento de aplicativos da Apple
• Práticas de ativação e desativação do SDK Singular