Rilevamento dell'input da videocamera

L'oggetto Camera consente di collegarsi alla videocamera locale dell'utente e trasmettere il video a livello locale (cioè, all'utente stesso) oppure a livello remoto a un server (ad esempio, Flash Media Server).

Grazie alla classe Camera, è possibile accedere ai seguenti tipi di informazioni relative alla videocamera dell'utente:

• quali videocamere installate sul computer dell'utente sono disponibili;

• se una videocamera è installata;

• se a Flash Player è consentito o negato l'accesso alla videocamera dell'utente;

• quale videocamera è attualmente attiva;

• la larghezza e l'altezza del video in corso di acquisizione.

La classe Camera fornisce diversi metodi e proprietà per eseguire operazioni con gli oggetti Camera. Ad esempio, la proprietà Camera.names statica contiene un array dei nomi di videocamera attualmente installati sul computer dell'utente. È anche possibile utilizzare la proprietà name per visualizzare il nome della videocamera attualmente attiva.

Il collegamento di una videocamera può richiedere una quantità di codice minore rispetto a quando si utilizzano le classi NetConnection e NetStream per caricare un video. La classe Camera può tuttavia diventare rapidamente complicata, dal momento che con Flash Player per accedere a una videocamera è necessaria l'autorizzazione da parte dell'utente per connettersi alla videocamera.

Il codice seguente dimostra come usare la classe Camera per collegarsi alla videocamera locale di un utente:

var cam:Camera = Camera.getCamera(); 
var vid:Video = new Video(); 
vid.attachCamera(cam); 
addChild(vid);

Quando create un'applicazione che si collega alla videocamera di un utente, dovete eseguire le seguenti operazioni relative al codice:

• Verificate se per l'utente è attualmente installata una videocamera. Gestite il caso in cui non è disponibile nessuna videocamera.

• Solo per Flash Player, controllate se l'utente ha esplicitamente consentito l'accesso alla videocamera. Per motivi di sicurezza, il lettore visualizza la finestra di dialogo Impostazioni di Flash Player che consente all'utente di autorizzare o negare l'accesso alla propria videocamera. In questo modo si impedisce a Flash Player di collegarsi alla videocamera di un utente e di trasmettere uno streaming video senza il suo permesso. Se un utente consente l'accesso, l'applicazione può collegarsi alla videocamera dell'utente. Se un utente non consente l'accesso, l'applicazione non può collegarsi alla videocamera dell'utente. Le applicazioni devono sempre gestire entrambi i casi.

• Solo per AIR, verificate se la classe Camera è supportata per i profili dispositivo supportati dall'applicazione.

• La classe Camera non è supportata nei browser per dispositivi mobili.

• La classe Camera non è supportata nelle applicazioni AIR mobili che utilizzano la modalità di rendering tramite GPU.

• Su iOS, solo una videocamera alla volta può essere attiva. Su Android, è possibile accedere solo alla videocamera rivolta in avanti.

La prima operazione da eseguire quando ci si collega alla videocamera di un utente consiste nel creare una nuova istanza di una variabile di tipo Camera in base al valore restituito dal metodo statico Camera.getCamera().

Quindi, è necessario creare un nuovo oggetto video e associare a esso l'oggetto Camera.

La terza operazione consiste nell'aggiungere l'oggetto video all'elenco di visualizzazione. Le operazioni 2 e 3 sono necessarie, dal momento che la classe Camera non estende la classe DisplayObject e pertanto non può essere aggiunta direttamente all'elenco di visualizzazione. Per visualizzare il video acquisito dalla videocamera, create un nuovo oggetto video e chiamate il metodo attachCamera().

Le tre operazioni sono illustrate nel codice seguente:

var cam:Camera = Camera.getCamera(); 
var vid:Video = new Video(); 
vid.attachCamera(cam); 
addChild(vid);

Notate che se per un utente non è installata una videocamera, l'applicazione non visualizza nulla.

Nella realtà, è necessario eseguire delle operazioni supplementari per l'applicazione. Per ulteriori informazioni, vedete Verifica dell'installazione delle videocamere e Rilevamento delle autorizzazioni per l'accesso alla videocamera.

Prima di tentare di usare qualunque metodo o proprietà su un'istanza Camera, è necessario verificare che per l'utente sia installata una videocamera. A tale scopo, potete utilizzare uno dei due metodi seguenti:

• Verificare la proprietà statica Camera.names, che contiene un array dei nomi di videocamera disponibili. Di solito, questo array ha al massimo una stringa, poiché per la maggior parte degli utenti non è installata più di una videocamera per volta. Il codice seguente illustra come è possibile verificare la proprietà Camera.names per determinare se per l'utente sono disponibili delle videocamere:

  if (Camera.names.length > 0) 
  { 
      trace("User has at least one camera installed."); 
      var cam:Camera = Camera.getCamera(); // Get default camera. 
  } 
  else 
  { 
      trace("User has no cameras installed."); 
  }

• Verificare il valore restituito dal metodo statico Camera.getCamera(). Se non è disponibile o installata alcuna videocamera, questo metodo restituisce null, in caso contrario restituisce un riferimento a un oggetto Camera. Il codice seguente illustra come è possibile verificare il metodo Camera.getCamera() per determinare se per l'utente sono disponibili delle videocamere:

  var cam:Camera = Camera.getCamera(); 
  if (cam == null) 
  { 
      trace("User has no cameras installed."); 
  } 
  else 
  { 
      trace("User has at least 1 camera installed."); 
  }

Dal momento che la classe Camera non estende la classe DisplayObject, non può essere aggiunta direttamente all'elenco di visualizzazione mediante il metodo addChild(). Per visualizzare il video acquisito dalla videocamera, create un nuovo oggetto Video e chiamate il metodo attachCamera() sull'istanza Video.

Questo snippet di codice mostra come associare la videocamera (se presente); in caso contrario, l'applicazione non visualizza nulla:

var cam:Camera = Camera.getCamera(); 
if (cam != null) 
{ 
    var vid:Video = new Video(); 
    vid.attachCamera(cam); 
    addChild(vid); 
}

Nella sandbox dell'applicazione AIR, l'applicazione può accedere a qualsiasi videocamera senza l'autorizzazione dell'utente. In Android, tuttavia, l'applicazione deve specificare l'autorizzazione Android CAMERA nel descrittore dell'applicazione.

Per consentire a Flash Player di visualizzare l'output della videocamera, l'utente deve consentire in maniera esplicita l'accesso alla videocamera. Quando il metodo attachCamera() viene chiamato, Flash Player visualizza la finestra di dialogo Impostazioni di Flash Player, che richiede all'utente di consentire o negare a Flash Player di accedere alla videocamera e al microfono. Se l'utente ha consentito l'accesso, Flash Player visualizza l'output della videocamera nell'istanza Video sullo Stage. Se l'utente non consente l'accesso, Flash Player non è in grado di collegarsi alla videocamera e l'oggetto Video non visualizza nulla.

Per rilevare se l'utente ha consentito o negato l'accesso alla videocamera, potete intercettare l'evento status della videocamera (StatusEvent.STATUS), come mostrato nel codice seguente:

var cam:Camera = Camera.getCamera(); 
if (cam != null) 
{ 
    cam.addEventListener(StatusEvent.STATUS, statusHandler); 
    var vid:Video = new Video(); 
    vid.attachCamera(cam); 
    addChild(vid); 
} 
function statusHandler(event:StatusEvent):void 
{ 
    // This event gets dispatched when the user clicks the "Allow" or "Deny" 
    // button in the Flash Player Settings dialog box. 
    trace(event.code); // "Camera.Muted" or "Camera.Unmuted" 
}

La funzione statusHandler() viene chiamata non appena l'utente fa clic su Consenti o Nega. Mediante uno dei due metodi seguenti potete rilevare su quale pulsante l'utente ha fatto clic:

• Il parametro event della funzione statusHandler() contiene una proprietà code che contiene la stringa “Camera.Muted” o “Camera.Unmuted”. Se il valore è “Camera.Muted”, l'utente che ha fatto clic sul pulsante Nega e Flash Player non può accedere alla videocamera. Lo snippet di codice seguente contiene un esempio:

  function statusHandler(event:StatusEvent):void 
  { 
      switch (event.code) 
      { 
          case "Camera.Muted": 
              trace("User clicked Deny."); 
              break; 
          case "Camera.Unmuted": 
              trace("User clicked Accept."); 
              break; 
      } 
  }

• La classe Camera contiene una proprietà di sola lettura di nome muted che specifica se l'utente ha negato (true) o consentito (false) l'accesso alla videocamera nel pannello Privacy di Flash Player. Lo snippet di codice seguente contiene un esempio:

  function statusHandler(event:StatusEvent):void 
  { 
      if (cam.muted) 
      { 
          trace("User clicked Deny."); 
      } 
      else 
      { 
          trace("User clicked Accept."); 
      } 
  }

Verificando l'avvenuto invio dell'evento status, potete scrivere del codice che gestisce l'accettazione o il rifiuto da parte dell'utente dell'accesso alla videocamera ed eseguire la pulizia appropriata del codice. Ad esempio, se l'utente fa clic sul pulsante Nega, potete visualizzare un messaggio che avvisa che è necessario fare clic su Consenti per partecipare a una chat video oppure potete fare in modo che l'oggetto Video nell'elenco di visualizzazione venga eliminato per liberare risorse di sistema.

In AIR, un oggetto Camera non invia eventi status poiché l'autorizzazione per utilizzare la video camera non è dinamica.

Per impostazione predefinita, le nuove istanze della classe Video sono larghe 320 pixel e alte 240 pixel. Per poter ottimizzare la qualità video, è necessario garantire sempre che l'oggetto video abbia le stesse dimensioni del video restituito dall'oggetto Camera. Potete ottenere la larghezza e l'altezza dell'oggetto Camera utilizzando le proprietà width e height della classe Camera, quindi potete impostare le proprietà width e height dell'oggetto Video in modo che corrispondano alle dimensioni dell'oggetto Camera oppure potete passare la larghezza e l'altezza della videocamera al metodo di costruzione della classe Video, come mostrato nello snippet di codice seguente:

var cam:Camera = Camera.getCamera(); 
if (cam != null) 
{ 
    var vid:Video = new Video(cam.width, cam.height); 
    vid.attachCamera(cam); 
    addChild(vid); 
}

Dal momento che il metodo getCamera() restituisce un riferimento a un oggetto Camera (oppure null se non è disponibile alcuna videocamera), potete accedere ai metodi e alle proprietà della videocamera anche se l'utente nega l'accesso alla propria videocamera. In questo modo potete impostare le dimensioni dell'istanza video mediante l'altezza e la larghezza native della videocamera.

var vid:Video; 
var cam:Camera = Camera.getCamera(); 
 
if (cam == null) 
{ 
    trace("Unable to locate available cameras."); 
} 
else 
{ 
    trace("Found camera: " + cam.name); 
    cam.addEventListener(StatusEvent.STATUS, statusHandler); 
    vid = new Video(); 
    vid.attachCamera(cam); 
} 
function statusHandler(event:StatusEvent):void 
{ 
    if (cam.muted) 
    { 
        trace("Unable to connect to active camera."); 
    } 
    else 
    { 
        // Resize Video object to match camera settings and  
        // add the video to the display list. 
        vid.width = cam.width; 
        vid.height = cam.height; 
        addChild(vid); 
    } 
    // Remove the status event listener. 
    cam.removeEventListener(StatusEvent.STATUS, statusHandler); 
}

Per informazioni sulla modalità a schermo intero, vedete la relativa sezione in Impostazione delle proprietà dello stage.

La classe Camera contiene alcune proprietà che consentono di monitorare lo stato corrente dell'oggetto Camera. Ad esempio, il codice seguente visualizza diverse delle proprietà della videocamera mediante un oggetto Timer e un'istanza di campo di testo nell'elenco di visualizzazione:

var vid:Video; 
var cam:Camera = Camera.getCamera(); 
var tf:TextField = new TextField(); 
tf.x = 300; 
tf.autoSize = TextFieldAutoSize.LEFT; 
addChild(tf); 
 
if (cam != null) 
{ 
    cam.addEventListener(StatusEvent.STATUS, statusHandler); 
    vid = new Video(); 
    vid.attachCamera(cam); 
} 
function statusHandler(event:StatusEvent):void 
{ 
    if (!cam.muted) 
    { 
        vid.width = cam.width; 
        vid.height = cam.height; 
        addChild(vid); 
        t.start(); 
    } 
    cam.removeEventListener(StatusEvent.STATUS, statusHandler); 
} 
 
var t:Timer = new Timer(100); 
t.addEventListener(TimerEvent.TIMER, timerHandler); 
function timerHandler(event:TimerEvent):void 
{ 
    tf.text = ""; 
    tf.appendText("activityLevel: " + cam.activityLevel + "\n"); 
    tf.appendText("bandwidth: " + cam.bandwidth + "\n"); 
    tf.appendText("currentFPS: " + cam.currentFPS + "\n"); 
    tf.appendText("fps: " + cam.fps + "\n"); 
    tf.appendText("keyFrameInterval: " + cam.keyFrameInterval + "\n"); 
    tf.appendText("loopback: " + cam.loopback + "\n"); 
    tf.appendText("motionLevel: " + cam.motionLevel + "\n"); 
    tf.appendText("motionTimeout: " + cam.motionTimeout + "\n"); 
    tf.appendText("quality: " + cam.quality + "\n"); 
}

Ogni 1/10 di secondo (100 millisecondi) l'evento timer dell'oggetto Timer viene inviato e la funzione timerHandler() aggiorna il campo di testo nell'elenco di visualizzazione.