package com.erkobridee.blazeds.util;
 
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.util.ArrayList;
import java.util.List;
 
import flex.messaging.FlexContext;
 
/**
 * @author Erko Bridee
 * @description Classe de gerenciamento de arquivos
 *
 */
public class FileUtils {
 
	private String dirPath = "files_dir";
 
	/**
	 * Método para receber um arquivo
	 *
	 * @param bytes byte[]
	 * @param fileName String
	 * @return String
	 * @throws Exception
	 */
	public String  doUpload(
			byte[] bytes, // bytes do arquivo
			String fileName // nome do arquivo
	) throws Exception {
		fileName = FlexContext.getServletContext().getRealPath(dirPath + "/" + fileName);
 
		System.out.println("doUpload: " + fileName);
 
		File f = new File(fileName);
		FileOutputStream fos = new FileOutputStream(f);
		fos.write(bytes);
		fos.close();
		return "success";
	}
 
	/**
	 * Retorna a listagem dos arquivos disponíveis
	 *
	 * @return List<FileInfo>
	 */
	public List<FileInfo> getDownloadList() throws Exception {
 
		System.out.println(FlexContext.getServletContext().getRealPath(dirPath));
 
		File dir = new File(FlexContext.getServletContext().getRealPath(dirPath));
 
		File[] files = dir.listFiles();
		List<FileInfo> dirList = new ArrayList<FileInfo>();
 
		if (files == null) {
			// caso o diretório não exista ou o caminho seja um diretório
		} else {
			for (int i=0; i<files.length; i++) {
				FileInfo info = new FileInfo();
 
				info.setName( files[i].getName() );
				info.setLength( files[i].length() );
 
				dirList.add( info );
			}
		}
		return dirList;
	}
 
	/**
	 * Método que recupera um arquivo e retorna seus bytes
	 *
	 * @param fileName
	 * @return byte[]
	 */
	public byte[] doDownload(String fileName) {
 
		System.out.println("doDownload: " + fileName);
 
		FileInputStream fis;
		byte[] data =null;
		FileChannel fc; 
 
		try {
			fileName = FlexContext.getServletContext().getRealPath(dirPath + "/" + fileName);
 
			fis = new FileInputStream(fileName);
			fc = fis.getChannel();
			data = new byte[(int)(fc.size())];
			ByteBuffer bb = ByteBuffer.wrap(data);
			fc.read(bb);
		} catch (FileNotFoundException e) {
			// TODO
		} catch (IOException e) {
			// TODO
		}
		return data;
	}	
 
	/**
	 * Método para apagar um determinado arquivo
	 *
	 * @param filename String
	 * @return String
	 */
	public String doDelete(String fileName) {
		String message = "fail";
 
		fileName = FlexContext.getServletContext().getRealPath(dirPath + "/" + fileName);
 
		System.out.println("doDelete: " + fileName);
 
		File file = new File(fileName);
		if( file.exists() ) {
			if( file.delete() ) {
				message = "success";
			}
		} 
 
		return message;
	}
 
}

<destination id="fileUtilService">
<properties>
		<source>com.erkobridee.blazeds.util.FileUtils</source>
	</properties>
</destination>

<mx:Panel
	xmlns:mx="http://www.adobe.com/2006/mxml"
	layout="vertical"
	width="100%"  height="100%"
	title="Upload : Arquivos">
 
	<mx:Script>
		<![CDATA[
			import vo.FileInfo;
			import mx.controls.Alert;
			import mx.rpc.AsyncToken;
			import mx.rpc.events.FaultEvent;
			import mx.rpc.events.ResultEvent;
 
			private var refUploadFile:FileReference;
 
			private var UploadFiles:Array = new Array();
 
			/*
				Chamado para adicionar os arquivos para upload
			*/
			private function addFiles():void {
				var FILE_FILTER_ALL_FILES_TYPE:Array = [new FileFilter("All files", "*.*")];
 
				refUploadFile = new  FileReference();
	  			refUploadFile.browse(FILE_FILTER_ALL_FILES_TYPE);
	  			refUploadFile.addEventListener(Event.SELECT,onFileSelect);
	  			refUploadFile.addEventListener(Event.COMPLETE,onFileComplete);
 
	  			refUploadFile.addEventListener(IOErrorEvent.IO_ERROR, frIOError);
    			refUploadFile.addEventListener(SecurityErrorEvent.SECURITY_ERROR, frSecError);
 
			}
 
			/*
				Chamado quando os arquivos são selecionado
			*/
			private function onFileSelect(event:Event):void {
 
				UploadFiles.push({
					name:refUploadFile.name,
					size:FileInfo.formatFileSize(refUploadFile.size),
					status:"inicial"
				});
 
				listFiles.dataProvider  = UploadFiles;
				listFiles.selectedIndex = UploadFiles.length - 1;
 
				try {
					refUploadFile.load();
				} catch( err:IOErrorEvent ) {
					Alert.show("erro");
				}
 
				for ( var i:int = 0 ; i <  UploadFiles.length ; i++ ) {
					if( UploadFiles[i].name == refUploadFile ) {
						UploadFiles[i].status = "carregado";
						listFiles.dataProvider  = UploadFiles;
						break;
					}
				}
			}
 
			/*
				Chamado quando for formatar a representação do tamanho do arquivo
			*/
			private function formatFileSize(numSize:Number):String {
				var strReturn:String;
				numSize = Number(numSize / 1000);
				strReturn = String(numSize.toFixed(1) + " KB");
				if (numSize > 1000) {
					numSize = numSize / 1000;
					strReturn = String(numSize.toFixed(1) + " MB");
					if (numSize > 1000) {
						numSize = numSize / 1000;
						strReturn = String(numSize.toFixed(1) + " GB");
					}
				}
				return strReturn;
			}
 
			private function onFileComplete(event:Event):void {
 
				refUploadFile = event.currentTarget as FileReference;
				var data:ByteArray = refUploadFile.data;  
 
				var token:AsyncToken = AsyncToken(
					remoteUpload.doUpload(data, refUploadFile.name)
				);
 
				token.kind = refUploadFile.name;
 
				for ( var i:int = 0 ; i <  UploadFiles.length ; i++ ) {
					if( UploadFiles[i].name == refUploadFile ) {
						UploadFiles[i].status = "enviando";
						listFiles.dataProvider  = UploadFiles;
						break;
					}
				}
			}
 
	  		private function uploadResultHandler(event:ResultEvent):void {
				for ( var i:int = 0 ; i <  UploadFiles.length ; i++ ) {
					if( UploadFiles[i].name == event.token.kind ) {
						UploadFiles[i].status = "OK";
						listFiles.dataProvider  = UploadFiles;
						break;
					}
				}
	  		}
 
	  		private function faultResultHandler(event:FaultEvent):void {
				for ( var i:int = 0 ; i <  UploadFiles.length ; i++ ) {
					if( UploadFiles[i].name == event.token.kind ) {
						UploadFiles[i].status = "erro";
						listFiles.dataProvider  = UploadFiles;
						break;
					}
				}
	  		}
 
			private function frIOError(evt:IOErrorEvent):void{
			    Alert.show(evt.toString());
			}
 
			private function frSecError(evt:SecurityErrorEvent):void{
			    Alert.show(evt.toString());
			}
 
			private function clearUploadList():void {
				UploadFiles = null;
				UploadFiles = new Array();
				listFiles.dataProvider = UploadFiles;
			}
 
		]]>
	</mx:Script>
 
	<mx:RemoteObject
		id="remoteUpload"
		destination="fileUtilService"
		result="uploadResultHandler(event)"
		fault="faultResultHandler(event)"/>
 
	<mx:Canvas width="100%" height="100%">
		<mx:DataGrid id="listFiles" left="0" top="0" bottom="0" right="0"
			allowMultipleSelection="true" verticalScrollPolicy="on"
			draggableColumns="false" resizableColumns="false" sortableColumns="false">
			<mx:columns>
				<mx:DataGridColumn headerText="Arquivo" width="150" dataField="name" wordWrap="true"/>
				<mx:DataGridColumn headerText="Tamanho" width="50" dataField="size" textAlign="right"/>
				<mx:DataGridColumn headerText="Status" width="50" dataField="status" textAlign="right"/>
			</mx:columns>
		</mx:DataGrid>
	</mx:Canvas>
	<mx:ControlBar horizontalAlign="center" verticalAlign="middle">
		<mx:Button
			id="btnAdd"
			toolTip="Adicionar arquivo(s)"
			click="addFiles()"
			label="Upload : Arquivo(s)"
			width="150"/>
		<mx:Button
			label="Limpar lista"
			click="{clearUploadList()}"/>
	</mx:ControlBar>
 
</mx:Panel>

<mx:Panel
	xmlns:mx="http://www.adobe.com/2006/mxml"
	layout="vertical"
	width="100%" height="100%"
	title="Download : Arquivos">
 
	<mx:Script>
		<![CDATA[
 
			import mx.controls.Alert;
			import mx.collections.ArrayCollection;
			import mx.rpc.events.FaultEvent;
			import mx.rpc.events.ResultEvent;
			import mx.rpc.AsyncToken;
 
			private var downloadFiles:ArrayCollection = new ArrayCollection();
			private var downloadFilesColl:ArrayCollection = new ArrayCollection();
			private var fileData:ByteArray = new ByteArray();
			private var fileName:String;
 
			private function downloadResultHandler(event:ResultEvent):void {
				if ( event.token.kind == "remoteFileList") {
					downloadFiles.removeAll();
					downloadFilesColl = event.result as ArrayCollection;
					for ( var i:int = 0 ; i <  downloadFilesColl.length ; i++ ) {
						downloadFiles.addItem({
							name:downloadFilesColl[i].name,
							size:downloadFilesColl[i].size,
							status:"Inicial"
						});
					}
					listFiles.dataProvider = downloadFiles;
				} else if(event.token.kind == "remoteDeleteFile") {
					Alert.show( event.result as String );
					getRemoteFiles();
				} else  {
					fileData = event.result as ByteArray;
					fileName = event.token.kind;
 
					Alert.show(fileName);
 
					for ( var b:int = 0 ; b <  downloadFiles.length ; b++ ) {
						if( downloadFiles[b].name == event.token.kind ) {
							downloadFiles[b].status = "Pronto";
							listFiles.dataProvider  = downloadFiles;
							break;
						}
					}
				}
			}
 
			private function faultResultHandler(event:FaultEvent):void {}
 
			private function saveFile():void {
				var fileReference:FileReference = new FileReference();
				fileReference.save(fileData,fileName);
			}
 
			private function getRemoteFiles():void {
				var token:AsyncToken = AsyncToken(remoteDownload.getDownloadList());
				token.kind = "remoteFileList";
			}
 
			private function getDownload():void {
				var token:AsyncToken = AsyncToken(remoteDownload.doDownload(listFiles.selectedItem.name));
				token.kind = listFiles.selectedItem.name;
			}
 
			private function doDelete():void {
				var token:AsyncToken = AsyncToken(remoteDownload.doDelete(listFiles.selectedItem.name));
				token.kind = "remoteDeleteFile";
			}
		]]>
	</mx:Script>
 
	<mx:RemoteObject
		id="remoteDownload"
		destination="fileUtilService"
		result="downloadResultHandler(event)"
		fault="faultResultHandler(event)"
		showBusyCursor="true"/>
 
	<mx:Canvas width="100%" height="100%">
		<mx:DataGrid id="listFiles" left="0" top="0" bottom="0" right="0"
			verticalScrollPolicy="on"
			draggableColumns="false" resizableColumns="false" sortableColumns="false">
			<mx:columns>
				<mx:DataGridColumn headerText="Arquivo" width="150" dataField="name" wordWrap="true"/>
				<mx:DataGridColumn headerText="Tamanho" width="50" dataField="size" textAlign="right"/>
				<mx:DataGridColumn headerText="Status" width="50" dataField="status" textAlign="right"/>
			</mx:columns>
 
		</mx:DataGrid>
	</mx:Canvas>
	<mx:ControlBar horizontalAlign="center" verticalAlign="middle">
		<mx:Button id="btnList" toolTip="Listar arquivos remotos"
			label="Listar arquivos"
			click="getRemoteFiles()"/>
		<mx:Button id="btnRetrieve" toolTip="Pegar arquivo"
			 click="getDownload()" label="Pegar arquivo"/>
		<mx:Button id="btnSave" toolTip="Salvar arquivo"
			 click="saveFile()" label="Salvar arquivo"/>
		<mx:Button label="Apagar arquivo" click="doDelete()"/>
	</mx:ControlBar>
 
</mx:Panel>

<?xml version="1.0" encoding="utf-8"?>
<mx:VBox
	xmlns:mx="http://www.adobe.com/2006/mxml"
	width="400" height="300"
	creationComplete="init()" horizontalAlign="center">
 
	<mx:Script>
		<![CDATA[
			import com.erkobridee.flex.util.file.LocalFileHelper;
 
			import mx.controls.Alert;
 
			import com.erkobridee.flex.util.file.enum.*;
			import com.erkobridee.flex.util.file.events.*;
 
			//------------------------------------------------------------------
			private var localFileHelper:LocalFileHelper;
			//------------------------------------------------------------------
			private function init():void {
				localFileHelper = new LocalFileHelper( FileTypeFormat.FILE_FILTER_TEXT_TYPE );
 
				localFileHelper.addEventListener(LocalFileEvent.FILE_LOAD_BROWSE, onFileSelect);
				localFileHelper.addEventListener(LocalFileEvent.FILE_SAVE_BROWSE, function():void { trace("Save browse complete"); } );
				localFileHelper.addEventListener(LocalFileEvent.FILE_SAVE_SUCCESSFULLY, function():void { trace("Save complete!"); } );
				localFileHelper.addEventListener(LocalFileEvent.FILE_CANCEL, function():void { Alert.show("Cancel"); } );
				localFileHelper.addEventListener(LocalFileErrorEvent.FILE_ERROR, function():void { trace("file error") } );
 
				localFileHelper.addEventListener(LocalFileLoadProgressEvent.FILE_LOAD_PROGRESS, onLoadProgress);
				localFileHelper.addEventListener(LocalFileSaveProgressEvent.FILE_SAVE_PROGRESS, onSaveProgress);
 
			}
			//------------------------------------------------------------------
			private function loadFile():void {
				this.reset();
 
				localFileHelper.browse();
			}
 
			//------- SAVE
 
			private function saveFile():void {
 
				localFileHelper.save( output.text, "output.txt" );
 
				this.reset();
			}
 
			private function reset():void {
				loadProgressBar.setProgress(0,0);
				saveProgressBar.setProgress(0,0);
				output.text = "";
				System.gc();
			}
 
			//------------------------------------------------------------------
			// event handlers
			private function onFileSelect(event:LocalFileEvent):void {
				localFileHelper.addEventListener(LocalFileLoadedEvent.DATA_LOADED, onDataLoaded );
				localFileHelper.load();
			}
 
			private function onDataLoaded(event:LocalFileLoadedEvent):void {
				output.text = LocalFileHelper.convertByteArrayToText( event.byteLoaded );
			}
 
			private function onLoadProgress(event:LocalFileLoadProgressEvent):void {
				loadProgressBar.setProgress(event.done, event.total);
			}
 
			private function onSaveProgress(event:LocalFileSaveProgressEvent):void {
				saveProgressBar.setProgress(event.done, event.total);
			}
 
		]]>
	</mx:Script>
 
	<mx:TextArea
		id="output"
		width="100%" height="100%"/>
 
	<mx:HBox width="100%" horizontalAlign="center">
		<mx:Button label="Load" click="loadFile()"/>
		<mx:Button label="Save" click="saveFile()"/>
		<mx:Button label="Reset" click="reset()"/>
	</mx:HBox>
 
	<mx:Form>
		<mx:FormItem label="File load">
			<mx:ProgressBar id="loadProgressBar" mode="manual"/>
		</mx:FormItem>
 
		<mx:FormItem label="File save">
			<mx:ProgressBar id="saveProgressBar" mode="manual"/>
		</mx:FormItem>
	</mx:Form>
 
</mx:VBox>

<mx:Application 
	xmlns:mx="http://www.adobe.com/2006/mxml" 
	pageTitle="Exemplo de uso QueryString"
	layout="vertical" 
	creationComplete="init()" horizontalAlign="center">
 
	<mx:Script>
		<![CDATA[
			import com.erkobridee.flex.util.html.QueryString;
 
			private function init():void {
				var query:QueryString = new QueryString();
 
				param1Field.text = query.parameters.param1; 
				// ou > query.parameters["param1"];
 
				param2Field.text = query.parameters.param2; 
				// ou > query.parameters["param2"]; 
			}
		]]>
	</mx:Script>
	<mx:Form>
		<mx:FormItem label="param1">
			<mx:TextInput id="param1Field"/>
		</mx:FormItem>
		<mx:FormItem label="param2">
			<mx:TextInput id="param2Field"/>
		</mx:FormItem>
	</mx:Form>
 
</mx:Application>

/**
 * Classe para auxiliar a leitura dos parâmetros presentes na URL
 * em uma aplicação Adobe Flex
 * 
 * Obs.: em todos os testes e uso até o presente momento, 
 * verifiquei a compatibilidade com os Web Browsers:
 * - Firefox
 * - Internet Explorer 8
 * - Google Chrome
 */
package com.erkobridee.flex.util.html {
 
	import flash.external.*;
	import flash.utils.*;
 
	public class QueryString {
 
		private var _queryString:String;
		private var _all:String;
		private var _params:Object;
 
		public function get queryString():String {
			return _queryString;
		}
		public function get url():String {
			return _all;
		}
		public function get parameters():Object {
			return _params;
		}
 
		public function QueryString() {
			readQueryString();
		}
 
		private function readQueryString():void {
			_params = {};
 
			try {
 
				// acessa as informações da página HTML
				_all =  ExternalInterface.call("window.location.href.toString");
				_queryString = ExternalInterface.call("window.location.search.substring", 1);
 
				if(_queryString) {
 
					var params:Array = _queryString.split('&');
					var length:uint = params.length;
 
					for (var i:uint=0,index:int=-1; i<length; i++) {
						var kvPair:String = params[i];
						if((index = kvPair.indexOf("=")) > 0) {
							var key:String = kvPair.substring(0,index);
							var value:String = kvPair.substring(index+1);
							_params[key] = value;
						}
					}
				}
			} catch(e:Error) { 
				trace("Some error occured. ExternalInterface doesn't work in Standalone player."); 
			}
		}
 
	}
 
}

private function setFocusHtml():void {
	ExternalInterface.call(
		"s = function() { window.document.getElementById('"+this.id+"').focus(); }"
	); 
}