(Herdado) Guia de SSO do Apple (REST API V1) apple-sso-cookbook-rest-api-v1

IMPORTANT
O conteúdo desta página é fornecido apenas para fins informativos. O uso desta API requer uma licença atual do Adobe. Não é permitida nenhuma utilização não autorizada.
IMPORTANT
Mantenha-se informado sobre os anúncios mais recentes do produto de Autenticação da Adobe Pass e as linhas do tempo de desativação agregadas na página Anúncios de produto.

A API REST V1 de autenticação da Adobe Pass tem suporte para Logon único de parceiro (SSO) para usuários finais de aplicativos clientes em execução no iOS, iPadOS ou tvOS.

Este documento atua como uma extensão para a documentação REST API V1 existente, que pode ser encontrada aqui.

Guia apple-sso-cookbook-rest-api-v1-cookbook

Para se beneficiar da experiência do usuário do Apple SSO, o aplicativo precisa integrar a Estrutura da Conta de Assinante de Vídeo desenvolvida pela Apple, enquanto para a comunicação REST API V1 de Autenticação da Adobe Pass, é necessário seguir a sequência de etapas apresentadas abaixo.

Permissão apple-sso-cookbook-rest-api-v1-permission

TIP
Dica Profissional: o aplicativo de streaming deve solicitar acesso às informações de assinatura do usuário salvas no nível do dispositivo, para o qual o usuário deve dar permissão ao aplicativo para continuar, de modo semelhante a fornecer acesso à câmera ou ao microfone do dispositivo. Esta permissão deve ser solicitada por aplicativo usando a Estrutura de Conta de Assinante de Vídeo da Apple, e o dispositivo salvará a seleção do usuário.
TIP
Dica Profissional: Recomendamos incentivar os usuários que se recusam a conceder permissão de acesso às informações de assinatura explicando os benefícios da experiência do usuário de logon único do Apple, mas esteja ciente de que o usuário pode alterar sua decisão acessando as configurações do aplicativo (acesso de permissão ao Provedor de TV) ou Settings -> TV Provider no iOS e iPadOS ou Settings -> Accounts -> TV Provider no tvOS.
TIP
Dica Profissional: recomendamos solicitar a permissão do usuário quando o aplicativo entrar no estado de primeiro plano, pois o aplicativo pode verificar a permissão para acessar as informações de assinatura do usuário a qualquer momento antes de solicitar a autenticação do usuário.

Autenticação apple-sso-cookbook-rest-api-v1-authentication

Etapa: "Há um token de autenticação de Adobe válido?" step1

TIP
Dica: implemente isso por meio do serviço de API Verificar Token de Autenticação da Autenticação do Adobe Pass.

Etapa: "O usuário está conectado por meio do SSO do parceiro?" step2

TIP
Dica: faça a implementação por meio da Estrutura da Conta de Assinante de Vídeo.
  • O aplicativo teria que verificar a permissão para acessar as informações de assinatura do usuário e continuar somente se o usuário permitisse.
  • O aplicativo teria que enviar uma solicitação para obter informações sobre a conta do assinante.
  • O aplicativo teria que aguardar e processar as informações de metadados.
TIP
Dica Profissional: Siga o trecho de código e preste mais atenção aos comentários.
...
let videoSubscriberAccountManager: VSAccountManager = VSAccountManager();

videoSubscriberAccountManager.checkAccessStatus(options: [VSCheckAccessOption.prompt: true]) { (accessStatus, error) -> Void in
            switch (accessStatus) {
            // The user allows the application to access subscription information.
            case VSAccountAccessStatus.granted:
                    // Construct the request for subscriber account information.
                    let vsaMetadataRequest: VSAccountMetadataRequest = VSAccountMetadataRequest();

                    // This is actually the SAML Issuer not the channel ID.
                    vsaMetadataRequest.channelIdentifier = "https://saml.sp.auth.adobe.com";

                    // This is the subscription account information needed at this step.
                    vsaMetadataRequest.includeAccountProviderIdentifier = true;

                    // This is the subscription account information needed at this step.
                    vsaMetadataRequest.includeAuthenticationExpirationDate = true;

                    // This is going to make the Video Subscriber Account Framework to refrain from prompting the user with the providers picker at this step.
                    vsaMetadataRequest.isInterruptionAllowed = false;

                    // Submit the request for subscriber account information - accountProviderIdentifier.
                    videoSubscriberAccountManager.enqueue(vsaMetadataRequest) { vsaMetadata, vsaError in
                        if (vsaMetadata != nil && vsaMetadata!.accountProviderIdentifier != nil) {
                            // The vsaMetadata!.authenticationExpirationDate will contain the expiration date for current authentication session.
                            // The vsaMetadata!.authenticationExpirationDate should be compared against current date.
                            ...
                            // The vsaMetadata!.accountProviderIdentifier will contain the provider identifier as it is known for the platform configuration.
                            // The vsaMetadata!.accountProviderIdentifier represents the platformMappingId in terms of Adobe Pass Authentication configuration.
                            ...
                            // The application must determine the MVPD id property value based on the platformMappingId property value obtained above.
                            // The application must use the MVPD id further in its communication with Adobe Pass Authentication services.
                            ...
                            // Continue with the "Obtain a profile request from Adobe for the selected MVPD" step.
                            ...
                            // Continue with the "Forward the Adobe request to Partner SSO to obtain the profile" step.
                            ...
                        } else {
                            // The user is not authenticated at platform level, continue with the "Fetch Adobe configuration" step.
                            ...
                        }
                    }

            // The user has not yet made a choice or does not allow the application to access subscription information.
            default:
                // Continue with the "Initiate regular authentication workflow" step.
                ...
            }
}
...

Etapa: "Buscar configuração de Adobe" step3

TIP
Dica: implemente-a por meio da Autenticação Adobe Pass Forneça o serviço de API MVPD List.
TIP
Dica Profissional: esteja ciente das propriedades do MVPD: enablePlatformServices, boardingStatus, displayInPlatformPicker, platformMappingId, requiredMetadataFields e preste atenção extra aos comentários apresentados em trechos de código de outras etapas.

Etapa "Iniciar fluxo de trabalho SSO do parceiro com configuração Adobe" step4

TIP
Dica: faça a implementação por meio da Estrutura da Conta de Assinante de Vídeo.
  • O aplicativo teria que verificar a permissão para acessar as informações de assinatura do usuário e continuar somente se o usuário permitisse.
  • O aplicativo teria que fornecer um delegate para o VSAccountManager.
  • O aplicativo teria que enviar uma solicitação para obter informações sobre a conta do assinante.
  • O aplicativo teria que aguardar e processar as informações de metadados.
TIP
Dica Profissional: Siga o trecho de código e preste mais atenção aos comentários.
    ...
    let videoSubscriberAccountManager: VSAccountManager = VSAccountManager();

    // This must be a class implementing the VSAccountManagerDelegate protocol.
    let videoSubscriberAccountManagerDelegate: VideoSubscriberAccountManagerDelegate = VideoSubscriberAccountManagerDelegate();

    videoSubscriberAccountManager.delegate = videoSubscriberAccountManagerDelegate;

    videoSubscriberAccountManager.checkAccessStatus(options: [VSCheckAccessOption.prompt: true]) { (accessStatus, error) -> Void in
                switch (accessStatus) {
                // The user allows the application to access subscription information.
                case VSAccountAccessStatus.granted:
                        // Construct the request for subscriber account information.
                        let vsaMetadataRequest: VSAccountMetadataRequest = VSAccountMetadataRequest();

                        // This is actually the SAML Issuer not the channel ID.
                        vsaMetadataRequest.channelIdentifier = "https://saml.sp.auth.adobe.com";

                        // This is the subscription account information needed at this step.
                        vsaMetadataRequest.includeAccountProviderIdentifier = true;

                        // This is the subscription account information needed at this step.
                        vsaMetadataRequest.includeAuthenticationExpirationDate = true;

                        // This is going to make the Video Subscriber Account Framework to prompt the user with the providers picker at this step.
                        vsaMetadataRequest.isInterruptionAllowed = true;

                        // This can be computed from the [Adobe Pass Authentication](/docs/pass/authentication/provide-mvpd-list.md) service response in order to filter the TV providers from the Apple picker.
                        vsaMetadataRequest.supportedAccountProviderIdentifiers = supportedAccountProviderIdentifiers;

                        // This can be computed from the [Adobe Pass Authentication](/docs/pass/authentication/provide-mvpd-list.md) service response in order to sort the TV providers from the Apple picker.
                        if #available(iOS 11.0, tvOS 11, *) {
                            vsaMetadataRequest.featuredAccountProviderIdentifiers = featuredAccountProviderIdentifiers;
                        }

                        // Submit the request for subscriber account information - accountProviderIdentifier.
                        videoSubscriberAccountManager.enqueue(vsaMetadataRequest) { vsaMetadata, vsaError in
                            // This represents the checks for the "Is user login successful?" step.
                            if (vsaMetadata != nil && vsaMetadata!.accountProviderIdentifier != nil) {
                                // The vsaMetadata!.authenticationExpirationDate will contain the expiration date for current authentication session.
                                // The vsaMetadata!.authenticationExpirationDate should be compared against current date.
                                ...
                                // The vsaMetadata!.accountProviderIdentifier will contain the provider identifier as it is known for the platform configuration.
                                // The vsaMetadata!.accountProviderIdentifier represents the platformMappingId in terms of Adobe Pass Authentication configuration.
                                ...
                                // The application must determine the MVPD id property value based on the platformMappingId property value obtained above.
                                // The application must use the MVPD id further in its communication with Adobe Pass Authentication services.
                                ...
                                // Continue with the "Obtain a profile request from Adobe for the selected MVPD" step.
                                ...
                                // Continue with the "Forward the Adobe request to Partner SSO to obtain the profile" step.
                                ...
                            } else {
                                // The user is not authenticated at platform level.
                                if (vsaError != nil) {
                                    // The application can check to see if the user selected a provider which is present in Apple picker, but the provider is not onboarded in platform SSO.
                                    if let error: NSError = (vsaError! as NSError), error.code == 1, let appleMsoId = error.userInfo["VSErrorInfoKeyUnsupportedProviderIdentifier"] as! String? {
                                        var mvpd: Mvpd? = nil;

                                        // The requestor.mvpds must be computed during the "Fetch Adobe configuration" step.
                                        for provider in requestor.mvpds {
                                            if provider.platformMappingId == appleMsoId {
                                                mvpd = provider;
                                                break;
                                            }
                                        }

                                        if mvpd != nil {
                                            // Continue with the "Initiate regular authentication workflow" step, but you can skip prompting the user with your MVPD picker and use the mvpd selection, therefore creating a better UX.
                                            ...
                                        } else {
                                            // Continue with the "Initiate regular authentication workflow" step.
                                            ...
                                        }
                                    } else {
                                        // Continue with the "Initiate regular authentication workflow" step.
                                        ...
                                    }
                                } else {
                                    // Continue with the "Initiate regular authentication workflow" step.
                                    ...
                                }
                            }
                        }

                // The user has not yet made a choice or does not allow the application to access subscription information.
                default:
                    // Continue with the "Initiate regular authentication workflow" step.
                    ...
                }
    }
    ...

Etapa: "O logon do usuário foi bem-sucedido?" step5

TIP
Dica de Profissional: esteja ciente do trecho de código da etapa "Iniciar fluxo de trabalho SSO de Parceiro com configuração Adobe". O logon do usuário é bem-sucedido caso o vsaMetadata!.accountProviderIdentifier contenha um valor válido e a data atual não tenha passado o valor vsaMetadata!.authenticationExpirationDate.

Etapa "Obter uma solicitação de perfil do Adobe para o MVPD selecionado" step6

TIP
Dica: implemente isso por meio do serviço de API Solicitação de perfil da Autenticação do Adobe Pass.
TIP
Dica de Profissional: esteja ciente de que o identificador do provedor obtido da Estrutura de Conta de Assinante de Vídeo representa o platformMappingId em termos de configuração de Autenticação do Adobe Pass. Portanto, o aplicativo deve determinar o valor da propriedade da MVPD id, usando o valor platformMappingId, por meio do serviço de API Autenticação da Adobe Pass Fornecer Lista da MVPD.

Etapa: "Encaminhar a solicitação de Adobe para o SSO do parceiro para obter o perfil" step7

TIP
Dica: faça a implementação por meio da Estrutura da Conta de Assinante de Vídeo.
  • O aplicativo teria que verificar a permissão para acessar as informações de assinatura do usuário e continuar somente se o usuário permitisse.
  • O aplicativo teria que enviar uma solicitação para obter informações sobre a conta do assinante.
  • O aplicativo teria que aguardar e processar as informações de metadados.
TIP
Dica Profissional: Siga o trecho de código e preste mais atenção aos comentários.
    ...
    let videoSubscriberAccountManager: VSAccountManager = VSAccountManager();

    videoSubscriberAccountManager.checkAccessStatus(options: [VSCheckAccessOption.prompt: true]) { (accessStatus, error) -> Void in
                switch (accessStatus) {
                // The user allows the application to access subscription information.
                case VSAccountAccessStatus.granted:
                        // Construct the request for subscriber account information.
                        let vsaMetadataRequest: VSAccountMetadataRequest = VSAccountMetadataRequest();

                        // This is actually the SAML Issuer not the channel ID.
                        vsaMetadataRequest.channelIdentifier = "https://saml.sp.auth.adobe.com";

                        // This is going to include subscription account information which should match the provider determined in a previous step.
                        vsaMetadataRequest.includeAccountProviderIdentifier = true;

                        // This is going to include subscription account information which should match the provider determined in a previous step.
                        vsaMetadataRequest.includeAuthenticationExpirationDate = true;

                        // This is going to make the Video Subscriber Account Framework to refrain from prompting the user with the providers picker at this step.
                        vsaMetadataRequest.isInterruptionAllowed = false;

                        // This are the user metadata fields expected to be available on a successful login and are determined from the [Adobe Pass Authentication](/docs/pass/authentication/provide-mvpd-list.md) service. Look for the requiredMetadataFields associated with the provider determined in a previous step.
                        vsaMetadataRequest.attributeNames = requiredMetadataFields;

                        // This is the payload from [Adobe Pass Authentication](/docs/pass/authentication/retrieve-profilerequest.md) service.
                        vsaMetadataRequest.verificationToken = profileRequestPayload;

                        // Submit the request for subscriber account information.
                        videoSubscriberAccountManager.enqueue(vsaMetadataRequest) { vsaMetadata, vsaError in
                            if (vsaMetadata != nil && vsaMetadata!.samlAttributeQueryResponse != nil) {
                                var samlResponse: String? = vsaMetadata!.samlAttributeQueryResponse!;

                                // Remove new lines, new tabs and spaces.
                                samlResponse = samlResponse?.replacingOccurrences(of: "[ \\t]+", with: " ", options: String.CompareOptions.regularExpression);
                                samlResponse = samlResponse?.components(separatedBy: CharacterSet.newlines).joined(separator: "");
                                samlResponse = samlResponse?.trimmingCharacters(in: CharacterSet.whitespacesAndNewlines);

                                // Base64 encode.
                                samlResponse = samlResponse?.data(using: .utf8)?.base64EncodedString(options: []);

                                // URL encode. Please be aware not to double URL encode it further.
                                samlResponse = samlResponse?.addingPercentEncoding(withAllowedCharacters: CharacterSet.init(charactersIn: "!*'();:@&=+$,/?%#[]").inverted);

                                // Continue with the "Exchange the Partner SSO profile for an Adobe authentication token" step.
                                ...
                            } else {
                                // Continue with the "Initiate regular authentication workflow" step.
                                ...
                            }
                        }

                // The user has not yet made a choice or does not allow the application to access subscription information.
                default:
                    // Continue with the "Initiate regular authentication workflow" step.
                    ...
                }
    }
    ...

Etapa: "Trocar o perfil SSO do parceiro por um token de autenticação Adobe" step8

TIP
Dica: implemente isso por meio do serviço de API Token Exchange da Autenticação do Adobe Pass.
TIP
Dica do Profissional: esteja ciente do trecho de código da etapa "Encaminhar a solicitação de Adobe para o SSO do Parceiro para obter o perfil". Este vsaMetadata!.samlAttributeQueryResponse! representa o SAMLResponse, que precisa ser passado no Token Exchange e requer manipulação e codificação de cadeia de caracteres (Base64 codificada e URL codificada posteriormente) antes de fazer a chamada.

Etapa: "O token Adobe foi gerado com êxito?" step9

TIP
Dica: implemente isso por meio da resposta bem-sucedida do Token Exchange da Autenticação do Adobe Pass, que será um 204 No Content, indicando que o token foi criado com êxito e está pronto para ser usado para os fluxos de autorização.

Etapa: "Iniciar fluxo de trabalho de autenticação regular" step10

TIP
Adobe Pass Dica: implemente isso por meio da Solicitação de Código de Registro, Iniciar Autenticação e Recuperar Token de Autenticação ou Verificar Token de Autenticação para os serviços de API.
TIP
Dica do profissional: siga as etapas abaixo para a implementação do tvOS.
TIP
Dica dos profissionais: Siga as etapas abaixo para a(s) implementação(ões) do iOS/iPadOS.

Etapa: "Continuar com os fluxos de autorização" step11

TIP
Dica: implemente isso por meio da Autenticação do Adobe Pass Iniciar Autorização e Obter Token de Mídia Curta para os serviços de API.

Sair apple-sso-cookbook-rest-api-v1-logout

A Estrutura de Conta de Assinante de Vídeo não fornece uma API para desconectar programaticamente as pessoas que entraram na conta do provedor de TV no nível do sistema do dispositivo. Portanto, para que o logout tenha efeito total, o usuário final teria que sair explicitamente do Settings -> TV Provider no iOS/iPadOS ou do Settings -> Accounts -> TV Provider no tvOS. A outra opção que o usuário teria é retirar a permissão para acessar as informações de assinatura do usuário na seção de configurações específicas do aplicativo (acesso ao Provedor de TV).

TIP
Dica: implemente isso por meio da mídia da Chamada de Metadados do Usuário e do Logout da Autenticação da Adobe Pass.
TIP
Dica do profissional: siga as etapas abaixo para a implementação do tvOS.
  • O aplicativo teria que determinar se a autenticação ocorreu como resultado de uma entrada através do SSO parceiro, usando os "metadados de usuário🔗 do tokenSource" do serviço de Autenticação do Adobe Pass.
  • O aplicativo teria que instruir/solicitar que o usuário saia explicitamente de Settings -> Accounts -> TV Provider no tvOS only caso o valor "tokenSource" fosse igual a "Apple".
  • O aplicativo teria que iniciar o logout do serviço de Autenticação do Adobe Pass usando uma chamada HTTP direta. Isso não facilitaria a limpeza da sessão no lado do MVPD.
TIP
Dica dos profissionais: Siga as etapas abaixo para a(s) implementação(ões) do iOS/iPadOS.
  • O aplicativo teria que determinar se a autenticação ocorreu como resultado de uma entrada através do SSO parceiro, usando os "metadados de usuário🔗 do tokenSource" do serviço de Autenticação do Adobe Pass.
  • O aplicativo teria que instruir/solicitar que o usuário saia explicitamente de Settings -> TV Provider no iOS/iPadOS only caso o valor "tokenSource" fosse igual a "Apple".
  • O aplicativo teria que iniciar o logout do serviço de Autenticação do Adobe Pass usando um WKWebView ou um componente SFSafariViewController. Isso facilitaria a limpeza da sessão no lado do MVPD.
recommendation-more-help
3f5e655c-af63-48cc-9769-2b6803cc5f4b