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 && 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.(@id == "11")[0];
* province = prov.@name;
* city = prov.city.(@id == "1")[0].@name;
* </pre>
* 通过名字得到id可以参考如下方法<br/>
* <pre>
* var prov:XML = provinces.province.(@name == "北京")[0];
* provinceID = prov.@id;
* cityID = prov.city.(@name == "东城区")[0].@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));
}
}
}
