ApsaraVideo Live:Utiliser le Push SDK pour Android

Tenez compte des limitations suivantes avant d'utiliser le Push SDK pour Android :

• Vous devez configurer l'orientation de l'écran avant l'ingestion du flux. Il est impossible de faire pivoter l'écran pendant le streaming en direct.

• Vous devez désactiver la rotation automatique de l'écran pour l'ingestion de flux en mode paysage.

• En mode d'encodage matériel, la valeur de la résolution de sortie doit être un multiple de 16 pour assurer la compatibilité avec l'encodeur. Par exemple, si vous définissez la résolution sur 540p, la résolution de sortie sera de 544 × 960. Vous devez adapter la taille de l'écran du lecteur à la résolution de sortie pour éviter l'apparition de bandes noires.

Enregistrer le SDK

Pour obtenir et configurer une licence, intégrez une licence Push SDK.

Appelez l'API d'enregistrement de licence au début du cycle de vie de votre application, avant d'utiliser le Push SDK pour Android.

AlivcLiveBase.setListener(new AlivcLiveBaseListener() {
  @Override
  public void onLicenceCheck(AlivcLivePushConstants.AlivcLiveLicenseCheckResultCode result, String reason) {
    Log.e(TAG, "onLicenceCheck: " + result + ", " + reason);
  }
});
AlivcLiveBase.registerSDK();

• Utilisez la classe AlivcLiveBase pour définir les niveaux de journalisation, spécifier les chemins d'accès locaux aux journaux et obtenir la version du SDK.

• Vous devez appeler la méthode registerSDK dans AlivcLiveBase pour enregistrer la licence du SDK.

• Implémentez le rappel onLicenceCheck dans l'interface AlivcLiveBase#setListener pour vérifier de manière asynchrone la configuration de la licence.

  Remarque

  Ce rappel n'est déclenché qu'après l'initialisation de l'instance de l'outil de push.

Ingérer un flux caméra

1. Initialisation.

   Appelez la méthode init après avoir configuré les paramètres d'ingestion de flux :

   AlivcLivePusher mAlivcLivePusher = new AlivcLivePusher();
   mAlivcLivePusher.init(mContext, mAlivcLivePushConfig);

   Remarque

   AlivcLivePusher ne prend pas en charge les instances multiples. Chaque appel à init doit être associé à un appel à destroy.

2. Enregistrez les rappels de prévisualisation.

   Appelez la méthode setLivePushInfoListener pour enregistrer les rappels de prévisualisation :

   /**
    * Set a listener for stream ingest event notifications.
    *
    * @param infoListener The notification listener.
    */
   mAlivcLivePusher.setLivePushInfoListener(new AlivcLivePushInfoListener() {
       @Override
       public void onPreviewStarted(AlivcLivePusher pusher) {
           // Notification that the preview has started.
       }
       // Other override methods
       //....
       //....
   });

3. Démarrez la prévisualisation.

   Démarrez la prévisualisation en transmettant le SurfaceView pour la prévisualisation de la caméra :

   mAlivcLivePusher.startPreview(mSurfaceView); // Starts the preview. You can also call the asynchronous startPreviewAsync method based on your needs.

4. Démarrez l'ingestion de flux.

   Ajoutez le code suivant dans la méthode de rappel onPreviewStarted.

   mAlivcLivePusher.startPush(mPushUrl);

   Remarque

   • Les URL d'ingestion pour RTMP et RTS (artc://) sont prises en charge. Pour obtenir les URL, consultez la section Générer des URL d'ingestion et de diffusion.

   • ApsaraVideo Live rejette les demandes d'ingestion de flux concurrentes vers la même URL.

/* Call to pause a stream that is being ingested. After pausing, the video preview and video stream ingest are held on the last frame, while audio stream ingest continues. */
mAlivcLivePusher.pause();
/* Call to resume a paused stream. After resuming, the audio and video preview and stream ingest return to normal. */
mAlivcLivePusher.resume();
/* Call to stop a stream that is being ingested. After completion, stream ingest stops. */
mAlivcLivePusher.stopPush();
/* Call to stop the preview only when in the previewing state. Calling this while ingesting a stream has no effect. After the preview stops, the preview frame freezes on the last frame. */
mAlivcLivePusher.stopPreview();
/* Call to restart stream ingest when a stream is being ingested or after receiving any error-related callback. In an error state, you can only call this API, reconnectPushAsync, or destroy. Restarting reinitializes all internal resources of AlivcLivePusher, including preview and stream ingest. */
mAlivcLivePusher.restartPush();
/* Call to reconnect a stream when it is being ingested or after receiving an error callback related to AlivcLivePusherNetworkDelegate. In an error state, you can only call this API, restartPush, or destroy. Reconnecting re-establishes the RTMP connection for stream ingest. */
mAlivcLivePusher.reconnectPushAsync();
/* Call to dispose of the stream ingest instance. After disposal, stream ingest and preview stop, and the preview surface is removed. All resources related to AlivcLivePusher are released. */
mAlivcLivePusher.destroy();

/* Switch between the front and rear cameras. */
mAlivcLivePusher.switchCamera();
/* Turn the flash on or off. Turning on the flash has no effect when the front camera is active. */
mAlivcLivePusher.setFlash(true); 
/* Adjust the focal length to zoom the captured image. The zoom range is [0, getMaxZoom()]. */
mAlivcLivePusher.setZoom(5);
/* Manually focus the camera. This requires two parameters: 1. `point` (the coordinates of the point to focus on) and 2. `autoFocus` (whether to enable autofocus for this specific operation). Subsequent autofocus behavior follows the value set by the setAutoFocus API. */
mAlivcLivePusher.focusCameraAtAdjustedPoint(x, y, true);
/* Set whether to enable autofocus. */
mAlivcLivePusher.setAutoFocus(true);
/* Configure mirroring. There are two mirroring APIs: PushMirror for the ingested stream and PreviewMirror for the local preview. PushMirror affects only the playback display, while PreviewMirror affects only the preview display. They do not affect each other. */
mAlivcLivePusher.setPreviewMirror(false);
mAlivcLivePusher.setPushMirror(false);

Ingérer un flux de partage d'écran

Le partage d'écran utilise MediaProjection et nécessite l'autorisation de l'utilisateur. Transmettez les données de résultat de l'autorisation au SDK. La caméra est désactivée par défaut pendant le partage d'écran.

// resultData is the screen sharing system intent.
mAlivcLivePushConfig.setMediaProjectionPermissionResultData(resultData);

mAlivcLivePusher.setScreenOrientation(0);

mAlivcLivePusher.pauseScreenCapture(); // Enable privacy protection.
mAlivcLivePusher.resumeScreenCapture(); // Disable privacy protection.

Ingérer des flux caméra et de partage d'écran

Vous pouvez activer l'ingestion caméra pendant le partage d'écran. Deux approches sont disponibles :

1. Le diffuseur dispose d'une prévisualisation caméra.

   Le diffuseur et les spectateurs peuvent tous deux voir le flux de la caméra.

2. Le diffuseur ne dispose pas de prévisualisation caméra.

   Par exemple, lors d'une diffusion de jeu, le diffuseur peut ne pas souhaiter que la vue de la caméra obstrue le jeu. Cependant, les spectateurs peuvent toujours voir le flux de la caméra du diffuseur dans le flux final.

mAlivcLivePusher.startCamera(surfaceView); // Start the camera preview.
mAlivcLivePusher.stopCamera(); // Stop the camera preview.

mAlivcLivePusher.startCameraMix(x, y, w, h); // Enable camera stream mixing and set the x, y, w, and h layout for the mixed stream.
mAlivcLivePusher.stopCameraMix(); // Stop camera stream mixing.

Mode d'affichage de la prévisualisation

Trois modes d'affichage de prévisualisation sont disponibles. Le mode d'affichage n'affecte pas l'ingestion de flux.

• ALIVC_LIVE_PUSHER_PREVIEW_SCALE_FILL : La vidéo remplit la fenêtre de prévisualisation. Si les rapports d'aspect de la vidéo et de la fenêtre diffèrent, la prévisualisation apparaît déformée.

• ALIVC_LIVE_PUSHER_PREVIEW_ASPECT_FIT : Le rapport d'aspect de la vidéo est préservé. Si les rapports d'aspect de la vidéo et de la fenêtre diffèrent, des bandes noires apparaissent dans la prévisualisation.

• ALIVC_LIVE_PUSHER_PREVIEW_ASPECT_FILL : La vidéo est recadrée pour s'adapter au rapport d'aspect de la fenêtre. Si les rapports d'aspect diffèrent, la vidéo est recadrée.

Le code suivant fournit un exemple :

mAlivcLivePushConfig.setPreviewDisplayMode(AlivcPreviewDisplayMode.ALIVC_LIVE_PUSHER_PREVIEW_ASPECT_FIT);

Ingestion de flux d'images

Le SDK peut ingérer une image de remplacement lorsque l'application est en arrière-plan ou que le réseau est de mauvaise qualité.

Lorsque l'application passe en arrière-plan, l'ingestion vidéo est mise en pause tandis que l'audio continue. Affichez une image de remplacement pour informer les spectateurs :

mAlivcLivePushConfig.setPausePushImage("path/to/background.png"); // Set the image for background stream ingest.

Le SDK ingère cette image lorsqu'il détecte un faible débit binaire, réduisant ainsi les saccades vidéo :

mAlivcLivePushConfig.setNetworkPoorPushImage("path/to/network_poor.png"); // Set the image to ingest in poor network conditions.

Ingestion de flux audio uniquement

mAlivcLivePushConfig.setAudioOnly(true);

Ingérer des flux audio et vidéo externes

Le SDK prend en charge l'ingestion d'audio et de vidéo provenant de sources externes, telles que des fichiers vidéo.

Activez d'abord l'entrée audio et vidéo personnalisée :

L'ingestion de flux audio et vidéo externes est prise en charge à partir du SDK 7.8.0. Les opérations principales sont setExternMainStream (active l'entrée audio et vidéo personnalisée), inputStreamAudioData (ingère un flux audio externe) et inputStreamVideoData (ingère un flux vidéo externe). Le SDK 7.11.0 optimise principalement la logique d'expiration de l'authentification client et ajoute un rappel d'erreur de capture vidéo ; il n'introduit pas l'ingestion de flux externes, vous n'avez donc pas besoin de mettre à niveau uniquement pour cette fonctionnalité.

/**
* Other parameters such as output resolution, audio sample rate, and number of channels are set in the config object
* using setResolution, setAudioSampleRate, and setAudioChannels.
*/
mAlivcLivePushConfig.setExternMainStream(true,AlivcImageFormat.IMAGE_FORMAT_YUVNV12,AlivcSoundFormat.SOUND_FORMAT_S16);

Après avoir activé l'entrée audio et vidéo personnalisée, vous pouvez ingérer des flux externes.

/**
* This API does not control timing. The caller must control the timing of the input audio frames.
*/
mAlivcLivePusher.inputStreamAudioData(byte[] data, int size, int sampleRate, int channels, long pts);

/**
* This API does not control timing. The caller must control the timing of the input video frames.
*/
mAlivcLivePusher.inputStreamVideoData(byte[] data, int width, int height, int stride, int size, long pts, int rotation);

Le Push SDK ne prend pas en charge le protocole RTSP. Pour ingérer un flux RTSP depuis une caméra réseau (caméra IP), décodez d'abord le flux au format YUV/PCM, puis ingérez-le à l'aide des API inputStreamAudioData/inputStreamVideoData.

Outils de décodage disponibles :

• FFmpeg : Prend en charge l'entrée RTSP et peut décoder en YUV420p et PCM s16le. Exemple de commande : ffmpeg -rtsp_transport tcp -i rtsp://camera_ip/stream -an -c:v rawvideo -pix_fmt yuv420p output.yuv

• GStreamer : Prend en charge l'entrée RTSP et peut décoder en YUV420p et PCM s16le.

• MediaCodec : Une API du framework Android (android.media.MediaCodec) qui prend en charge le décodage matériel H.264 vers YUV à partir d'Android 4.1 (niveau d'API 16).

Le format des données décodées doit correspondre à votre configuration SDK : définissez le format vidéo sur IMAGE_FORMAT_YUVNV12 et le format audio sur SOUND_FORMAT_S16.

Configurer les filigranes

Ajoutez un ou plusieurs filigranes au format PNG :

mAlivcLivePushConfig.addWaterMark(waterPath,0.1,0.2,0.3); // Add a watermark.

Configurer la qualité vidéo

Trois modes de qualité vidéo sont pris en charge : mode Priorité à la résolution, mode Priorité à la fluidité et mode Personnalisé.

mAlivcLivePushConfig.setQualityMode(AlivcQualityModeEnum.QM_RESOLUTION_FIRST); // Prioritize resolution.

mAlivcLivePushConfig.setQualityMode(AlivcQualityModeEnum.QM_FLUENCY_FIRST); // Prioritize fluency.

mAlivcLivePushConfig.setQualityMode(AlivcQualityModeEnum.QM_CUSTOM); // Custom mode
mAlivcLivePushConfig.setTargetVideoBitrate(1000); // Target bitrate: 1,000 kbit/s
mAlivcLivePushConfig.setMinVideoBitrate(300); // Minimum bitrate: 300 kbit/s
mAlivcLivePushConfig.setInitialVideoBitrate(800); // Initial bitrate: 800 kbit/s

Résolution adaptative

La résolution adaptative réduit automatiquement la résolution lorsque les conditions réseau sont dégradées afin d'améliorer la fluidité :

mAlivcLivePushConfig.setEnableAutoResolution(true); // Enable adaptive resolution. Default is false.

Musique de fond

Le SDK prend en charge la lecture de musique de fond, le mixage audio, la réduction du bruit, la surveillance in-ear (retour casque) et la mise en sourdine :

/* Start playing background music. */
mAlivcLivePusher.startBGMAsync(mPath)；
/* Stop playing background music. If BGM is already playing and you need to switch songs, just call the start background music API again. You do not need to stop the current BGM. */
mAlivcLivePusher.stopBGMAsync();
/* Pause background music. This can only be called after BGM has started playing. */
mAlivcLivePusher.pauseBGM();
/* Resume background music. This can only be called when BGM is paused. */
mAlivcLivePusher.resumeBGM();
/* Enable looping for background music. */
mAlivcLivePusher.setBGMLoop(true);
/* Set the denoise switch. When enabled, non-human sounds in the captured audio are filtered. This may slightly suppress human voices. We recommend letting users choose whether to enable this feature. It is disabled by default. */
mAlivcLivePusher.setAudioDenoise(true);
/* Set the in-ear monitoring switch. This feature is mainly used in karaoke scenarios. When enabled with headphones plugged in, the streamer will hear their own voice. When disabled, they will not. This has no effect if headphones are not plugged in. */
mAlivcLivePusher.setBGMEarsBack(true);
/* Configure mixing to adjust the volume of background music and captured voice. */
mAlivcLivePusher.setBGMVolume(50); // Set background music volume.
mAlivcLivePusher.setCaptureVolume(50); // Set captured voice volume.
/* Mute the audio. This mutes both music and voice input. To mute only music or voice, use the mixing volume adjustment APIs. */
mAlivcLivePusher.setMute(true);

Capture d'écran du flux

Effectuez une capture d'écran du flux vidéo local :

// Take a snapshot of the video stream. Parameters: number of images to capture, interval between each capture in seconds, and a callback listener.
pusher.snapshot(1, 1, new AlivcSnapshotListener() {
    @Override
    public void onSnapshot(Bitmap bmp) {
        // You can save the snapshot to a local PNG file. The following code is an example.
        String dateFormat = new SimpleDateFormat("yyyy-MM-dd-hh-mm-ss-SS").format(new Date());
        File f = new File(context.getExternalFilesDir(Environment.DIRECTORY_PICTURES), "snapshot-" + dateFormat + ".png");
        if (f.exists()) {
            f.delete();
        }
        try {
            FileOutputStream out = new FileOutputStream(f);
            bmp.compress(Bitmap.CompressFormat.PNG, 90, out);
            out.flush();
            out.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
});

Exécution en arrière-plan et verrouillage de l'écran

• Lorsque votre application passe en arrière-plan ou que l'écran est verrouillé, appelez les méthodes pause() ou resume() de AlivcLivePusher pour suspendre ou reprendre l'ingestion de flux.

• Pour les appels audio et vidéo hors système, le SDK capture et ingère le son. Selon vos besoins métier, utilisez l'API mAlivcLivePusher.setMute(true or false) pour déterminer si l'audio doit être capturé lorsque l'application est en arrière-plan ou que l'écran est verrouillé.

Rappels (Callbacks)

Méthodes et API courantes

/* In Custom mode, you can adjust the minimum and target bitrates in real time. */
mAlivcLivePusher.setTargetVideoBitrate(800);
mAlivcLivePusher.setMinVideoBitrate(400);
/* Check if the camera supports autofocus. */
mAlivcLivePusher.isCameraSupportAutoFocus();
/* Check if the camera supports flash. */
mAlivcLivePusher.isCameraSupportFlash();
/* Get the current stream ingest status. */
mAlivcLivePusher.isPushing(); 
/* Get the ingest URL. */
mAlivcLivePusher.getPushUrl();
/* Get stream ingest performance and debugging information. For details on performance parameters, see the API reference or interface comments. */
mAlivcLivePusher.getLivePushStatsInfo();
/* Get the SDK version number. */
mAlivcLivePusher.getSDKVersion();
/* Set the log level to filter debugging information as needed. */
mAlivcLivePusher.setLogLevel(AlivcLivePushLogLevelAll);
/* Get the current status of the SDK. */
mAlivcLivePusher.getCurrentStatus();
/* Get the last error code. Returns ALIVC_COMMON_RETURN_SUCCESS if there are no errors. */
mAlivcLivePusher.getLastError();

Intégrer la retouche

Importez la bibliothèque de retouche et configurez les rappels pour activer la fonctionnalité.

1. Importez la bibliothèque de retouche via Maven. Ajoutez les éléments suivants à votre fichier build.gradle. Consultez la dernière Démo pour connaître la version du SDK.

   implementation "com.aliyun.maliang.android:queen:2.5.0-official-full"
   implementation("com.aliyun.maliang.android:queen_menu:2.5.0-official-full") {
       exclude group: 'com.aliyun.maliang.android', module: 'queen'
   }

   Vous pouvez également intégrer le module LiveBeauty de la démo :

   Fichier ou dossier	Description
   live_beauty	Classe abstraite de base pour la retouche.
   queen_beauty	Contrôles d'interface utilisateur de base pour la retouche.

2. Obtenez la bibliothèque de plug-ins de retouche LiveBeauty.

   1. Utilisez la commande clone pour télécharger le code de la bibliothèque de plug-ins associée depuis le chemin LiveBeauty vers votre machine locale.

      git clone https://github.com/MediaBox-Demos/amdemos-android-live.git

   2. Ouvrez la ligne de commande dans le répertoire racine de votre projet Android Studio. Exécutez le code suivant, puis utilisez File > New > Import Module pour importer le module LiveBeauty dans votre projet Android.

      git submodule add https://github.com/MediaBox-Demos/amdemos-android-live.git ***/***/***

      Remarque

      Dans l'exemple de code, */**** est un espace réservé pour le chemin d'accès au module LiveBeauty.

   3. Dans le fichier settings.gradle du projet, ajoutez le chemin du module :

      include ':app', ':LiveBeauty', ':LiveBeauty:live_queenbeauty'

      Remarque

      Dans l'exemple de code, « app » est le module principal.

   4. Également, dans le fichier build.gradle du module principal du projet, ajoutez une dépendance au module LiveBeauty :

      dependencies {
          implementation project(':LiveBeauty')
          implementation project(':LiveBeauty:live_queenbeauty')
      }

   5. Cliquez sur File > Sync Project with Gradle Files. Une fois la synchronisation Gradle terminée, vous pouvez utiliser le module LiveBeauty.

3. Configurez le module d'interface utilisateur du plug-in de retouche.

   1. Ajoutez le contrôle QueenBeautyMenu au fichier XML de mise en page de votre projet. Par exemple :

      <com.aliyunsdk.queen.menu.QueenBeautyMenu
          android:id="@+id/beauty_beauty_menuPanel"
          android:layout_width="match_parent"
          android:layout_height="wrap_content"
          android:layout_alignParentBottom="true"
          android:layout_centerHorizontal="true" />

   2. Initialisez QueenBeautyMenu dans l'Activity. Par exemple :

      // Initialize the retouching menu panel.
      QueenMenuPanel beautyMenuPanel = QueenBeautyMenu.getPanel(context);
      beautyMenuPanel.onHideMenu(); 
      beautyMenuPanel.onHideValidFeatures(); 
      beautyMenuPanel.onHideCopyright(); 
      
      // Add the retouching menu to the layout.
      QueenBeautyMenu beautyBeautyContainerView = findViewById(R.id.beauty_beauty_menuPanel);
      beautyBeautyContainerView.addView(beautyMenuPanel);

4. Définissez les rappels de reconnaissance faciale et de retouche.

   Si vous devez intégrer une bibliothèque de retouche tierce, définissez les rappels setCustomDetect et setCustomFilter.

   • Dans customDetectProcess, le paramètre data est un pointeur vers les données capturées pour le traitement tiers.

   • Dans customFilterProcess, le paramètre inputTexture est la texture d'image à traiter. Renvoyez l'ID de texture traité, ou la inputTexture d'origine si elle n'a pas été modifiée.

   Exemple de code

   /**
    * Facial recognition callback.
    */
   mAlivcLivePusher.setCustomDetect(new AlivcLivePushCustomDetect() {
       @Override
       public void customDetectCreate() {
   
       }
   
       @Override
       public long customDetectProcess(long dataPtr, int width, int height, int rotation, int format, long extra) {
           return 0;
       }
   
       @Override
       public void customDetectDestroy() {
   
       }
   });
   
   /**
    * Retouching callback.
    */
    
   /**
    * Initialize BeautyManager.
    */
   mAlivcLivePusher.setCustomFilter(new AlivcLivePushCustomFilter() {
       @Override
       public void customFilterCreate() {
           initBeautyManager();
       }
   
   /**
    * Process the ingested video stream and add retouching effects.
    */
       @Override
       public int customFilterProcess(int inputTexture, int textureWidth, int textureHeight, long extra) {
           if (mBeautyManager == null) {
               return inputTexture;
           }
   
           return mBeautyManager.onTextureInput(inputTexture, textureWidth, textureHeight);
       }
   
       @Override
       public void customFilterDestroy() {
           destroyBeautyManager();
       }
   });