Enregistrer l'image JPG capturé par l'appareil photo

Question

J'utilise le code ci-dessous pour ouvrir l'appareil photo pour un appareil Android. Comment enregistrer une image JPG capturée par cet appareil photo? Quel code/bouton devrais-je ajouter à ma programmation AS3/AIR?

public class Test_Cam extends Sprite { 
private var cam: Camera; 
public function Test_Cam() { 
cam = Camera.getCamera(); 
connectCamera(); 
function connectCamera(): void { 
var vid: Video = new Video(cam.width, cam.height); 
vid.x = 100; 
vid.y = 200; 
vid.attachCamera(cam); 
addChild(vid); 
} 
} 
} 

:(Je ne pouvais pas mettre en œuvre mon code: Saving and masking webcam still AS3 AIR IOS

Answer 1

Il suffit d'appliquer comme votre classe racine et donner les autorisations requises

package { 
    import flash.desktop.NativeApplication; 
    import flash.display.Loader; 
    import flash.display.MovieClip; 
    import flash.display.StageAlign; 
    import flash.display.StageScaleMode; 
    import flash.events.ErrorEvent; 
    import flash.events.Event; 
    import flash.events.IOErrorEvent; 
    import flash.events.MediaEvent; 
    import flash.media.CameraUI; 
    import flash.media.MediaPromise; 
    import flash.media.MediaType; 
    import flash.display.DisplayObject; 
    import flash.filesystem.*; 
    import flash.events.Event; 
    import flash.utils.ByteArray; 
    import com.adobe.images.PNGEncoder; 


    public class CameraUISaveImage extends MovieClip { 

     private var deviceCameraApp: CameraUI = new CameraUI(); 
     private var imageLoader: Loader; 
     private var docsDir: File = File.documentsDirectory; 

     public function CameraUISaveImage() { 
      this.stage.align = StageAlign.TOP_LEFT; 
      this.stage.scaleMode = StageScaleMode.NO_SCALE; 

      if (CameraUI.isSupported) { 
       trace("Initializing camera..."); 

       deviceCameraApp.addEventListener(MediaEvent.COMPLETE, imageCaptured); 
       deviceCameraApp.addEventListener(Event.CANCEL, captureCanceled); 
       deviceCameraApp.addEventListener(ErrorEvent.ERROR, cameraError); 
       deviceCameraApp.launch(MediaType.IMAGE); 
      } else { 
       trace("Camera interface is not supported."); 
      } 
     } 

     private function imageCaptured(event: MediaEvent): void { 
      trace("Media captured..."); 

      var imagePromise: MediaPromise = event.data; 

      if (imagePromise.isAsync) { 
       trace("Asynchronous media promise."); 
       imageLoader = new Loader(); 
       imageLoader.contentLoaderInfo.addEventListener(Event.COMPLETE, asyncImageLoaded); 
       imageLoader.addEventListener(IOErrorEvent.IO_ERROR, cameraError); 

       imageLoader.loadFilePromise(imagePromise); 
      } else { 
       trace("Synchronous media promise."); 
       imageLoader.loadFilePromise(imagePromise); 
       saveMedia(imageLoader); 
      } 
     } 

     private function captureCanceled(event: Event): void { 
      trace("Media capture canceled."); 
      NativeApplication.nativeApplication.exit(); 
     } 

     private function asyncImageLoaded(event: Event): void { 
      trace("Media loaded in memory."); 
      saveMedia(imageLoader); 
     } 

     private function saveMedia(loader: Loader): void { 
      try { 
       docsDir = File.applicationDirectory 
       docsDir.browseForSave("Save As"); 
       docsDir.addEventListener(Event.SELECT, saveData); 
      } catch (error: Error) { 
       trace("Failed:", error.message); 
      } 
     } 


     function saveData(event: Event): void { 
      var newFile: File = event.target as File; 
      if (!newFile.exists) // remove this 'if' if overwrite is OK. 
      { 
       var stream: FileStream = new FileStream(); 
       stream.open(newFile, FileMode.WRITE); 
       stream.writeBytes(imageLoader.loaderInfo.bytes); 
       stream.close(); 
      } else trace('Selected path already exists.'); 
     } 

     private function cameraError(error: ErrorEvent): void { 
      trace("Error:" + error.text); 
      NativeApplication.nativeApplication.exit(); 
     } 
    } 
}