Base de connaissance

Back to support overview

Avec le kit de développement logiciel (SDK) TeamViewer, vous pouvez utiliser toutes les fonctionnalités d'Assist AR (= Augmented Reality) et offrir la meilleure expérience de téléassistance AR à vos clients en intégrant des capacités de téléassistance AR dans vos propres applications mobiles.

Le SDK vous permet d'établir des connexions sécurisées et conformes au GDPR avec les appareils de vos clients.

Cet article s'applique à tous les utilisateurs de TeamViewer Assist AR.

Prérequis

  • Android 5.0 et plus
  • Un compte existant sur TeamViewer

Si vous n'avez pas de compte TeamViewer, suivez les étapes ci-dessous pour en créer un :

  1. Allez sur https://login.teamviewer.com/et cliquez sur S'inscrire.
  2. Suivez les étapes pour créer un compte et valider votre adresse électronique.

Générer une clé API

1. Allez sur https://login.teamviewer.com/ et connectez-vous en utilisant votre compte TeamViewer.

2. En bas de la page, cliquez sur Apps.

3. Cliquez sur le bouton Créer une application.

4. Activez le jeton SDK mobile, saisissez un nom et ajoutez une brève description (facultatif).

5. Activez Android.

6. Cliquez sur Créer.

Votre jeton est affiché lors de l'ouverture de l'application créée :

Copiez ce jeton dans votre presse-papiers et collez-le dans un endroit sûr.

🚨 IMPORTANT : Ne partagez pas ce jeton avec qui que ce soit !

Obtenez le SDK de TeamViewer Mobile

Le SDK est disponible pour les clients disposant d'une licence Assist AR Professional et est distribué par l'équipe de support TeamViewer.

Intégrez votre SDK mobile TeamViewer

1) TeamViewer Mobile SDK pour Android contient les fichiers suivants :

  1. TeamViewerSdk.aar (TeamViewer Mobile SDK )
  2. AssistARSessionUI.aar (nécessaire uniquement si vous voulez établir une session AssistAR à l'aide du SDK)
  3. ScreenSharingSdk-docs (documentation de TeamViewerSdk)
  4. AssistARSessionUI-docs (documentation AssistARSessionUI)
  5. L'application de démonstration est disponible sur https://github.com/teamviewer/TravelApp/.

2) Créez un dossier libs sous le répertoire de votre application et copiez-y les fichiers *.aar.

📌 Note : le SDK prend en charge les architectures suivantes : armeabi-v7a, arm64-v8a, x86, x86_64.

3) Activez ViewBinding et ajoutez les dépendances suivantes au build.gradle de votre application :

android { 
 
   buildFeatures { 
      viewBinding true 
   } 
} 
 
dependencies { 
   implementation files('libs/TeamViewerSdk.aar') 
   implementation files('libs/AssistARSessionUI.aar') //(Add only if you plan to use AssistAR Session 
    
// Add dependencies of AssistARSessionUI.aar(Add only if you plan to use AssistAR Session): 
   runtimeOnly "androidx.camera:camera-camera2:1.0.2" 
   runtimeOnly "androidx.camera:camera-lifecycle:1.0.2" 
   runtimeOnly "androidx.constraintlayout:constraintlayout:2.0.4" 
   runtimeOnly "androidx.fragment:fragment-ktx:1.3.6" 
   runtimeOnly "androidx.lifecycle:lifecycle-livedata-ktx:2.3.1" 
   runtimeOnly "androidx.work:work-runtime-ktx:2.5.0" 
   runtimeOnly "com.google.android.material:material:1.4.0" 
   runtimeOnly "de.javagl:obj:0.3.0" 
   runtimeOnly "org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.5.31" 
   runtimeOnly "com.google.android.gms:play-services-mlkit-text-recognition:17.0.0" 
   runtimeOnly "com.squareup.picasso:picasso:2.8" 
}

Pour obtenir une liste actualisée des dépendances, veuillez consulter AssistARSessionUI-docs/index.html qui fera partie du paquet SDK que vous recevrez de TeamViewer.

4) Construisez l'objet TeamViewerSdk :

    teamViewerSdk = TeamViewerSdk.Builder(context) 
        .withToken(SDK_TOKEN) 
        .withAuthenticationCallback(sdkAuthenticationCallback) 
        .withSessionCallback(sdkSessionCallback) 
        .withErrorCallback(sdkErrorCallback) 
        .withOnlineStateCallback(onlineStateCallback) 
        .withMicInitiallyMuted(true) 
        .build() 
} 

L'exemple ci-dessus montre la création de l'objet teamViewerSdk en utilisant SDK_TOKEN (utiliser SDK_TOKEN créé ci-dessus à l'étape 7 de "Generate API Key Section")

Veuillez consulter ScreenSharingSdk-docs/com/teamviewer/sdk/screensharing/TeamViewerSdk.Builder.html pour obtenir plus de détails sur ces méthodes de construction. La documentation fera partie du paquet SDK que vous recevrez de TeamViewer.

5) Se connecter à un code de session

Le SDK partagé fournit une méthode pour établir une connexion à un code de session. Ce code de session peut être de deux types :

  • Assistance à distance ou
  • Assist AR

6) Créez des codes de session dans votre client TeamViewer (sélectionnez le type Remote Support ou AssistAR en fonction de la session souhaitée) ou via l'API REST TeamViewer.

teamViewerSdk.connectToSessionCode(sessionCode)

Une fois que le sessionCode (= code de session) est en ligne, une connexion peut être initiée depuis le côté client de TeamViewer.

L'état du code de session peut être vérifié à l'aide de OnlineStateCallback

(ScreenSharingSdk-docs/com/teamviewer/sdk/screensharing/TeamViewerSdk.Builder.html#withOnlineStateCallback

(com.teamviewer.sdk.screensharing.OnlineStateCallback).

OnlineStateCallback est utile pour être informé de l'état en ligne/hors ligne/connecté du SDK :

private val onlineStateCallback = OnlineStateCallback { onlineState -> 
    val isSdkOnline = OnlineStateCallback.OnlineState.OFFLINE 
    val isSdkOffline = OnlineStateCallback.OnlineState.ONLINE 
    val isSessionCodeConnected = OnlineStateCallback.OnlineState.CONNECTED 
}

ErrorCallback est utile pour gérer les codes d'erreur envoyés par le SDK dans le cas où le code de la session est invalide, expiré ou fermé.

(ScreenSharingSdk-docs/com/teamviewer/sdk/screensharing/TeamViewerSdk.Builder.html#withErrorCallback

(com.teamviewer.sdk.screensharing.ErrorCallback))

private val sdkErrorCallback = ErrorCallback { errorCode -> 
    val invalid = errorCode == ErrorCallback.ErrorCode.SESSION_CODE_INVALID 
    val expired = errorCode == ErrorCallback.ErrorCode.SESSION_CODE_EXPIRED 
    val closed = errorCode == ErrorCallback.ErrorCode.SESSION_CODE_CLOSED 
}

Réagir aux connexions entrantes

Le SDK fournit des méthodes de rappel pour réagir aux événements de connexion entrants.

1. AuthenticationCallback

AuthenticationCallback est utile pour gérer les connexions entrantes.

Le paramètre AuthenticationData contient le nom de l'agent d'assistance et une fonction de rappel pour autoriser ou rejeter la connexion entrante.

private val sdkAuthenticationCallback = object : AuthenticationCallback { 
    override fun onAuthentication(data: AuthenticationData?) { 
	//set true to accept call, set false to reject call 
        data?.callback?.onAuthenticationResult(true) 
        Logging.info(TAG, "TeamViewer connected to ${data?.partnerName}") 
    } 
 
    override fun onAuthenticationCanceled() { 
        // Is called when TeamViewer Authentication was cancelled from TeamViewer client/expert side 
    } 
}

Si la connexion entrante est acceptée, la connexion TeamViewer correspondante est établie.

  • Pour la connexion ScreenShare, une demande d'autorisation de microphone est affichée à l'utilisateur. (La demande d'autorisation de microphone pour la session ScreenShare doit être implémentée par le développeur d'applications dans le SessionCallback).
  • Pour la connexion Assist AR, les autorisations du système pour l'accès à la caméra et au microphone sont affichées. Si l'utilisateur l'autorise, la session de AR est lancée.
  • Si le client/expert envoie des fichiers au serveur, une autorisation de stockage est demandée pour déplacer les fichiers vers le répertoire Téléchargements après la fin de la session.
  • Il existe une communication VoIP bidirectionnelle entre l'utilisateur et l'agent d'assistance. L'état initial du micro est non-muté, mais cela peut être modifié en utilisant la méthode du constructeur sdk withMicInitiallyMuted(boolean muted).

2. SessionCallback

Une fois la connexion initiée du côté de TeamViewer, le SDK est informé de cette tentative de connexion via SessionCallback.

I) AssistARSession (AssistARSession) :

Pour les sessions AssistAR, veillez à ➜

  • Mettre AssistARSessionUI.currentSession = session dans onSessionStarted()
  • Lancer AssistARSessionActivity comme indiqué dans le code ci-dessous.
  • Mettre AssistARSessionUI.currentSession = null in onSessionEnded()
private val sdkSessionCallback = object : SessionCallback { 
    override fun onSessionStarted(session: TeamViewerSession?) { 
        if (session is AssistARSession) { 
            AssistARSessionUI.currentSession = session 
            val intent = AssistARSessionUI.createIntentForAssistARSessionActivity(context, "StorageFolderName") 
            intent.flags = Intent.FLAG_ACTIVITY_NEW_TASK 
            context.startActivity(intent) 
        } 
  	if (session is ScreenSharingSession) { 
//Request microphone permission if you intend to use VOIP with ScreenShare Session 
       } 
    } 
 
    override fun onSessionEnded() { 
        Logging.info(TAG, "TeamViewer Session ended") 
        AssistARSessionUI.currentSession = null 
    } 
} 

Il est obligatoire de transmettre storageFolderName à la méthode createIntentForAssistARSessionActivity car il s'agit du nom du dossier dans lequel les documents partagés seront stockés sous le dossier Téléchargements. Pour plus de détails, consultez AssistARSessionUI-docs/-pilot-session-u-i/com.teamviewer.sdk.assistarsessionui/-assist-a-r-session-u-i/create-intent-for-assist-a-r-session-activity.html

II) ScreenSharingSession :

ScreenSharingSession nécessite de demander la permission de microphone dans OnSessionStarted() si vous avez l'intention d'utiliser la VOIP.

L'enregistrement :

La méthode du constructeur withLogger(Logger callback) définit un callback de logger vers lequel toutes les sorties de log du Sdk TeamViewer sont déléguées.

Pour consulter les détails de ce rappel et d'autres rappels supplémentaires disponibles avec le constructeur Sdk, veuillez visiter ScreenSharingSdk-docs/com/teamviewer/sdk/screensharing/TeamViewerSdk.Builder.html.