vertical-s3_swf_upload 0.3.2.1

data/flex_src/src/com/elctech/S3UploadRequest.as

@@ -0,0 +1,259 @@
+package com.elctech {
+
+	// import flash.events.*;
+	import flash.events.EventDispatcher;
+	import flash.events.ProgressEvent;
+	import flash.events.Event;
+	import flash.events.IOErrorEvent;
+	import flash.events.SecurityErrorEvent;
+	import flash.events.HTTPStatusEvent;
+	import flash.events.DataEvent;
+	
+	// import flash.net.*;
+  import flash.net.FileReference;
+	import flash.net.URLVariables;
+  import flash.net.URLRequest;
+	import flash.net.URLRequestMethod;
+
+	import flash.system.Security;
+	import flash.xml.XMLDocument;
+	import flash.xml.XMLNode;
+	// import mx.controls.Alert;
+	
+	/**
+     * This class encapsulates a POST request to S3.
+     * 
+     * After you create an S3PostRequest, invoke S3PostRequest::upload(fileReference:FileReference).
+     * 
+     */
+	public class S3UploadRequest extends EventDispatcher {
+
+		[Event(name="open", type="flash.events.Event.OPEN")]
+        [Event(name="uploadCompleteData", type="flash.events.DataEvent.UPLOAD_COMPLETE_DATA")]        
+        [Event(name="ioError", type="flash.events.IOErrorEvent.IO_ERROR")]
+        [Event(name="securityError", type="flash.events.SecurityErrorEvent.SECURITY_ERROR")]
+        [Event(name="progress", type="flash.events.ProgressEvent.PROGRESS")]
+        
+        private var _accessKeyId:String;
+        private var _bucket:String;
+        private var _key:String;
+        private var _options:S3UploadOptions;
+        private var _httpStatusErrorReceived:Boolean;
+        private var _uploadStarted:Boolean;
+        private var fileReference:FileReference;
+        
+        private const ENDPOINT:String = "s3.amazonaws.com";
+        private const MIN_BUCKET_LENGTH:int = 3;
+        private const MAX_BUCKET_LENGTH:int = 63;
+		
+		
+		/**
+         * Creates and initializes a new S3PostRequest object.
+         * @param    accessKeyId The AWS access key id to authenticate the request
+         * @param    bucket The bucket to POST into
+         * @param    key The key to create
+         * @param    options Options for this request
+         */
+		public function S3UploadRequest(options:S3UploadOptions) {
+			
+            _accessKeyId = options.AWSAccessKeyId;
+            _bucket      = options.bucket;
+            _key         = options.key;
+            _options     = options;
+            
+            if (options.newKey) {  //NOTE that we stop caring about the specified prefix if we have a newkey.
+              _key = options.newKey;
+              options.key = options.newKey; //so we output the right value in callbacks, etc.
+            }
+		}
+
+		private function buildUrl():String {
+
+            var canUseVanityStyle:Boolean = canUseVanityStyle(_bucket);
+            
+            if(_options.Secure!="false" && canUseVanityStyle && _bucket.match(/\./)) {
+                // We cannot use SSL for bucket names containing "."
+                // The certificate won't match "my.bucket.s3.amazonaws.com"
+                throw new SecurityError("Cannot use SSL with bucket name containing '.': " + _bucket);
+            }
+            
+            var postUrl:String = "http" + ((_options.Secure == 'true') ? "s" : "") + "://";
+            
+            if(canUseVanityStyle) {
+                postUrl += _bucket + "." + ENDPOINT;
+            } else {
+                postUrl += ENDPOINT + "/" + _bucket;
+            }
+            
+            return postUrl;
+        }
+        
+        private function canUseVanityStyle(bucket:String):Boolean {
+            if( bucket.length < MIN_BUCKET_LENGTH ||
+                bucket.length > MAX_BUCKET_LENGTH ||
+                bucket.match(/^\./) ||
+                bucket.match(/\.$/) ) {
+                return false;
+            }
+            
+            // must be lower case
+            if(bucket.toLowerCase() != bucket) {
+                return false;
+            }
+            
+            // Check not IPv4-like
+            if (bucket.match(/^[0-9]|+\.[0-9]|+\.[0-9]|+\.[0-9]|+$/)) {
+                return false;
+            }
+            
+                // Check each label
+            if(bucket.match(/\./)) {
+                var labels:Array = bucket.split(/\./);
+                for (var i:int = 0;i < labels.length; i++) {
+                    if(!labels[i].match(/^[a-z0-9]([a-z0-9\-]*[a-z0-9])?$/)) {
+                        return false;
+                    }
+                }
+            }
+            
+            return true;
+        }
+        
+        private function loadPolicyFile(postUrl:String):void {
+            /*
+             * Due to the restrictions imposed by the Adobe Flash security sandbox,
+             * the bucket being uploaded to must contain a public-readable crossdomain.xml
+             * file that allows access from the domain that served the SWF hosting this code.
+             * 
+             * Read Adobe's documentation on the Flash security sandbox for more information.
+             * 
+             */
+            
+            Security.loadPolicyFile(postUrl + "/crossdomain.xml");
+        }
+		
+				
+				public function removeListeners():void {
+						trace('removeListeners');
+            fileReference.removeEventListener(Event.OPEN, onOpen);
+            fileReference.removeEventListener(ProgressEvent.PROGRESS, onProgress);
+            fileReference.removeEventListener(IOErrorEvent.IO_ERROR, onIOError);
+            fileReference.removeEventListener(SecurityErrorEvent.SECURITY_ERROR, onSecurityError);
+            fileReference.removeEventListener(DataEvent.UPLOAD_COMPLETE_DATA, onUploadCompleteData);
+            fileReference.removeEventListener(HTTPStatusEvent.HTTP_STATUS, onHttpStatus);
+				}
+		/**
+         * Initiates a POST upload request to S3
+         * @param    fileReference A FileReference object referencing the file to upload to S3.
+         */
+        public function upload(_fileReference:FileReference):void {
+            
+            if(_uploadStarted) {
+                throw new Error("S3PostRequest object cannot be reused.  Create another S3PostRequest object to send another request to Amazon S3.");
+            }
+            _uploadStarted = true;
+
+            // Save the FileReference object so that it doesn't get GCed.
+            // If this happens, we can lose events that should be dispatched.
+            fileReference = _fileReference;
+
+            var postUrl:String = buildUrl();
+            loadPolicyFile(postUrl);
+            var urlRequest:URLRequest = new URLRequest(postUrl);
+            urlRequest.method = URLRequestMethod.POST;
+            urlRequest.data = buildPostVariables();
+            
+            // set up event handlers *****************************************************
+            fileReference.addEventListener(Event.OPEN, onOpen);
+            fileReference.addEventListener(ProgressEvent.PROGRESS, onProgress);
+            fileReference.addEventListener(IOErrorEvent.IO_ERROR, onIOError);
+            fileReference.addEventListener(SecurityErrorEvent.SECURITY_ERROR, onSecurityError);
+            fileReference.addEventListener(DataEvent.UPLOAD_COMPLETE_DATA, onUploadCompleteData);
+            fileReference.addEventListener(HTTPStatusEvent.HTTP_STATUS, onHttpStatus);
+            // *****************************************************************************
+            
+            // send the request
+            fileReference.upload(urlRequest, "file", false);
+        }
+        
+        private function buildPostVariables():URLVariables {
+            
+            var postVariables:URLVariables = new URLVariables();
+            
+            postVariables.key                     = _key;
+            postVariables.acl                     = _options.acl;
+            postVariables.AWSAccessKeyId          = _accessKeyId;
+            postVariables.signature               = _options.signature;
+            postVariables["Content-Type"]         = _options.ContentType;
+            postVariables["Content-Disposition"]  = _options.ContentDisposition;
+            postVariables.policy                  = _options.policy;
+            
+            /**
+             * Certain combinations of Flash player version and platform don't handle
+             * HTTP responses with the header 'Content-Length: 0'.  These clients do not
+             * dispatch completion or error events when such a response is received.
+             * Therefore it is impossible to tell when the upload has completed or failed.
+             * 
+             * Flash clients should always set the success_action_status parameter to 201
+             * so that Amazon S3 returns a response with Content-Length being non-zero.
+             * 
+             */
+            postVariables.success_action_status = "201";
+            
+            return postVariables;
+        }
+        
+        private function onOpen(event:Event):void {
+						trace('onOpen: '+this._key);
+            this.dispatchEvent(event);
+        }
+        private function onIOError(event:IOErrorEvent):void {
+            /*
+             * FileReference.upload likes to send cryptic IOErrors when it doesn't get a status code that it likes.
+             * If we already got an error HTTP status code, don't propagate this event since the HTTPStatusEvent
+             * event handler dispatches an IOErrorEvent.
+             */
+            if(!_httpStatusErrorReceived) {
+                this.dispatchEvent(event);
+            }
+        }
+        private function onSecurityError(event:SecurityErrorEvent):void {
+            this.dispatchEvent(event);
+        }
+        private function onProgress(event:ProgressEvent):void {
+            this.dispatchEvent(event);
+        }
+        private function onUploadCompleteData(event:DataEvent):void {
+            var data:String = event.data;
+            if(isError(data)) {
+                this.dispatchEvent(
+                    new IOErrorEvent(IOErrorEvent.IO_ERROR, event.bubbles, event.cancelable, "Amazon S3 returned an error: " + data + ".")
+                );
+            } else {
+                this.dispatchEvent(new DataEvent(DataEvent.UPLOAD_COMPLETE_DATA, event.bubbles, event.cancelable, data));
+            }
+        }
+        private function onHttpStatus(event:HTTPStatusEvent):void {
+            _httpStatusErrorReceived = true;
+            if(Math.floor(event.status/100) == 2) {
+                this.dispatchEvent(new DataEvent(DataEvent.UPLOAD_COMPLETE_DATA, event.bubbles, event.cancelable, "Amazon S3 returned HTTP status " + event.status.toString() + "."));
+            } else {
+                this.dispatchEvent(new IOErrorEvent(IOErrorEvent.IO_ERROR, event.bubbles, event.cancelable, "Amazon S3 returned an error: HTTP status " + event.status.toString() + "."));
+            }
+        }
+		
+		private function isError(responseText:String):Boolean {
+            var xml:XMLDocument = new XMLDocument();
+            xml.ignoreWhite = true;
+            xml.parseXML(responseText);
+            var root:XMLNode = xml.firstChild;
+            if( root == null || root.nodeName != "Error" )
+            {
+                return false;
+            }
+            return true;
+        }
+
+	}
+	
+}

data/flex_src/src/com/nathancolgate/s3_swf_upload/BrowseButton.as

@@ -0,0 +1,55 @@
+package com.nathancolgate.s3_swf_upload {
+	
+	import flash.display.*;
+	import flash.events.MouseEvent;
+	import flash.events.Event;
+	import flash.net.*;
+
+	public dynamic class BrowseButton extends Sprite {
+
+		private var _playButton:flash.display.SimpleButton;
+		
+		public function BrowseButton(width:Number,
+																	height:Number,
+																	buttonUpUrl:String,
+																	buttonDownUrl:String,
+																	buttonOverUrl:String)
+		{
+			super();
+			
+			_playButton = new flash.display.SimpleButton();
+			_playButton.useHandCursor = true;
+			addChild(_playButton);
+			
+			// Hit Test
+      var hit_test:Shape = new flash.display.Shape();            
+			hit_test.graphics.beginFill(0xFFCC00);
+      hit_test.graphics.drawRect(0, 0, width, height);            
+			hit_test.graphics.endFill();
+			_playButton.hitTestState = hit_test;
+			
+			// Up
+			var upLoader:Loader = new Loader();
+			upLoader.contentLoaderInfo.addEventListener(Event.COMPLETE,function(e:Event):void{ 
+				_playButton.upState = new Bitmap(e.target.content.bitmapData);
+			});
+			upLoader.load(new URLRequest(buttonUpUrl));
+
+			// Down
+			var downLoader:Loader = new Loader();
+			downLoader.contentLoaderInfo.addEventListener(Event.COMPLETE,function(e:Event):void{ 
+				_playButton.downState = new Bitmap(e.target.content.bitmapData);
+			});
+			downLoader.load(new URLRequest(buttonDownUrl));
+			
+			// Over
+			var overLoader:Loader = new Loader();
+			overLoader.contentLoaderInfo.addEventListener(Event.COMPLETE,function(e:Event):void{ 
+				_playButton.overState = new Bitmap(e.target.content.bitmapData);
+			});
+			overLoader.load(new URLRequest(buttonOverUrl));
+		}
+
+
+	}
+}

data/flex_src/src/com/nathancolgate/s3_swf_upload/S3Queue.as

@@ -0,0 +1,117 @@
+package com.nathancolgate.s3_swf_upload {
+	
+	import mx.collections.ArrayCollection;
+	import mx.events.CollectionEvent;
+  import flash.external.ExternalInterface;
+	import flash.net.FileReference;
+	import com.nathancolgate.s3_swf_upload.*;
+	
+  public class S3Queue extends ArrayCollection {
+	
+		// S3 Interaction Vars
+		private var _signatureUrl:String;
+		private var _prefixPath:String;
+
+		public var currentSignature:S3Signature;		
+
+		public function S3Queue(signatureUrl:String,
+														prefixPath:String,
+														source:Array = null) {
+															
+			_signatureUrl = signatureUrl;
+			_prefixPath	  = prefixPath;
+			super(source);
+
+			// Outgoing calls
+			this.addEventListener(CollectionEvent.COLLECTION_CHANGE, changeHandler);
+			// Incoming calls
+			ExternalInterface.addCallback("startUploading", startUploadingHandler);
+			ExternalInterface.addCallback("clearQueue", clearHandler);
+			ExternalInterface.addCallback("stopUploading", stopUploadingHandler);
+		}
+		
+		public function uploadNextFile():void{
+			// ExternalInterface.call('s3_swf.jsLog','uploadNextFile');
+			// ExternalInterface.call('s3_swf.jsLog','Start uploadNextFile...');
+			var next_file:FileReference = FileReference(this.getItemAt(0));
+			currentSignature = new S3Signature(next_file,_signatureUrl,_prefixPath);
+			// ExternalInterface.call('s3_swf.jsLog','End uploadNextFile');
+		}
+		
+		// whenever the queue changes this function is called 
+		private function changeHandler(event:CollectionEvent):void{
+			// ExternalInterface.call('s3_swf.jsLog','changeHandler');
+			// ExternalInterface.call('s3_swf.jsLog','Calling onQueueChange...');
+			ExternalInterface.call(S3Uploader.s3_swf_obj+'.onQueueChange',this.toJavascript());
+			// ExternalInterface.call('s3_swf.jsLog','onQueueChange called');      
+		}
+		
+		// Remove all files from the upload queue;
+		private function clearHandler():void{
+			// ExternalInterface.call('s3_swf.jsLog','clearHandler');
+			// ExternalInterface.call('s3_swf.jsLog','Removing All...');
+			this.removeAll();
+			// ExternalInterface.call('s3_swf.jsLog','All removed');
+			// ExternalInterface.call('s3_swf.jsLog','Calling onQueueClear...');
+			ExternalInterface.call(S3Uploader.s3_swf_obj+'.onQueueClear',this.toJavascript());
+			// ExternalInterface.call('s3_swf.jsLog','onQueueClear called');
+		}
+
+		// Start uploading the files from the queue
+		private function startUploadingHandler():void{
+			// ExternalInterface.call('s3_swf.jsLog','startUploadingHandler');
+			if (this.length > 0){
+				// ExternalInterface.call('s3_swf.jsLog','Calling onUploadingStart...');
+				ExternalInterface.call(S3Uploader.s3_swf_obj+'.onUploadingStart');
+				// ExternalInterface.call('s3_swf.jsLog','onUploadingStart called');
+	      // ExternalInterface.call('s3_swf.jsLog','Uploading next file...');
+				uploadNextFile();
+				// ExternalInterface.call('s3_swf.jsLog','Next file uploaded');
+			} else {
+				// ExternalInterface.call('s3_swf.jsLog','Calling onQueueEmpty...');
+				ExternalInterface.call(S3Uploader.s3_swf_obj+'.onQueueEmpty',this);
+				// ExternalInterface.call('s3_swf.jsLog','onQueueEmpty called');
+			}
+		}
+		
+		// Cancel Current File Upload
+		// Which stops all future uploads as well
+		private function stopUploadingHandler():void{
+			// ExternalInterface.call('s3_swf.jsLog','stopUploadingHandler');
+			if (this.length > 0){
+				var current_file:FileReference = FileReference(this.getItemAt(0));
+				// ExternalInterface.call('s3_swf.jsLog','Cancelling current file...');
+				current_file.cancel();
+
+				currentSignature.s3upload.removeListeners();
+
+				// ExternalInterface.call('s3_swf.jsLog','Current file cancelled');
+				// ExternalInterface.call('s3_swf.jsLog','Calling onUploadingStop...');
+				ExternalInterface.call(S3Uploader.s3_swf_obj+'.onUploadingStop');
+				// ExternalInterface.call('s3_swf.jsLog','onUploadingStop called');
+	    } else {
+				// ExternalInterface.call('s3_swf.jsLog','Calling onQueueEmpty...');
+				ExternalInterface.call(S3Uploader.s3_swf_obj+'.onQueueEmpty',this.toJavascript());
+				// ExternalInterface.call('s3_swf.jsLog','onQueueEmpty called');
+			}
+		}
+		
+		// This is a rather silly function to need, especially since it worked at one point
+		// In flash player 10.1, you could no longer send files over external reference
+		// This is the hack to get around the problem.  Essentially: turn all those 
+		// Files into objects
+		// August 27, 2010 - NCC@BNB
+		public function toJavascript():Object {
+			var faux_queue:Object = new Object();
+      faux_queue.files = new Array();
+			for (var i:int = 0;i < source.length; i++) {
+				faux_queue.files[i] = new Object();
+				faux_queue.files[i].name = source[i].name;
+	      faux_queue.files[i].size = source[i].size;
+	      faux_queue.files[i].type = source[i].type;
+      }
+			return faux_queue;
+		}
+
+	}
+}

data/flex_src/src/com/nathancolgate/s3_swf_upload/S3Signature.as

@@ -0,0 +1,119 @@
+package com.nathancolgate.s3_swf_upload {
+	
+	import com.elctech.S3UploadOptions;
+	import com.nathancolgate.s3_swf_upload.*;
+  import flash.external.ExternalInterface;
+	import com.adobe.net.MimeTypeMap;
+
+	import flash.net.*
+	import flash.events.*
+	
+  public class S3Signature {
+
+		private var upload_options:S3UploadOptions;
+		private var _file:FileReference;
+    //private var _prefixPath:String
+
+		public var s3upload:S3Upload;
+
+		public function S3Signature(file:FileReference,
+																	signatureUrl:String,
+																	prefixPath:String) {	
+			_file														= file;
+//			_prefixPath                     = prefixPath
+			// Create options list for file s3 upload metadata 
+			upload_options									= new S3UploadOptions;
+			upload_options.FileSize         = _file.size.toString();
+			upload_options.FileName         = getFileName(_file);
+			upload_options.ContentType      = getContentType(upload_options.FileName);
+			upload_options.key              = prefixPath + upload_options.FileName;
+			
+			var variables:URLVariables 			= new URLVariables();
+			variables.key              			= upload_options.key
+			variables.content_type     			= upload_options.ContentType;
+		                              		
+			var request:URLRequest     			= new URLRequest(signatureUrl);
+			request.method             			= URLRequestMethod.GET;
+			request.data               			= variables;
+			                            		
+			var signature:URLLoader       	= new URLLoader();
+			signature.dataFormat          	= URLLoaderDataFormat.TEXT;
+			signature.addEventListener(Event.OPEN, openHandler);
+			signature.addEventListener(ProgressEvent.PROGRESS, progressHandler);
+			signature.addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler);
+			signature.addEventListener(HTTPStatusEvent.HTTP_STATUS, httpStatusHandler);
+			signature.addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler);
+			signature.addEventListener(Event.COMPLETE, completeHandler);
+			signature.load(request);
+  	}
+
+		private function openHandler(event:Event):void {
+			ExternalInterface.call(S3Uploader.s3_swf_obj+'.onSignatureOpen',toJavascript(_file),event);
+		}
+
+		private function progressHandler(progress_event:ProgressEvent):void {
+			ExternalInterface.call(S3Uploader.s3_swf_obj+'.onSignatureProgress',toJavascript(_file),progress_event);
+		}
+
+		private function securityErrorHandler(security_error_event:SecurityErrorEvent):void {
+			ExternalInterface.call(S3Uploader.s3_swf_obj+'.onSignatureSecurityError',toJavascript(_file),security_error_event);
+		}
+
+		private function httpStatusHandler(http_status_event:HTTPStatusEvent):void {
+			ExternalInterface.call(S3Uploader.s3_swf_obj+'.onSignatureHttpStatus',toJavascript(_file),http_status_event);
+		}
+
+		private function ioErrorHandler(io_error_event:IOErrorEvent):void {
+			ExternalInterface.call(S3Uploader.s3_swf_obj+'.onSignatureIOError',toJavascript(_file),io_error_event);
+		}
+
+  	private function completeHandler(event:Event):void {
+			ExternalInterface.call(S3Uploader.s3_swf_obj+'.onSignatureComplete',toJavascript(_file),event);
+      var loader:URLLoader = URLLoader(event.target);
+      var xml:XML  = new XML(loader.data);
+      
+      // create the s3 options object
+      upload_options.policy             = xml.policy;
+      upload_options.signature          = xml.signature;
+      upload_options.bucket             = xml.bucket;
+      upload_options.AWSAccessKeyId     = xml.accesskeyid;
+      upload_options.acl                = xml.acl;
+      upload_options.Expires            = xml.expirationdate;
+      upload_options.Secure             = xml.https;
+	  upload_options.ContentDisposition = xml.contentDisposition;
+      upload_options.newKey             = xml.newKey;  //NOTE that we stop caring about the specified prefix if we have a newkey.
+
+      if (xml.errorMessage != "") {
+				ExternalInterface.call(S3Uploader.s3_swf_obj+'.onSignatureXMLError',toJavascript(_file),xml.errorMessage);
+				return;
+      }
+			
+      s3upload = new S3Upload(upload_options);
+		}
+		
+		/* MISC */
+		
+		private function getContentType(fileName:String):String {
+			var fileNameArray:Array    = fileName.split(/\./);
+			var fileExtension:String   = fileNameArray[fileNameArray.length - 1];
+			var mimeMap:MimeTypeMap		 = new MimeTypeMap;
+			var contentType:String     = mimeMap.getMimeType(fileExtension);
+			return contentType;
+		}
+		
+		private function getFileName(file:FileReference):String {
+			var fileName:String = file.name.replace(/^.*(\\|\/)/gi, '').replace(/[^A-Za-z0-9\.\-]/gi, '_');
+			return fileName;
+		}
+		
+		// Turns a FileReference into an Object so that ExternalInterface doesn't choke
+		private function toJavascript(file:FileReference):Object{
+			var javascriptable_file:Object = new Object();
+			javascriptable_file.name = file.name;
+			javascriptable_file.size = file.size;
+			javascriptable_file.type = file.type;
+			return javascriptable_file;
+		}
+		
+	}
+}