Arbeta med kameror

Med Camera-objektet kan du ansluta användarens lokala kamera och sända videon lokalt (tillbaka till användaren) eller externt till en server (t.ex Flash Media Server).

När du använder Camera-klassen har du åtkomst till följande information om användarens kamera:

• Vilka kameror som installerats på och är tillgängliga för användarens dator eller enhet

• Om en kamera har installerats

• Om Flash Player kan neka åtkomst till användarens kamera

• Vilken kamera som är aktiv

• Bredden och höjden för videon som spelas in.

Klassen Camera innehåller flera användbara metoder och egenskaper för arbete med kameraobjekt. Den statiska Camera.names -egenskapen innehåller t.ex. en array med kameranamn som finns installerade på användarens dator. Du kan också använda name -egenskapen för att visa namnet på den kamera som är aktiv.

Om du ansluter till en kamera kan det kräva mindre kod än när du använder klasserna NetConnection och NetStream för att läsa in en videofil. Kameraklassen kan också snart bli svårhanterlig eftersom du behöver användarens tillstånd att ansluta Flash Player till kameran innan du får åtkomst till den.

I koden nedan visas hur du kan använda klassen Camera för att ansluta till användarens lokala kamera:

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

När du skriver ett program som ansluter till användarens kamera behöver du ta hänsyn till följande i koden:

• Kontrollera om användaren har installerat en kamera. Hantera de fall då ingen kamera är tillgänglig.

• När det gäller Flash Player måste du kontrollera om användaren uttryckligen har tillåtit åtkomst till kameran. Av säkerhetsskäl visas dialogrutan Flash Player-inställningar i spelaren där användaren kan tillåta eller neka åtkomst till kameran. Det förhindrar att Flash Player ansluter till en användares kamera och sänder ett videoflöde utan tillstånd. Om användaren tillåter det, kan ditt program ansluta till användarens kamera. Om användaren nekar det, kan ditt program inte ansluta till användarens kamera. Ditt program bör alltid hantera båda fallen på ett smidigt sätt.

• (Gäller endast AIR) Kontrollera om klassen Camera stöds för de enhetsprofiler som programmet har stöd för.

• Klassen Camera stöds inte i mobilwebbläsare.

• Klassen Camera stöds inte i AIR-program för mobiler som använder GPU-återgivning.

• På mobilenheter kan endast en kamera i taget vara aktiv.

Steg ett när du ansluter till en användares kamera är att skapa en ny kamerainstans genom att skapa en variabel av typen Camera och initiera den att returnera värden från den statiska Camera.getCamera() -metoden.

I nästa steg skapar du ett nytt videoobjekt och kopplar Camera-objektet till det.

I steg tre lägger du till videoobjektet i visningslistan. Du måste utföra steg 2 och 3 eftersom klassen Camera inte utökar klassen DisplayObject, vilket betyder att den inte kan läggas till direkt i visningslistan. För att visa den kamerainspelade videon skapar du ett nytt videoobjekt och anropar attachCamera() -metoden.

De tre stegen visas i följande kod:

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

Observera, att om användaren inte har installerat någon kamera visar programmet ingenting.

I verkligheten måste du utföra ytterligare steg i programmet. Mer information finns i Verifiera att en kamera har installerats och Identifiera tillstånd för kameraåtkomst .

Innan du försöker använda några metoder eller egenskaper på en kamerainstans kontrollerar du att användaren har installerat en kamera. Det finns två sätt att kontrollera om användaren har en kamera installerad:

• Kontrollera den statiska Camera.names -egenskapen som innehåller en array med kameranamn som är tillgängliga. Vanligtvis har arrayen endast en eller inga strängar alls eftersom de flesta användare troligen inte har fler än en kamera installerad samtidigt. I följande kod visas hur du kan kontrollera Camera.names -egenskapen för att se om användaren har en tillgänglig kamera:

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

• Kontrollera returvärdet för den statiska Camera.getCamera() -metoden. Om det inte finns några tillgängliga kameror returnerar metoden null , annars returneras en referens till ett Camera-objekt. I följande kod visas hur du kan kontrollera Camera.getCamera() -metoden för att se om användaren har en tillgänglig kamera:

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

Eftersom klassen Camera inte utökar klassen DisplayObject, kan den inte läggas till direkt i visningslistan med metoden addChild() . För att visa den kamerainspelade videon måste du skapa ett nytt videoobjekt och anropa attachCamera() -metoden i Video-instansen.

I kodutdraget visas hur du kan bifoga en kamera om det finns någon. Om inte, visar programmet ingenting:

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

I AIR-programmets säkerhetssandlåda kan programmet få tillgång till alla kameror utan användarens tillåtelse. På Android måste programmet däremot ange Android-behörigheten CAMERA i programbeskrivningsfilen.

Innan Flash Player kan visa en kameras utdata måste användaren uttryckligen tillåta Flash Player att få åtkomst till kameran. När attachCamera() -metoden anropas, visas dialogrutan Flash Player-inställningar som uppmanar användaren att antingen tillåta eller neka Flash Player åtkomst till kameran och mikrofonen. Om användaren klickar på Tillåt, visas kamerainspelningen i Video-instansen på scenen. Om användaren klickar på Neka, kan inte Flash Player ansluta till kameran och videoobjektet visar ingenting.

Om du vill ta reda på om användaren tillåter åtkomst till kameran, kan du avlyssna kamerans status -händelse ( StatusEvent.STATUS ), enligt exempel i följande 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" 
}

Funktionen statusHandler() anropas så fort som användaren klickar på Tillåt eller Neka. Du kan ta reda på vilken knapp användaren klickade på med någon av de här två metoderna:

• event -parametern för statusHandler() -funktionen innehåller en kodegenskap som innehåller strängen ”Camera.Muted” eller ”Camera.Unmuted”. Om värdet är ”Camera.Muted” klickade användaren på Neka och Flash Player får inte åtkomst till kameran. Ett exempel på det här visas i följande utdrag:

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

• Klassen Camera innehåller en skrivskyddad egenskap med namnet muted som specificerar om användaren nekar åtkomst till kameran ( true ) eller tillåter åtkomst ( false ) på panelen Sekretess i Flash Player. Ett exempel på det här visas i följande utdrag:

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

Genom att kontrollera när statushändelsen ska skickas, kan du skriva kod som hanterar när användaren tillåter eller nekar åtkomst till kameran och rensa upp på rätt sätt. Om användaren t.ex. klickar på Neka kan du visa ett meddelande om att avändaren måste klicka på Tillåt om han eller hon vill delta i en videochattsession, eller så kan du i stället kontrollera att videoobjektet i visningslistan tas bort för att frigöra systemresurser.

I AIR skickar ett Camera-objekt inga statushändelser, eftersom behörigheten att använda kameran inte är dynamisk.

Som standard är nya instanser i Video-klassen 320 pixlar breda och 240 pixlar höga. För att maximera videokvaliteten bör du alltid kontrollera att videoobjektet har samma dimensioner som videon som returneras från kameraobjektet. Du kan hämta kamerans bredd och höjd med klassen Cameras width - och height -egenskaper, sedan kan du ange videoobjektets width - och height -egenskaper så att de stämmer överens med kameraobjektets dimensioner, eller också kan du överföra kamerans bredd och höjd till klassen Videos konstruktormetod enligt exempel i följande kodutdrag:

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

Eftersom getCamera() -metoden returnerar en referens till kameraobjektet (eller null om ingen kamera är tillgänglig) har du åtkomst till kamerans metoder och egenskaper även om användaren nekar åtkomst till sin kamera. Det här innebär att du kan ange storleken för videoinstansen med kamerans ursprungliga höjd och bredd.

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

Mer information om helskärmsläget finns i avsnittet om helskärmsläge under Inställning av scenegenskaper .

Klassen Camera innehåller flera egenskaper med vilka du kan övervaka Camera-objektets aktuella status. I följande kod visas t.ex. flera av kameraegenskaperna som använder ett Timer-objekt och en textfältsinstans i visningslistan:

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

Var 1/10 sekund (100 millisekunder) skickas Timer-objektets timer -händelse och timerHandler() -funktionen uppdaterar textfältet i visningslistan.