在ActionScript3.0中, 将Flash本地图像上传到服务器上

在ActionScript3.0中, 将Flash本地图像上传到服务器上

有这样一些应用：用户在Flash中编辑照片，将编辑后的图片使用WEB SERVICE发送到服务器.
在AS2.0中，要实现这个功能非常麻烦，需要逐像素点处理图片，然后生产可读字符串，传送到服务器上。
在AS3.0中，加入了ByteArray对象，使一切都变得简单方便多了

首先需要2个AS类 PNGEncoder 和Base64
前者在Adobe网站上可以找到， 后者是开源的

PNGEncoder
/**/ /*
    Adobe Systems Incorporated(r) Source Code License Agreement
    Copyright(c) 2005 Adobe Systems Incorporated. All rights reserved.
    
    Please read this Source Code License Agreement carefully before using
    the source code.
    
    Adobe Systems Incorporated grants to you a perpetual, worldwide, non-exclusive, 
    no-charge, royalty-free, irrevocable copyright license, to reproduce,
    prepare derivative works of, publicly display, publicly perform, and
    distribute this source code and such derivative works in source or 
    object code form without any attribution requirements.  
    
    The name "Adobe Systems Incorporated" must not be used to endorse or promote products
    derived from the source code without prior written permission.
    
    You agree to indemnify, hold harmless and defend Adobe Systems Incorporated from and
    against any loss, damage, claims or lawsuits, including attorney's 
    fees that arise or result from your use or distribution of the source 
    code.
    
    THIS SOURCE CODE IS PROVIDED "AS IS" AND "WITH ALL FAULTS", WITHOUT 
    ANY TECHNICAL SUPPORT OR ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING,
    BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
    FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  ALSO, THERE IS NO WARRANTY OF 
    NON-INFRINGEMENT, TITLE OR QUIET ENJOYMENT.  IN NO EVENT SHALL MACROMEDIA
    OR ITS SUPPLIERS 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 SOURCE CODE, EVEN IF
    ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com
{
    import flash.geom. * ;
    import flash.display.Bitmap;
    import flash.display.BitmapData;
    import flash.utils.ByteArray;

     public   class  PNGEncoder
     {
         public   static  function encode(img:BitmapData):ByteArray  {
             //  Create output byte array
            var png:ByteArray  =   new  ByteArray();
             //  Write PNG signature
            png.writeUnsignedInt( 0x89504e47 );
            png.writeUnsignedInt( 0x0D0A1A0A );
             //  Build IHDR chunk
            var IHDR:ByteArray  =   new  ByteArray();
            IHDR.writeInt(img.width);
            IHDR.writeInt(img.height);
            IHDR.writeUnsignedInt( 0x08060000 );  //  32bit RGBA
            IHDR.writeByte( 0 );
            writeChunk(png, 0x49484452 ,IHDR);
             //  Build IDAT chunk
            var IDAT:ByteArray =   new  ByteArray();
             for (var i: int = 0 ;i  <  img.height;i ++ )  {
                 //  no filter
                IDAT.writeByte( 0 );
                var p: uint ;
                var j: int ;
                 if  (  ! img.transparent )  {
                     for (j = 0 ;j  <  img.width;j ++ )  {
                        p  =  img.getPixel(j,i);
                        IDAT.writeUnsignedInt(
                             uint (((p & 0xFFFFFF )  <<   8 ) | 0xFF ));
                    }
                }   else   {
                     for (j = 0 ;j  <  img.width;j ++ )  {
                        p  =  img.getPixel32(j,i);
                        IDAT.writeUnsignedInt(
                             uint (((p & 0xFFFFFF )  <<   8 ) |
                            (p >>> 24 )));
                    }
                }
            }
            IDAT.compress();
            writeChunk(png, 0x49444154 ,IDAT);
             //  Build IEND chunk
            writeChunk(png, 0x49454E44 , null );
             //  return PNG
             return  png;
        }
    
         private   static  var crcTable:Array;
         private   static  var crcTableComputed:Boolean  =   false ;
    
         private   static  function writeChunk(png:ByteArray, 
                type: uint , data:ByteArray): void   {
             if  ( ! crcTableComputed)  {
                crcTableComputed  =   true ;
                crcTable  =  [];
                var c: uint ;
                 for  (var n: uint   =   0 ; n  <   256 ; n ++ )  {
                    c  =  n;
                     for  (var k: uint   =   0 ; k  <   8 ; k ++ )  {
                         if  (c  &   1 )  {
                            c  =   uint ( uint ( 0xedb88320 )  ^  
                                 uint (c  >>>   1 ));
                        }   else   {
                            c  =   uint (c  >>>   1 );
                        }
                    }
                    crcTable[n]  =  c;
                }
            }
            var len: uint   =   0 ;
             if  (data  !=   null )  {
                len  =  data.length;
            }
            png.writeUnsignedInt(len);
            var p: uint   =  png.position;
            png.writeUnsignedInt(type);
             if  ( data  !=   null  )  {
                png.writeBytes(data);
            }
            var e: uint   =  png.position;
            png.position  =  p;
            c  =   0xffffffff ;
             for  (var i: int   =   0 ; i  <  (e - p); i ++ )  {
                c  =   uint (crcTable[
                    (c  ^  png.readUnsignedByte())  &  
                     uint ( 0xff )]  ^   uint (c  >>>   8 ));
            }
            c  =   uint (c ^ uint ( 0xffffffff ));
            png.position  =  e;
            png.writeUnsignedInt(c);
        }
    }
}

Base64
/**/ /* *********************************************************\ 
|                                                          | 
| The implementation of PHPRPC Protocol 3.0                | 
|                                                          | 
| Base64.as                                                | 
|                                                          | 
| Release 3.0.0                                            | 
| Copyright (c) 2005-2007 by Team-PHPRPC                   | 
|                                                          | 
| WebSite:   http://www.phprpc.org/                          | 
|            http://www.phprpc.net/                          | 
|            http://www.phprpc.com/                          | 
|            http://sourceforge.net/projects/php-rpc/        | 
|                                                          | 
| Authors:  Ma Bingyao <[email protected]>                  | 
|                                                          | 
| This file may be distributed and/or modified under the   | 
| terms of the GNU Lesser General Public License (LGPL)    | 
| version 3.0 as published by the Free Software Foundation | 
| and appearing in the included file LICENSE.              | 
|                                                          | 
\********************************************************* */  
/**/ /*  Base64 library for ActionScript 3.0. 
* 
* Copyright (C) 2007 Ma Bingyao <[email protected]> 
* Version: 1.1 
* LastModified: Oct 26, 2007 
* This library is free.  You can redistribute it and/or modify it. 
*/  
/**/ /*  
* interfaces: 
* import org.phprpc.util.Base64; 
* import flash.utils.ByteArray; 
* var data:ByteArray = new ByteArray(); 
* data.writeUTFBytes("Hello PHPRPC"); 
* var b64:String = Base64.encode(data); 
* trace(b64); 
* trace(Base64.decode(b64)); 
*/  
  
package com { 
    import flash.utils.ByteArray; 
     public   class  Base64  { 
         private   static    const  encodeChars:Array  =  
        [ ' A ' , ' B ' , ' C ' , ' D ' , ' E ' , ' F ' , ' G ' , ' H ' , 
         ' I ' , ' J ' , ' K ' , ' L ' , ' M ' , ' N ' , ' O ' , ' P ' , 
         ' Q ' , ' R ' , ' S ' , ' T ' , ' U ' , ' V ' , ' W ' , ' X ' , 
         ' Y ' , ' Z ' , ' a ' , ' b ' , ' c ' , ' d ' , ' e ' , ' f ' , 
         ' g ' , ' h ' , ' i ' , ' j ' , ' k ' , ' l ' , ' m ' , ' n ' , 
         ' o ' , ' p ' , ' q ' , ' r ' , ' s ' , ' t ' , ' u ' , ' v ' , 
         ' w ' , ' x ' , ' y ' , ' z ' , ' 0 ' , ' 1 ' , ' 2 ' , ' 3 ' , 
         ' 4 ' , ' 5 ' , ' 6 ' , ' 7 ' , ' 8 ' , ' 9 ' , ' + ' , ' / ' ]; 
         private   static    const  decodeChars:Array  =  
        [ - 1 ,  - 1 ,  - 1 ,  - 1 ,  - 1 ,  - 1 ,  - 1 ,  - 1 , 
         - 1 ,  - 1 ,  - 1 ,  - 1 ,  - 1 ,  - 1 ,  - 1 ,  - 1 , 
         - 1 ,  - 1 ,  - 1 ,  - 1 ,  - 1 ,  - 1 ,  - 1 ,  - 1 , 
         - 1 ,  - 1 ,  - 1 ,  - 1 ,  - 1 ,  - 1 ,  - 1 ,  - 1 , 
         - 1 ,  - 1 ,  - 1 ,  - 1 ,  - 1 ,  - 1 ,  - 1 ,  - 1 , 
         - 1 ,  - 1 ,  - 1 ,  62 ,  - 1 ,  - 1 ,  - 1 ,  63 , 
         52 ,  53 ,  54 ,  55 ,  56 ,  57 ,  58 ,  59 , 
         60 ,  61 ,  - 1 ,  - 1 ,  - 1 ,  - 1 ,  - 1 ,  - 1 , 
         - 1 ,   0 ,   1 ,   2 ,   3 ,   4 ,   5 ,   6 , 
          7 ,   8 ,   9 ,  10 ,  11 ,  12 ,  13 ,  14 , 
         15 ,  16 ,  17 ,  18 ,  19 ,  20 ,  21 ,  22 , 
         23 ,  24 ,  25 ,  - 1 ,  - 1 ,  - 1 ,  - 1 ,  - 1 , 
         - 1 ,  26 ,  27 ,  28 ,  29 ,  30 ,  31 ,  32 , 
         33 ,  34 ,  35 ,  36 ,  37 ,  38 ,  39 ,  40 , 
         41 ,  42 ,  43 ,  44 ,  45 ,  46 ,  47 ,  48 , 
         49 ,  50 ,  51 ,  - 1 ,  - 1 ,  - 1 ,  - 1 ,  - 1 ]; 
         public   static  function encode(data:ByteArray):String  { 
            var  out :Array  =  []; 
            var i: int   =   0 ; 
            var j: int   =   0 ; 
            var r: int   =  data.length  %   3 ; 
            var len: int   =  data.length  -  r; 
            var c: int ; 
             while  (i  <  len)  { 
                c  =  data[i ++ ]  <<   16   |  data[i ++ ]  <<   8   |  data[i ++ ]; 
                 out [j ++ ]  =  encodeChars[c  >>   18 ]  +  encodeChars[c  >>   12   &   0x3f ]  +  encodeChars[c  >>   6   &   0x3f ]  +  encodeChars[c  &   0x3f ]; 
            }  
             if  (r  ==   1 )  { 
                c  =  data[i ++ ]; 
                 out [j ++ ]  =  encodeChars[c  >>   2 ]  +  encodeChars[(c  &   0x03 )  <<   4 ]  +   " == " ; 
            }  
             else   if  (r  ==   2 )  { 
                c  =  data[i ++ ]  <<   8   |  data[i ++ ]; 
                 out [j ++ ]  =  encodeChars[c  >>   10 ]  +  encodeChars[c  >>   4   &   0x3f ]  +  encodeChars[(c  &   0x0f )  <<   2 ]  +   " = " ; 
            }  
             return   out .join( '' ); 
        }  
         public   static  function decode(str:String):ByteArray  { 
            var c1: int ; 
            var c2: int ; 
            var c3: int ; 
            var c4: int ; 
            var i: int ; 
            var len: int ; 
            var  out :ByteArray; 
            len  =  str.length; 
            i  =   0 ; 
             out   =   new  ByteArray(); 
             while  (i  <  len)  { 
                 //  c1 
                 do   { 
                    c1  =  decodeChars[str.charCodeAt(i ++ )  &   0xff ]; 
                }   while  (i  <  len  &&  c1  ==   - 1 ); 
                 if  (c1  ==   - 1 )  { 
                     break ; 
                }  
                 //  c2    
                 do   { 
                    c2  =  decodeChars[str.charCodeAt(i ++ )  &   0xff ]; 
                }   while  (i  <  len  &&  c2  ==   - 1 ); 
                 if  (c2  ==   - 1 )  { 
                     break ; 
                }  
                 out .writeByte((c1  <<   2 )  |  ((c2  &   0x30 )  >>   4 )); 
                 //  c3 
                 do   { 
                    c3  =  str.charCodeAt(i ++ )  &   0xff ; 
                     if  (c3  ==   61 )  { 
                         return   out ; 
                    }  
                    c3  =  decodeChars[c3]; 
                }   while  (i  <  len  &&  c3  ==   - 1 ); 
                 if  (c3  ==   - 1 )  { 
                     break ; 
                }  
                 out .writeByte(((c2  &   0x0f )  <<   4 )  |  ((c3  &   0x3c )  >>   2 )); 
                 //  c4 
                 do   { 
                    c4  =  str.charCodeAt(i ++ )  &   0xff ; 
                     if  (c4  ==   61 )  { 
                         return   out ; 
                    }  
                    c4  =  decodeChars[c4]; 
                }   while  (i  <  len  &&  c4  ==   - 1 ); 
                 if  (c4  ==   - 1 )  { 
                     break ; 
                }  
                 out .writeByte(((c3  &   0x03 )  <<   6 )  |  c4); 
            }  
             return   out ; 
        }  
    }  
}

下面的代码就很简单了，首先获取到BitmapData对象，然后用PNGEncoder编码压缩一次，再用Base64编码得到可读字符串，然后通过WEB SERVICE发送到服务器

     var  objBitmap:BitmapData  =   new  BitmapData( mcPlaceHolder.width
                                               , mcPlaceHolder.height
                                               , true
                                               , 0
                                               );
    objBitmap.draw(mcPlaceHolder)
     var  bytes:ByteArray  =  PNGEncoder.encode(objBitmap);   
     // trace( Base64.encode(bytes) );
    
     var  paramObj:Object  =  LoaderInfo( this .root.loaderInfo).parameters;

     var  ws:WebService  =   new  WebService(paramObj[ " WebSvcPath " ]);
    ws.onLoad  =   function (e)
     {
        trace(this.getWsInfo());
    }
    ws.onError  =   function (e)
     {
        trace(e.toString());
    }
    

     var  sr:EventDispatcher  =  ws.call( " TestUpdate " , Base64.encode(bytes));
    sr.addEventListener( " complete " , completeHandler);
    sr.addEventListener( " error " , errorHandler);

     function  errorHandler(e)
     {
         
    }
     function  completeHandler(e)
     {
         trace("-------------------------");
         trace("TestUpdate xml:");
         trace(e.xml);
         
         trace("-------------------------");
         trace("TestUpdate data:");
         trace(e.data);
    }