Erfassen von Kameraeingaben

Mit dem Camera-Objekt können Sie eine Verbindung zu einer lokalen Kamera herstellen und das Video entweder lokal (zurück an den Benutzer) senden oder remote an einen Server (z. B. an Flash Media Server) übertragen.

Mithilfe der Camera-Klasse können Sie auf die folgenden Arten von Informationen zur Benutzerkamera zugreifen:

• Welche der auf dem Benutzercomputer installierten Kameras stehen zur Verfügung

• Ist überhaupt eine Kamera installiert

• Ist Flash Player der Zugriff auf die Benutzerkamera gestattet oder nicht

• Welche Kameras sind derzeit aktiviert

• Wie lauten Größe und Höhe des erfassten Videos

Die Camera-Klasse umfasst mehrere nützliche Methoden und Eigenschaften für die Verwendung von Camera-Objekten. Beispielsweise enthält die statische Camera.names-Eigenschaft ein Array mit den Namen der Kameras, die derzeit auf dem Benutzercomputer installiert sind. Mit der name-Eigenschaft können Sie auch den Namen der aktuellen aktiven Kamera anzeigen.

Für das Anschließen einer Kamera kann weniger Code erforderlich sein als für das Verwenden der NetConnection- und NetStream-Klasse zum Laden einer Videodatei. Andererseits kann die Camera-Klasse auch schnell kompliziert werden, da Sie mit Flash Player eine Genehmigung des Benutzers für eine Verbindung zu dessen Kamera benötigen, bevor Sie darauf zugreifen können.

Mit dem folgenden Code wird gezeigt, wie Sie mit der Camera-Klasse eine Verbindung zu einer lokal angeschlossenen Benutzerkamera herstellen können:

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

Beim Schreiben einer Anwendung, die eine Verbindung mit einer Benutzerkamera herstellt, muss im Code Folgendes berücksichtigt werden:

• Prüfen, ob der Benutzer derzeit eine Kamera installiert hat. Verarbeiten einer Situation, in der keine Kamera verfügbar ist.

• Nur bei Verwendung von Flash Player müssen Sie prüfen, ob der Benutzer den Zugriff auf die Kamera ausdrücklich zugelassen hat. Aus Sicherheitsgründen wird das Dialogfeld „Flash Player-Einstellungen“ angezeigt, in dem Benutzer den Zugriff auf ihre Kamera zulassen oder verweigern können. Auf diese Weise wird verhindert, dass Flash Player eine Verbindung zu einer Benutzerkamera herstellt und einen Video-Stream ohne Genehmigung des Benutzers überträgt. Wenn der Benutzer auf „Zulassen“ klickt, kann Ihre Anwendung eine Verbindung zur Benutzerkamera herstellen. Wenn der Benutzer auf „Verweigern“ klickt, kann Ihre Anwendung keine Verbindung zur Benutzerkamera herstellen. Ihre Anwendungen sollten beide Fälle kulant verarbeiten.

• Überprüfen Sie in AIR, ob die Camera-Klasse für die von Ihrer Anwendung unterstützten Geräteprofile unterstützt wird.

• Die Camera-Klasse wird in mobilen Browsern nicht unterstützt.

• Die Camera-Klasse wird nicht in mobilen AIR-Anwendungen unterstützt, die den GPU-Rendermodus verwenden.

• Unter iOS kann immer nur eine Kamera aktiv sein. Unter Android ist nur die nach vorne gerichtete Kamera verfügbar.

Der erste Schritt beim Herstellen einer Verbindung mit einer Kamera ist das Erstellen einer neuen Camera-Instanz. Dazu erstellen Sie zunächst eine Variable des Typs Camera und initialisieren diese dann mit dem Rückgabewert der statischen Camera.getCamera()-Methode.

Der nächste Schritt ist das Erstellen eines neuen Video-Objekts und das Anhängen des Camera-Objekts an das Video-Objekt.

Der dritte Schritt ist das Hinzufügen des Video-Objekts zur Anzeigeliste. Sie müssen die Schritte 2 und 3 ausführen, da die Camera-Klasse die DisplayObject-Klasse nicht erweitert und somit nicht direkt zur Anzeigeliste hinzugefügt werden kann. Um das von der Kamera erfasste Video anzuzeigen, erstellen Sie ein neues Video-Objekt, und rufen Sie die attachCamera()-Methode auf.

Diese drei Schritte werden im folgenden Beispielcode gezeigt:

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

Wenn ein Benutzer keine Kamera installiert hat, wird in der Anwendung keine Ausgabe angezeigt.

In der realen Welt müssen Sie zusätzliche Schritte für Ihre Anwendung ausführen. Weitere Informationen finden Sie unter Prüfen auf installierte Kameras und Erfassen der Zugriffsberechtigungen für eine Kamera.

Bevor Sie versuchen, Methoden oder Eigenschaften an einer Camera-Instanz anzuwenden, sollten Sie überprüfen, ob der Benutzer eine Kamera installiert hat. Es gibt zwei Möglichkeiten, um zu überprüfen, ob der Benutzer eine Kamera installiert hat:

• Prüfen Sie in der statischen Camera.names-Eigenschaft, welche Kameras verfügbar sind. Diese Eigenschaft enthält ein Array der Kameranamen. In der Regel enthält dieses Array maximal einen String, da die meisten Benutzer wahrscheinlich nur eine Kamera installiert haben. Mit dem folgenden Code wird gezeigt, wie Sie die Eigenschaft Camera.names überprüfen können, um festzustellen, ob der Benutzer verfügbare Kameras installiert hat:

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

• Überprüfen Sie den Rückgabewert der statischen Camera.getCamera()-Methode. Wenn keine Kameras verfügbar oder installiert sind, gibt diese Methode null zurück. Andernfalls gibt sie einen Verweis auf ein Camera-Objekt zurück. Im folgenden Code wird gezeigt, wie Sie mit der Camera.getCamera()-Methode überprüfen können, ob der Benutzer verfügbare Kameras installiert hat:

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

Da die Camera-Klasse die DisplayObject-Klasse nicht erweitert, kann sie der Anzeigeliste nicht direkt mit der addChild()-Methode hinzugefügt werden. Um das von der Kamera erfasste Video anzuzeigen, müssen Sie ein neues Video-Objekt erstellen und die attachCamera()-Methode der Video-Instanz aufrufen.

Im folgenden Codeausschnitt wird gezeigt, wie Sie eine Verbindung mit einer vorhandenen Kamera herstellen. Wenn keine Kamera vorhanden ist, wird in der Anwendung keine Ausgabe angezeigt:

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

In der AIR-Anwendungs-Sandbox kann die Anwendung ohne Berechtigung des Benutzers auf alle Kameras zugreifen. Doch unter Android muss die Anwendung die Android-Berechtigung CAMERA im Anwendungsdeskriptor angeben.

Bevor die Ausgabe einer Kamera angezeigt werden kann, muss der Benutzer Flash Player den Zugriff auf die Kamera explizit gestatten. Wenn die attachCamera()-Methode aufgerufen wird, wird in Flash Player das Dialogfeld Flash Player-Einstellungen angezeigt, in dem der Benutzer aufgefordert wird, den Zugriff auf die Kamera und das Mikrofon zuzulassen oder zu verweigern. Klickt der Benutzer auf die Schaltfläche „Zulassen“, zeigt Flash Player die Ausgabe der Kamera in der Video-Instanz auf der Bühne an. Klickt der Benutzer auf die Schaltfläche „Verweigern“, kann Flash Player keine Verbindung zur Kamera herstellen und das Video-Objekt bleibt leer.

Um festzustellen, ob der Benutzer Flash Player den Zugriff auf die Kamera erlaubt oder verweigert hat, können Sie das status-Ereignis der Kamera überwachen (StatusEvent.STATUS), wie im folgenden Code dargestellt:

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

Die statusHandler()-Funktion wird aufgerufen, sobald der Benutzer entweder auf „Zulassen“ oder „Verweigern“ klickt. Auf welche Schaltfläche der Benutzer geklickt hat, können Sie mit einer der folgenden beiden Methoden feststellen:

• Der event-Parameter der statusHandler()-Funktion enthält eine code-Eigenschaft mit dem String „Camera.Muted “oder „Camera.Unmuted“. Beim Wert „Camera.Muted“ hat der Benutzer auf die Schaltfläche „Verweigern“ geklickt und Flash Player kann nicht auf die Kamera zugreifen. Ein Beispiel hierfür wird im folgenden Codeausschnitt gezeigt:

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

• Die Camera-Klasse enthält eine schreibgeschützte Eigenschaft namens muted, mit der festgelegt wird, ob der Benutzer den Zugriff auf die Kamera im Flash Player-Bedienfeld „Zugriffsschutz“ verweigert (true) oder gewährt (false) hat. Ein Beispiel hierfür wird im folgenden Codeausschnitt gezeigt:

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

Indem Sie überprüfen, ob das status-Ereignis ausgelöst wurde, können Sie Code schreiben, der das Zulassen oder Verweigern des Zugriffs auf die Kamera verarbeitet und entsprechend reagiert. Wenn der Benutzer auf die Schaltfläche „Verweigern“ klickt, können Sie den Benutzer in einer Meldung darauf hinweisen, dass er auf „Zulassen“ klicken muss, wenn er an einem Video-Chat teilnehmen möchte, oder Sie können sicherstellen, dass das Video-Objekt aus der Anzeigeliste gelöscht wird, um Systemressourcen freizugeben.

In AIR löst ein Camera-Objekt keine status-Ereignisse aus, da die Berechtigung zur Verwendung der Kamera nicht dynamisch ist.

Standardmäßig sind neue Instanzen der Video-Klasse 320 Pixel breit und 240 Pixel hoch. Zur Maximierung der Videoqualität müssen Sie sicherstellen, dass Ihr Video-Objekt den Abmessungen des vom Camera-Objekt zurückgegebenen Videos entspricht. Sie können die Breite und Höhe des Camera-Objekts mithilfe der Eigenschaften width und height der Camera-Klasse abrufen. Sie können dann die Eigenschaften width und height des Video-Objekts so festlegen, dass sie den Abmessungen des Camera-Objekts entsprechen, oder Sie können die Breite und Höhe der Kamera an die Konstruktormethode der Video-Klasse übergeben. Dies wird im folgenden Codeausschnitt gezeigt:

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

Da die getCamera()-Methode einen Verweis auf ein Camera-Objekt zurückgibt (oder null, wenn keine Kameras verfügbar sind), können Sie auch dann auf die Methoden und Eigenschaften der Kamera zugreifen, wenn der Benutzer den Zugriff auf die Kamera verweigert hat. Auf diese Weise können Sie die Größe der Video-Instanz mithilfe der nativen Höhe und Breite der Kamera einstellen.

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

Informationen zum Vollbildmodus finden Sie unter Festlegen der Stage-Eigenschaften.

Die Camera-Klasse enthält verschiedene Eigenschaften, mit denen Sie den aktuellen Status des Camera-Objekts überwachen können. Der folgende Code beispielsweise zeigt verschiedene Eigenschaften der Kamera an. Dazu wird ein Timer-Objekt und eine Textfeld-Instanz in der Anzeigeliste verwendet:

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

Alle 100 Millisekunden wird das timer-Ereignis des Timer-Objekts ausgelöst, und die timerHandler()-Funktion aktualisiert das Textfeld in der Anzeigeliste.