zoukankan      html  css  js  c++  java
  • microblog actionscript API

    package com.sina.microblog
    {
        import com.adobe.crypto.HMAC;
        import com.adobe.crypto.SHA1;
        import com.dynamicflash.util.Base64;
        import com.sina.microblog.data.MicroBlogComment;
        import com.sina.microblog.data.MicroBlogCount;
        import com.sina.microblog.data.MicroBlogDirectMessage;
        import com.sina.microblog.data.MicroBlogProfileUpdateParams;
        import com.sina.microblog.data.MicroBlogRateLimit;
        import com.sina.microblog.data.MicroBlogStatus;
        import com.sina.microblog.data.MicroBlogUser;
        import com.sina.microblog.data.MicroBlogUsersRelationship;
        import com.sina.microblog.events.MicroBlogErrorEvent;
        import com.sina.microblog.events.MicroBlogEvent;
        import com.sina.microblog.utils.GUID;
        import com.sina.microblog.utils.StringEncoders;
        import com.ut.nm_test_internal;
        
        import flash.events.Event;
        import flash.events.EventDispatcher;
        import flash.events.IOErrorEvent;
        import flash.events.SecurityErrorEvent;
        import flash.net.URLLoader;
        import flash.net.URLRequest;
        import flash.net.URLRequestHeader;
        import flash.net.URLRequestMethod;
        import flash.net.URLVariables;
        import flash.net.getClassByAlias;
        import flash.net.navigateToURL;
        import flash.system.ApplicationDomain;
        import flash.system.Capabilities;
        import flash.utils.ByteArray;
        import flash.utils.Dictionary;
        import flash.utils.Endian;
        import flash.utils.getDefinitionByName;
    
        use namespace nm_test_internal;
        
        /**
         *  当OAuth过程发生错误时触发该事件.
         *
         *  <p>当consumerKey和consumerSecret不为空时,使用OAuth方式进行认证</p>
         *
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="oauthCertifcateError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
        
        /**
         *  当加载公共微博消息成功时触发该事件.
         *
         *  <p>调用loadPublicTimeLine成功时,事件的<code>result</code>属性为一个<code>MicroBlogStatus</code>
         *  对象数组.</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="loadPublicTimeLineResult", type="com.sina.microblog.events.MicroBlogEvent")]
        /**
         *  当加载公共微博消息失败时触发该事件.
         *
         *  <p>调用loadPublicTimeLine失败时,事件的<code>message</code>为失败原因描述</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="loadPublicTimeLineError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
        
        /**
         *  当加载用户所有关注的用户最新的n条微博消息成功时触发该事件.
         *
         *  <p>调用loadFriendsTimeLine成功时,事件的<code>result</code>属性为一个<code>MicroBlogStatus</code>
         *  对象数组.</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="loadFriendsTimeLineResult", type="com.sina.microblog.events.MicroBlogEvent")]
        /**
         *  当加载用户所有关注的用户最新的n条微博消息失败时触发该事件.
         *
         *  <p>调用loadFriendsTimeLine失败时,事件的<code>message</code>为失败原因描述</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="loadFriendsTimeLineError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
        
        /**
         *  当加载指定用户的微博消息成功时触发该事件.
         *
         *  <p>调用loadUserTimeLine成功时,事件的<code>result</code>属性为一个<code>MicroBlogStatus</code>
         *  对象数组.</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="loadUserTimeLineResult", type="com.sina.microblog.events.MicroBlogEvent")]
        /**
         *  当加载指定用户的微博消息失败时触发该事件.
         *
         *  <p>调用loadUserTimeLine失败时,事件的<code>message</code>为失败原因描述</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="loadUserTimeLineError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
        
        /**
         *  当加载提及博主的微博消息成功时触发该事件.
         *
         *  <p>调用loadMensions成功时,事件的<code>result</code>属性为一个<code>MicroBlogStatus</code>
         *  对象数组.</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="loadMensionsResult", type="com.sina.microblog.events.MicroBlogEvent")]
        /**
         *  当加载指定用户的微博消息失败时触发该事件.
         *
         *  <p>调用loadMensions失败时,事件的<code>message</code>为失败原因描述</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="loadMensionsError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
        
        /**
         *  当加载对博主所发微博消息的评论成功时触发该事件.
         *
         *  <p>调用loadCommentsTimeline成功时,事件的<code>result</code>属性为一个<code>MicroBlogComment</code>
         *  对象数组.</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="loadCommentsTimelineResult", type="com.sina.microblog.events.MicroBlogEvent")]
        /**
         *  当加载指定用户的微博消息失败时触发该事件.
         *
         *  <p>调用loadMensions失败时,事件的<code>message</code>为失败原因描述</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="loadCommentsTimelineError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
        
        /**
         *  当加载博主所发表评论成功时触发该事件.
         *
         *  <p>调用loadMyComments成功时,事件的<code>result</code>属性为一个<code>MicroBlogComment</code>
         *  对象数组.</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="loadMyCommentsResult", type="com.sina.microblog.events.MicroBlogEvent")]
        /**
         *  当加载博主所发表评论失败时触发该事件.
         *
         *  <p>调用loadMyComments失败时,事件的<code>message</code>为失败原因描述</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="loadMyCommentsError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
        
        /**
         *  当加载对微博消息的评论成功时触发该事件.
         *
         *  <p>调用loadComments成功时,事件的<code>result</code>属性为一个<code>MicroBlogComment</code>
         *  对象数组.</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="loadCommentsResult", type="com.sina.microblog.events.MicroBlogEvent")]
        /**
         *  当加载对微博消息的评论失败时触发该事件.
         *
         *  <p>调用loadComments失败时,事件的<code>message</code>为失败原因描述</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="loadCommentsError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
        
        /**
         *  当加载微博消息相关统计数据成功时触发该事件.
         *
         *  <p>调用loadStatusCounts成功时,事件的<code>result</code>属性为一个<code>MicroBlogCount</code>
         *  对象数组.</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="loadStatusCountsResult", type="com.sina.microblog.events.MicroBlogEvent")]
        /**
         *  当加载微博消息相关统计数据失败时触发该事件.
         *
         *  <p>调用loadStatusCounts失败时,事件的<code>message</code>为失败原因描述</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="loadStatusCountsError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
        
        /**
         *  当发布微博消息成功时触发该事件.
         *
         *  <p>调用updateStatus成功时,事件的<code>result</code>属性为刚发布的<code>MicroBlogStatus</code>
         *  对象.</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="updateStatusResult", type="com.sina.microblog.events.MicroBlogEvent")]
        /**
         *  当发布微博消息失败时触发该事件.
         *
         *  <p>调用updateStatus失败时,事件的<code>message</code>为失败原因描述</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="updateStatusError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
        
        /**
         *  当删除微博消息成功时触发该事件.
         *
         *  <p>调用deleteStatus成功时,事件的<code>result</code>属性为被删除的<code>MicroBlogStatus</code>
         *  对象.</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="deleteStatusResult", type="com.sina.microblog.events.MicroBlogEvent")]
        /**
         *  当删除微博消息失败时触发该事件.
         *
         *  <p>调用deleteStatus失败时,事件的<code>message</code>为失败原因描述</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="deleteStatusError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
        
        /**
         *  当加载某个微博消息成功时触发该事件.
         *
         *  <p>调用loadStatusInfo成功时,事件的<code>result</code>属性为<code>MicroBlogStatus</code>
         *  对象.</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="loadStatusInfoResult", type="com.sina.microblog.events.MicroBlogEvent")]
        /**
         *  当加载某个微博消息失败时触发该事件.
         *
         *  <p>调用loadStatusInfo失败时,事件的<code>message</code>为失败原因描述</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="loadStatusInfoError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
        
        /**
         *  当删除某个微博消息评论成功时触发该事件.
         *
         *  <p>调用deleteComment成功时,事件的<code>result</code>属性为<code>MicroBlogComment</code>
         *  对象.</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="deleteCommentResult", type="com.sina.microblog.events.MicroBlogEvent")]
        /**
         *  当删除某个微博消息评论失败时触发该事件.
         *
         *  <p>调用deleteComment失败时,事件的<code>message</code>为失败原因描述</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="deleteCommentError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
        
        /**
         *  当评论某个微博消息成功时触发该事件.
         *
         *  <p>调用commentStatus成功时,事件的<code>result</code>属性为<code>MicroBlogComment</code>
         *  对象.</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="commentStatusResult", type="com.sina.microblog.events.MicroBlogEvent")]
        /**
         *  当评论某个微博消息失败时触发该事件.
         *
         *  <p>调用commentStatus失败时,事件的<code>message</code>为失败原因描述</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="commentStatusError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
        
        /**
         *  当转发某个微博消息成功时触发该事件.
         *
         *  <p>调用repostStatus成功时,事件的<code>result</code>属性为<code>MicroBlogStatus</code>
         *  对象.</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="repostStatusResult", type="com.sina.microblog.events.MicroBlogEvent")]
        /**
         *  当转发某个微博消息失败时触发该事件.
         *
         *  <p>调用repostStatus失败时,事件的<code>message</code>为失败原因描述</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="repostStatusError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
        
        /**
         *  当回复某个微博评论成功时触发该事件.
         *
         *  <p>调用replyStatus成功时,事件的<code>result</code>属性为<code>MicroBlogStatus</code>
         *  对象.</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="replyStatusResult", type="com.sina.microblog.events.MicroBlogEvent")]
        /**
         *  当回复某个微博评论失败时触发该事件.
         *
         *  <p>调用replyStatus失败时,事件的<code>message</code>为失败原因描述</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="replyStatusError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
        
        /**
         *  当加载接收到的私信列表成功时触发该事件.
         *
         *  <p>调用loadDirectMessagesReceived成功时,事件的<code>result</code>属性为<code>MicroBlogDirectMessage</code>
         *  对象数组.</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="loadDirectMessagesReceivedResult", type="com.sina.microblog.events.MicroBlogEvent")]
        /**
         *  当加载接收到的私信列表失败时触发该事件.
         *
         *  <p>调用loadDirectMessagesReceived失败时,事件的<code>message</code>为失败原因描述</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="loadDirectMessagesReceivedError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
        
        /**
         *  当加载发出的私信列表成功时触发该事件.
         *
         *  <p>调用loadDirectMessagesSent成功时,事件的<code>result</code>属性为<code>MicroBlogDirectMessage</code>
         *  对象数组.</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="loadDicrectMessagesSentResult", type="com.sina.microblog.events.MicroBlogEvent")]
        /**
         *  当加载发出的私信列表失败时触发该事件.
         *
         *  <p>调用loadDirectMessagesSent失败时,事件的<code>message</code>为失败原因描述</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="loadDicrectMessagesSentError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
        
        /**
         *  当删除私信成功时触发该事件.
         *
         *  <p>调用deleteDirectMessage成功时,事件的<code>result</code>属性为被删除的<code>MicroBlogDirectMessage</code>
         *  对象.</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="deleteDirectMessageResult", type="com.sina.microblog.events.MicroBlogEvent")]
        /**
         *  当删除私信失败时触发该事件.
         *
         *  <p>调用deleteDirectMessage失败时,事件的<code>message</code>为失败原因描述</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="deleteDirectMessageError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
        
        /**
         *  当发送私信成功时触发该事件.
         *
         *  <p>调用sendDirectMessage成功时,事件的<code>result</code>属性<code>MicroBlogDirectMessage</code>
         *  对象.</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="sendDirectMessageResult", type="com.sina.microblog.events.MicroBlogEvent")]
        /**
         *  当发送私信失败时触发该事件.
         *
         *  <p>调用deleteDirectMessage失败时,事件的<code>message</code>为失败原因描述</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="sendDirectMessageSentError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
        
        /**
         *  当加载指定用户信息成功时触发该事件.
         *
         *  <p>调用loadUserInfo成功时,事件的<code>result</code>属性<code>MicroBlogUser</code>
         *  对象.</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="loadUserInfoResult", type="com.sina.microblog.events.MicroBlogEvent")]
        /**
         *  当加载指定用户信息失败时触发该事件.
         *
         *  <p>调用loadUserInfo失败时,事件的<code>message</code>为失败原因描述</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="loadUserInfoError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
        
        /**
         *  当加载用户关注的博主列表成功时触发该事件.
         *
         *  <p>调用loadFriendsInfo成功时,事件的<code>result</code>属性<code>MicroBlogUser</code>
         *  对象数组.</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="loadFriendsInfoResult", type="com.sina.microblog.events.MicroBlogEvent")]
        /**
         *  当加载用户关注的博主列表失败时触发该事件.
         *
         *  <p>调用loadFriendsInfo失败时,事件的<code>message</code>为失败原因描述</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="loadFriendsInfoError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
        
        /**
         *  当加载关注用户的博主列表成功时触发该事件.
         *
         *  <p>调用loadFollowersInfo成功时,事件的<code>result</code>属性<code>MicroBlogUser</code>
         *  对象数组.</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="loadFollowersInfoResult", type="com.sina.microblog.events.MicroBlogEvent")]
        /**
         *  当加载关注用户的博主列表失败时触发该事件.
         *
         *  <p>调用loadFollowersInfo失败时,事件的<code>message</code>为失败原因描述</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="loadFollowersInfoError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
        
        /**
         *  当关注某博主成功时触发该事件.
         *
         *  <p>调用follow成功时,事件的<code>result</code>属性<code>MicroBlogUser</code>
         *  对象.</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="followResult", type="com.sina.microblog.events.MicroBlogEvent")]
        /**
         *  当关注某博主失败时触发该事件.
         *
         *  <p>调用follow失败时,事件的<code>message</code>为失败原因描述</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="followError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
        
        /**
         *  当取消关注某博主成功时触发该事件.
         *
         *  <p>调用cancelFollowing成功时,事件的<code>result</code>属性<code>MicroBlogUser</code>
         *  对象.</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="cancelFollowingResult", type="com.sina.microblog.events.MicroBlogEvent")]
        /**
         *  当取消关注某博主失败时触发该事件.
         *
         *  <p>调用cancelFollowing失败时,事件的<code>message</code>为失败原因描述</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="cancelFollowingError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
        
        /**
         *  当查询两个微博用户关系成功返回时触发该事件.
         *
         *  <p>调用checkIsFollowing成功时,事件的<code>result</code>属性<code>MicroBlogRelationship</code>
         *  对象.</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="checkIsFollowingResult", type="com.sina.microblog.events.MicroBlogEvent")]
        /**
         *  当查询两个微博用户关系失败时触发该事件.
         *
         *  <p>调用checkIsFollowing失败时,事件的<code>message</code>为失败原因描述</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="checkIsFollowingError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
        
        /**
         *  当加载博主关注的用户id列表成功时触发该事件.
         *
         *  <p>调用loadFriendsIDList成功时,事件的<code>result</code>属性<code>uint</code>
         *  数组.</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="loadFriendsIDListResult", type="com.sina.microblog.events.MicroBlogEvent")]
        /**
         *  当加载博主关注的用户id列表失败时触发该事件.
         *
         *  <p>调用loadFriendsIDList失败时,事件的<code>message</code>为失败原因描述</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="loadFriendsIDListError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
        
        /**
         *  当加关注载博主的用户id列表成功时触发该事件.
         *
         *  <p>调用loadFollowersIDList成功时,事件的<code>result</code>属性<code>uint</code>
         *  数组.</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="loadFollowersIDListResult", type="com.sina.microblog.events.MicroBlogEvent")]
        /**
         *  当加载关注博主的用户id列表失败时触发该事件.
         *
         *  <p>调用loadFollowersIDList失败时,事件的<code>message</code>为失败原因描述</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="loadFollowersIDListError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
        
        /**
         *  当验证用户信息成功和登陆成功时触发该事件.
         *
         *  <p>调用verifyCrendentials成功时,事件的<code>result</code>属性<code>MicroBlogUser</code>
         *  对象.</p>
         *  <p>注意:当使用Basic方式验证的时候调用login成功时也会触发该事件</p>
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="verifyCredentialsResult", type="com.sina.microblog.events.MicroBlogEvent")]
        /**
         *  当验证用户信息失败时触发该事件.
         *
         *  <p>调用verifyCrendentials失败时,事件的<code>message</code>为失败原因描述</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="verifyCredentialsError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
        
        /**
         *  当获取调用速率限制信息成功时触发该事件.
         *
         *  <p>调用getRateLimitStatus成功时,事件的<code>result</code>属性<code>MicroBlogUser</code>
         *  数组.</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="getRateLimitStatusResult", type="com.sina.microblog.events.MicroBlogEvent")]
        /**
         *  当获取调用速率限制信息失败时触发该事件.
         *
         *  <p>调用getRateLimitStatus失败时,事件的<code>message</code>为失败原因描述</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="getRateLimitStatusError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
        
        /**
         *  当用户成功注销时触发该事件.
         *
         *  <p>调用logout成功时,事件的<code>result</code>属性<code>MicroBlogRateLimit</code>
         *  数组.</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="logoutResult", type="com.sina.microblog.events.MicroBlogEvent")]
        /**
         *  当用户注销失败时触发该事件.
         *
         *  <p>调用logout失败时,事件的<code>message</code>为失败原因描述</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="logoutError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
        
        /**
         *  当更新用户信息成功时触发该事件.
         *
         *  <p>调用updateProfile成功时,事件的<code>result</code>属性<code>MicroBlogUser</code>
         *  对象.</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="updateProfileResult", type="com.sina.microblog.events.MicroBlogEvent")]
        /**
         *  当更新用户信息失败时触发该事件.
         *
         *  <p>调用updateProfile失败时,事件的<code>message</code>为失败原因描述</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="updateProfileError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
        
        /**
         *  当更新用户头像成功时触发该事件.
         *
         *  <p>调用updateProfileImage成功时,事件的<code>result</code>属性<code>MicroBlogUser</code>
         *  对象.</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="updateProfileImageResult", type="com.sina.microblog.events.MicroBlogEvent")]
        /**
         *  当更新用户头像失败时触发该事件.
         *
         *  <p>调用updateProfileImage失败时,事件的<code>message</code>为失败原因描述</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="updateProfileImageError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
        
        
        /**
         *  当加载用户收藏列表成功时触发该事件.
         *
         *  <p>调用loadFavoriteList成功时,事件的<code>result</code>属性<code>MicroBlogStatus</code>
         *  对象数组.</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="loadFavoriteListResult", type="com.sina.microblog.events.MicroBlogEvent")]
        /**
         *  当加载用户收藏列表失败时触发该事件.
         *
         *  <p>调用loadFavoriteList失败时,事件的<code>message</code>为失败原因描述</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="loadFavoriteListError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
        
        /**
         *  当收藏微博消息成功时触发该事件.
         *
         *  <p>调用addToFavorites成功时,事件的<code>result</code>属性<code>MicroBlogStatus</code>
         *  对象.</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="addToFavoritesResult", type="com.sina.microblog.events.MicroBlogEvent")]
        /**
         *  当收藏微博消息失败时触发该事件.
         *
         *  <p>调用addToFavorites失败时,事件的<code>message</code>为失败原因描述</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="addToFavoritesError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
        
        /**
         *  当将微博消息移出收藏列表成功时触发该事件.
         *
         *  <p>调用removeFromFavorites成功时,事件的<code>result</code>属性<code>MicroBlogStatus</code>
         *  对象.</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="removeFromFavoritesResult", type="com.sina.microblog.events.MicroBlogEvent")]    
        /**
         *  当将微博消息移出收藏列表失败时触发该事件.
         *
         *  <p>调用addToFavorites失败时,事件的<code>message</code>为失败原因描述</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="removeFromFavoritesError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
        
        /**
         *  当允许/不允许某用户通知成功时触发该事件.
         *
         *  <p>调用enableNotification成功时,事件的<code>result</code>属性<code>MicroBlogUser</code>
         *  对象.</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="enableNotificationResult", type="com.sina.microblog.events.MicroBlogEvent")]
        /**
         *  当允许/不允许某用户通知失败时触发该事件.
         *
         *  <p>调用enableNotification失败时,事件的<code>message</code>为失败原因描述</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="enableNotificationError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
        
        /**
         *  当请求省份,城市与id对应列表成功时触发该事件.
         *
         *  <p>调用loadProvinceCityIDList成功时,事件的<code>result</code>属性<code>XML</code>
         *  对象.</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="loadProvinceCityIdListResult", type="flash.events.MicroBlogEvent")]
        /**
         *  当请求省份,城市与id对应列表失败时触发该事件.
         *
         *  <p>调用loadProvinceCityIDList失败时,事件的<code>message</code>为失败原因描述</p>
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="loadProvinceCityIdListError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
        
        /**
         *  当请求未被验证,服务器调用产生安全错误时触发该事件.
         *
         *  @see flash.events.SecurityErrorEvent
         *  
         *  @langversion 3.0
         *  @productversion MicroBlog-API 
         */
        [Event(name="securityError", type="flash.events.SecurityErrorEvent")]
        
        /**
         * MicroBlog是新浪微博AS3 API的核心类.
         *
         * <p>其主要功能包括:</br>
         * <ul>
         * <li>封装核心的平台API</li>
         * <li>封装了两种用户认证方式:用户名/密码和OAuth方式</li>
         * <li>使用事件来返回API调用结果</li>
         * <li>对API调用的结果(XML)进行强类型的封装</li>
         * </ul>
         * 一般情况下,当一个API调用成功时,将会抛出一个<b>MicroBlogEvent</b>事件,而调用失败将会抛出<b>MicroBlogErrorEvent</b>事件。</br>
         * 具体事件类型请参照函数说明文档。
         * </p>
         * <p>
         * <b>例1 使用用户名密码进行用户认证</b>
         * <pre><br/>
         * private var mb:MicroBlog = new MicroBlog();
         * public function init():void 
         * {
         *         mb.login(username, password);
         * }</pre>
         * </p>
         * <p>
         * <b>例2 使用OAuth进行认证</b>
         * <pre><br/>
         * private var mb:MicroBlog = new MicroBlog();
         * public function init():void
         * {
         *         mb.consumerKey = xxxxxx;
         *         mb.consumerSecret = xxxxxx;
         *         if ( accessTokenKey &#38;&#38; accessTokenSecret )
         *         //如果保存了用户认证过的Token,则不需要登陆,也不需要pin_onClick的调用过程
         *         {
         *             mb.accessTokenKey = accessTokenKey;
         *             mb.accessTokenSecret = accessTokenSecret;
         *         } else
         *         {
         *             mb.login();
         *         }
         * }
         * //当用户在网页上认证了该请求以后
         * private function pin_onClick():void
         * {
         *         mb.pin = xxxxx;//如果不使用pin码,将pin置为空即可mb.pin="";
         * }
         * //然后就可以访问微博数据了
         * </pre>
         * </p>
         * <p>
         * <b>例3 一个典型的服务器调用过程,包括调用api,监听事件</b>
         * <pre><br/>
         * private var mb:MicroBlog = new MicroBlog();
         * private function initListeners():void
         * {
         *         mb.addEventListener(MicroBlogEvent.LOAD_PUBLIC_TIMELINE_RESULT, mb_onPublicTimeline, false, 0, true);
         *         mb.addEventListener(MicroBlogErrorEvent.LOAD_PUBLIC_TIMELINE_ERROR, mb_onError, false, 0, true);
         * }
         * public function loadPublicTimeline():void
         * {
         *         mb.loadPublicTimeline();
         * }
         * private function mb_onPublicTimeline(event:MicroBlogEvent):void
         * {
         *         //处理成功返回的数据
         *         var data:Array = event.result;
         *         xxxxxx
         * }
         * private function mb_onError(event:MicroBlogErrorEvent):void
         * {
         *         var msg:String = event.message;
         *         xxxxxxx
         * }
         * </pre>
         * </p>
         *
         */
        public class MicroBlog extends EventDispatcher
        {
    
            private static const API_BASE_URL:String="http://api.t.sina.com.cn/";
    
            private static const OAUTH_REQUEST_TOKEN_REQUEST_URL:String=API_BASE_URL + "oauth/request_token";
            //private static const OAUTH_REQUEST_TOKEN_REQUEST_URL:String="http://twitter.com/oauth/request_token";
            private static const OAUTH_AUTHORIZE_REQUEST_URL:String=API_BASE_URL + "oauth/authorize";
            private static const OAUTH_ACCESS_TOKEN_REQUEST_URL:String=API_BASE_URL + "oauth/access_token";
    
            private static const PUBLIC_TIMELINE_REQUEST_URL:String=API_BASE_URL + "statuses/public_timeline.xml";
            private static const FRIENDS_TIMELINE_REQUEST_URL:String=API_BASE_URL + "statuses/friends_timeline.xml";
            private static const USER_TIMELINE_REQUEST_URL:String=API_BASE_URL + "statuses/user_timeline$user.xml";
            private static const MENTIONS_REQUEST_URL:String=API_BASE_URL + "statuses/mentions.xml";
            private static const COMMENTS_TIMELINE_REQUEST_URL:String=API_BASE_URL + "statuses/comments_timeline.xml";
            private static const COMMENTS_BY_ME_REQUEST_URL:String=API_BASE_URL + "statuses/comments_by_me.xml";
            private static const COMMENTS_REQUEST_URL:String=API_BASE_URL + "statuses/comments.xml";
            private static const STATUS_COUNTS_REQUEST_URL:String=API_BASE_URL + "statuses/counts.xml";
    
            private static const UPDATE_STATUS_REQUEST_URL:String=API_BASE_URL + "statuses/update.xml";
            private static const UPDATE_STATUS_WITH_IMAGE_REQUEST_URL:String=API_BASE_URL + "statuses/upload.xml";
            private static const SHOW_STATUS_REQUEST_URL:String=API_BASE_URL + "statuses/show/$id.xml";
            private static const DELETE_STATUS_REQUEST_URL:String=API_BASE_URL + "statuses/destroy/$id.xml";
            private static const COMMENT_STATUS_REQUEST_URL:String=API_BASE_URL + "statuses/comment.xml";
            private static const DELETE_COMMENT_REQUEST_URL:String=API_BASE_URL + "statuses/comment_destroy/$id.xml";
            private static const REPOST_STATUS_REQUEST_URL:String=API_BASE_URL + "statuses/repost.xml";
            private static const REPLY_STATUS_REQUEST_URL:String=API_BASE_URL + "statuses/reply.xml";
    
            private static const LOAD_DIRECT_MESSAGES_RECEIVED_REQUEST_URL:String=API_BASE_URL + "direct_messages.xml";
            private static const LOAD_DIRECT_MESSAGES_SENT_REQUEST_URL:String=API_BASE_URL + "direct_messages/sent.xml";
            private static const SEND_DIRECT_MESSAGE_REQUEST_URL:String=API_BASE_URL + "direct_messages/new.xml";
            private static const DELETE_DIRECT_MESSAGE_REQUEST_URL:String=API_BASE_URL + "direct_messages/destroy/$id.xml";
    
            private static const LOAD_USER_INFO_REQUEST_URL:String=API_BASE_URL + "users/show$user.xml";
            private static const LOAD_FRIENDS_INFO_REQUEST_URL:String=API_BASE_URL + "statuses/friends$user.xml";
            private static const LOAD_FOLLOWERS_INFO_REQUEST_URL:String=API_BASE_URL + "statuses/followers$user.xml";
    
            private static const FOLLOW_REQUEST_URL:String=API_BASE_URL + "friendships/create$user.xml";
            private static const CANCEL_FOLLOWING_REQUEST_URL:String=API_BASE_URL + "friendships/destroy$user.xml";
            private static const CHECK_IS_FOLLOWING_REQUEST_URL:String=API_BASE_URL + "friendships/show.xml";
    
            private static const LOAD_FRIENDS_ID_LIST_REQUEST_URL:String=API_BASE_URL + "friends/ids$user.xml";
            private static const LOAD_FOLLOWERS_ID_LIST_REQUEST_URL:String=API_BASE_URL + "followers/ids$user.xml";
            
            private static const VERIFY_CREDENTIALS_REQUEST_URL:String=API_BASE_URL + "account/verify_credentials.xml";
            private static const GET_RATE_LIMIT_STATUS_REQUEST_URL:String=API_BASE_URL + "account/rate_limit_status.xml";
            private static const LOGOUT_REQUEST_URL:String=API_BASE_URL + "account/end_session.xml";
            private static const UPDATE_PROFILE_IMAGE_REQUEST_URL:String=API_BASE_URL + "account/update_profile_image.xml";
            private static const UPDATE_PROFILE_REQUEST_URL:String=API_BASE_URL + "account/update_profile.xml";
    
            private static const LOAD_FAVORITE_LIST_REQUEST_URL:String=API_BASE_URL + "favorites.xml";
            private static const ADD_TO_FAVORITES_REQUEST_URL:String=API_BASE_URL + "favorites/create.xml";
            private static const REMOVE_FROM_FAVORITES_REQUEST_URL:String=API_BASE_URL + "favorites/destroy/$id.xml";
    
            private static const ENABLE_NOTIFICATION_REQUEST_URL:String=API_BASE_URL + "notifications/$enabled$user.xml";
        
            private static const LOAD_PROVINCE_CITY_ID_LIST:String=API_BASE_URL + "provinces.xml";
    //        private static const VERIFY_CREDENTIALS:String = "1";
    //        private static const LOGOUT:String = "2";
    
            private static const USER_ID:String="user_id";
            private static const SCREEN_NAME:String="screen_name";
            private static const SINCE_ID:String="since_id";
            private static const MAX_ID:String="max_id";
            private static const COUNT:String="count";
            private static const PAGE:String="page";
            private static const ROLE:String="role";
            private static const ID:String="id";
            private static const CURSOR:String="cursor";
            private static const FOLLOW:String="follow";
            private static const SOURCE_ID:String="source_id";
            private static const SOURCE_SCREEN_NAME:String="source_screen_name";
            private static const TARGET_ID:String="target_id";
            private static const TARGET_SCREEN_NAME:String="target_screen_name";
    
            private static const MULTIPART_FORMDATA:String="multipart/form-data; boundary=";
            private static const CONTENT_DISPOSITION_BASIC:String='Content-Disposition: form-data; name="$name"';
    
            private static const CONTENT_TYPE_JPEG:String="Content-Type: image/pjpeg";
            private static const CONTENT_TRANSFER_ENCODING:String="Content-Transfer-Encoding: binary";
            
            private static const SOURCE_ADOBE_AIR_CLIENT:String = "Adobe Air Client";
            private var _consumerKey:String="";
            private var _consumerSecret:String="";
            private var _accessTokenKey:String="";
            private var _accessTokenSecret:String="";
            private var _pin:String="";
            private var _source:String = SOURCE_ADOBE_AIR_CLIENT;
            private var authHeader:URLRequestHeader;
    
            private var serviceLoader:Dictionary=new Dictionary();
            private var loaderMap:Dictionary=new Dictionary();
    
            private var oauthLoader:URLLoader;
            
            /**
             * @private Used for test purpose.
             */
            nm_test_internal var lastLoader:URLLoader;
            nm_test_internal var lastRequest:URLRequest;
            
            public function MicroBlog()
            {
    
            }
    
            /**
             * consumerKey是一个只写属性,用于验证客户端的合法性,
             * 必须在调用login之前将其设置为合适值.
             */
            public function set consumerKey(value:String):void
            {
                if ( value )
                {
                    _consumerKey=value;
                } else
                {
                    _consumerKey = "";
                }
            }
    
            /**
             * consumerSecret是一个只写属性,用于和consumerKey一起验证客户端的合法性,
             * 必须在调用login之前将其设置为合适值.
             */
            public function set consumerSecret(value:String):void
            {
                if ( value )
                {
                    _consumerSecret=value;
                } else
                {
                    _consumerSecret = "";
                }
            }
            /**
             * pin是用于OAuth认证用的属性,由登陆页面生成.仅在登陆时使用.
             * 
             */
            public function set pin(value:String):void
            {
                _pin=value;
                //Case that the saved user come back. 
                //The oauthLoader will not created before login
                //Actually, the application could save last token and
                //reset after the application restarted.
                if ( oauthLoader )
                {
                    var url:String=OAUTH_ACCESS_TOKEN_REQUEST_URL;
                    var req:URLRequest=signRequest(URLRequestMethod.GET, url, null);
                    oauthLoader.load(req);
                    _pin = ""; // Just use once.
                }
            }
            
            /**
             * accessTokenKey是用于OAuth认证的访问资源的token,由用户授权.
             * 
             */
            public function set accessTokenKey(value:String):void
            {
                if (null != value)
                {
                    _accessTokenKey=value;
                } else
                {
                    _accessTokenKey = "";
                }
            }
    
            public function get accessTokenKey():String
            {
                return _accessTokenKey;
            }
            /**
             * accessTokenSecret是用于OAuth认证的访问资源的token的密钥.
             * 
             */
            public function get accessTokenSecrect():String
            {
                return _accessTokenSecret;
            }
            public function set accessTokenSecrect(value:String):void
            {
                if (null != value)
                {
                    _accessTokenSecret=value;
                } else
                {
                    _accessTokenSecret = "";
                }
            }
            /**
             * source是标识客户端来源.必须设置为新浪认证的应用程序id
             * 
             */
            public function set source(value:String):void
            {
                _source = StringEncoders.urlEncodeUtf8String(value);
            }
            public function get source():String
            {
                return _source;
            }
            /**
             * login函数封装了OAuth所要求的验证的三个步骤,
             * 调用者只需要将新浪微博的用户名和密码
             * (之前输入的consumerKey和consumerSecret)
             * 传入函数即可.
             *
             * @param userName 是合法的新浪微博用户名.
             * @param password 是与用户名对应的密码.
             *
             * login函数没有返回值,验证结果将采用消息的方式通知api调用者.
             * @see com.sina.microblog.events.MicroBlogEvent#LOGIN_RESULT
             *
             */
            public function login(userName:String=null, password:String=null):void
            {
                if (_accessTokenKey.length > 0 && _accessTokenSecret.length > 0)
                {
                    return;
                }
    
                if (_consumerKey.length > 0 && _consumerSecret.length > 0)
                {
                    if (null == oauthLoader)
                    {
                        oauthLoader=new URLLoader();
                        oauthLoader.addEventListener(Event.COMPLETE, oauthLoader_onComplete, false, 0, true);
                        oauthLoader.addEventListener(IOErrorEvent.IO_ERROR, oauthLoader_onError, false, 0, true);
                        oauthLoader.addEventListener(SecurityErrorEvent.SECURITY_ERROR, oauthLoader_onSecurityError, false, 0, true);
                    }
                    var req:URLRequest=signRequest(URLRequestMethod.GET, OAUTH_REQUEST_TOKEN_REQUEST_URL, null);
                    oauthLoader.load(req);
                }
                else if (userName != null && password != null)
                {
                    var creds:String=userName + ":" + password;
                    var encodedCredentials:String=Base64.encode(creds);
                    authHeader=new URLRequestHeader("Authorization", "Basic " + encodedCredentials);
                    verifyCredentials();
                }
    
            }
    
            /**
             * 返回最新更新的20条公共微博消息.
             *
             * <b>有请求数限制</b>
             * 
             * <p>如果该函数被成功执行,将会抛出MicroBlogEvent事件<br/>
             * type为<b>MicroBlogEvent.STATUS_PUBLIC_TIMELINE_RESULT</b><br/>
             * success为<b>true</b>如果该属性为false,则表示该次操作失败<br/>
             * result为一个MicroBlogStatus数组,该数组包含了最新的20条微博消息.</p>
             *
             * <p>如果该函数调用失败,将会抛出MicroBlogErrorEvent事件,该事件<br/>
             * type为<b>MicroErrorEvent.STATUS_PUBLIC_TIMELINE_ERROR</b></p>
             *
             */
            public function loadPublicTimeline():void
            {
                addProcessor(PUBLIC_TIMELINE_REQUEST_URL, processStatusArray, MicroBlogEvent.LOAD_PUBLIC_TIMELINE_RESULT, MicroBlogErrorEvent.LOAD_PUBLIC_TIMELINE_ERROR);
                executeRequest(PUBLIC_TIMELINE_REQUEST_URL, getMicroBlogRequest(PUBLIC_TIMELINE_REQUEST_URL, null, URLRequestMethod.GET));
            }
    
            /**
             * 返回用户所有关注的用户最新的n条微博消息.
             *
             * <b>有请求数限制</b>
             * 
             * <p>如果该函数被成功执行,将会抛出MicroBlogEvent事件,该事件<br/>
             * type为<b>MicroBlogEvent.STATUS_FRIENDS_TIMELINE_RESULT</b><br/>
             * result为一个MicroBlogStatus数组,该数组包含了所请求的微博消息.</p>
             *
             * <p>如果该函数调用失败,将会抛出MicroBlogErrorEvent事件,该事件<br/>
             * type为<b>MicroErrorEvent.STATUS_FRIENDS_TIMELINE_ERROR</b><br/></p>
             *
             * @param sinceID 请求大于该id的所有消息更新,默认值为0,表示不限制.
             * @param maxID 请求小于该id的所有消息更新,默认为0,表示不限制.
             * @param count 请求的页大小,即一页包含多少条记录;默认值0,表示使用服务器默认分页大小.
             * @param page 请求的页序号,默认值0,返回第一页.
             *
             */
            public function loadFriendsTimeline(sinceID:uint=0, maxID:uint=0, count:uint=0, page:uint=0):void
            {
                addProcessor(FRIENDS_TIMELINE_REQUEST_URL, processStatusArray, MicroBlogEvent.LOAD_FRIENDS_TIMELINE_RESULT, MicroBlogErrorEvent.LOAD_FRIENDS_TIMELINE_ERROR);
                var url:String=FRIENDS_TIMELINE_REQUEST_URL;
                var params:Object=new Object();
                makeQueryCombinatory(params, sinceID, maxID, count, page);
                executeRequest(FRIENDS_TIMELINE_REQUEST_URL, getMicroBlogRequest(url, params, URLRequestMethod.GET));
            }
    
            /**
             * 返回用户发布的最新的n条微博消息.
             *
             * <b>有请求数限制</b>
             * 
             * <p>如果该函数被成功执行,将会抛出MicroBlogEvent事件,该事件<br/>
             * type为<b>MicroBlogEvent.STATUS_USER_TIMELINE_RESULT</b><br/>
             * result为一个MicroBlogStatus数组,该数组包含了所请求的微博消息.
             * 由于分页限制,最多只能返回用户最新的300条微博信息</p>
             *
             * <p>如果该函数调用失败,将会抛出MicroBlogErrorEvent事件,该事件<br/>
             * type为<b>MicroErrorEvent.STATUS_USER_TIMELINE_ERROR</b></p>
             *
             * @param id 可选参数. 根据指定用户UID或用户帐号来返回微博信息.
             * @param userID 可选参数. 指定用户UID来返回微博信息,主要是用来区分用户UID跟用户账号一样,产生歧义的时候,特别是在用户账号为数字导致和用户Uid发生歧义.
             * @param screenName 可选参数,指定用户的微博昵称,主要是用来区分用户UID跟用户账号一样,产生歧义的时候。
             * @param sinceID 请求大于该id的所有消息更新,默认值为0,表示不限制.
             * @param maxID 请求小于该id的所有消息更新,默认为0,表示不限制.
             * @param count 请求的页大小,即一页包含多少条记录;默认值0,表示使用服务器默认分页大小.
             * @param page 请求的页序号,默认值0,返回第一页.
             *
             *
             */
            public function loadUserTimeline(id:*=null, userID:uint=0, screenName:String=null, sinceID:uint=0, maxID:uint=0, count:uint=0, page:uint=0):void
            {
                //TO-DO: if the parameter equals to zero, don't include this parameter when build request url.
                addProcessor(USER_TIMELINE_REQUEST_URL, processStatusArray, MicroBlogEvent.LOAD_USER_TIMELINE_RESULT, MicroBlogErrorEvent.LOAD_USER_TIMELINE_ERROR);
                var user:String;
                if (id)
                {
                    user="/" + String(id);
                }
                else
                {
                    user="";
                }
                var url:String=USER_TIMELINE_REQUEST_URL.replace("$user", user);
                var params:Object=new Object();
                makeUserParams(params, userID, screenName, -1);
                makeQueryCombinatory(params, sinceID, maxID, count, page);
    
                executeRequest(USER_TIMELINE_REQUEST_URL, getMicroBlogRequest(url, params, URLRequestMethod.GET));
            }
    
            /**
             * 返回最近n条提及我的微博消息.
             *
             * <b>有请求数限制</b>
             * 
             * <p>如果该函数被成功执行,将会抛出MicroBlogEvent事件,该事件<br/>
             * type为<b>MicroBlogEvent.STATUS_MENTIONS_RESULT</b><br/>
             * result为一个MicroBlogStatus数组,该数组包含了所请求的微博消息.</p>
             *
             * <p>如果该函数调用失败,将会抛出MicroBlogErrorEvent事件,该事件<br/>
             * type为<b>MicroErrorEvent.STATUS_MENTIONS_ERROR</b></p>
             *
             * @param sinceID 请求大于该id的所有消息更新,默认值为0,表示不限制.
             * @param maxID 请求小于该id的所有消息更新,默认为0,表示不限制.
             * @param count 请求的页大小,即一页包含多少条记录;默认值0,表示使用服务器默认分页大小.
             * @param page 请求的页序号,默认值0,返回第一页.
             *
             */
            public function loadMentions(sinceID:uint=0, maxID:uint=0, count:uint=0, page:uint=0):void
            {
                //TO-DO: if the parameter equals to zero, don't include this parameter when build request url.
                addProcessor(MENTIONS_REQUEST_URL, processStatusArray, MicroBlogEvent.LOAD_MENSIONS_RESULT, MicroBlogErrorEvent.LOAD_MENSIONS_ERROR);
                var url:String=MENTIONS_REQUEST_URL;
                var params:Object=new Object();
                makeQueryCombinatory(params, sinceID, maxID, count, page);
                executeRequest(MENTIONS_REQUEST_URL, getMicroBlogRequest(url, params, URLRequestMethod.GET));
            }
    
            /**
             * 返回最近n条评论.
             * 
             * <b>有请求数限制</b>
             * 
             * <p>如果该函数被成功执行,将会抛出MicroBlogEvent事件,该事件<br/>
             * type为<b>MicroBlogEvent.STATUS_COMMENTS_TIMELINE_RESULT</b><br/>
             * result为一个MicroBlogStatus数组,该数组包含了所请求的微博消息.</p>
             *
             * <p>如果该函数调用失败,将会抛出MicroBlogErrorEvent事件,该事件<br/>
             * type为<b>MicroErrorEvent.STATUS_COMMENTS_TIMELINE_ERROR</b></p>
             *
             * @param sinceID 请求大于该id的所有消息更新,默认值为0,表示不限制.
             * @param maxID 请求小于该id的所有消息更新,默认为0,表示不限制.
             * @param count 请求的页大小,即一页包含多少条记录;默认值0,表示使用服务器默认分页大小.
             * @param page 请求的页序号,默认值0,返回第一页.
             *
             */
            public function loadCommentsTimeline(sinceID:uint=0, maxID:uint=0, count:uint=0, page:uint=0):void
            {
                addProcessor(COMMENTS_TIMELINE_REQUEST_URL, processCommentArray, MicroBlogEvent.LOAD_COMMENTS_TIMELINE_RESULT, MicroBlogErrorEvent.LOAD_COMMENTS_TIMELINE_ERROR);
                var url:String=COMMENTS_TIMELINE_REQUEST_URL;
                var params:Object=new Object();
                makeQueryCombinatory(params, sinceID, maxID, count, page);
                executeRequest(COMMENTS_TIMELINE_REQUEST_URL, getMicroBlogRequest(url, params, URLRequestMethod.GET));
            }
    
            /**
             * 返回我发表的评论.
             *
             * <b>有请求数限制</b>
             * 
             * <p>如果该函数被成功执行,将会抛出MicroBlogEvent事件,该事件<br/>
             * type为<b>MicroBlogEvent.STATUS_COMMENTS_BY_ME_RESULT</b><br/>
             * result为一个MicroBlogStatus数组,该数组包含了所请求的微博消息.</p>
             *
             * <p>如果该函数调用失败,将会抛出MicroBlogErrorEvent事件,该事件<br/>
             * type为<b>MicroErrorEvent.STATUS_COMMENTS_TIMELINE_ERROR</b></p>
             *
             * @param sinceID 请求大于该id的所有消息更新,默认值为0,表示不限制.
             * @param maxID 请求小于该id的所有消息更新,默认为0,表示不限制.
             * @param count 请求的页大小,即一页包含多少条记录;默认值0,表示使用服务器默认分页大小.
             * @param page 请求的页序号,默认值0,返回第一页.
             *
             */
            public function loadMyComments(sinceID:uint=0, maxID:uint=0, count:uint=0, page:uint=0):void
            {
                addProcessor(COMMENTS_BY_ME_REQUEST_URL, processCommentArray, MicroBlogEvent.LOAD_MY_COMMENTS_RESULT, MicroBlogErrorEvent.LOAD_MY_COMMENTS_ERROR);
                var url:String=COMMENTS_BY_ME_REQUEST_URL;
                var params:Object=new Object();
                makeQueryCombinatory(params, sinceID, maxID, count, page);
                executeRequest(COMMENTS_BY_ME_REQUEST_URL, getMicroBlogRequest(url, params, URLRequestMethod.GET));
            }
    
            /**
             * 返回指定微博的最新n条评论.
             *
             * <b>有请求数限制</b>
             * 
             * <p>如果该函数被成功执行,将会抛出MicroBlogEvent事件,该事件<br/>
             * type为<b>MicroBlogEvent.STATUS_COMMENTS_RESULT</b><br/>
             * result为一个MicroBlogStatus数组,该数组包含了所请求的微博消息.</p>
             *
             * @param id 必选参数,指定微博ID.
             * @param count 请求的页大小,即一页包含多少条记录;默认值0,表示使用服务器默认分页大小.
             * @param page 请求的页序号,默认值0,返回第一页.
             */
            public function loadCommentList(id:uint, count:uint=0, page:uint=0):void
            {
                addProcessor(COMMENTS_REQUEST_URL, processCommentArray, MicroBlogEvent.LOAD_COMMENTS_RESULT, MicroBlogErrorEvent.LOAD_COMMENTS_ERROR);
                var url:String=COMMENTS_REQUEST_URL;
                var params:Object=new Object();
                params[ID]=id;
                makeQueryCombinatory(params, 0, 0, count, page);
                executeRequest(COMMENTS_REQUEST_URL, getMicroBlogRequest(url, params, URLRequestMethod.GET));
            }
    
            /**
             * 批量统计微薄的评论数,转发数.单次最多获取100个.
             *
             * <b>有请求数限制</b>
             * 
             * <p>如果该函数被成功执行,将会抛出MicroBlogEvent事件,该事件<br/>
             * type为<b>MicroBlogEvent.STATUS_COUNTS_RESULT</b><br/>
             * result为一个MicroBlogCounts实例.</p>
             *
             * @param ids 必选参数,指定微博ID数组.
             *
             */
            public function loadStatusCounts(ids:Array):void
            {
                addProcessor(STATUS_COUNTS_REQUEST_URL, processCounts, MicroBlogEvent.LOAD_STATUS_COUNTS_RESULT, MicroBlogErrorEvent.LOAD_STATUS_COUNTS_ERROR);
                var idsParam:String="";
                
                if (null == ids || ids.length == 0)
                {
                    return;
                }
                var len:int=ids.length - 1;
                for (var i:int=0; i < len; ++i)
                {
                    idsParam+=ids[i].toString() + ",";
                }
                idsParam+=ids[len].toString();
                var params:Object=new Object();
                params["ids"]=idsParam;
                var url:String=STATUS_COUNTS_REQUEST_URL;
                executeRequest(STATUS_COUNTS_REQUEST_URL, getMicroBlogRequest(url, params, URLRequestMethod.GET));
            }
    
            /**
             * 获取单条ID的微博信息,作者信息将同时返回.
             *
             * <b>有请求数限制</b>
             * 
             * <p>如果该函数被成功执行,将会抛出MicroBlogEvent事件,该事件<br/>
             * type为<b>MicroBlogEvent.SHOW_STATUS_RESULT</b><br/>
             * result为一个MicroBlogStatus实例.</p>
             *
             * @param id 必选参数,指定微博消息ID.
             *
             */
            public function loadStatusInfo(id:uint):void
            {
                addProcessor(SHOW_STATUS_REQUEST_URL, processStatus, MicroBlogEvent.LOAD_STATUS_INFO_RESULT, MicroBlogErrorEvent.LOAD_STATUS_INFO_ERROR);
                var url:String=SHOW_STATUS_REQUEST_URL.replace("$id", id);
                executeRequest(SHOW_STATUS_REQUEST_URL, getMicroBlogRequest(url, null, URLRequestMethod.GET));
            }
    
            /**
             * 发布一条微博信息.为防止重复,发布的信息与当前最新信息一样话,将会被忽略.
             *
             * <p>如果该函数被成功执行,将会抛出MicroBlogEvent事件,该事件<br/>
             * type为<b>MicroBlogEvent.UPDATE_STATUS_RESULT</b><br/>
             * result为一个MicroBlogStatus实例.</p>
             *
             * @param status 必选参数,要更新的微博信息,信息内容部超过140个汉字.
             * @param filename 可选参数,上传的jpeg文件名.
             * @param imgData 可选参数,为需要上传的jpeg文件数据,为空则不上传图片.
             *
             * 如果没有登录或超过发布上限,将返回错误
             * 系统将忽略重复发布的信息.每次发布将比较最后一条发布消息,如果一样将被忽略.因此用户不能连续提交相同信息.
             */
            public function updateStatus(status:String, filename:String=null, imgData:ByteArray=null):void
            {
                addProcessor(UPDATE_STATUS_REQUEST_URL, processStatus, MicroBlogEvent.UPDATE_STATUS_RESULT, MicroBlogErrorEvent.UPDATE_STATUS_ERROR);
                var req:URLRequest;
                var params:URLVariables=new URLVariables();
                
                if ( status )
                {
                    params.status= encodeMsg(status);
                } else
                {
                    if ( imgData == null )
                    {
                        return;
                    }
                }
                
                var url:String;
    
                if (imgData)
                {
                    url=UPDATE_STATUS_WITH_IMAGE_REQUEST_URL;
                    req=getMicroBlogRequest(url, params, URLRequestMethod.POST);
                    var boundary:String=makeBoundary();
                    req.contentType=MULTIPART_FORMDATA + boundary;
                    req.data=makeMultipartPostData(boundary, "pic", filename, imgData, params);
                }
                else
                {
                    
                    url=UPDATE_STATUS_REQUEST_URL;
                    req=getMicroBlogRequest(url, params, URLRequestMethod.POST);
                    req.data=params;
                }
                executeRequest(UPDATE_STATUS_REQUEST_URL, req);
    
            }
    
            /**
             * 返回发布一条带图片的微博信息的<code>URLRequest对象</code>.
             *
             * 
             * <p>如果消息成功发送,将会抛出MicroBlogEvent事件,该事件<br/>
             * type为<b>MicroBlogEvent.UPDATE_STATUS_RESULT</b><br/>
             * result为一个MicroBlogStatus实例.</p>
             *
             *
             * @return <code>URLRequest</code>对象,用于在flash中用File对象上传图片,在调用File对象的upload时uploadDataFieldName必须为pic。
             *
             * 如果没有登录或超过发布上限,将返回错误
             * 系统将忽略重复发布的信息.每次发布将比较最后一条发布消息,如果一样将被忽略.因此用户不能连续提交相同信息.
             *
             * @see #updateStatus()
             */
            public function getUploadImageRequest(status:String):URLRequest
            {
                var req:URLRequest;
                
                var url:String=UPDATE_STATUS_WITH_IMAGE_REQUEST_URL;
                var data:URLVariables=new URLVariables();
                data.status=encodeMsg(status);
                req=getMicroBlogRequest(url, data, URLRequestMethod.POST);
                req.data=data;
                return req;
            }
    
            /**
             * 删除微博信息.注意:只能删除自己发布的信息.
             * 
             * <p> 如果该函数被成功执行,将会抛出MicroBlogEvent事件,该事件<br/>
             * type为<b>MicroBlogEvent.DELETE_STATUS_RESULT</b><br/>
             * result为一个MicroBlogStatus实例.</p>
             *
             * @param id 必填参数,要删除的微博信息ID.
             *
             */
            public function deleteStatus(id:uint):void
            {
                addProcessor(DELETE_STATUS_REQUEST_URL, processStatus, MicroBlogEvent.DELETE_STATUS_RESULT, MicroBlogErrorEvent.DELETE_STATUS_ERROR);
                var url:String=DELETE_STATUS_REQUEST_URL.replace("$id", id);
                var postData:URLVariables = new URLVariables();
                var req:URLRequest = getMicroBlogRequest(url, postData, URLRequestMethod.POST);
                req.data = postData;
                executeRequest(DELETE_STATUS_REQUEST_URL, req);
                
            }
    
            /**
             * 转发一条微博信息.为防止重复,发布的信息与当前最新信息一样话,将会被忽略.
             *
             * <p>如果该函数被成功执行,将会抛出MicroBlogEvent事件,该事件<br/>
             * type为<b>MicroBlogEvent.REPOST_STATUS_RESULT</b><br/>
             * result为一个MicroBlogStatus实例.</p>
             *
             * @param id 必填参数,转发的微博ID.
             * @param status 可选参数,要更新的微博信息,信息内容部超过140个汉字.
             * 
             * <p>如果没有登录或超过发布上限,将返回错误
             * 系统将忽略重复发布的信息.每次发布将比较最后一条发布消息,如果一样将被忽略.因此用户不能连续提交相同信息.
             * </p>
             */
            public function repostStatus(id:uint, status:String=null):void
            {
                addProcessor(REPOST_STATUS_REQUEST_URL, processStatus, MicroBlogEvent.REPOST_STATUS_RESULT, MicroBlogErrorEvent.REPOST_STATUS_ERROR);
    
                var variable:URLVariables=new URLVariables();
                variable.id=id;
                if (status && status.length > 0)
                {
                    variable.status=encodeMsg(status);
                }
                var req:URLRequest=getMicroBlogRequest(REPOST_STATUS_REQUEST_URL, variable, URLRequestMethod.POST);
                req.data=variable;
                executeRequest(REPOST_STATUS_REQUEST_URL, req);
            }
    
            /**
             * 对一条微博信息进行评论.为防止重复,发布的信息与当前最新信息一样话,将会被忽略.
             *
             * <p>如果该函数被成功执行,将会抛出MicroBlogEvent事件,该事件
             * type为<b>MicroBlogEvent.COMMENT_STATUS_RESULT</b><br/>
             * result为一个MicroBlogComment实例.</p>
             *
             * <p>如果没有登录或超过发布上限,将返回错误<br/>
             * 系统将忽略重复发布的信息.每次发布将比较最后一条发布消息,如果一样将被忽略.因此用户不能连续提交相同信息.</p>
             *
             * @param id 必填参数, 要评论的微博ID.
             * @param comment 必选参数,要更新的微博信息,信息内容部超过140个汉字.
             * @param cid 选填参数,要评论的评论ID.
             *
             */
            public function commentStatus(id:uint, comment:String, cid:uint=0):void
            {
                addProcessor(COMMENT_STATUS_REQUEST_URL, processComment, MicroBlogEvent.COMMENT_STATUS_RESULT, MicroBlogErrorEvent.COMMENT_STATUS_ERROR);
    
                var variable:URLVariables=new URLVariables();
                variable.id=id;
                if (comment )
                {
                    variable.comment=encodeMsg(comment);
                }
                if (cid > 0)
                {
                    variable.cid=cid;
                }
                var req:URLRequest=getMicroBlogRequest(COMMENT_STATUS_REQUEST_URL, variable, URLRequestMethod.POST);
                req.data=variable;
                executeRequest(COMMENT_STATUS_REQUEST_URL, req);
            }
    
            /**
             * 删除评论.注意:只能删除自己发布的信息.
             *
             * <p> 如果该函数被成功执行,将会抛出MicroBlogEvent事件,该事件<br/>
             * type为<b>MicroBlogEvent.DELETE_STATUS_COMMENT_RESULT</b><br/>
             * result为一个MicroBlogComment实例.</p>
             *
             * @param id 必填参数,要删除的微博评论信息ID.
             *
             */
            public function deleteComment(id:uint):void
            {
                addProcessor(DELETE_COMMENT_REQUEST_URL, processComment, MicroBlogEvent.DELETE_COMMENT_RESULT, MicroBlogErrorEvent.DELETE_COMMENT_ERROR);
                var url:String=DELETE_COMMENT_REQUEST_URL.replace("$id", id);
                var postData:URLVariables = new URLVariables();
                var req:URLRequest = getMicroBlogRequest(url, postData, URLRequestMethod.POST);
                req.data = postData;
                executeRequest(DELETE_COMMENT_REQUEST_URL, req);
            }
    
            /**
             * 对一条微博评论信息进行回复.为防止重复,发布的信息与当前最新信息一样话,将会被忽略.
             *
             * <p>如果该函数被成功执行,将会抛出MicroBlogEvent事件,该事件<br/>
             * type为<b>MicroBlogEvent.REPLY_STATUS_RESULT</b><br/>
             * result为一个MicroBlogStatus实例.</p>
             *
             * @param id 必填参数, 要评论的微博消息ID.
             * @param comment 必选参数,要更新的微博信息,信息内容部超过140个汉字.
             * @param cid 必选参数,要评论的评论ID.
             * 
             * <p>如果没有登录或超过发布上限,将返回错误
             * 系统将忽略重复发布的信息.每次发布将比较最后一条发布消息,如果一样将被忽略.因此用户不能连续提交相同信息.
             * </p>
             */
            public function replyStatus(id:uint, comment:String, cid:uint):void
            {
                addProcessor(REPLY_STATUS_REQUEST_URL, processComment, MicroBlogEvent.REPLY_STATUS_RESULT, MicroBlogErrorEvent.REPLY_STATUS_ERROR);
                var variable:URLVariables=new URLVariables();
                variable.id=id;
                if ( comment )
                {
                    variable.comment=encodeMsg(comment);
                }
                variable.cid=cid;
                var req:URLRequest=getMicroBlogRequest(REPLY_STATUS_REQUEST_URL, variable, URLRequestMethod.POST);
                req.data=variable;
                executeRequest(REPLY_STATUS_REQUEST_URL, req);
            }
    
            /**
             * 按用户UID或昵称返回用户资料,同时也将返回用户的最新发布的微博.
             *
             * <b>有请求数限制</b>
             * 
             * <p>如果该函数被成功执行,将会抛出MicroBlogEvent事件,该事件<br/>
             * type为<b>MicroBlogEvent.SHOW_USERS_RESULT</b><br/>
             * result为一个MicroBlogUser实例.</p>
             *
             * @param user 用户UID或用户帐号.
             * @param userID 指定用户UID,主要是用来区分用户UID跟用户账号一样,产生歧义的时候,特别是在用户账号为数字导致和用户Uid发生歧义.
             * @param screenName 指定微博昵称,主要是用来区分用户UID跟用户账号一样,产生歧义的时候.
             *
             * <br/>
             * <b>以上三个参数必须至少给一个</b>
             * 为了保护用户隐私,只有用户设置了公开或对粉丝设置了公开的数据才会返回.
             */
            public function loadUserInfo(user:String=null, userID:uint=0, screenName:String=null):void
            {
                addProcessor(LOAD_USER_INFO_REQUEST_URL, processUser, MicroBlogEvent.LOAD_USER_INFO_RESULT, MicroBlogErrorEvent.LOAD_USER_INFO_ERROR);
                if (user && user.length > 0)
                {
                    user="/" + user;
                }
                else
                {
                    user="";
                }
                var url:String=LOAD_USER_INFO_REQUEST_URL.replace("$user", user);
                var params:Object=new Object();
                makeUserParams(params, userID, screenName, -1);
                executeRequest(LOAD_USER_INFO_REQUEST_URL, getMicroBlogRequest(url, params, URLRequestMethod.GET));
    
            }
    
            /**
             * 返回用户关注实例列表,并返回最新微博文章.按关注人的关注时间倒序返回,
             * 每次返回100个,通过cursor参数来取得多于100的关注人.
             * 也可以通过ID,nickname,user_id参数来获取其他人的关注人列表.
             *
             * <b>有请求数限制</b>
             * 
             * <p>如果该函数被成功执行,将会抛出MicroBlogEvent事件,该事件<br/>
             * type为<b>MicroBlogEvent.FRIENDS_RESULT</b><br/>
             * result为一个MicroBlogUser数组.</p>
             *
             * @param user 用户UID或用户帐号.
             * @param userID 指定用户UID,主要是用来区分用户UID跟用户账号一样,产生歧义的时候,特别是在用户账号为数字导致和用户Uid发生歧义.
             * @param screenName 指定微博昵称,主要是用来区分用户UID跟用户账号一样,产生歧义的时候.
             * @param cursor 选填参数. 单页只能包含100个关注列表,为了获取更多则cursor默认从-1开始,通过增加或减少cursor来获取更多的关注列表.
             *
             * <p>为了保护用户隐私,只有用户设置了公开或对粉丝设置了公开的数据才会返回.</p>
             */
            public function loadFriendsInfo(user:String=null, userID:uint=0, screenName:String=null, cursor:Number=-1):void
            {
                addProcessor(LOAD_FRIENDS_INFO_REQUEST_URL, processUserArray, MicroBlogEvent.LOAD_FRIENDS_INFO_RESULT, MicroBlogErrorEvent.LOAD_FRIENDS_INFO_ERROR);
                if (user && user.length > 0)
                {
                    user="/" + user;
                }
                else
                {
                    user="";
                }
                var url:String=LOAD_FRIENDS_INFO_REQUEST_URL.replace("$user", user);
                var params:Object=new Object();
                makeUserParams(params, userID, screenName, cursor);
                executeRequest(LOAD_FRIENDS_INFO_REQUEST_URL, getMicroBlogRequest(url, params, URLRequestMethod.GET));
            }
    
            /**
             * 返回用户的粉丝列表,并返回粉丝的最新微博.按粉丝的关注时间倒序返回,
             * 每次返回100个,通过cursor参数来取得多于100的粉丝.
             *
             * <b>有请求数限制</b>
             * 
             * <p>如果该函数被成功执行,将会抛出MicroBlogEvent事件,该事件<br/>
             * type为<b>MicroBlogEvent.FOLLOWERS_RESULT</b><br/>
             * result为一个MicroBlogUser数组.</p>
             *
             * @param user 用户UID或用户帐号.
             * @param userID 指定用户UID,主要是用来区分用户UID跟用户账号一样,产生歧义的时候,特别是在用户账号为数字导致和用户Uid发生歧义.
             * @param screenName 指定微博昵称,主要是用来区分用户UID跟用户账号一样,产生歧义的时候.
             * @param cursor 选填参数. 单页只能包含100个关注列表,为了获取更多则cursor默认从-1开始,通过增加或减少cursor来获取更多的关注列表.
             *
             * <p>为了保护用户隐私,只有用户设置了公开或对粉丝设置了公开的数据才会返回.</p>
             */
            public function loadFollowersInfo(user:String=null, userID:uint=0, screenName:String=null, cursor:int=-1):void
            {
                addProcessor(LOAD_FOLLOWERS_INFO_REQUEST_URL, processUserArray, MicroBlogEvent.LOAD_FOLLOWERS_INFO_RESULT, MicroBlogErrorEvent.LOAD_FOLLOWERS_INFO_ERROR);
                if (user && user.length > 0)
                {
                    user="/" + user;
                }
                else
                {
                    user="";
                }
                var url:String=LOAD_FOLLOWERS_INFO_REQUEST_URL.replace("$user", user);
                var params:Object=new Object();
                makeUserParams(params, userID, screenName, cursor);
                executeRequest(LOAD_FOLLOWERS_INFO_REQUEST_URL, getMicroBlogRequest(url, params, URLRequestMethod.GET));
            }
    
            /**
             * 返回用户的最新n条私信.
             *
             * <b>有请求数限制</b>
             * 
             * <p> 如果该函数被成功执行,将会抛出MicroBlogEvent事件,该事件<br/>
             * type为<b>MicroBlogEvent.DIRECT_MESSAGES_RESULT</b><br/>
             * result为一个MicroBlogDirectMessage数组.</p>
             *
             * @param sinceID 请求大于该id的所有消息更新,默认值为0,表示不限制.
             * @param maxID 请求小于该id的所有消息更新,默认为0,表示不限制.
             * @param count 请求的页大小,即一页包含多少条记录;默认值0,表示使用服务器默认分页大小.
             * @param page 请求的页序号,默认值0,返回第一页.
             *
             * <p>为了保护用户隐私,只有用户设置了公开或对粉丝设置了公开的数据才会返回.</p>
             */
            public function loadDirectMessagesReceived(sinceID:uint=0, maxID:uint=0, count:uint=0, page:uint=0):void
            {
                addProcessor(LOAD_DIRECT_MESSAGES_RECEIVED_REQUEST_URL, processDirectMessageArray, MicroBlogEvent.LOAD_DIRECT_MESSAGES_RECEIVED_RESULT, MicroBlogErrorEvent.LOAD_DIRECT_MESSAGES_RECEIVED_ERROR);
                var url:String=LOAD_DIRECT_MESSAGES_RECEIVED_REQUEST_URL;
                var params:Object=new Object();
                makeQueryCombinatory(params, sinceID, maxID, count, page);
                executeRequest(LOAD_DIRECT_MESSAGES_RECEIVED_REQUEST_URL, getMicroBlogRequest(url, params, URLRequestMethod.GET));
            }
    
            /**
             * 返回登录用户已发送最新n条私信.
             *
             * <b>有请求数限制</b>
             * 
             * <p> 如果该函数被成功执行,将会抛出MicroBlogEvent事件,该事件<br/>
             * type为<b>MicroBlogEvent.SENT_DIRECT_MESSAGES_RESULT</b><br/>
             * result为一个MicroBlogDirectMessage数组.</p>
             *
             * @param sinceID 请求大于该id的所有消息更新,默认值为0,表示不限制.
             * @param maxID 请求小于该id的所有消息更新,默认为0,表示不限制.
             * @param count 请求的页大小,即一页包含多少条记录;默认值0,表示使用服务器默认分页大小.
             * @param page 请求的页序号,默认值0,返回第一页.
             *
             * <p>为了保护用户隐私,只有用户设置了公开或对粉丝设置了公开的数据才会返回.</p>
             */
            public function loadDirectMessagesSent(sinceID:uint=0, maxID:uint=0, count:uint=0, page:uint=0):void
            {
                addProcessor(LOAD_DIRECT_MESSAGES_SENT_REQUEST_URL, processDirectMessageArray, MicroBlogEvent.LOAD_DIRECT_MESSAGES_SENT_RESULT, MicroBlogErrorEvent.LOAD_DIRECT_MESSAGES_SENT_ERROR);
                var url:String=LOAD_DIRECT_MESSAGES_SENT_REQUEST_URL;
                var params:Object=new Object();
                makeQueryCombinatory(params, sinceID, maxID, count, page);
                
                executeRequest(LOAD_DIRECT_MESSAGES_SENT_REQUEST_URL, getMicroBlogRequest(url, params, URLRequestMethod.GET));
            }
    
            /**
             * 返发送一条私信.必须包含参数user和message,
             * userID和screenName必须选一个.
             *
             * <p>如果该函数被成功执行,将会抛出MicroBlogEvent事件,该事件<br/>
             * type为<b>MicroBlogEvent.NEW_DIRECT_MESSAGES_RESULT</b><br/>
             * result为一个MicroBlogDirectMessage实例.</p>
             *
             * @param user 用户UID或用户帐号.
             * @param message 必须参数. 要发生的消息内容,文本大小必须小于140个汉字.
             * @param userID 指定用户UID,主要是用来区分用户UID跟用户账号一样,产生歧义的时候,特别是在用户账号为数字导致和用户Uid发生歧义.
             * @param screenName 指定微博昵称,主要是用来区分用户UID跟用户账号一样,产生歧义的时候.
             *
             */
            public function sendDirectMessage(user:String, message:String, userID:uint=0, screenName:String=null):void
            {
                //curl -u user:password -d "text=all your bases are belong to us&user=user_2" http://api.t.sina.com.cn/direct_messages/new.xml
                addProcessor(SEND_DIRECT_MESSAGE_REQUEST_URL, processDirectMessage, MicroBlogEvent.SEND_DIRECT_MESSAGE_RESULT, MicroBlogErrorEvent.SEND_DIRECT_MESSAGE_ERROR);
                if (userID == 0 && screenName == null)
                {
                    var e:MicroBlogErrorEvent=new MicroBlogErrorEvent(MicroBlogErrorEvent.SEND_DIRECT_MESSAGE_ERROR);
                    e.message="参数错误";
                    dispatchEvent(e);
                }
    
                var data:URLVariables=new URLVariables();
                if (userID > 0)
                {
                    data.user_id=userID;
                }
                if (screenName)
                {
                    data.screen_name=screenName;
                }
                data.id = user;
                data.text = encodeMsg(message);
                var req:URLRequest=getMicroBlogRequest(SEND_DIRECT_MESSAGE_REQUEST_URL, data, URLRequestMethod.POST);
                req.data=data;
                executeRequest(SEND_DIRECT_MESSAGE_REQUEST_URL, req);
            }
    
            /**
             * 按ID删除私信.操作用户必须为私信的接收人.
             *
             * <p>如果该函数被成功执行,将会抛出MicroBlogEvent事件,该事件<br/>
             * type为<b>MicroBlogEvent.DELETE_DIRECT_MESSAGES_RESULT</b><br/>
             * result为一个MicroBlogDirectMessage实例.</p>
             *
             * @param id 必填参数,要删除的私信主键ID.
             *
             */
            public function deleteDirectMessage(id:uint):void
            {
                //curl -u user:password --http-request DELETE http://api.t.sina.com.cn/direct_messages/destroy/88619848.xml
                addProcessor(DELETE_DIRECT_MESSAGE_REQUEST_URL, processDirectMessage, MicroBlogEvent.DELETE_DIRECT_MESSAGE_RESULT, MicroBlogErrorEvent.DELETE_DIRECT_MESSAGE_ERROR);
                var url:String=DELETE_DIRECT_MESSAGE_REQUEST_URL.replace("$id", id);
                var postData:URLVariables = new URLVariables();
                var req:URLRequest = getMicroBlogRequest(url, postData, URLRequestMethod.POST);
                req.data = postData;
                executeRequest(DELETE_DIRECT_MESSAGE_REQUEST_URL, req);
            }
    
            /**
             * 关注一个用户.成功则返回关注人的资料,
             * 失败则返回一条字符串的说明.
             *
             * <p> 如果该函数被成功执行,将会抛出MicroBlogEvent事件,该事件<br/>
             * type为<b>MicroBlogEvent.CREATE_FRIENDSHIPS_RESULT</b><br/>
             * result为一个MicroBlogUser实例.</p>
             *
             * @param user 用户UID或用户帐号.
             * @param userID 主要是用来区分用户UID跟用户账号一样,产生歧义的时候,特别是在用户账号为数字导致和用户Uid发生歧义.
             * @param screenName 指定微博昵称,主要是用来区分用户UID跟用户账号一样,产生歧义的时候.
             * @param isFollow 可选参数.将是自己粉丝的用户加为关注.
             *
             */
            public function follow(user:String, userID:uint, screenName:String, isFollow:Boolean=true):void
            {
                //TO-DO: if the parameter equals to zero, don't include this parameter when build request url.
                addProcessor(FOLLOW_REQUEST_URL, processUser, MicroBlogEvent.FOLLOW_RESULT, MicroBlogErrorEvent.FOLLOW_ERROR);
                if (user && user.length > 0)
                {
                    user="/" + user;
                } else
                {
                    user="";
                }
                var url:String=FOLLOW_REQUEST_URL.replace("$user", user);
                var params:URLVariables=new URLVariables();
                if ( userID > 0 )
                {
                    params.user_id = userID;
                }
                if ( screenName && screenName.length > 0 )
                {
                    params.screen_name = screenName;
                }
                params.follow = isFollow;
                
                var req:URLRequest=getMicroBlogRequest(url, params, URLRequestMethod.POST);
                req.data = params;
                executeRequest(FOLLOW_REQUEST_URL, req);
            }
    
            /**
             * 取消关注某用户.成功则返回被取消关注人的资料,
             * 失败则返回一条字符串的说明.
             *
             * <p>如果该函数被成功执行,将会抛出MicroBlogEvent事件,该事件<br/>
             * type为<b>MicroBlogEvent.DESTROY_FRIENDSHIPS_RESULT</b><br/>
             * result为一个MicroBlogUser实例.</p>
             *
             * @param user 用户UID或用户帐号.
             * @param userID 主要是用来区分用户UID跟用户账号一样,产生歧义的时候,特别是在用户账号为数字导致和用户Uid发生歧义.
             * @param screenName 指定微博昵称,主要是用来区分用户UID跟用户账号一样,产生歧义的时候.
             *
             */
            public function cancelFollowing(user:String, userID:uint, screenName:String):void
            {
                //TO-DO: if the parameter equals to zero, don't include this parameter when build request url.
                addProcessor(CANCEL_FOLLOWING_REQUEST_URL, processUser, MicroBlogEvent.CANCEL_FOLLOWING_RESULT, MicroBlogErrorEvent.CANCEL_FOLLOWING_ERROR);
                if (user && user.length > 0)
                {
                    user="/" + user;
                } else
                {
                    user="";
                }
                var url:String=CANCEL_FOLLOWING_REQUEST_URL.replace("$user", user);
                var params:URLVariables=new URLVariables();
                if ( userID > 0 )
                {
                    params.user_id = userID;
                }
                if ( screenName && screenName.length > 0 )
                {
                    params.screen_name = screenName;
                }
                
                var req:URLRequest=getMicroBlogRequest(url, params, URLRequestMethod.POST);
                req.data = params;
                executeRequest(CANCEL_FOLLOWING_REQUEST_URL, req);
            }
    
            /**
             * 返回两个用户关系的详细情况.
             *
             * <b>有请求数限制</b>
             * 
             * <p>如果该函数被成功执行,将会抛出MicroBlogEvent事件,该事件<br/>
             * type为<b>MicroBlogEvent.CHECK_FRIENDSHIPS_RESULT</b><br/>
             * result为<code>MicroBlogUsersRelationship</code>值.</p>
             *
             * @param targetID 选填参数,要判断的目标用户的uid.
             * @param targetScreenName  选填参数,要判断的目标用户的昵称.targetID和targetScreenName两个参数必须填一个.
             * @param sourceID 选填参数,要判断的源用户的uid
             * @param sourceScreenName 选填参数,要判断的源用户的昵称.如果sourceID和sourceScreenName均未填,则以当前用户为源用户
             *
             */
            public function checkIsFollowing(targetID:uint=0, targetScreenName:String=null, sourceID:uint=0, sourceScreenName:String=null):void
            {
                addProcessor(CHECK_IS_FOLLOWING_REQUEST_URL, processRelationship, MicroBlogEvent.CHECK_IS_FOLLOWING_RESULT, MicroBlogErrorEvent.CHECK_IS_FOLLOWING_ERROR);
                var params:Object=new Object();
                var needExecute:Boolean=false;
                if (targetID > 0)
                {
                    params[TARGET_ID]=targetID;
                    needExecute=true;
                }
                if (targetScreenName && targetScreenName.length > 0)
                {
                    params[TARGET_SCREEN_NAME]=StringEncoders.urlEncodeUtf8String(targetScreenName);
                    needExecute=true;
                }
                if (!needExecute)
                {
                    return;
                }
                if (sourceID > 0)
                {
                    params[SOURCE_ID]=sourceID;
                }
                if (sourceScreenName && sourceScreenName.length > 0)
                {
                    params[SOURCE_SCREEN_NAME]=StringEncoders.urlEncodeUtf8String(sourceScreenName);
                }
                var url:String=CHECK_IS_FOLLOWING_REQUEST_URL;
                executeRequest(CHECK_IS_FOLLOWING_REQUEST_URL,getMicroBlogRequest(url, params, URLRequestMethod.GET));
            }
    
            /**
             * 返回用户关注对象的user_id列表.
             *
             * <b>有请求数限制</b>
             * 
             * <p>如果该函数被成功执行,将会抛出MicroBlogEvent事件,该事件<br/>
             * type为<b>MicroBlogEvent.LOAD_FRIENDS_ID_LIST_RESULT</b><br/>
             * result为<code>uint数组</code>实例.</p>
             *
             * <p>如果该函数调用失败,将会抛出MicroBlogErrorEvent事件,该事件<br/>
             * type为<b>MicroErrorEvent.LOAD_FRIENDS_ID_LIST_ERROR</b><br/>
             * message为错误描述.</p>
             *
             * @param user 用户UID或用户帐号.
             * @param userID 主要是用来区分用户UID跟用户账号一样,产生歧义的时候,特别是在用户账号为数字导致和用户Uid发生歧义.
             * @param screenName 指定微博昵称,主要是用来区分用户UID跟用户账号一样,产生歧义的时候.
             * @param cursor 选填参数. 单页只能包含5000个id,为了获取更多则cursor默认从-1开始,通过增加或减少cursor来获取更多的关注列表.
             * @param count 可选参数. 每次返回的最大记录数(即页面大小),不大于5000。
             */
            public function loadFriendsIDList(user:String, userID:uint=0, screenName:String=null, cursor:Number=-1, count:uint=5000):void
            {
                addProcessor(LOAD_FRIENDS_ID_LIST_REQUEST_URL, processIDSArray, MicroBlogEvent.LOAD_FRIENDS_ID_LIST_RESULT, MicroBlogErrorEvent.LOAD_FRIENDS_ID_LIST_ERROR);
                if (user && user.length > 0)
                {
                    user="/" + user;
                }
                else
                {
                    user="";
                }
                var url:String=LOAD_FRIENDS_ID_LIST_REQUEST_URL.replace("$user", user);
                var params:Object=new Object();
                makeUserParams(params, userID, screenName, cursor);
                params["count"] = count;
                executeRequest(LOAD_FRIENDS_ID_LIST_REQUEST_URL, getMicroBlogRequest(url, params, URLRequestMethod.GET));
            }
    
            /**
             * 返回用户粉丝的user_id列表.
             *
             * <b>有请求数限制</b>
             * 
             * <p>如果该函数被成功执行,将会抛出MicroBlogEvent事件,该事件<br/>
             * type为<b>MicroBlogEvent.LOAD_FOLLOWERS_ID_LIST_RESULT</b><br/>
             * result为<code>uint数组</code>实例.</p>
             *
             * <p>如果该函数调用失败,将会抛出MicroBlogErrorEvent事件,该事件<br/>
             * type为<b>MicroErrorEvent.LOAD_FOLLOWERS_ID_LIST_ERROR</b><br/>
             * message为错误描述.</p>
             *
             * @param user 用户UID或用户帐号.
             * @param userID 主要是用来区分用户UID跟用户账号一样,产生歧义的时候,特别是在用户账号为数字导致和用户Uid发生歧义.
             * @param screenName 指定微博昵称,主要是用来区分用户UID跟用户账号一样,产生歧义的时候.
             * @param cursor 选填参数. 单页只能包含5000个id,为了获取更多则cursor默认从-1开始,通过增加或减少cursor来获取更多的关注列表.
             * @param count 可选参数. 每次返回的最大记录数(即页面大小),不大于5000。
             */
            public function loadFollowersIDList(user:String, userID:uint=0, screenName:String=null, cursor:Number=-1, count:uint=5000):void
            {
                addProcessor(LOAD_FOLLOWERS_ID_LIST_REQUEST_URL, processIDSArray, MicroBlogEvent.LOAD_FOLLOWERS_ID_LIST_RESULT, MicroBlogErrorEvent.LOAD_FOLLOWERS_ID_LIST_ERROR);
                if (user && user.length>0)
                {
                    user="/" + user;
                }
                else
                {
                    user="";
                }
                var url:String=LOAD_FOLLOWERS_ID_LIST_REQUEST_URL.replace("$user", user);
                var params:Object=new Object();
                makeUserParams(params, userID, screenName, cursor);
                params["count"]=count;
                executeRequest(LOAD_FOLLOWERS_ID_LIST_REQUEST_URL, getMicroBlogRequest(url, params, URLRequestMethod.GET));
            }
    
            /**
             * 判断用户身份是否合法.
             *
             * <b>有请求数限制</b>
             * 
             * <p>如果该函数被成功执行,将会抛出MicroBlogEvent事件,该事件<br/>
             * type为<b>MicroBlogEvent.VERIFY_CREDENTIALS_RESULT</b><br/>
             * result为<code>MicroBlogUser</code>实例.</p>
             *
             * <p>如果该函数调用失败,将会抛出MicroBlogErrorEvent事件,该事件<br/>
             * type为<b>MicroErrorEvent.VERIFY_CREDENTIALS_ERROR</b><br/>
             * message为错误描述.</p>
             *
             */
            public function verifyCredentials():void
            {
                //TO-DO: if the parameter equals to zero, don't include this parameter when build request url.
                //curl -u user:password http://api.t.sina.com.cn/account/verify_credentials.xml
                addProcessor(VERIFY_CREDENTIALS_REQUEST_URL, processUser, MicroBlogEvent.VERIFY_CREDENTIALS_RESULT, MicroBlogErrorEvent.VERIFY_CREDENTIALS_ERROR);
                executeRequest(VERIFY_CREDENTIALS_REQUEST_URL, getMicroBlogRequest(VERIFY_CREDENTIALS_REQUEST_URL, null));
            }
    
            /**
             * 获取当前的API调用次数限制.
             *
             * <b>有请求数限制</b>
             * 
             * <p>如果该函数被成功执行,将会抛出MicroBlogEvent事件,该事件<br/>
             * type为<b>MicroBlogEvent.RATE_LIMIT_INFO_RESULT</b><br/>
             * result为<code>MicroBlogRateInfo</code>实例.</p>
             *
             * <p>如果该函数调用失败,将会抛出MicroBlogErrorEvent事件,该事件<br/>
             * type为<b>MicroErrorEvent.RATE_LIMIT_INFO_ERROR</b><br/>
             * message为错误描述.</p>
             *
             */
            public function getRateLimitInfo():void
            {
                //curl -u user:password http://api.t.sina.com.cn/account/rate_limit_status.xml
                addProcessor(GET_RATE_LIMIT_STATUS_REQUEST_URL, processRateLimit, MicroBlogEvent.GET_RATE_LIMIT_STATUS_RESULT, MicroBlogErrorEvent.GET_RATE_LIMIT_STATUS_ERROR);
                executeRequest(GET_RATE_LIMIT_STATUS_REQUEST_URL, getMicroBlogRequest(GET_RATE_LIMIT_STATUS_REQUEST_URL, null) );
            }
    
            /**
             * 登陆用户退出.
             *
             * <p>如果该函数被成功执行,将会抛出MicroBlogEvent事件,该事件<br/>
             * type为<b>MicroBlogEvent.LOGOUT_RESULT</b><br/></p>
             *
             * <p>如果该函数调用失败,将会抛出MicroBlogErrorEvent事件,该事件<br/>
             * type为<b>MicroErrorEvent.LOGOUT_ERROR</b><br/>
             * message为错误描述.</p>
             *
             */
            public function logout():void
            {
                //curl -u user:password -d "" http://api.t.sina.com.cn/account/end_session.xml
                addProcessor(LOGOUT_REQUEST_URL, processLogout, MicroBlogEvent.LOGOUT_RESULT, MicroBlogErrorEvent.LOGOUT_ERROR);
                var postData:URLVariables = new URLVariables();
                postData.source = "air client";
                var req:URLRequest = getMicroBlogRequest(LOGOUT_REQUEST_URL, postData, URLRequestMethod.POST);
                req.data = postData;
                executeRequest(LOGOUT_REQUEST_URL, req );
            }
    
    
            /**
             * 用户可以通过此接口来更新头像.
             *
             * <p>如果该函数被成功执行,将会抛出MicroBlogEvent事件,该事件<br/>
             * type为<b>MicroBlogEvent.UPDATE_PROFILE_IMAGE_RESULT</b><br/>
             * result为一个MicroBlogUser实例.</p>
             *
             * <p>如果该函数调用失败,将会抛出MicroBlogErrorEvent事件,该事件<br/>
             * type为<b>MicroErrorEvent.UPDATE_PROFILE_IMAGE_ERROR</b><br/>
             * message为错误描述.</p>
             *
             * @param imgData  必须为小于700K的有效的GIF, JPG, 或 PNG 图片. 如果图片大于500像素将按比例缩放
             *
             */
            public function updateProfileImage(imgData:ByteArray, filename:String):void
            {
                //TO-DO: Need to be verified.
                addProcessor(UPDATE_PROFILE_IMAGE_REQUEST_URL, processUser, MicroBlogEvent.UPDATE_PROFILE_IMAGE_RESULT, MicroBlogErrorEvent.UPDATE_PROFILE_IMAGE_ERROR);
                var boundary:String=makeBoundary();
                var postData:Object = {image:imgData};
                var req:URLRequest=getMicroBlogRequest(UPDATE_PROFILE_IMAGE_REQUEST_URL, postData, URLRequestMethod.POST);
                delete postData["image"];
                req.contentType=MULTIPART_FORMDATA + boundary;
                req.data=makeMultipartPostData(boundary, "image", filename, imgData, postData);
                executeRequest(UPDATE_PROFILE_IMAGE_REQUEST_URL, req);
            }
    
            /**
             * 用户可以通过此接口来更改微博信息的来源.用于无法传递ByteArray为参数的情况.
             *
             * <p>如果图片上传成功,将会抛出MicroBlogEvent事件,该事件<br/>
             * type为<b>MicroBlogEvent.UPDATE_DELIVERY_DEVICE_RESULT</b><br/>
             * result为一个MicroBlogUser实例.</p>
             *
             * <p>如果图片上传失败,将会抛出MicroBlogErrorEvent事件,该事件<br/>
             * type为<b>MicroErrorEvent.UPDATE_DELIVERY_DEVICE_ERROR</b><br/>
             * message为错误描述.</p>
             *
             * @return 返回用于上传图片的URLRequest.用于在flash中用File对象上传图片,在调用File对象的upload时uploadDataFieldName必须为image
             *
             */
            public function getUpdateProfileImageRequest():URLRequest
            {
                addProcessor(UPDATE_PROFILE_IMAGE_REQUEST_URL, processUser, MicroBlogEvent.UPDATE_PROFILE_IMAGE_RESULT, MicroBlogErrorEvent.UPDATE_PROFILE_IMAGE_ERROR);
                var postData:URLVariables = new URLVariables();
                var req:URLRequest=getMicroBlogRequest(UPDATE_PROFILE_IMAGE_REQUEST_URL, postData, URLRequestMethod.POST);
                req.data=postData;
                return req;
            }
    
            /**
             * 用户可以通过此接口来更新微博页面参数.
             *
             * <p>如果该函数被成功执行,将会抛出MicroBlogEvent事件,该事件<br/>
             * type为<b>MicroBlogEvent.UPDATE_PROFILE_RESULT</b><br/>
             * result为一个MicroBlogUser实例.</p>
             *
             * <p>如果该函数调用失败,将会抛出MicroBlogErrorEvent事件,该事件<br/>
             * type为<b>MicroErrorEvent.UPDATE_PROFILE_ERROR</b><br/>
             * message为错误描述.</p>
             *
             * @param params MicroBlogProfileUpdateParams对象,用于更新个人设置@see com.sina.microblog.data.MicroBlogProfileUpdateParams.
             *
             *
             */
            public function updateProfile(params:MicroBlogProfileUpdateParams):void
            {
                //curl -u user:password -d "update_delivery_device=none" http://api.t.sina.com.cn/account/update_profile_colors.xml
                addProcessor(UPDATE_PROFILE_REQUEST_URL, processUser, MicroBlogEvent.UPDATE_PROFILE_RESULT, MicroBlogErrorEvent.UPDATE_PROFILE_ERROR);
                if (null==params || params.isEmpty)
                {
                    return;
                }
                var postData:URLVariables = params.postData;
                var req:URLRequest=getMicroBlogRequest(UPDATE_PROFILE_REQUEST_URL, postData, URLRequestMethod.POST);
                req.data=postData;
                executeRequest(UPDATE_PROFILE_REQUEST_URL, req);
            }
    
            /**
             * 返回用户的最近20条收藏信息,和用户收藏页面返回内容是一致的.
             *
             * <b>有请求数限制</b>
             * 
             * <p>如果该函数被成功执行,将会抛出MicroBlogEvent事件,该事件<br/>
             * type为<b>MicroBlogEvent.LOAD_FAVORIT_LIST_RESULT</b><br/>
             * result为一个MicroBlogStatus对象数组.</p>
             *
             * <p>如果该函数调用失败,将会抛出MicroBlogErrorEvent事件,该事件<br/>
             * type为<b>MicroErrorEvent.LOAD_FAVORIT_LIST_ERROR</b><br/>
             * message为错误描述.</p>
             *
             * @param page  可选参数. 返回结果的页序号。注意:有分页限制.
             *
             *
             */
            public function loadFavoriteList(page:uint=0):void
            {
                addProcessor(LOAD_FAVORITE_LIST_REQUEST_URL, processStatusArray, MicroBlogEvent.LOAD_FAVORITE_LIST_RESULT, MicroBlogErrorEvent.LOAD_FAVORITE_LIST_ERROR);
        
                var url:String=LOAD_FAVORITE_LIST_REQUEST_URL;
                var params:Object=new Object();
                if ( page > 0 )
                {
                    params["page"]=page.toString();
                }
                executeRequest(LOAD_FAVORITE_LIST_REQUEST_URL, getMicroBlogRequest(url, params, URLRequestMethod.GET));
            }
    
            /**
             * 收藏一条微博信息.
             *
             * <p>如果该函数被成功执行,将会抛出MicroBlogEvent事件,该事件<br/>
             * type为<b>MicroBlogEvent.ADD_TO_FAVORITES_RESULT</b><br/>
             * result为一个MicroBlogStatus对象.</p>
             *
             * <p>如果该函数调用失败,将会抛出MicroBlogErrorEvent事件,该事件<br/>
             * type为<b>MicroErrorEvent.ADD_TO_FAVORITES_ERROR</b><br/>
             * message为错误描述.</p>
             *
             * @param statusID 必填参数, 要收藏的微博id.
             *
             */
            public function addToFavorites(statusID:uint):void
            {
                if ( statusID <= 0 )
                {
                    return;
                }
                addProcessor(ADD_TO_FAVORITES_REQUEST_URL, processStatus, MicroBlogEvent.ADD_TO_FAVORITES_RESULT, MicroBlogErrorEvent.ADD_TO_FAVORITES_ERROR);
    
                var postData:URLVariables=new URLVariables();
                postData.id=statusID.toString();
                var req:URLRequest=getMicroBlogRequest(ADD_TO_FAVORITES_REQUEST_URL, postData, URLRequestMethod.POST);
                req.data=postData;
                executeRequest(ADD_TO_FAVORITES_REQUEST_URL, req);
            }
    
            /**
             * 从收藏列表里删除一条微博信息.
             *
             * <p>如果该函数被成功执行,将会抛出MicroBlogEvent事件,该事件<br/>
             * type为<b>MicroBlogEvent.ADD_TO_FAVORITES_RESULT</b><br/>
             * result为一个MicroBlogStatus对象.</p>
             *
             * <p>如果该函数调用失败,将会抛出MicroBlogErrorEvent事件,该事件<br/>
             * type为<b>MicroErrorEvent.ADD_TO_FAVORITES_ERROR</b><br/>
             * message为错误描述.</p>
             *
             * @param statusID 必填参数, 要收藏的微博id.
             *
             */
            public function removeFromFavorites(statusID:uint):void
            {
                if ( statusID <= 0)
                {
                    return;
                }
                addProcessor(REMOVE_FROM_FAVORITES_REQUEST_URL, processStatus, MicroBlogEvent.REMOVE_FROM_FAVORITES_RESULT, MicroBlogErrorEvent.REMOVE_FROM_FAVORITES_ERROR);
                var postData:URLVariables = new URLVariables();
                var req:URLRequest=getMicroBlogRequest(REMOVE_FROM_FAVORITES_REQUEST_URL.replace("$id", statusID), postData, URLRequestMethod.POST);
                req.data = postData;
                executeRequest(REMOVE_FROM_FAVORITES_REQUEST_URL, req);
            }
    
    //        /**
    //         * 允许/禁止通知更新给指定用户.
    //         *
    //         * <b>有请求数限制</b>
    //         * 
    //         * <p>如果该函数被成功执行,将会抛出MicroBlogEvent事件,该事件<br/>
    //         * type为<b>MicroBlogEvent.FOLLOW_NOTIFICATION_RESULT</b><br/>
    //         * result为一个MicroBlogUser对象.</p>
    //         *
    //         * <p>如果该函数调用失败,将会抛出MicroBlogErrorEvent事件,该事件<br/>
    //         * type为<b>MicroErrorEvent.FOLLOW_NOTIFICATION_ERROR</b><br/>
    //         * message为错误描述.</p>
    //         *
    //         * @param isEnable 必选参数
    //         * @param user 指定的用户ID或用户帐号.
    //         * @param page  指定的用户UID.
    //         * @param screenName 指定的用户帐号
    //         *
    //         * 以上三个可选参数必须设置一个
    //         *
    //         */
    //        public function enableNotification(isEnable:Boolean, user:String=null, userID:uint=0, screenName:String=null):void
    //        {
    //            addProcessor(ENABLE_NOTIFICATION_REQUEST_URL, processUser, MicroBlogEvent.ENABLE_NOTIFICATION_RESULT, MicroBlogErrorEvent.ENABLE_NOTIFICATION_ERROR);
    //            var hasParam:Boolean=false;
    //            if (user && user.length > 0)
    //            {
    //                user="/" + user;
    //                hasParam=true;
    //            }
    //            else
    //            {
    //                user="";
    //            }
    //            var url:String;
    //            if (isEnable)
    //            {
    //                url=ENABLE_NOTIFICATION_REQUEST_URL.replace("$enabled", "follow");
    //            }
    //            else
    //            {
    //                url=ENABLE_NOTIFICATION_REQUEST_URL.replace("$enabled", "leave");
    //            }
    //            url=url.replace("$user", user);
    //            var postData:URLVariables=new URLVariables();
    //            if (userID > 0)
    //            {
    //                postData.user_id=userID;
    //                hasParam=true;
    //            }
    //            if (screenName && screenName.length > 0)
    //            {
    //                postData.screen_name=StringEncoders.urlEncodeUtf8String(screenName);
    //                hasParam=true;
    //            }
    //            if (!hasParam)
    //            {
    //                return;
    //            }
    //            var req:URLRequest=getMicroBlogRequest(url, postData, URLRequestMethod.POST);
    //            req.data=postData;
    //            executeRequest(ENABLE_NOTIFICATION_REQUEST_URL, req);
    //        }
    //        
            /**
             * 返回省份,城市的名字对应id的列表,为xml格式.
             *
             * <b>有请求数限制</b>
             * 
             * <p>如果该函数被成功执行,将会抛出MicroBlogEvent事件,该事件<br/>
             * type为<b>MicroBlogEvent.LOAD_PROVINCE_CITY_ID_LIST_RESULT</b><br/>
             * result为一个XML对象.</p>
             *
             * <p>如果该函数调用失败,将会抛出MicroBlogErrorEvent事件,该事件<br/>
             * type为<b>MicroErrorEvent.LOAD_PROVINCE_CITY_ID_LIST_ERROR</b><br/>
             * message为错误描述.</p>
             *
             * <p>返回的xml数据格式请参看新浪微博开放平台 http://open.t.sina.com.cn
             * </p>
             * 
             * <p>要想获取省份id为11,城市id为1的地址信息可以参考以下方法<br/>
             * <pre>
             * var prov:XML = provinces.province.(&#64;id == "11")[0];
             * province = prov.&#64;name;
             * city = prov.city.(&#64;id == "1")[0].&#64;name;
             * </pre>
             * 通过名字得到id可以参考如下方法<br/>
             * <pre>
             * var prov:XML = provinces.province.(&#64;name == "北京")[0];
             * provinceID = prov.&#64;id;
             * cityID = prov.city.(&#64;name == "东城区")[0].&#64;id;
             * </pre>
             * </p>
             */
            public function loadProvinceCityIDList():void
            {
                addProcessor(LOAD_PROVINCE_CITY_ID_LIST, processProvincesXML, MicroBlogEvent.LOAD_PROVINCE_CITY_ID_LIST_RESULT, MicroBlogErrorEvent.LOAD_PROVINCE_CITY_ID_LIST_ERROR);
                executeRequest(LOAD_PROVINCE_CITY_ID_LIST, getMicroBlogRequest(LOAD_PROVINCE_CITY_ID_LIST, null) );
            }
            //Event handler
    
            private function addProcessor(name:String, dataProcess:Function, resultEventType:String, errorEventType:String):void
            {
                if (null == serviceLoader[name])
                {
                    var loader:URLLoader=new URLLoader();
                    loader.addEventListener(Event.COMPLETE, loader_onComplete);
                    loader.addEventListener(IOErrorEvent.IO_ERROR, loader_onError);
                    loader.addEventListener(SecurityErrorEvent.SECURITY_ERROR, loader_onSecurityError);
                    serviceLoader[name]=loader;
                    loaderMap[loader]={dataFunc: dataProcess, resultEvent: resultEventType, errorEvent: errorEventType};
                }
            }
            
            private function executeRequest(name:String, req:URLRequest):void
            {
                var urlLoader:URLLoader = serviceLoader[name] as URLLoader;
                lastLoader = urlLoader;
                lastRequest = req;
                urlLoader.load(req);
            }
    
            private function loader_onComplete(event:Event):void
            {
                var loader:URLLoader=event.target as URLLoader;
                var processor:Object=loaderMap[loader];
                var dataStr:String = loader.data as String;
                if ( dataStr.length  <= 0 )
                {
                    var ioError:MicroBlogErrorEvent = new MicroBlogErrorEvent(MicroBlogErrorEvent.NET_WORK_ERROR);
                    ioError.message = "The network error";
                    dispatchEvent(ioError);
                    return;
                }
                var result:XML=new XML(loader.data);
                
                if (result.child("error").length() > 0)
                {
                    var error:MicroBlogErrorEvent=new MicroBlogErrorEvent(processor.errorEvent);
                    error.message="Error " + result.error_code + " : " + result.error;
                    dispatchEvent(error);
                }
                else
                {
                    var e:MicroBlogEvent=new MicroBlogEvent(processor.resultEvent);
                    e.result=processor.dataFunc(result);
                    e.nextCursor=Number(result.next_cursor);
                    e.previousCursor=Number(result.previous_cursor);
                    dispatchEvent(e);
                }
                //trace(loader.data);
            }
    
            private function loader_onError(event:IOErrorEvent):void
            {
                var loader:URLLoader=event.target as URLLoader;
                var processor:Object=loaderMap[loader];
                var error:MicroBlogErrorEvent=new MicroBlogErrorEvent(processor.errorEvent);
                error.message=event.text;
                dispatchEvent(error);
            }
    
            private function loader_onSecurityError(event:SecurityErrorEvent):void
            {
                dispatchEvent(event);
            }
    
            private function getMicroBlogRequest(url:String, params:Object, requestMethod:String="GET"):URLRequest
            {
                var req:URLRequest;
                
                if ( null == params )
                {
                    params = new Object();
                }
                params["source"] = source;
                if ( accessTokenKey.length > 0)
                {
                    req=signRequest(requestMethod, url, params, false);
                }
                else
                {
                    if (requestMethod == URLRequestMethod.GET)
                    {
                        url+=makeGETParamString(params);
                    }
                    req=new URLRequest(url);
                    if ( authHeader )
                    {
                        req.requestHeaders.push(authHeader);
                    }
                }
                req.method=requestMethod;
                return req;
            }
    
            private function processStatusArray(statuses:XML):Array
            {
                var microBlogStatus:MicroBlogStatus;
                var statusArray:Array=[];
                for each (var status:XML in statuses.status)
                {
                    microBlogStatus=new MicroBlogStatus(status);
                    statusArray.push(microBlogStatus);
                }
                return statusArray;
            }
    
            private function processStatus(status:XML):MicroBlogStatus
            {
                return new MicroBlogStatus(status);
            }
    
            private function processCommentArray(comments:XML):Array
            {
                var microBlogComment:MicroBlogComment;
                var commentArray:Array=[];
                for each (var comment:XML in comments.comment)
                {
                    microBlogComment=new MicroBlogComment(comment);
                    commentArray.push(microBlogComment);
                }
                return commentArray;
            }
    
            private function processComment(comment:XML):MicroBlogComment
            {
                return new MicroBlogComment(comment);
            }
    
            private function processCounts(counts:XML):Array
            {
                var countArray:Array=[];
                var count:MicroBlogCount;
                for each (var countValue:XML in counts.children())
                {
                    count=new MicroBlogCount(countValue);
                    countArray.push(count);
                }
                return countArray;
            }
    
            private function processUser(user:XML):MicroBlogUser
            {
                return new MicroBlogUser(user);
            }
    
            private function processUserArray(users:XML):Array
            {
                var userArray:Array=[];
                var mbUser:MicroBlogUser;
                for each (var userValue:XML in users.user)
                {
                    mbUser=new MicroBlogUser(userValue);
                    userArray.push(mbUser);
                }
                return userArray;
            }
    
            private function processDirectMessageArray(messages:XML):Array
            {
                var messageArray:Array=[];
                var mbMessage:MicroBlogDirectMessage;
                for each (var messageValue:XML in messages.direct_message)
                {
                    mbMessage=new MicroBlogDirectMessage(messageValue);
                    messageArray.push(mbMessage);
                }
                return messageArray;
            }
    
            private function processDirectMessage(message:XML):MicroBlogDirectMessage
            {
                return new MicroBlogDirectMessage(message);
            }
    
    //        private function processBoolean(message:XML):Boolean
    //        {
    //            return message.toString() == "true";
    //        }
    
            private function processRelationship(message:XML):MicroBlogUsersRelationship
            {
                return new MicroBlogUsersRelationship(message);
            }
    
            private function processIDSArray(message:XML):Array
            {
                var ar:Array=[];
                for each (var id:XML in message.ids[0].children())
                {
                    ar.push(uint(id.toString()));
                }
                return ar;
            }
            private function processRateLimit(message:XML):MicroBlogRateLimit
            {
                return new MicroBlogRateLimit(message);
            }
            private function processLogout(user:XML):MicroBlogUser
            {
                _accessTokenKey = "";
                _accessTokenSecret = "";
                authHeader = null;
                return new MicroBlogUser(user);
            }
            private function processProvincesXML(result:XML):XML
            {
                return result;
            }
            private function makeGETParamString(parameters:Object):String
            {
                var paramStr:String=makeParamsToUrlString(parameters);
                if (paramStr.length > 0)
                {
                    paramStr="?" + paramStr;
                }
                return paramStr;
            }
    
            private function makeQueryCombinatory(params:Object, sinceID:uint, maxID:uint, count:uint, page:uint):void
            {
    
                if (sinceID > 0)
                {
                    params[SINCE_ID]=sinceID;
    
                }
                if (maxID > 0)
                {
                    params[MAX_ID]=maxID;
    
                }
                if (count > 0)
                {
                    params[COUNT]=count;
    
                }
                if (page > 0)
                {
                    params[PAGE]=page;
                }
    
            }
    
            private function makeUserParams(params:Object, userID:uint, screenName:String, cursor:Number):void
            {
    
                if (userID > 0)
                {
                    params[USER_ID]=userID;
    
                }
                if (screenName)
                {
                    params[SCREEN_NAME]=screenName;
    
                }
                if (cursor >= 0)
                {
                    params[CURSOR]=cursor;
    
                }
    
            }
    
            private function makeBoundary():String
            {
                var boundary:String="";
    
                for (var i:int=0; i < 13; i++)
                {
                    boundary+=String.fromCharCode(int(97 + Math.random() * 25));
                }
                boundary="---------------------------" + boundary;
    
                return boundary;
            }
    
            private function encodeMsg(status:String):String
            {
                return StringEncoders.urlEncodeSpecial(status);
            }
    
            private function makeMultipartPostData(boundary:String, imgFieldName:String, filename:String, imgData:ByteArray, params:Object):Object
            {
                var req:URLRequest=new URLRequest();
                var postData:ByteArray=new ByteArray();
                postData.endian=Endian.BIG_ENDIAN;
                var value:String;
    
                //add params to the post data.
                if (params)
                {
                    for (var name:String in params)
                    {
                        boundaryPostData(postData, boundary);
                        addLineBreak(postData);
                        //writeStringToByteArray(postData, CONTENT_DISPOSITION_BASIC.replace("$name", name));
                        postData.writeUTFBytes(CONTENT_DISPOSITION_BASIC.replace("$name", name));
                        addLineBreak(postData);
                        addLineBreak(postData);
                        postData.writeUTFBytes(params[name]);
                        addLineBreak(postData);
                    }
                }
                //add image;
    //            --BbC04y
    //            Content-Disposition: file; filename="file2.jpg"
    //            Content-Type: image/jpeg
    //            Content-Transfer-Encoding: binary
    //            
    //            ...contents of file2.jpg...
    //            --BbC04y--
    
                boundaryPostData(postData, boundary);
                addLineBreak(postData);
                //writeStringToByteArray(postData, CONTENT_DISPOSITION_BASIC.replace("$name", "files") + '; filename="'+filename + '"');
                postData.writeUTFBytes(CONTENT_DISPOSITION_BASIC.replace("$name", imgFieldName) + '; filename="' + filename + '"');
                addLineBreak(postData);
                //writeStringToByteArray(postData, CONTENT_TYPE_JPEG);
                postData.writeUTFBytes(CONTENT_TYPE_JPEG);
                addLineBreak(postData);
                //writeStringToByteArray(postData,CONTENT_TRANSFER_ENCODING);
                //postData.writeUTFBytes(CONTENT_TRANSFER_ENCODING);
                //addLineBreak(postData);
                addLineBreak(postData);
                postData.writeBytes(imgData, 0, imgData.length);
                addLineBreak(postData);
    
                boundaryPostData(postData, boundary);
                addDoubleDash(postData);
    
                trace(postData.toString());
                postData.position=0;
                return postData;
            }
    
            private function boundaryPostData(data:ByteArray, boundary:String):void
            {
                var len:int=boundary.length;
                addDoubleDash(data);
                for (var i:int=0; i < len; ++i)
                {
                    data.writeByte(boundary.charCodeAt(i));
                }
            }
    
            private function addDoubleDash(data:ByteArray):void
            {
                data.writeShort(0x2d2d);
            }
    
            private function addLineBreak(data:ByteArray):void
            {
                data.writeShort(0x0d0a);
            }
    
    
            private function signRequest(requestMethod:String, url:String, requestParams:Object, useHead:Boolean=false):URLRequest
            {
                var method:String=requestMethod.toUpperCase();
                var oauthParams:Object=getOAuthParams();
                var params:Object=new Object;
                for (var key:String in oauthParams)
                {
                    params[key]=oauthParams[key];
                }
                for (var key1:String in requestParams)
                {
                    params[key1]=requestParams[key1];
                }
    
                var req:URLRequest=new URLRequest();
                req.method=method;
                req.url=url;
                var paramsStr:String=makeSignableParamStr(params);
                var msgStr:String=StringEncoders.urlEncodeUtf8String(requestMethod.toUpperCase()) + "&";
                msgStr+=StringEncoders.urlEncodeUtf8String(url);
                msgStr+="&";
                msgStr+=StringEncoders.urlEncodeUtf8String(paramsStr);
                
                var secrectStr:String=_consumerSecret + "&";
                if (_accessTokenSecret.length > 0 && _accessTokenKey.length > 0)
                {
                    secrectStr+=_accessTokenSecret;
                }
                var sig:String=Base64.encode(HMAC.hash(secrectStr, msgStr, SHA1));
                // The matchers are specified in OAuth only.
                sig = sig.replace(/+/g, "%2B");
                
                oauthParams["oauth_signature"]=sig;
                trace("BaseString:::::", msgStr);
                trace("signature::::", sig);
                
                if (method == URLRequestMethod.GET)
                {
                    if (useHead)
                    {
                        req.url+=("?" + makeSignableParamStr(requestParams));
                        req.requestHeaders.push(makeOauthHeaderFromArray(oauthParams));
                    }
                    else
                    {
                        req.url+=("?" + paramsStr + '&oauth_signature=' + sig);
                    }
                }
                else if (requestMethod == URLRequestMethod.POST)
                {
                    req.requestHeaders.push(makeOauthHeaderFromArray(oauthParams));
                }
                return req;
            }
    
            private function makeSignableParamStr(params:Object):String
            {
                var retParams:Array=[];
    
                for (var param:String in params)
                {
                    if (param != "oauth_signature")
                    {
                        retParams.push(param + "=" + StringEncoders.urlEncodeUtf8String(params[param].toString()));
                        //retParams.push(param + "=" +params[param].toString());
                    }    
                    
                }
    
                retParams.sort();
    
                return retParams.join("&");
            }
    
            private function makeParamsToUrlString(params:Object):String
            {
                var retParams:Array=[];
    
                for (var param:String in params)
                {
                    retParams.push(param + "=" + params[param].toString());
                }
    
                retParams.sort();
    
                return retParams.join("&");
            }
    
            private function makeOauthHeaderFromArray(params:Object):URLRequestHeader
            {
                var oauthHeaderValue:String='OAuth realm="' + API_BASE_URL + '",';
                var parseParams:Array=[];
                for (var key:String in params)
                {
                    parseParams.push(key + '="' + params[key] + '"');
                }
                oauthHeaderValue+=parseParams.join(",");
    
                var reqHeader:URLRequestHeader=new URLRequestHeader("Authorization", oauthHeaderValue);
                return reqHeader;
            }
    
            private function getOAuthParams():Object
            {
                var params:Object=new Object;
                var now:Date=new Date();
    
                params["oauth_consumer_key"]=_consumerKey;
                if (_accessTokenKey.length > 0)
                {
                    params["oauth_token"]=_accessTokenKey;
                }
                if ( _pin && _pin.length > 0 )
                {
                    params["oauth_verifier"] = _pin;
                }
                params["oauth_signature_method"]="HMAC-SHA1";
                params["oauth_timestamp"]=now.time.toString().substr(0, 10);
                params["oauth_nonce"]=GUID.createGUID();
                params["oauth_version"]="1.0";
                params["oauth_callback"]="oob";
                return params;
            }
    
            private function oauthLoader_onComplete(event:Event):void
            {
                trace(oauthLoader.data);
                var needRequestAuthorize:Boolean=_accessTokenKey.length == 0;
                var result:String=oauthLoader.data as String;
    
                if (result.length > 0)
                {
                    var urlVar:URLVariables=new URLVariables(oauthLoader.data);
                    _accessTokenKey=urlVar.oauth_token;
                    _accessTokenSecret=urlVar.oauth_token_secret;
                    if (needRequestAuthorize)
                    {
                        requestAuthorize();
                        needRequestAuthorize=false;
                    }
                    else
                    {
                        var e:MicroBlogEvent=new MicroBlogEvent(MicroBlogEvent.OAUTH_CERTIFICATE_RESULT);
                        e.result={oauthTokenKey: _accessTokenKey, oauthTokenSecrect: _accessTokenSecret};
                        dispatchEvent(e);
                        verifyCredentials();
                    }
                }
    
            }
    
            private function oauthLoader_onError(event:IOErrorEvent):void
            {
                //var urlData:URLVariables = new URLVariables(oauthLoader.data);
                var e:MicroBlogErrorEvent = new MicroBlogErrorEvent(MicroBlogErrorEvent.OAUTH_CERTIFICATE_ERROR);
                e.message = oauthLoader.data;
                dispatchEvent(e);
            }
    
            private function oauthLoader_onSecurityError(event:SecurityErrorEvent):void
            {
                dispatchEvent(event);
            }
    
            private function requestAuthorize():void
            {
                var url:String=OAUTH_AUTHORIZE_REQUEST_URL;
                url+="?oauth_token=" + StringEncoders.urlEncodeUtf8String(_accessTokenKey);
                url+="&oauth_callback=oob";
                navigateToURL(new URLRequest(url));
            }
        }
    }
  • 相关阅读:
    linux命令练习
    Centos修改用户密码
    Git使用
    使用SecureCRT连接虚拟机中Linux系统 和 虚拟机网络配置
    CentOS里Tomcat端口开放
    Linux下安装Tomcat
    laravel 中将DB::select 得到的内容转为数组
    nginx 转发 由于php语法错误 导致的 50x
    windows 下后台启动 redis
    sublime 非常好用的注释工具
  • 原文地址:https://www.cnblogs.com/ffmpeg/p/4379145.html
Copyright © 2011-2022 走看看