Suporte a SKAdNetwork

SKAdNetwork é a estrutura de atribuição focada na privacidade da Apple para campanhas de instalação de aplicativos iOS. A partir da versão 4.0.17 do SDK do Unity, 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 de valores 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.

Versões antigas do SDK

Se você estiver usando uma versão do SDK do Unity anterior à 4.0.17, precisará ativar manualmente o suporte a SKAdNetwork usando um dos seguintes métodos.

using UnityEngine;
using Singular;

public class AppInitializer : MonoBehaviour
{
    void Awake()
    {
        // Register for SKAdNetwork attribution
        SingularSDK.SkanRegisterAppForAdNetworkAttribution();
    }
}

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 sua aplicação.

public static bool SkanUpdateConversionValue(int value)

using UnityEngine;
using Singular;

public class ConversionTracker : MonoBehaviour
{
    void OnUserSignUp()
    {
        // Track the sign-up event
        SingularSDK.Event("SignUp");

        // Update SKAN conversion value to 7
        bool success = SingularSDK.SkanUpdateConversionValue(7);

        if (success)
        {
            Debug.Log("Conversion value updated successfully");
        }
        else
        {
            Debug.LogWarning("Failed to update conversion value");
        }
    }

    void OnPurchaseComplete(float purchaseAmount)
    {
        // Track revenue event
        SingularSDK.Revenue("USD", purchaseAmount);

        // Update conversion value based on purchase tier
        int conversionValue = CalculateConversionValue(purchaseAmount);
        SingularSDK.SkanUpdateConversionValue(conversionValue);
    }

    int CalculateConversionValue(float amount)
    {
        // Your custom logic to determine conversion value
        if (amount >= 100) return 63;      // High value
        if (amount >= 50) return 40;       // Medium value
        if (amount >= 10) return 20;       // Low value
        return 10;                          // Minimal value
    }
}

public static int? SkanGetConversionValue()

using UnityEngine;
using Singular;

public class ConversionMonitor : MonoBehaviour
{
    void CheckConversionValue()
    {
        int? currentValue = SingularSDK.SkanGetConversionValue();

        if (currentValue.HasValue)
        {
            Debug.Log($"Current conversion value: {currentValue.Value}");

            // Only update if current value is below threshold
            if (currentValue.Value < 30)
            {
                SingularSDK.SkanUpdateConversionValue(30);
            }
        }
        else
        {
            Debug.LogWarning("Conversion value not available");
        }
    }
}

public static void SetConversionValueUpdatedHandler(SingularConversionValueUpdatedHandler handler)

using UnityEngine;
using Singular;

public class ConversionValueMonitor : MonoBehaviour, SingularConversionValueUpdatedHandler
{
    void Awake()
    {
        // Register this class as the conversion value update handler
        SingularSDK.SetConversionValueUpdatedHandler(this);
    }

    // This method is called whenever the conversion value is updated
    public void OnConversionValueUpdated(int newValue)
    {
        Debug.Log($"Conversion value updated to: {newValue}");

        // Log the update to your analytics
        LogConversionValueUpdate(newValue);

        // Trigger any app-specific behavior
        if (newValue >= 50)
        {
            UnlockPremiumFeature();
        }
    }

    void LogConversionValueUpdate(int value)
    {
        // Your analytics logging logic
        Debug.Log($"Analytics: SKAN CV = {value}");
    }

    void UnlockPremiumFeature()
    {
        // Your custom logic
        Debug.Log("Premium feature unlocked based on high conversion value");
    }
}

Suporte ao App Tracking Transparency (ATT)

A App Tracking Transparency (ATT) é a estrutura de privacidade da Apple que requer 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 utilizador antes de inicializar, definindo a propriedade waitForTrackingAuthorizationWithTimeoutInterval. Este atraso dá ao utilizador tempo para responder ao pedido ATT, evitando atrasos indefinidos se o pedido não for apresentado.

Etapas de configuração

1. Selecione o objeto SingularSDKObject na hierarquia da cena do Unity.
2. No painel Inspetor, localize a propriedade waitForTrackingAuthorizationWithTimeoutInterval.
3. Defina o valor com base na sua implementação de ATT:
   • Mostrar prompt ATT: Defina como 300(5 minutos)
   • Não mostrar aviso de ATT: Deixar em 0(sem espera)

Exemplo de implementação

Veja como implementar a ATT em seu aplicativo Unity com o tempo de inicialização adequado do SDK.

using UnityEngine;
using Singular;

#if UNITY_IOS
using Unity.Advertisement.IosSupport;
#endif

public class ATTManager : MonoBehaviour
{
    void Start()
    {
#if UNITY_IOS
        // Check ATT status on iOS
        RequestTrackingAuthorization();
#else
        // Initialize SDK immediately on non-iOS platforms
        InitializeSingularSDK();
#endif
    }

#if UNITY_IOS
    void RequestTrackingAuthorization()
    {
        // Check current authorization status
        var status = ATTrackingStatusBinding.GetAuthorizationTrackingStatus();

        if (status == ATTrackingStatusBinding.AuthorizationTrackingStatus.NOT_DETERMINED)
        {
            // Request authorization if not yet determined
            ATTrackingStatusBinding.RequestAuthorizationTracking(OnATTResponse);
        }
        else
        {
            // Status already determined, initialize SDK
            InitializeSingularSDK();
        }
    }

    void OnATTResponse(int status)
    {
        // Log the user's response
        switch (status)
        {
            case (int)ATTrackingStatusBinding.AuthorizationTrackingStatus.AUTHORIZED:
                Debug.Log("User authorized tracking - IDFA will be available");
                break;
            case (int)ATTrackingStatusBinding.AuthorizationTrackingStatus.DENIED:
                Debug.Log("User denied tracking - IDFA not available");
                break;
            case (int)ATTrackingStatusBinding.AuthorizationTrackingStatus.RESTRICTED:
                Debug.Log("Tracking restricted by device settings");
                break;
            default:
                Debug.Log("ATT status unknown");
                break;
        }

        // Initialize SDK after receiving response
        InitializeSingularSDK();
    }
#endif

    void InitializeSingularSDK()
    {
        // SDK is initialized with waitForTrackingAuthorizationWithTimeoutInterval
        // configured in the Inspector, so it will wait for ATT if needed
        // If Initialize On Awake is disabled, manually initialize here
        // SingularSDK.InitializeSingularSDK();

        Debug.Log("Singular SDK initialized");
    }
}

Melhores práticas de ATT

• Mensagens pré-prompt: Mostre aos utilizadores um ecrã pré-ATT que explique por que motivo 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

• Documentação da estrutura de transparência de rastreamento de aplicativos da Apple
• Práticas de ativação e desativação do SDK da Singular
• Diretrizes da Apple sobre privacidade do utilizador e utilização de dados