Publier : Contrôle en amont et autorisations

Pour voir un aperçu de la vidéo avant que l'éditeur ne commence à la diffuser, appelez la fonction startPreview() de l'objet Publisher :

mPublisher.startPreview();

Si vous appelez le startPreview() vous devez appeler la méthode destroy() de l'éditeur pour supprimer la vue de l'éditeur (et la vidéo), lorsque l'éditeur arrête la diffusion (lorsque la méthode onStreamDestroyed(PublisherKit publisher, Stream stream) du PublisherListener est appelée).

Vous pouvez contrôler le moment où cette invite est affichée en appelant AVCaptureDevice requestAccess(for:completionHandler:) avec AVMediaType.Videoqui affichera l'invite lors de la première exécution. Les appels suivants exécuteront le gestionnaire d'achèvement avec la préférence enregistrée par l'utilisateur.

AVCaptureDevice.requestAccess(for: .video) { granted in
	if granted {
		// Access to the camera is granted. You can publish.
	} else {
		// Access to the camera is not granted.
	}
}

Vous pouvez contrôler le moment où cette invite est affichée en appelant [AVCaptureDevice requestAccessForMediaType:completionHandler:] avec AVMediaTypeVideoqui affichera l'invite lors de la première exécution. Les appels suivants exécuteront le gestionnaire d'achèvement avec la préférence enregistrée par l'utilisateur.

[AVCaptureDevice requestAccessForMediaType:AVMediaTypeVideo completionHandler:^(BOOL granted) {
        if(granted){
            // Access to the camera is granted. You can publish.
        } else {
            // Access to the camera is not granted.
        }
    }];

Une fois que vous vous êtes connecté à une session, vous pouvez vérifier si le client peut publier. Définissez une référence à l'élément OTSession et appeler son objet getCapabilites() dans la méthode sessionConnected (gestionnaire d'événement). Cette méthode renvoie une promesse avec un objet qui comprend un canPublish de la propriété. Vous pouvez ensuite procéder à une publication conditionnelle en fonction de cette valeur :

import React, {Component} from 'react';
import {View} from 'react-native';
import {OTSession, OTPublisher, OTSubscriber} from 'opentok-react-native';

class App extends Component {
  constructor(props) {
    super(props);
    this.apiKey = 'your API key';
    this.sessionId = 'a session ID';
    this.token = 'a valid token';
    this.state = {canPublish: false};

    this.sessionEventHandlers = {
      sessionConnected: event => {
        this.connectionCount++;
        this.session.getCapabilities().then(capabilities => {
          this.setState({canPublish: capabilities.canPublish});
        });
      },
    };
  }

  render() {
    return (
      <View
        <OTSession
          applicationId={this.apiKey}
          sessionId={this.sessionId}
          token={this.token}
          ref={instance => {
            this.session = instance;
          }}
          eventHandlers={this.sessionEventHandlers}>
          {this.state.canPublish ? (
            <OTPublisher/>
          ) : null}
          <OTSubscriber/>
        </OTSession>
      </View>
    );
  }
}

export default App;

Pour publier, le client doit se connecter à la session à l'aide d'un jeton auquel est attribué un code rôle qui soutient la publication.

Vérifier la valeur du capabilities.publish de la propriété Session objet. S'il vaut 1, le client peut publier :

if (session.capabilities.publish == 1) {
    // The client can publish. See the next section.
} else {
    // The client cannot publish.
    // You may want to notify the user.
}

Pour publier, le client doit se connecter à la session à l'aide d'un jeton auquel est attribué un rôle qui prend en charge la publication. Une caméra et un microphone doivent être connectés. L'environnement du client doit également prendre en charge la publication (voir Prise en charge des navigateurs).

En outre, la publication n'est possible que sur les pages HTTPS.

Vérifier la valeur du OTSession capablilites.canPublish propriété. Si elle a pour valeur truele client peut publier :

if let capabilities = session.capabilities, capabilities.canPublish {
    // The client can publish.
} else {
    // The client cannot publish.
    // You may want to notify the user.
}

Pour publier, le client doit se connecter à la session avec un jeton auquel est attribué un rôle prenant en charge la publication. Voir la page Aperçu de la création de jetons.

Vérifier la valeur du [OTSession.capablilites.canPublish:] propriété. Si elle a pour valeur YESle client peut publier :

if (session.capabilities.canPublish) {
    // The client can publish.
} else {
    // The client cannot publish.
    // You may want to notify the user.
}

Pour publier, le client doit se connecter à la session avec un jeton auquel est attribué un rôle prenant en charge la publication. Voir la page Aperçu de la création de jetons.