Gerenciamento de tradução

Over the Air (Strings)

O conteúdo de toda a Central de Ajuda é traduzido automaticamente de inglês pelo Phrase Language AI.

Atualize as traduções para aplicativos iOS, Android, React Native e Flutter com um único clique sem lançar uma nova versão na App Store ou no Google Play. As atualizações de etiquetas de texto são pushed instantaneamente para aplicativos móveis.

OTA_user_device_diagram.png

O Over-the-Air (OTA) também se integra com as plataformas i18Next e Rails, permitindo que os usuários atualizem e gerenciem conteúdo localizado em aplicativos da Web sem precisarem de uma reimplantação.

Um novo lançamento deve ser criado para que as configurações atualizadas sejam aplicadas. Todo o conteúdo incluído em um lançamento deve estar disponível no Phrase Strings, que faz fluir traduções diretamente para o aplicativo. Se o conteúdo não estiver presente, as traduções não serão entregues.

Ao iniciar um aplicativo que implemente o iOS, Android, React Native ou Flutter SDK pela primeira vez em um dispositivo, um identificador de dispositivo exclusivo e aleatório é gerado. Este identificador rastreia usuários ativos em um determinado período de tempo. Ele não é usado para qualquer outra forma ou meio de rastreamento e não contém informações de usuário ou dispositivo.

O único limite para a OTA é a quantidade de MAU (usuários ativos mensais), dependendo do plano de preços selecionado.

O MAU é o número de dispositivos exclusivos a partir dos quais as traduções são solicitadas. A cada dispositivo é atribuído um ID aleatório, e o MAU é calculado a partir do número de IDs diferentes atribuídos nos últimos 30 dias. Qualquer interação com servidores do Phrase é considerada uma solicitação.

Dados

O SDK comunica com o serviço OTA para verificar atualizações e inclui os seguintes detalhes com cada solicitação:

  • Identificador do dispositivo (p.ex: "F3AFCB10-80A2-84CB-94C0-27F5EF58876D". É exclusivo para este aplicativo e, portanto, não permite o rastreamento de um dispositivo específico.)

  • Versão do aplicativo (p.ex: "1.2.0")

  • Última atualização do arquivo de tradução (p.ex: "1542187679")

  • Versão de SDK (p.ex: "1.0.0")

  • Local (p.ex. "de-DE")

  • Formato de arquivo (p.ex. "strings")

  • Cliente (p.ex. "ios")

  • ID de distribuição (ID da distribuição)

  • Segredo ambiental (para distinguir entre o desenvolvimento e a produção)

Distribuições OTA

As plataformas de destino são definidas dentro da distribuição:

  • iOS

  • Android

  • Flutter

  • i18next

  • Carris

As distribuições múltiplas são possíveis, mas idealmente há uma distribuição por projeto. Se utilizar uma distribuição para iOS e Android, os marcadores de posição dos dois formatos são convertidos automaticamente.

Fallbacks

Se as fallbacks de idioma forem definidas nas configurações de idioma do projeto ao qual a distribuição está conectada, strings do idioma selecionado serão exibidas se o idioma solicitado existir, mas a chave não for traduzida.

Se um idioma específico de país (p.ex. en-GB) for usado, mas não fizer parte do lançamento, o sistema poderá voltar a usar uma versão padrão (p.ex. en) desse idioma se ele existir no projeto. Se o idioma solicitado não for encontrado, o local padrão do projeto poderá ser utilizado.

Criar uma distribuição

Para criar uma distribuição, siga estes passos:

  1. Na caixa Over the air (OTA) na página de Integrações, clique em configurar ou no número de configurações, se algumas já existirem.

    A página Over the air é aberta e mostra configurações existentes.

  2. Clique em Nova distribuição. A janela Adicionar distribuição é aberta.

  3. Na aba Geral, forneça um nome, ao qual o projeto a distribuição está associado, os idiomas necessários e as platas necessárias.

    • Para distribuições Android, clique na aba Android para selecionar a opção de formato que inclua qualquer tradução contendo códigos HTML em CDATA, se necessário.

    • Após selecionar o projeto a ser associado à distribuição, a aba Cronograma fica disponível. Se necessário, use esta guia para configurar lançamentos programados do OTA na distribuição.

  4. Na aba idiomas de fallback, selecione configurações de fallback específicas da distribuição conforme necessário. As opções de fallback são prioritárias conforme exibido na lista.

  5. Opcionalmente, clique na aba traduções para selecionar a opção de usar a versão mais recente revisada das traduções. Ative esta opção apenas ao trabalhar com o fluxo de trabalho de revisão avançado.

  6. Clique em Gravar.

    Os detalhes da distribuição são exibidos com IDs exigidos pelos SDKs. Os detalhes podem ser exibidos novamente clicando na distribuição na página Mais sobre o ar.

OTA Releases

Para atualizar as traduções, crie um novo lançamento na distribuição. O estado atual do projeto é exportado e disponibilizado a clientes conectados.

Para criar um lançamento, siga estes passos:

  1. Na página Over the air, clique em Adicionar lançamento ao lado da distribuição necessária.

    A janela Novo lançamento é aberta.

  2. Forneça uma descrição, as versões necessárias da plataforma, do ramo, de locais e do aplicativo.

    Se necessário, insira códigos para incluir apenas chaves com códigos específicos no lançamento.

  3. Clique em Gravar.

    O lançamento está adicionado à lista na parte de baixo da página de detalhes de distribuição.

Cronograma de lançamentos de OTA

Para configurar cronogramas recorrentes para lançar a distribuição, execute estas etapas:

  1. Na página Mais sobre o ar, clique no ícone de Phrase_Gear.png de roda cônica ao lado da distribuição necessária.

    A janela Editar distribuição é exibida.

  2. Selecione a aba Cronograma lançamento e clique em Habilitar agendamento.

    As opções de programação do lançamento são exibidas.

    Nota

    As opções de agendamento também estão disponíveis na criação de uma nova distribuição.

  3. No crie lançamentos suspenso, escolha a frequência de lançamento selecionando uma das opções disponíveis:

    • dia

    • Semana

      Selecione os dias úteis desejados das lançamentos programadas.

  4. Forneça um horário e fuso horário relevantes.

  5. Se necessário, selecione Ramo, códigos e idiomas para os lançamentos programados.

    • O campo Ramo é exibido apenas se o ramo estiver habilitado no projeto. Selecionar um ramo atualiza a lista de locais e idiomas.

  6. Opcionalmente, especifique as versões do aplicativo nos campos Versão mínima e Versão máxima.

    Deixe em branco para aplicar o lançamento do cronograma a todas as versões do aplicativo.

  7. Clique em Gravar.

    A distribuição é atualizada com informações de cronograma de lançamento.

Desativar o cronograma interrompe o lançamento automático da distribuição, mas as configurações configuradas são gravadas.

Nota

Devido a melhorias constantes, a interface do usuário pode não ser exatamente a mesma que é apresentada no vídeo.

Relatórios de SDK móveis de OTA e biblioteca de Web

A integração do SDK móvel apropriado ou da biblioteca da Web permite atualizar traduções com um único clique, mas também fornece métricas para medir o uso. Os relatórios do SDK móvel e da biblioteca da Web fornecem informações valiosas sobre usuários ativos do aplicativo e seus idiomas de aplicativo. Este conjunto de relatórios pode ser acessado para cada distribuição e os dados dos relatórios são atualizados duas vezes por dia.

São fornecidos relatórios sobre o número de usuários ativos, solicitações gerais, solicitações por idioma, solicitações por plataforma e idiomas de dispositivos não fornecidos.

Os relatórios para cada distribuição são acessados pelo ícone de Reports.jpg na página Mais de o ar.

Instalação de OTA Android SDK

Com o SDK, o aplicativo verifica regularmente traduções atualizadas e faz download deles no background.

Verifique regularmente as últimas lançamentos do SDK Android, especialmente considerando upgrades.

Se as traduções não estiverem sendo atualizadas:

  • Certifique-se de que o ID de distribuição e o segredo do ambiente estão corretos.

  • Certifique-se de que um lançamento foi criado para a versão atual do aplicativo.

  • Recarregue o ViewController para fazer com que as alterações apareçam imediatamente.

Se a versão errada de uma tradução estiver sendo usada, certifique-se de que um lançamento com as traduções mais recentes, a versão atual do aplicativo está disponível e o versionName para o aplicativo definido e está usando o formato <major>.<minor>.<point>.

Requisitos

  • O SDK requer pelo menos a versão appcompat 1.2.0. Se estiver usando uma versão mais antiga do appcompat, considere usar a Versão SDK 2.1.3

  • A biblioteca depende do AndroidX para usar elementos de interface compatíveis com a anterior, como a barra de ferramentas.

Incluir o SDK

Adicionar um novo repositório ao root build.gradle:

allprojects {
    repositories {
        ...
        maven { url "https://maven.download.phrase.com" }
    }
}

Adicionar a biblioteca como dependência:

dependencies {
    implementation "com.phrase.android:ota-sdk:3.5.0"
    ...
}

Suporte para Jetpack

Para ativar o suporte do Jetpack Compose para traduções OTA, execute estas etapas:

  1. Adicione a implementação de biblioteca "com.phrase.android:ota-sdk-compose:3.5.0" ao build.gradle raiz.

  2. Envolva o código do Jetpack Compose no Phrase {... }.

Configuração

Inicialize o SDK na classe de aplicativo e adicione o ID de distribuição e o segredo do ambiente. As classes herdadas do Aplicativo devem substituir o attachBaseContext para habilitar traduções fora do contexto da atividade:

public class MainApplication extends Application {
  @Override
  public void onCreate() {
      super.onCreate();
      Phrase.setup(this, "DISTRIBUTION_ID", "ENVIRONMENT_TOKEN");
      Phrase.updateTranslations();
  }

  @Override
  protected void attachBaseContext(Context newBase) {
    super.attachBaseContext(Phrase.wrapApplicationContext(newBase));
  }  
}

Injectar o SDK em cada atividade, p.ex., criando uma atividade base da qual todas as outras atividades herdam:

public class BaseActivity extends AppCompatActivity {
  @NonNull
  @Override
  public AppCompatDelegate getDelegate() {
    return Phrase.getDelegate(this, super.getDelegate());
  }
}

As traduções podem ser usadas como normalmente nos layouts:

<TextView android:text="@string/translation_key" />

E dentro do código:

TextView text = (TextView) findViewById(R.id.text_id);
text.setText(R.string.translation_key);

Algumas bibliotecas não aceitam o desenchimento automático do contexto e esperam uma classe específica. Neste caso, a envoltura de contexto nos componentes Jetpack Compose pode ser desativada com:

Phrase(contextWrapping = false) {
    Text( text = phraseString(R.string.test) )
}

Configurações para níveis de registro:

  • Java PhraseLog.setLogLevel(Severity.Debug);

  • Kotlin

    PhraseLog.logLevel = Severity.Verbose

  • Outras opções de registro aceitas

    • None

    • Error

    • Warning

    • Info

    • Debug

    • Verbose

Alterar idioma

Se não estiver usando o idioma do sistema, um idioma diferente poderá ser definido no método setLocaleCode. O código do idioma (local) precisa estar presente em um lançamento.

Phrase.setLocaleCode("fr");
Phrase.updateTranslations();

Versão de aplicativo personalizada

O SDK usa a versão do aplicativo como padrão para retornar um lançamento que corresponda às restrições de lançamento para a versão mínima e máxima. A versão do aplicativo deve usar a versão semântica, caso contrário, nenhuma atualização da tradução será gerada. Caso o aplicativo não use a versão semântica, é possível substituir manualmente a versão do aplicativo usado.

Exemplo:

Phrase.setAppVersion("3.2.4");

A versão precisa ser definida antes de chamar updateTranslations( ).

Confirmar tempo limite

O tempo limite padrão para downloads de tradução está definido para 10 segundos.

O padrão pode ser alterado com:

Phrase.setTimeout(10000); // Timeout in milliseconds

Atualizar retorno

Se o tratamento de atualizações de tradução bem-sucedidas for necessário, anexe um operador de retorno:

Phrase.updateTranslations(new TranslationsSyncCallback() {
    @Override
    public void onSuccess(boolean translationsChanged) {
    }

    @Override
    public void onFailure() {
    }
});

As atualizações da tradução também podem ser acionadas manualmente. As traduções recém-checadas são exibidas no próximo lançamento do aplicativo.

Para tornar as últimas traduções disponíveis imediatamente, use o método Phrase.applyPendingUpdates(). Isso pode ser combinado com ouvir atualizações de tradução:

Phrase.updateTranslations(new TranslationsSyncCallback() {
    @Override
    public void onSuccess(boolean translationsChanged) {
      if(translationsChanged) {
         Phrase.applyPendingUpdates()
        // Custom logic to refresh UI
      }
    }

    @Override
    public void onFailure() {
    }
});

A interface não exibe traduções automaticamente e deve ser recriada.

Configurar centro de dados US

O centro de dados Phrase US também é aceito. O centro de dados US pode ser configurado chamando:

Phrase.setHost("https://ota.us.phrase.com/")

Fallback

Caso não seja possível acessar o Phrase devido a uma conexão de rede ausente do cliente ou uma interrupção de serviço, o SDK usa as traduções pacotadas do arquivo de recurso. Recomenda-se atualizar regularmente as traduções pacotadas no aplicativo. O SDK também cache as traduções localmente no dispositivo. Se houver esse cache, ele será usado até a próxima atualização da tradução.

O SDK usa o lançamento mais recente para as traduções. Caso o versionName para o aplicativo seja definido, será usado o lançamento mais recente que satisfaça às restrições de versão.

Adicionar um novo idioma

Criando o novo idioma no Phrase e criando um novo lançamento. O SDK busca o idioma quando este é o idioma do dispositivo de um usuário. Recomenda-se adicionar regularmente um novo strings.xml para novos arquivos de idiomas ao lançar uma nova versão do aplicativo ou os usuários verão apenas as traduções de fallback determinadas pelo Android na primeira inicialização do aplicativo.

Revisão

O SDK é de texto original fechado e não pode ser visualizado ou modificado. Se for uma exigência da organização, podem ser fornecidas auditorias. Entre em contato para obter mais detalhes, se necessário.

Personalizar visualização do suporte

As exibições personalizadas podem ser traduzidas usando atributos estilizados. Como o TypedArray não permite substituir os recursos, pequenas alterações na exibição personalizada são necessárias:

  • Exemplo de Kotlin

    Antes:

    context.obtainStyledAttributes(attrs, R.styleable.CustomView, defStyleAttr, 0).use {
        text = it.getText(R.styleable.CustomView_android_text)
    }

    Após:

    context.obtainStyledAttributes(attrs, R.styleable.CustomView, defStyleAttr, 0).use {
        text = it.getTextWithPhrase(R.styleable.CustomView_android_text)
    }
  • Exemplo de Java

    Antes:

    final TypedArray ta = context.obtainStyledAttributes(attrs, R.styleable.CustomView, defStyleAttr, 0);
    try {
        setText(ta.getText(R.styleable.CustomView_android_text));
    } finally {
        ta.recycle();
    }

    Após:

    final TypedArray ta = context.obtainStyledAttributes(attrs, R.styleable.CustomView, defStyleAttr, 0);
    try {
        setText(PhraseTypedArray.getTextWithPhrase(ta, R.styleable.CustomView_android_text));
    } finally {
        ta.recycle();
    }

Exemplo de aplicativo

https://github.com/phrase/android-sdk-example

Instalação de OTA Flutter SDK

Com o SDK, o aplicativo verifica regularmente traduções atualizadas e faz download deles no background.

Requisitos

Esta biblioteca depende da versão 0.18.0 da biblioteca intl do Flutter.Siga o seu guia para adicionar suporte de localizações ao aplicativo.

Instalação

Adicionar o Phrase ao pubspec.yaml:

dependencies:
  phrase: ^2.5.1 
  ...
  intl: ^0.18.0
  flutter_localizations:
    sdk: flutter
  ...

flutter:
  generate: true
  ...

Como na biblioteca intl, a geração de código é usada para processar arquivos ARB. Execute este comando para atualizar:

flutter pub run phrase

Usando build_runner:

flutter pub run build_runner watch

Uso

Inicializar o Phrase no arquivo main.dart:

import 'package:flutter/material.dart';
import 'package:flutter_gen/gen_l10n/app_localizations.dart';
import 'package:flutter_gen/gen_l10n/phrase_localizations.dart';
import 'package:phrase/phrase.dart';

void main() {
  Phrase.setup("[DISTRIBUTION_ID]", "[ENVIRONMENT_ID]");
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Demonstração de flutador',
      //..
      localizationsDelegates: PhraseLocalizations.localizationsDelegates,
      supportedLocales: PhraseLocalizations.supportedLocales,
    );
  }
}

Acessar mensagens com:

Text(AppLocalizations.of(context)!.helloWorld);

Personalizar

Atualizar comportamento

As traduções do OTA são atualizadas sempre que o aplicativo é lançado. Para desabilitar este:

Phrase.setup("[DISTRIBUTION_ID]", "[ENVIRONMENT_ID]", 
    checkForUpdates: false);

Para atualizar manualmente:

Phrase.updateTranslations(context).then((_) => print("Done!"));

Versão de aplicativo personalizada

O SDK usa a versão do aplicativo como padrão para retornar um lançamento que corresponda às restrições de lançamento para a versão mínima e máxima. A versão do aplicativo deve usar a versão semântica, caso contrário, nenhuma atualização da tradução será gerada. Caso o aplicativo não use a versão semântica, a versão do aplicativo pode ser substituída manualmente: é possível substituir a versão do aplicativo manualmente:

Phrase.setup("[DISTRIBUTION_ID]", "[ENVIRONMENT_ID]",
    customAppVersion: "1.2.3");

Configurar centro de dados US

O centro de dados Phrase US também é aceito. O centro de dados US pode ser selecionado aprovando o parâmetro de hostname da API relevante na configuração SDK:

Phrase.setup("[DISTRIBUTION_ID]", "[ENVIRONMENT_ID]", host: PhraseHost.us);

Exemplo de aplicativo

https://github.com/phrase/flutter_sdk_example

Instalação de OTA iOS

Com o SDK, o aplicativo verifica regularmente traduções atualizadas e faz download deles no background.

O Mac Catalyst também é aceito.

O SDK pode ser instalado manualmente ou por meio do gerente de pacotes do Swift, Carthage ou Cocoa Pods.

Se as traduções não estiverem sendo atualizadas:

  • Certifique-se de que o ID de distribuição e o segredo do ambiente estão corretos.

  • Certifique-se de que um lançamento foi criado para a versão atual do aplicativo.

  • Recarregue o ViewController para fazer com que as alterações apareçam imediatamente.

Se a versão errada de uma tradução estiver sendo usada, certifique-se de que um lançamento com as traduções mais recentes e a versão atual do aplicativo está disponível.

Swift Package Manager

Adicione o URL do repositório público (https://github.com/phrase/ios-sdk/). O Xcode lida com o restante da instalação automaticamente.

Cartago

Adicione a seguinte linha ao seu Cartfile:

binary "https://raw.githubusercontent.com/phrase/ios-sdk/master/PhraseSDK.json" ~> 3.0.0

Execute a atualização do carthage e adicione o PhraseApp.framework ao seu projeto como descrito na documentação carthage.

Cocoa Pods

Adicione a seguinte linha ao seu Podfile:

pod 'PhraseSDK'

Execute a instalação do pod. Se você é novo(a) no CocoaPods, consulte sua documentação.

Instalação manual

Execute estas etapas:

  1. Baixe a última versão.

  2. Adicione PhraseSDK.framework em Xcode como o binário vinculado à tradução.

  3. Um roteiro para apagar os binários extras precisa ser executado antes de fazer upload do aplicativo, pois a loja da Apple reprova aplicativos incluindo simuladores de binários.

    Vá para Construir fases e adicione uma seção Executar scripts clicando no símbolo +. Colar neste roteiro:

    FRAMEWORK="PhraseSDK"
    FRAMEWORK_EXECUTABLE_PATH="${BUILT_PRODUCTS_DIR}/${FRAMEWORKS_FOLDER_PATH}/$FRAMEWORK.framework/$FRAMEWORK"
    EXTRACTED_ARCHS=()
    for ARCH in $ARCHS
    do
       lipo -extract "$ARCH" "$FRAMEWORK_EXECUTABLE_PATH" -o "$FRAMEWORK_EXECUTABLE_PATH-$ARCH"
       EXTRACTED_ARCHS+=("$FRAMEWORK_EXECUTABLE_PATH-$ARCH")
    done
    lipo -o "$FRAMEWORK_EXECUTABLE_PATH-merged" -create "${EXTRACTED_ARCHS[@]}"
    rm "${EXTRACTED_ARCHS[@]}"
    rm "$FRAMEWORK_EXECUTABLE_PATH"
    mv "$FRAMEWORK_EXECUTABLE_PATH-merged" "$FRAMEWORK_EXECUTABLE_PATH"

Configuração

  1. Import PhraseSDK:

    import PhraseSDK
  2. Inicialize o SDK chamando o seguinte código:

    Phrase.shared.setup(
      distributionID: <Distribution ID>, 
      environmentSecret: <Environment Secret>
    )
  3. Para atualizar arquivos de localização, chama Phrase.shared.updateTranslation().

    Este método criará uma exceção se o SDK não estiver configurado corretamente.

    Para configurar o OTA para usar o centro de dados US, defina o host antes de ligar para PhraseApp.shared.updateTranslation() com Phrase.shared.configuration.apiHost = .us.

Recomenda-se a chamada de ambas as funções dentro do AppDelegate no método didFinishLaunchingWithOptions.

Objetivo-C

Integrar o SDK no aplicativo Objective-C:

@import PhraseSDK;

@implementation AppDelegate

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
  [[Phrase shared] setDebugMode:true]; // Optional

  [[Phrase shared] setupWithDistributionID:@"Your Distribution ID"
                         environmentSecret:@"Your Environment Secret"];

  // OR:
  //
  //  [[Phrase shared] setupWithDistributionID:@"Your Distribution ID"
  //                         environmentSecret:@"Your Environment Secret"
  //                                   timeout:10];

  // Update translations using callback block:
  [[Phrase shared] updateTranslationsWithCompletionHandler:^(BOOL updated, NSError* error){
    NSLog(@"Updated: %@", updated ? @"true" : @"false");

    if (error) {
      NSLog(@"Domain: %@ Code: %ld Message: %@", error.domain, (long)error.code, error.localizedDescription);
    } else {
      NSLog(@"No error");
    }

    // Translate via bundle proxy:
    NSString *translation = NSLocalizedString(@"layouts.application.about", @"");
    NSLog(@"NSLocalizedString via bundle proxy: %@", translation);

    // OR:
    //
    // Translate using fallback method:
    NSString *otherTranslation = [[Phrase shared]
                                  localizedStringForKey:@"layouts.application.about" value:NULL table:NULL];
    NSLog(@"Phrase.shared localizedStringForKey: %@", otherTranslation);
  }];

  // OR:
  //
  // [[Phrase shared] updateTranslationsWithCompletionHandler:NULL]; // ignore result and errors (not recommended)

  // [...] Your other code
  
  return YES;
}

Desativar o balanço

Para desativar o swizzling, defina PhraseSDKMainBundleProxyDisabled para YES no arquivo Info.plist.

Quando o recurso swizzling está desativado, as traduções atualizadas não são mais exibidas. A tradução ainda será sincronizada se updateTranslation for chamado e poder ser acessada com o método Phrase.localizedString().

Manuseio de versões do aplicativo

Para determinar qual lançamento deve ser retornado, o SDK requer uma versão semântica do aplicativo para que as traduções sejam atualizadas.

O SDK tenta obter uma versão semântica da seguinte maneira:

  • O CFBundleShortVersionString é usado se for semântico.

  • Caso contrário, a CFBundleVersion é usada se for semântica.

  • Se os dois não forem semânticos, é usada uma combinação de (CFBundleShortVersionString.CFBundleVersion).

Se CFBundleShortVersionString estiver ausente ou não puder ser criado com uma versão semântica em conjunto com CFBundleVersion, o SDK lançará a mensagem PhraseSetupError.appVersionNotSemantic.

Desabilitar tradução para várias tabelas

Para evitar que o OTA traduza tabelas no pacote principal do iOS além da tabela padrão Localizável, defina a seguinte opção:

Phrase.shared.configuration.ignoreOtherTables = true

Chamadas

Anexe um operador de retorno para processar as atualizações de tradução bem-sucedidas:

Phrase.shared.updateTranslation { result in
            switch result {
            case .success(let updated):
            case .failure:
            }
        }

Modo de depuração

Se forem necessárias mais informações, ative o modo de depuração para obter logon adicional do PhraseSDK.framework na consola:

Phrase.shared.configuration.debugMode = true

Confirmar tempo limite para solicitações

Defina um tempo limite para as solicitações contra o Phrase ligando:

Phrase.shared.configuration.timeout = TimeInterval(20)

O tempo limite padrão é de 10 segundos e conexões que levam mais de 10 segundos serão fechadas.

Fornecer substituição de idioma manual

Se não usar o idioma do sistema como local, um local diferente poderá ser definido na chamada init. O código de local precisa estar presente em um lançamento do Phrase:

Phrase.shared.configuration.localeOverride = "en-US"

Fallback

Caso não possam ser obtidas novas traduções do Phrase por meio do SDK, os arquivos de tradução mais recentes da instalação recebidos são usados. Se o aplicativo nunca recebeu novos arquivos do Phrase, ele usa os arquivos de tradução compilados do aplicativo. Isso evita erros em caso de qualquer dificuldade técnica ou erros de rede. Recomenda-se manter os seus arquivos de tradução compilados no aplicativo atualizados a cada lançamento.

Revisão

O SDK é de texto original fechado e não pode ser visualizado ou modificado. Se for uma exigência da organização, podem ser fornecidas auditorias. Entre em contato para obter mais detalhes, se necessário.

Instalação de OTA React Native SDK

Com o SDK, o aplicativo verifica regularmente traduções atualizadas e faz download deles no background.

A biblioteca para traduções OTA só funciona com a biblioteca react-i18next.

Para instalar o React Native SDK, siga estes passos:

  1. Executar este comando:

    $ npm install react-native-phrase-sdk --save
  2. Inicializar o Phrase:

    import Phrase from "react-native-phrase-sdk";
    
    let phrase = new Phrase(
        "YOUR_DISTRIBUTION_ID",
        "YOUR_DEVELOPMENT_OR_PRODUCTION_SECRET",
        "YOUR_APP_VERSION",
        "i18next"
    );

    O formato de arquivo pode ser i18next (como no exemplo acima) ou i18next_4, o que resulta no arquivo de formato i18next v4.

    O Phrase US data center também é aceito. Para usar o React Native SDK com o centro de dados US, informe o host relevante durante a inicialização:

    import Phrase from "react-native-phrase-sdk";
    
    let phrase = new Phrase(
        "YOUR_DISTRIBUTION_ID",
        "YOUR_DEVELOPMENT_OR_PRODUCTION_SECRET",
        "YOUR_APP_VERSION",
        "i18next",
        host="https://ota.us.phrase.com/"
    );  
    
  3. Criar backend i18next com base na instância:

    import resourcesToBackend from "i18next-resources-to-backend";
    
    const backendPhrase = resourcesToBackend((language, namespace, callback) => {
        phrase.requestTranslation(language)
            .then((remoteResources) => {
                callback(null, remoteResources);
            })
            .catch((error) => {
                callback(error, null);
            });
    });
    
    const backendFallback = resourcesToBackend(localResources)
  4. Inicializar i18n com o backend do Phrase:

    i18n
      .use(ChainedBackend)
      .use(initReactI18next)
      .init({
        backend: {
            backends: [backendPhrase, backendFallback]
        }
        //...
      });

Exemplo de arquivo i18next.js

import i18n from "i18next";
import { initReactI18next } from "react-i18next";
import ChainedBackend from "i18next-chained-backend";
import resourcesToBackend from "i18next-resources-to-backend";
import translationEN from "./locales/en/translation.json";
import translationRU from "./locales/ru/translation.json";
import Phrase from "react-native-phrase-sdk";

const localResources = {
  en: {
    translation: translationEN,
  },
  ru: {
    translation: translationRU,
  },
};

let phrase = new Phrase(
    "YOUR_DISTRIBUTION_ID",
    "YOUR_ENVIRONMENT_ID",
    require('./package.json').version,
    "i18next"
);

const backendPhrase = resourcesToBackend((language, namespace, callback) => {
    phrase.requestTranslation(language)
        .then((remoteResources) => {
            callback(null, remoteResources);
        })
        .catch((error) => {
            callback(error, null);
        });
});

const backendFallback = resourcesToBackend(localResources)

i18n
  .use(ChainedBackend)
  .use(initReactI18next)
  .init({
    backend: {
        backends: [backendPhrase, backendFallback]
    },
    debug: true,
    lng: "en",
    fallbackLng: "en",
    interpolation: {
      escapeValue: false, // not needed for react as it escapes by default
    }
  });

Exemplo de aplicativo

https://github.com/phrase/react_native_sdk_example

Instalação de backend OTA i18next

A biblioteca i18next-phrase-backend implanta um exemplo de backend para i18next que recupera as traduções de lançamentos OTA.

Para criar um novo lançamento, a plataforma i18next precisa ser definida para a distribuição e fazer parte de um lançamento.

Uso

Para inicializar o Phrase:

import i18n from "i18next";
import { I18nextPhraseBackend } from "@phrase/i18next-backend";

i18n
  .use(I18nextPhraseBackend)
  .init({
    fallbackLng: 'en',
    backend: {
      distribuição: 'DISTRIBUTION_ID',
      segredo: 'YOUR_ENVIRONMENT_SECRET',
      appVersion: '1.0.0', '1.0.0',
    }
  });

Caching

A biblioteca está cacheando traduções e não verificará novas traduções por 5 minutos. O cache pode ser configurado definindo a opção cacheExpirationTime na configuração do backend para fins de teste.

i18n
  .use(I18nextPhraseBackend)
  .init({
    fallbackLng: 'en',
    backend: {
      distribuição: 'DISTRIBUTION_ID',
      segredo: 'YOUR_ENVIRONMENT_SECRET',
      appVersion: '1.0.0', '1.0.0',
      cacheExpirationTime: 60 * 5, // tempo em segundos
    }
  });

Nota

Recomenda-se usar pelo menos 5 minutos de tempo de cache em ambientes de produção.

Exemplo de aplicativo

https://github.com/phrase/ota-web-demo

Instalação de backend de rails OTA

A biblioteca phrase-ota-i18n implanta um exemplo de backend para a joia I18n que recupera as traduções de lançamentos OTA. Com a biblioteca, o aplicativo verifica regularmente traduções atualizadas e faz download deles no background.

A biblioteca é válida para qualquer aplicativo Ruby utilizando a joia i18n.

Para criar um novo lançamento, a plataforma Rails precisa ser definida para a distribuição e fazer parte de um lançamento.

Instalação

  1. Adicione a seguinte linha ao Gemfile do aplicativo:

    gem 'phrase-ota-i18n'
  2. Executar:

    $ bundle install
  3. Em alternativa, instale-o como:

    $ gem install phrase-ota-i18n

Uso

Para gerar a configuração:

bundle exec rails generate phrase_ota:install --distribution-id <DISTRIBUTION_ID> --secret-token <SECRET>

Debugging

A jóia tem uma configuração de debug que pode ser ativada no inicializador definindo:

config.debug = true
Esse artigo foi útil?

Sorry about that! In what way was it not helpful?

The article didn’t address my problem.
I couldn’t understand the article.
The feature doesn’t do what I need.
Other reason.

Note that feedback is provided anonymously so we aren't able to reply to questions.
If you'd like to ask a question, submit a request to our Support team.
Thank you for your feedback.