保存相机拍摄的图像JPG

Question

I'm using the code below to open the camera for an Android device. How do I save a image JPG, captured by this camera? What code/Button should I add to my programming 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);
}
}
}

:( I could not implement my code: Saving and masking webcam still AS3 AIR IOS

Answer 1

Just apply it as your root class and give required permissions

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