ActionScript3でTwitter連携
【AIR for iOS／AIR for Android／desktop AIR対応】

package twitter
{
	import com.dborisenko.api.twitter.oauth.OAuthTwitterConnection;
	import com.dborisenko.api.twitter.oauth.events.OAuthTwitterEvent;
	
	import mx.rpc.events.FaultEvent;
	import mx.rpc.events.ResultEvent;
	import mx.rpc.http.HTTPService;
	
	import org.iotashan.oauth.OAuthRequest;
	import org.iotashan.oauth.OAuthSignatureMethod_HMAC_SHA1;
	
	[Event(name="requestTokenError",type="com.dborisenko.api.twitter.oauth.events.OAuthTwitterEvent")]

	[Event(name="requestTokenReceived",type="com.dborisenko.api.twitter.oauth.events.OAuthTwitterEvent")]

	[Event(name="accessTokenError",type="com.dborisenko.api.twitter.oauth.events.OAuthTwitterEvent")]

	[Event(name="authorized",type="com.dborisenko.api.twitter.oauth.events.OAuthTwitterEvent")]

	public class OAuthTwitterConnection2 extends OAuthTwitterConnection
	{
		//ついでにプロトコルもhttpsにしちゃう
		private static const REQUEST_TOKEN_URL:String = "https://twitter.com/oauth/request_token";
		private static const ACCESS_TOKEN_URL:String = "https://twitter.com/oauth/access_token";
		private static const AUTHORIZE_URL:String = "https://twitter.com/oauth/authorize";
		
		private var _authorized:Boolean = false;
		private var signatureMethod:OAuthSignatureMethod_HMAC_SHA1 = new OAuthSignatureMethod_HMAC_SHA1();
		
		private var userId:String;
		private var screenName:String;
		
		/**
		 * @constructor
		 */
		public function OAuthTwitterConnection2()
		{
			super();
		}
		
		/**
		 * リクエストトークンも受け取れるように改造
		 */
		public function setRequestToken(requestKey:String, requestSecret:String):void
		{
			requestToken.key = requestKey;
			requestToken.secret = requestSecret;
		}
		
		/**
		 * コールバックURLを受け取るように改造
		 */
		public function authorize2(consumerKey:String, consumerSecret:String, callbackUrl:String = null):void
		{
			if (_authorized)
				return;
			
			consumer.key = consumerKey;
			consumer.secret = consumerSecret;
			var params:Object = null;
			if(!(!callbackUrl)){
				params = {oauth_callback:callbackUrl};
			}
			getRequestToken(params);
		}
		
		/**
		 * コールバック用にパラメーターを受け取るように改造
		 */
		private function getRequestToken(params:Object = null):void
		{
			if (_authorized)
				return;
			
			var oauthRequest:OAuthRequest = new OAuthRequest(OAuthRequest.HTTP_METHOD_GET, REQUEST_TOKEN_URL, params, consumer);
			var url:String = oauthRequest.buildRequest(signatureMethod);
			
			var service:HTTPService = new HTTPService();
			service.url = url;
			service.addEventListener(ResultEvent.RESULT, handleRequestToken);
			service.addEventListener(FaultEvent.FAULT, handleRequestTokenError);
			service.resultFormat = HTTPService.RESULT_FORMAT_TEXT;
			service.send();
		}
		
		private function handleRequestToken(event:ResultEvent):void
		{
			var params:Array = event.result.toString().split("&");
			for (var i:int = 0; i < params.length; i++) 
			{
				var param:String = params[i];
				var nameValue:Array = param.split("=");
				if (nameValue.length == 2) 
				{
					switch (nameValue[0]) 
					{
						case "oauth_token":
							requestToken.key = nameValue[1];
							break;
						case "oauth_token_secret":
							requestToken.secret = nameValue[1];
							break;
						default:
					}
				}
			}
			dispatchEvent(new OAuthTwitterEvent(OAuthTwitterEvent.REQUEST_TOKEN_RECEIVED, requestToken.key));
		}
		
		private function handleRequestTokenError(event:FaultEvent):void
		{
			dispatchEvent(new OAuthTwitterEvent(OAuthTwitterEvent.REQUEST_TOKEN_ERROR, event.fault.message));
		}
		
		private function getAccessToken(pin:String):void 
		{
			if (_authorized)
				return;
			
			var oauthRequest:OAuthRequest = new OAuthRequest(OAuthRequest.HTTP_METHOD_GET, ACCESS_TOKEN_URL, {oauth_verifier: pin}, consumer, requestToken);
			var url:String = oauthRequest.buildRequest(signatureMethod);
			
			var service:HTTPService = new HTTPService();
			service.url = url;
			service.addEventListener(ResultEvent.RESULT, handleAccessToken);
			service.addEventListener(FaultEvent.FAULT, handleAccessTokenError);
			service.resultFormat = HTTPService.RESULT_FORMAT_TEXT;
			service.send();
		}
		
		private function handleAccessToken(event:ResultEvent):void
		{
			var params:Array = event.result.toString().split("&");
			for (var i:int = 0; i < params.length; i++) 
			{
				var param:String = params[i];
				var nameValue:Array = param.split("=");
				if (nameValue.length == 2) 
				{
					switch (nameValue[0]) 
					{
						case "oauth_token":
							accessToken.key = nameValue[1];
							break;
						case "oauth_token_secret":
							accessToken.secret = nameValue[1];
							break;
						case "user_id":
							userId = nameValue[1];
							break;
						case "screen_name":
							screenName = nameValue[1];
							break;
						default:
					}
				}
			}
			_authorized = true;
			dispatchEvent(new OAuthTwitterEvent(OAuthTwitterEvent.AUTHORIZED));
		}
		
		private function handleAccessTokenError(event:FaultEvent):void
		{
			dispatchEvent(new OAuthTwitterEvent(OAuthTwitterEvent.ACCESS_TOKEN_ERROR, event.fault.message));
		}
	}
}

package twitter
{
	import com.dborisenko.api.twitter.TwitterAPI;
	import com.dborisenko.api.twitter.oauth.OAuthTwitterConnection;
	import com.dborisenko.api.twitter.twitter_internal;
	
	use namespace twitter_internal;
	
	public class TwitterAPI2 extends TwitterAPI
	{	
		/**
		 * 独自に拡張したOAuthTwitterConnectionです。
		 */
		protected var _connection2:OAuthTwitterConnection2 = new OAuthTwitterConnection2();

		/**
		 * 独自に拡張したOAuthTwitterConnectionを返します。
		 */
		override public function get connection():OAuthTwitterConnection
		{
			return _connection2;
		}

		/**
		 * @constructor
		 */
		public function TwitterAPI2()
		{
			super();
		}
	}
}

const _CALLBACK_URL:String = 'myAppScheme://auth';
var _api = new TwitterAPI2();
//認証を開始する
function startAuth():void
{
	_api.connection.setConsumer(KEY, SECRET);
	_api.connection.addEventListener(OAuthTwitterEvent.REQUEST_TOKEN_RECEIVED, function(e:OAuthTwitterEvent):void{
		_api.connection.removeEventListener(OAuthTwitterEvent.REQUEST_TOKEN_RECEIVED, arguments.callee);
		var requestToken:OAuthToken = _api.connection.requestToken;
		//ブラウザに飛ぶので、一旦リクエストトークンをSharedObjectに保存
		SOManager.getInstance().setRequestToken(requestToken.key, requestToken.secret);
		//受け取った認証用トークンをもとに認証画面へ飛ぶ
		navigateToURL(new URLRequest(_api.connection.authorizeURL));
	});
	//コールバックを指定して認証用トークンの発行を依頼
	OAuthTwitterConnection2(_api.connection).authorize2(KEY, SECRET, _CALLBACK_URL);
}

package data
{
	import flash.net.SharedObject;
	import flash.utils.flash_proxy;
	
	import org.iotashan.oauth.OAuthToken;

	public class SOManager
	{
		private static const _SO_NAME:String = 'twitterTest0000';
		private static const _REQUEST_TOKEN_NAME:String = 'requestToken';
		private static const _ACCESS_TOKEN_NAME:String = 'accessToken';
		
		private var _so:SharedObject;

		public function set accessToken(value:OAuthToken):void
		{
			_so.data[_ACCESS_TOKEN_NAME] = value;
			_so.flush();
		}
		
		public function get accessToken():OAuthToken
		{
			return _so.data[_ACCESS_TOKEN_NAME] as OAuthToken;
		}
		
		public function setRequestToken(key:String, secret:String):void
		{
			var token:OAuthToken = new OAuthToken(key, secret);
			_so.data[_REQUEST_TOKEN_NAME] = token;
			_so.flush();
		}
		
		public function get requestToken():OAuthToken
		{
			return _so.data[_REQUEST_TOKEN_NAME];
		}
		
		
		private static var _instance:SOManager;
		
		public static function getInstance():SOManager
		{
			if(!SOManager._instance){
				SOManager._instance = new SOManager(new Enforcer());
			}
			if(!SOManager._instance._so){
				SOManager._instance._so = SharedObject.getLocal(_SO_NAME);
			}
			return SOManager._instance;
		}
		
		public function SOManager(enforcer:Enforcer)
		{
		}
	}
}
class Enforcer{}

//認証を完了する
function setAuth(param:String):void
{
	//パラメーターから認証証明を取得
	var p:Object = getParams(param);
	var verifier:String = p['oauth_verifier'];
	//一旦保存してあったリクエストトークンを取得
	var requestToken:OAuthToken = SOManager.getInstance().requestToken;
	//コンシューマートークンとアクセストークンを設定
	_api.connection.setConsumer(KEY, SECRET);
	OAuthTwitterConnection2(_api.connection).setRequestToken(requestToken.key, requestToken.secret);
	_api.connection.addEventListener(OAuthTwitterEvent.AUTHORIZED, function(e:OAuthTwitterEvent):void{
		_api.connection.removeEventListener(OAuthTwitterEvent.AUTHORIZED, arguments.callee);
		var accessToken:OAuthToken = _api.connection.accessToken;
		SOManager.getInstance().accessToken = new OAuthToken(accessToken.key, accessToken.secret);
		dispatchEvent(new OAuthTwitterEvent(OAuthTwitterEvent.AUTHORIZED));
	});
	//認証証明からアクセストークンの発行を依頼
	_api.connection.grantAccess(verifier);
}

package twitter
{
	import com.dborisenko.api.enums.ResultFormat;
	
	public class UpdateStatus2 extends StatusOperation2
	{

		protected static const URL:String = "https://api.twitter.com/1.1/statuses/update.json";
		
		public function UpdateStatus2(statusText:String, inReplyToStatusId:String=null)
		{
			super(URL);
			resultFormat = ResultFormat.JSON;
			method = METHOD_POST;
			_requiresAuthentication = true;
			_apiRateLimited = false;
			
			statusText = statusText.replace(/\r\n/g, " ");
			statusText = statusText.replace(/\n/g, " ");
			statusText = statusText.replace(/\r/g, " ");
			
			parameters = {status: statusText, in_reply_to_status_id: inReplyToStatusId};
		}

	}
}

package twitter
{
	import com.dborisenko.api.enums.ResultFormat;
	import com.dborisenko.api.twitter.data.TwitterStatus;
	import com.dborisenko.api.twitter.net.TwitterOperation;
	
	import flash.events.Event;
	
	public class StatusOperation2 extends TwitterOperation
	{
		private var isMention:Boolean = false;
		
		public function StatusOperation2(url:String, requiresAuthentication:Boolean=true, params:Object=null, isMentions:Boolean=false)
		{
			super(url, requiresAuthentication, params);
		}
		
		[Bindable]
		public function get status():TwitterStatus
		{
			return data as TwitterStatus;
		}
		public function set status(value:TwitterStatus):void
		{
			data = value;
		}
		
		override protected function handleResult(event:Event):void
		{
			switch (resultFormat){
				case ResultFormat.JSON:
					var json:Object = getJSON();
					status = new TwitterStatus(json);
					break;
				case ResultFormat.XML:
					var xml:XML = getXML();
					if (xml.name() == "status")
					{
						status = new TwitterStatus(xml);
					}
					break;
			}
			super.handleResult(event);
		}
	}
}

/** UpdateStatusWithMedia.as
 * 
 * @author Masamune Utsunomiya
 */
package twitter
{
	import com.dborisenko.api.enums.ResultFormat;
	
	import flash.display.BitmapData;
	import flash.net.URLRequestHeader;
	import flash.utils.ByteArray;
	
	import mx.graphics.codec.JPEGEncoder;
	import mx.graphics.codec.PNGEncoder;
	import mx.rpc.events.FaultEvent;
	import mx.rpc.events.ResultEvent;
	
	/**
	 * Updates the authenticating user's status.  Requires the status parameter specified below.  Request must be a POST.  
	 * A status update with text identical to the authenticating user's current status will be ignored to prevent 
	 * duplicates.
	 * 
	 * @see https://dev.twitter.com/docs/api/1.1/post/statuses/update_with_media
	 */
	public class UpdateStatusWithMedia extends StatusOperation2
	{
		/**
		 * @private
		 */
		protected static const URL:String = "https://api.twitter.com/1.1/statuses/update_with_media.json";
		
		public static const BOUNDARY:String = 'bbbboooouuuunnnnddddaaaarrrryyyy';
		private static const _DELIMITER:String = '--';
		
		public function UpdateStatusWithMedia(statusText:String, media:ByteArray, inReplyToStatusId:String=null)
		{
			super(URL);
			resultFormat = ResultFormat.JSON;
			method = METHOD_POST;
			_requiresAuthentication = true;
			_apiRateLimited = false;
			
			statusText = statusText.replace(/\r\n/g, " ");
			statusText = statusText.replace(/\n/g, " ");
			statusText = statusText.replace(/\r/g, " ");
			
			parameters = {status: statusText, in_reply_to_status_id: inReplyToStatusId};
			parameters['media[]'] = media;
		}
		
		override public function execute():void
		{
			initOperation();
			serviceDelegate = new HTTPServiceDelegateForMultipart();
			serviceDelegate.headers = headers;
			serviceDelegate.method = method;
			serviceDelegate.params = params;
			serviceDelegate.resultFormat = resultFormat;
			serviceDelegate.url = url;
			
			serviceDelegate.addEventListener(ResultEvent.RESULT, handleResult);
			serviceDelegate.addEventListener(FaultEvent.FAULT, handleFault);
			serviceDelegate.send();
		}
		
		override protected function initOperation():void
		{
			if (requiresAuthentication && twitterAPI.connection != null)
			{
				var oauthParams:Object = params;
				var newUrl:String = url;
				
				var headerParams:Object = {};
				
				for (var key:String in oauthParams)
				{
					headerParams[key] = oauthParams[key];
				}
				
				var header:URLRequestHeader = twitterAPI.connection.createOAuthHeader(
					method, newUrl, {});
				if (header)
				{
					var hName:String = header.name;
					var hValue:String = header.value;
					headers[hName] = hValue;
				}
			}
		}

		private static function _addBoundary():String
		{
			return _DELIMITER + BOUNDARY;
		}
		
		private static function _addData(d:ByteArray, key:String, value:*):ByteArray
		{
			d.writeUTFBytes("\r\n");
			if(value is ByteArray){
				d.writeUTFBytes('Content-Type: application/octet-stream');
				d.writeUTFBytes("\r\n");
			}
			d.writeUTFBytes('Content-Disposition: form-data; name="' + key + '"');
			if(value is ByteArray){
				d.writeUTFBytes(';');
			}
			d.writeUTFBytes("\r\n\r\n");
			if(value is ByteArray){
				d.writeBytes(value);
			}else{
				d.writeUTFBytes(value);
			}
			d.writeUTFBytes("\r\n");
			d.writeUTFBytes(_addBoundary());
			return d;
		}
		
		public static function buildData(params:Object):ByteArray
		{
			var b:ByteArray = new ByteArray();
			b.writeUTFBytes(_addBoundary());
			for(var key:String in params){
				b = _addData(b, key, params[key]);
			}
			b.writeUTFBytes(_DELIMITER);
			return b;
		}
		
		public static function jpeg(bitmapData:BitmapData):ByteArray
		{
			var e:JPEGEncoder = new JPEGEncoder(80);
			return e.encode(bitmapData);
		}
		
		public static function png(bitmapData:BitmapData):ByteArray
		{
			var e:PNGEncoder = new PNGEncoder();
			return e.encode(bitmapData);
		}
	}
}

//ツイートする文字
var text:String = 'てすとなう。';
//連投禁止仕様回避のため、時刻をつけてつぶやく
var d:Date = new Date();
var dateStr:String = d.fullYear + '/' + String((d.month + 1)) + '/' + d.date + ' ' + d.hours + ':' + d.minutes + ':' + d.seconds + '.' + d.milliseconds;
//ツイートに添える格好良い画像を生成！
var sp:Sprite = new Sprite();
sp.graphics.beginFill(0xFFFF00);
sp.graphics.drawRect(0, 0, 300, 200);
sp.graphics.endFill();
var t:TextField = new TextField();
t.text = 'てすとなうなう。';
t.x = (sp.width - t.width) * 0.5;
t.y = (sp.height - t.height) * 0.5;
sp.addChild(t);
var bitmapData:BitmapData = new BitmapData(300, 200);
bitmapData.draw(sp);
var byte:ByteArray = UpdateStatusWithMedia.jpeg(bitmapData);
//画像付きでツイート
var op:TwitterOperation = new UpdateStatusWithMedia(text + dateStr, byte);
op.addEventListener(TwitterEvent.COMPLETE, function(e:TwitterEvent):void{
	trace(e.success);
	trace(e.data.toString());
});
_api.post(op);