Przechwytywanie danych z kamery

Obiekt Camera umożliwia nawiązanie połączenia z lokalną kamerą użytkownika i rozgłaszanie wideo z kamery lokalnie (na komputerze użytkownika) lub zdalnie do serwera (np. Flash Media Server).

Korzystając z klasy Camera, można uzyskać dostęp do następujących rodzajów informacji o kamerze użytkownika:

• które z kamer zainstalowanych w komputerze użytkownika są dostępne;

• czy w ogóle jest zainstalowana kamera;

• czy program Flash Player ma zezwolenie na dostęp do kamery użytkownika;

• która kamera jest obecnie aktywna;

• szerokość i wysokość przechwytywanego wideo.

Klasa Camera zawiera kilka użytecznych metod i właściwości służących do pracy z obiektami kamer. Na przykład statyczna właściwość Camera.names zawiera tablicę nazw kamer zainstalowanych obecnie w komputerze użytkownika. Można również skorzystać z właściwości name w celu wyświetlenia nazwy kamery, która jest obecnie aktywna.

Połączenie z kamerą można zrealizować w prostszy sposób niż ładowanie wideo przy użyciu klas NetConnection i NetStream. Z drugiej strony, sposób użycia klasy Camera nie zawsze jest oczywisty, ponieważ w programie Flash Player dostęp do kamery jest możliwy dopiero po udzieleniu przez użytkownika zgody na taki dostęp.

Poniższy kod ilustruje sposób użycia klasy Camera do nawiązania połączenia z lokalną kamerą użytkownika:

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

Pisząc aplikację nawiązującą połączenie z kamerą użytkownika, należy uwzględnić następujące uwarunkowania:

• Należy sprawdzić, czy użytkownik ma zainstalowaną kamerę. Należy obsłużyć sytuację, w której nie jest dostępny żadna kamera.

• Tylko w przypadku programu Flash Player — należy sprawdzić, czy użytkownik jawnie zezwolił na dostęp do kamery. Ze względów bezpieczeństwa wyświetlane jest okno dialogowe ustawień programu Flash Player, w którym użytkownik może zezwolić na dostęp do kamery lub odmówić takiego dostępu. Uniemożliwia to programowi Flash Player nawiązanie połączenia z kamerą i rozgłaszanie strumienia wideo bez zgody użytkownika. Jeśli użytkownik kliknie opcję zezwolenia, aplikacja może nawiązać połączenie z kamerą użytkownika. Jeśli użytkownik kliknie opcję odmowy, aplikacja nie będzie miała dostępu do kamery. Aplikacja powinna zawsze prawidłowo reagować na obie decyzje użytkownika.

• Tylko w środowisku AIR należy sprawdzić, czy klasa Camera jest obsługiwana dla profilów urządzeń obsługiwanych przez aplikację.

• Klasa Camera nie jest obsługiwana w przeglądarkach na urządzeniach przenośnych.

• Klasa Camera nie jest obsługiwana w aplikacjach AIR na urządzeniach przenośnych, w których jest używany tryb renderowania GPU.

• W systemie iOS może być aktywna tylko jedna kamera naraz. W systemie Android można uzyskać dostęp tylko do kamery przedniej.

Pierwszym krokiem przy nawiązywaniu połączenia z kamerą użytkownika jest utworzenie nowej instancji kamery poprzez utworzenie zmiennej typu Camera i zainicjowanie jej wartością zwróconą ze statycznej metody Camera.getCamera().

Następnym krokiem jest utworzenie obiektu wideo i przyłączenie do niego obiektu Camera.

Trzecim krokiem jest dodanie obiektu wideo do listy wyświetlania. Kroki 2 i 3 są konieczne, ponieważ klasa Camera nie rozszerza klasy DisplayObject i obiektów klasy Camera nie można dodawać bezpośrednio do listy wyświetlania. Aby wyświetlać obraz wideo przechwytywany z kamery, należy utworzyć nowy obiekt wideo i wywołać metodę attachCamera().

Poniższy kod ilustruje wymienione trzy kroki:

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

Należy zwrócić uwagę, że jeśli użytkownik nie ma zainstalowanej kamery, aplikacja nie wyświetla żadnych informacji.

W prawdziwej aplikacji konieczne jest wykonanie dodatkowych kroków. Więcej informacji zawierają sekcje Sprawdzanie, czy kamera jest zainstalowania oraz Wykrywanie uprawnień dostępu do kamery.

Przed próbą użycia jakichkolwiek metod lub właściwości instancji kamery należy sprawdzić, czy w komputerze użytkownika jest zainstalowana kamera. Istnieją dwa sposoby sprawdzenia, czy użytkownik ma zainstalowaną kamerę:

• Odczyt statycznej właściwości Camera.names, która zawiera listę nazw dostępnych kamer. Zwykle ta tablica będzie zawierała jeden ciąg znaków lub w ogóle nie będzie zawierała ciągów znaków, ponieważ użytkownicy rzadko mają zainstalowaną więcej niż jedną kamerę. Poniższy kod ilustruje sposób odczytywania właściwości Camera.names w celu sprawdzenia, czy w komputerze użytkownika są dostępne kamery:

  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."); 
  }

• Sprawdzenie wartości zwracanej przez statyczną metodę Camera.getCamera(). Jeśli żadne kamery nie są dostępne lub zainstalowane, metoda ta zwraca null, w przeciwnym razie zwraca odwołanie do obiektu Camera. Poniższy kod ilustruje sposób odczytywania wyniku metody Camera.getCamera() w celu sprawdzenia, czy w komputerze użytkownika są dostępne kamery:

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

Ponieważ klasa Camera nie rozszerza klasy DisplayObject, obiektów Camera nie można dodawać bezpośrednio do listy wyświetlania przy użyciu metody addChild(). Aby wyświetlać obraz wideo z kamery, należy utworzyć nowy obiekt Video i wywołać metodę attachCamera() w instancji obiektu Video.

Poniższy urywek kodu ilustruje sposób przyłączania kamery (jeśli kamera istnieje); w razie braku kamery aplikacja nie wyświetla żadnego obrazu:

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

W obszarze izolowanym aplikacji środowiska AIR aplikacja ma dostęp do każdej kamery, bez pytania użytkownika o zgodę. W systemie Android w deskryptorze aplikacji musi być określone uprawnienie CAMERA systemu Android.

Jednak aby program Flash Player mógł wyświetlać obraz z kamery, użytkownik musi jawnie zezwolić mu na dostęp do kamery. Po wywołaniu przez aplikację metody attachCamera() program Flash Player wyświetla okno dialogowe Ustawienia Flash Player z monitem o zezwolenie lub odmowę dostępu do kamery i mikrofonu zainstalowanych w systemie. Jeśli użytkownik kliknie przycisk zezwolenia, program Flash Player wyświetli obraz z kamery w instancji Video na stole montażowym. Jeśli użytkownik kliknie przycisk odmowy, program Flash Player nie będzie mógł nawiązać połączenia z kamerą, a obiekt Video nie wyświetli żadnych informacji.

Aby sprawdzić, czy użytkownik zezwolił programowi Flash Player na dostęp do kamery, można wykrywać zdarzenia status kamery (StatusEvent.STATUS), co ilustruje poniższy kod:

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" 
}

Funkcja statusHandler() jest wywoływana w momencie, gdy użytkownik kliknie przycisk zezwolenia albo odmowy. Aby sprawdzić, który przycisk został kliknięty, można skorzystać z jednej z dwóch metod:

• Parametr event funkcji statusHandler() zawiera właściwość code, która z kolei zawiera ciąg znaków "Camera.Muted" albo "Camera.Unmuted". Wartość "Camera.Muted" oznacza, że użytkownik kliknął przycisk odmowy, a program Flash Player nie ma dostępu do kamery. Oto przykład zastosowania tej metody:

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

• Klasa Camera zawiera właściwość muted przeznaczoną tylko do odczytu; właściwość ta określa, czy użytkownik odmówił dostępu do kamery (true), czy zezwolił na taki dostęp (false) w panelu Prywatność programu Flash Player. Oto przykład zastosowania tej metody:

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

Wykrywając zdarzenie status, kod może odpowiednio reagować na zgodę lub odmowę użytkownika na dostęp do kamery i wykonać odpowiednie czynności porządkowe. Na przykład, jeśli użytkownik kliknie przycisk odmowy, może zostać wyświetlony komunikat informujący, że bez zgody na dostęp do kamery nie będzie możliwy udział użytkownika w wideoczacie. Kod może także usuwać obiekt Video z listy wyświetlania w celu zwolnienia zasobów systemowych.

W środowisku AIR obiekt Camera nie wywołuje zdarzeń stanu, ponieważ uprawnienie do używania kamery nie jest dynamiczne.

Domyślnie nowe instancje klasy Video mają szerokość 320 pikseli i wysokość 240 pikseli. Aby uzyskać jak najlepszą jakość wideo, należy zawsze dbać o to, aby obiekt wideo aplikacji miał te same wymiary, co obraz wideo przesyłany z obiektu kamery. Szerokość i wysokość obrazu z obiektu kamery można uzyskać, odczytując właściwości width i height klasy Camera. Następnie można przypisać właściwościom width i height obiektu wideo wymiary obrazu lub przekazać szerokość i wysokość obrazu z kamery do konstruktora klasy Video, co ilustruje poniższy fragment:

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

Ponieważ metoda getCamera() zwraca odwołanie do obiektu kamery (lub null, jeśli nie ma dostępnej kamery), możliwe jest uzyskiwanie dostępu do metod i właściwości kamery nawet wówczas, gdy użytkownik odmówi dostępu do swojej kamery. Dzięki temu możliwe jest dopasowanie rozmiaru instancji Video do natywnej wysokości i szerokości obrazu z kamery.

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); 
}

Informacje na temat trybu pełnoekranowego zawiera punkt dotyczący tego trybu w sekcji Ustawianie właściwości obiektu Stage.

Klasa Camera zawiera kilka właściwości umożliwiających monitorowanie bieżącego statusu obiektu Camera. Na przykład poniższy kod wyświetla kilka właściwości kamery przy użyciu obiektu Timer i instancji pola tekstowego na liście wyświetlania:

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"); 
}

Co 1/10 sekundy (100 milisekund) wywoływane jest zdarzenie timer obiektu Timer, a funkcja timerHandler() aktualizuje pole tekstowe na liście wyświetlania.