Created 3.1 and 3.2 dirs

flash/3.1/PubNubEvent.as

@@ -0,0 +1,37 @@
+package
+{
+    import flash.events.Event;
+
+    /**
+     * Pub Nub Event
+     * @author Fan Di
+     */
+    public class PubNubEvent extends Event 
+    {
+        public static const SUBSCRIBE_CONNECTED:String = "SubscribeConnected";
+        public static const PUBLISH:String = "Publish";
+        public static const SUBSCRIBE:String = "Subscribe";
+        public static const HISTORY:String = "History";
+        public static const TIME:String="Time";
+        public static const UNSUBSCRIBE:String = "Unsubscribe";
+        public static const ERROR:String = "Error";
+        public static const INIT:String = "Init";
+        public var data:Object;
+
+        public function PubNubEvent(type:String, d:Object = null, bubbles:Boolean=false, cancelable:Boolean=false) 
+        { 
+            data = d;
+            super(type, bubbles, cancelable);
+        } 
+
+        public override function clone():Event 
+        { 
+            return new PubNubEvent(type, data, bubbles, cancelable);
+        } 
+
+        public override function toString():String 
+        { 
+            return formatToString("PubNubEvent", "type", "bubbles", "cancelable", "eventPhase"); 
+        }
+    }
+}

flash/3.1/PubnubCrypto.as

@@ -0,0 +1,135 @@
+package
+{
+    import flash.display.Sprite;
+    import com.adobe.utils.IntUtil;
+    import flash.utils.ByteArray;
+
+    import com.hurlant.crypto.symmetric.AESKey;
+    import com.hurlant.crypto.symmetric.ICipher;
+    import com.hurlant.crypto.symmetric.IVMode;
+    import com.hurlant.crypto.symmetric.CBCMode;
+    import com.hurlant.crypto.symmetric.IMode;
+    import com.hurlant.crypto.symmetric.NullPad;
+    import com.hurlant.crypto.symmetric.PKCS5;
+    import com.hurlant.crypto.symmetric.IPad;
+    import com.hurlant.util.Base64;
+    import com.hurlant.util.Hex;
+    import com.hurlant.crypto.Crypto;
+
+    import com.adobe.crypto.MD5;
+    import com.adobe.serialization.json.JSON;
+
+    public class PubnubCrypto extends Sprite
+    {
+        private var type:String='aes-cbc';
+
+        //Basic encryption for string
+        public function encryptString(cipher_key:String, plainStr:String ):String
+        {        
+            cipher_key = md5Key(cipher_key);    
+            var key:ByteArray =   Hex.toArray(cipher_key);    
+            var data:ByteArray = Hex.toArray(Hex.fromString(plainStr));
+            var cbc:CBCMode = new CBCMode(new AESKey(key),new PKCS5());
+            cbc.IV = Hex.toArray(Hex.fromString("0123456789012345"));
+            cbc.encrypt(data);
+            return Base64.encodeByteArray(data);                         
+        }
+
+        //Basic decryption for string
+        public function decryptString(cipher_key:String, cipherStr:String):String
+        {        
+            var data:ByteArray = Base64.decodeToByteArray(cipherStr);                        
+            cipher_key = md5Key(cipher_key);
+            var key:ByteArray =   Hex.toArray(cipher_key);
+            var testkey:ByteArray = new ByteArray;
+            var cbc:CBCMode = new CBCMode(new AESKey(key), new PKCS5());
+            cbc.IV = Hex.toArray(Hex.fromString("0123456789012345"));
+            cbc.decrypt(data);
+            return Hex.toString(Hex.fromArray(data));
+        }
+
+        //Encryption for string/object/array
+        public function encrypt(cipher_key:String, plainObj:* ):*
+        {
+             if(typeof(plainObj) == "object")
+             {
+                 if(plainObj.length == undefined) //plainObj is object
+                 {
+                     var cipherObj:Object = new Object();
+                     for(var s:String in plainObj)
+                     {            
+                        if(typeof(plainObj[s]) == "object")
+						{
+							cipherObj[s] = encrypt(cipher_key,plainObj[s]);		
+						}
+						else
+						{
+                        	cipherObj[s] = encryptString(cipher_key,plainObj[s]);							
+						}
+                     }
+                     return cipherObj;
+                }
+                else     
+                {
+                    //plainObj is array
+                    var cipherArray:Array = new Array();
+                    for(var i:int =0;i<plainObj.length;i++)
+                    {
+                        cipherArray[i] = encryptString(cipher_key,plainObj[i])
+                    }
+                    return cipherArray;
+                }
+             }
+             else if(typeof(plainObj) == "string")
+             {
+                return encryptString(cipher_key,plainObj);
+             }
+        }
+
+        //Decryption for string/object/array
+        public function decrypt(cipher_key:String, cipherObj:* ):*
+        {
+             if(typeof(cipherObj) == "object")
+             {
+                 if(cipherObj.length == undefined) //cipherObj is object
+                 {
+                     var plainObj:Object = new Object();
+                     for(var s:String in cipherObj)
+                     {            
+                        if(typeof(cipherObj[s]) == "object")
+						{
+							plainObj[s] = decrypt(cipher_key,cipherObj[s]);		
+							plainObj[s] = JSON.decode(plainObj[s].toString());
+						}
+						else
+						{
+                        	plainObj[s] = decryptString(cipher_key,cipherObj[s]);							
+						}
+                     }
+                     return JSON.encode(plainObj);
+                }
+                else     
+                {
+                    //cipherObj is array
+                    var plainArray:Array = new Array();
+                    for(var i:int =0;i<cipherObj.length;i++)
+                    {
+                        plainArray[i] = decryptString(cipher_key,cipherObj[i])
+                    }
+                    return JSON.encode(plainArray);
+                }
+             }
+             else if(typeof(cipherObj) =="string")
+             {
+                return JSON.encode(decryptString(cipher_key,cipherObj));
+             }
+        }
+
+        function md5Key(s:String) :String
+        {
+            var ba:ByteArray = new ByteArray();
+            ba.writeUTFBytes(s);    
+            return MD5.hashBinary(ba);
+        }
+    }
+}

flash/3.2/com/adobe/air/logging/FileTarget.as

@@ -0,0 +1,98 @@
+/*
+  Copyright (c) 2008, Adobe Systems Incorporated
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without 
+  modification, are permitted provided that the following conditions are
+  met:
+
+  * Redistributions of source code must retain the above copyright notice, 
+    this list of conditions and the following disclaimer.
+  
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the 
+    documentation and/or other materials provided with the distribution.
+  
+  * Neither the name of Adobe Systems Incorporated nor the names of its 
+    contributors may be used to endorse or promote products derived from 
+    this software without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
+  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+package com.adobe.air.logging
+{
+	import mx.logging.AbstractTarget;
+	import flash.filesystem.File;
+	import flash.filesystem.FileStream;
+	import flash.filesystem.FileMode;
+	import mx.logging.LogEvent;
+	import flash.system.System;
+	import flash.system.Capabilities;
+	import mx.logging.targets.LineFormattedTarget;
+	import mx.core.mx_internal;
+
+	use namespace mx_internal;
+
+	/**
+	 * An Adobe AIR only class that provides a log target for the Flex logging
+	 * framework, that logs files to a file on the user's system.
+	 * 
+	 * This class will only work when running within Adobe AIR>
+	 */
+	public class FileTarget extends LineFormattedTarget
+	{
+		private const DEFAULT_LOG_PATH:String = "app-storage:/application.log";
+
+		private var log:File;
+
+		public function FileTarget(logFile:File = null)
+		{
+			if(logFile != null)
+			{
+				log = logFile;
+			}
+			else
+			{
+				log = new File(DEFAULT_LOG_PATH);
+			}
+		}
+
+		public function get logURI():String
+		{
+			return log.url;
+		}
+
+		mx_internal override function internalLog(message:String):void
+	    {
+			write(message);
+	    }		
+
+		private function write(msg:String):void
+		{		
+			var fs:FileStream = new FileStream();
+				fs.open(log, FileMode.APPEND);
+				fs.writeUTFBytes(msg + "\n");
+				fs.close();
+		}	
+
+		public function clear():void
+		{
+			var fs:FileStream = new FileStream();
+				fs.open(log, FileMode.WRITE);
+				fs.writeUTFBytes("");
+				fs.close();			
+		}
+
+	}
+}