• Peerクラスほぼ完成

(記事のタイトルをクリックでPeerクラスを表示)

package jp.sourceforge.aramaki.net {
import flash.events.EventDispatcher;
import flash.events.NetStatusEvent;
import flash.net.NetConnection;
import flash.net.NetStream;

import jp.sourceforge.aramaki.events.PeerChangeGroupEvent;
import jp.sourceforge.aramaki.events.PeerEvent;
import jp.sourceforge.aramaki.events.PeerMessageEvent;

/**
* ピア接続完了イベント
*
* @eventType jp.sourceforge.aramaki.events.PeerEvent.PEER_CONNECT
*/
[Event(name="peerConnect",type="jp.sourceforge.aramaki.events.PeerEvent")]
/**
* グループ変更イベント
*
* @eventType jp.sourceforge.aramaki.events.PeerChangeGroupEvent.PEER_CHANGE_GROUP
*/
[Event(name="peerChangeGroup",type="jp.sourceforge.aramaki.events.PeerChangeGroupEvent")]
/**
* メッセージ受信イベント
*
* @eventType jp.sourceforge.aramaki.events.PeerMessageEvent.PEER_MESSAGE
*/
[Event(name="peerMessage",type="jp.sourceforge.aramaki.events.PeerMessageEvent")]

public class Peer extends EventDispatcher {
/**
* 出力ストリーム
*/
private var outgoingStream:NetStream;
/**
* 入力ストリーム
*/
private var incomingStream:NetStream;
/**
* @private
*/
private var _id:String;
/**
* StratusへのNetConnection
*/
private var netConnection:NetConnection;
/**
* @private
*/
private var _connected:Boolean=false;
/**
* @private
*/
private var _group:String="";
/**
* 入力ストリーム準備完了フラグ
*/
private var incomingStreamReady:Boolean;

/**
* ピアへ接続
*
* @param netConnection Stratusへ接続したNetConnection
* @param id 接続先ピアのID
*/
public function connect(netConnection:NetConnection,id:String):void {
_id=id;
this.netConnection=netConnection;

doConnect();
}

/**
* ピアへ接続
*/
private function doConnect():void {
incomingStreamReady=false;

netConnection.addEventListener(NetStatusEvent.NET_STATUS,netConnectionNetStatusHandler);

outgoingStream=new NetStream(netConnection,NetStream.DIRECT_CONNECTIONS);
outgoingStream.addEventListener(NetStatusEvent.NET_STATUS,outgoingStreamNetStatusHandler);
outgoingStream.publish(_id);

incomingStream=new NetStream(netConnection,_id);
incomingStream.client={message:peerMessageHandler,changeGroup:peerChangeGroupHandler};
incomingStream.addEventListener(NetStatusEvent.NET_STATUS,incomingStreamNetStatusHandler);
incomingStream.play(netConnection.nearID);
}

/**
* 入力ストリームのNetStatusEventハンドラ
*/
private function incomingStreamNetStatusHandler(event:NetStatusEvent):void {
switch(event.info.code) {
case "NetStream.Play.Start": {
if (!_connected) {
if (outgoingStream.peerStreams.length) {
//出力ストリームの準備が完了
//接続完了
_connected=true;
dispatchEvent(new PeerEvent(PeerEvent.PEER_CONNECT,false,false,this));
} else {
incomingStreamReady=true;
}
}

break;
}
}
}

/**
* 出力ストリームのNetStatusEventハンドラ
*/
private function outgoingStreamNetStatusHandler(event:NetStatusEvent):void {
switch(event.info.code) {
case "NetStream.Play.Start": {
if ((!_connected)&&incomingStreamReady) {
//接続完了
_connected=true;
dispatchEvent(new PeerEvent(PeerEvent.PEER_CONNECT,false,false,this));
}

break;
}
}
}

/**
* NetConnectionのNetStatusEventハンドラ
*/
private function netConnectionNetStatusHandler(event:NetStatusEvent):void {
switch(event.info.code) {
case "NetStream.Connect.Failed":
case "NetStream.Connect.Closed": {
if (event.info.stream.farID==_id&&_connected) {
_connected=false;

netConnection.removeEventListener(NetStatusEvent.NET_STATUS,netConnectionNetStatusHandler);

outgoingStream.removeEventListener(NetStatusEvent.NET_STATUS,outgoingStreamNetStatusHandler);
outgoingStream.close();
outgoingStream=null;

incomingStream.removeEventListener(NetStatusEvent.NET_STATUS,incomingStreamNetStatusHandler);
incomingStream.close();
incomingStream=null;

doConnect();
}
break;
}
}
}

/**
* メッセージを受信
*/
private function peerMessageHandler(handlerName:String,args:Array):void {
dispatchEvent(new PeerMessageEvent(PeerMessageEvent.PEER_MESSAGE,false,false,this,handlerName,args));
}

/**
* グループ変更
*/
private function peerChangeGroupHandler(group:String):void {
_group=group;
dispatchEvent(new PeerChangeGroupEvent(PeerChangeGroupEvent.PEER_CHANGE_GROUP,false,false,this,group));
}

/**
* メッセージを送信
*
* @param handlerName ハンドラの名前
*/
public function send(handlerName:String,…args):void {
outgoingStream.send("message",handlerName,args);
}

/**
* グループの変更を通知
*/
internal function notifyChangeGroup(group:String):void {
outgoingStream.send("changeGroup",group);
}

/**
* 接続中フラグ
*/
public function get connected():Boolean {
return _connected;
}

/**
* 所属グループ
*/
public function get group():String {
return _group;
}

/**
* 接続を閉じる
*/
public function close():void {
_connected=false;

netConnection.removeEventListener(NetStatusEvent.NET_STATUS,netConnectionNetStatusHandler);
netConnection.close();
netConnection=null;

outgoingStream.removeEventListener(NetStatusEvent.NET_STATUS,outgoingStreamNetStatusHandler);
outgoingStream.close();
outgoingStream=null;

incomingStream.removeEventListener(NetStatusEvent.NET_STATUS,incomingStreamNetStatusHandler);
incomingStream.close();
incomingStream=null;
}
}
}

• ネットワーク周りの構造を変更中
• Flex SDKを3.3へアップデート

↓記事のタイトルをクリックするとNetwork.as,Peer.asを表示

Network.as

/*
AramakiOnline
Copyright (C) 2008-2009 superbacker

This program is free software; you can redistribute it and/or modify it under the terms
of the GNU General Public License as published by the Free Software Foundation;
either version 3 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this
program. If not, see <http://www.gnu.org/licenses/>.
*/

package jp.sourceforge.aramaki.net {
import flash.events.ErrorEvent;
import flash.events.Event;
import flash.events.EventDispatcher;
import flash.events.NetStatusEvent;
import flash.net.NetConnection;
import flash.net.NetStream;

import jp.sourceforge.aramaki.events.PeerChangeGroupEvent;
import jp.sourceforge.aramaki.events.PeerEvent;
import jp.sourceforge.aramaki.events.PeerIdEvent;
import jp.sourceforge.aramaki.events.PeerMessageEvent;

/**
* 接続イベント
* @eventType flash.events.Event.CONNECT
*/
[Event(name="connect",type="flash.events.Event")]

/**
* 接続失敗イベント
* @eventType flash.events.ErrorEvent.ERROR
*/
[Event(name="error",type="flash.events.ErrorEvent")]

/**
* 切断イベント
* @eventType flash.events.Event.CLOSE
*/
[Event(name="close",type="flash.events.Event")]

/**
* グループが変更されたときに呼ばれる
* @eventType jp.sourceforge.aramaki.events.PeerChangeGroupEvent.PEER_CHANGE_GROUP
*/
[Event(name="peerChangeGroup",type="jp.sourceforge.aramaki.events.PeerChangeGroupEvent")]

/**
* ピア接続イベント
* @eventType jp.sourceforge.aramaki.events.PeerEvent.CONNECT
*/
[Event(name="peerConnect",type="jp.sourceforge.aramaki.events.PeerEvent")]

/**
* ピア切断イベント
* @eventType jp.sourceforge.aramaki.events.PeerEvent.CLOSE
*/
[Event(name="peerClose",type="jp.sourceforge.aramaki.events.PeerEvent")]

/**
* ネットワーククラス
*/
public class Network extends EventDispatcher {
/**
* デベロッパーキー
*/
private const DEVELOPPER_KEY:String = "6ea6f12c8cca3fc6293596f3-1724aff91113";
/**
* Adobe Stratusへの接続用NetConnection
*/
private var netConnection:NetConnection;
/**
* メッセージを受信したときコールバックメソッドが呼び出されるオブジェクト
*/
public var client:Object={};
/**
* @private
*/
private var _group:String="__default_group__";
/**
* ピア管理クラス
*/
private var peerManager:PeerManager;
/**
* @private
*/
private var _peers:Object={};

/**
* 自身が属するグループ
*
* @default "__default_group__"
*/
public function get group():String {
return _group;
}

/**
* @private
*/
public function set group(value:String):void {
_group=value;

for each(var peer:Peer in _peers) {
peer.notifySendGroup(value);
}
}

/**
* ピア
*/
public function get peers():Object {
return _peers;
}

/**
* ネットワークへ接続
*
* netConnectionを作成しStratusへ接続
*/
public function connect():void {
netConnection=new NetConnection;
netConnection.maxPeerConnections=0xffff;
netConnection.addEventListener(NetStatusEvent.NET_STATUS,netConnectionNetStatusHandler);
netConnection.connect("rtmfp://stratus.adobe.com/"+DEVELOPPER_KEY);
}

/**
* NetConnectionのNetStatusEventハンドラ
*/
private function netConnectionNetStatusHandler(event:NetStatusEvent):void {
trace("Network: NetConnection:"+event.info.code);

switch(event.info.code) {
case "NetConnection.Connect.Success": {
//Stratusへ接続完了
peerManager=new PeerManager;
peerManager.addEventListener(Event.CONNECT,dispatchEvent);
peerManager.addEventListener(Event.CLOSE,peerManagerCloseHandler);
peerManager.addEventListener(ErrorEvent.ERROR,peerManagerConnectFailedHandler);
peerManager.addEventListener(PeerIdEvent.PEER_CONNECT,peerManagerPeerConnectHandler);
peerManager.addEventListener(PeerIdEvent.PEER_CLOSE,peerManagerPeerCloseHandler);
peerManager.connect(netConnection.nearID);

break;
}
case "NetConnection.Connect.Failed": {
//Stratusへの接続に失敗
dispose();

dispatchEvent(new ErrorEvent(ErrorEvent.ERROR,false,false,"Stratusへの接続に失敗しました。"));

break;
}
case "NetConnection.Connect.Closed": {
//Startusから切断
dispose();

dispatchEvent(new Event(Event.CLOSE));

break;
}
}
}

/**
* ピア管理サーバーへの接続に失敗
*/
private function peerManagerConnectFailedHandler(event:ErrorEvent):void {
dispose();

dispatchEvent(event);
}

/**
* ピア管理サーバーから切断
*/
private function peerManagerCloseHandler(event:Event):void {
close();
}

/**
* ピアへの接続要求
*/
private function peerManagerPeerConnectHandler(event:PeerIdEvent):void {
var peer:Peer=new Peer;
peer.connect(event.id);
_peers[event.id]=peer;
}

/**
* ピアが切断
*/
private function peerManagerPeerCloseHandler(event:PeerIdEvent):void {
_peers[event.id].close();
delete _peers[event.id];
}

/**
* 後始末
*/
private function dispose():void {
if (peerManager) {
peerManager.removeEventListener(Event.CONNECT,peerManagerConnectHandler);
peerManager.removeEventListener(Event.CLOSE,peerManagerCloseHandler);
peerManager.removeEventListener(ErrorEvent.ERROR,peerManagerConnectFailedHandler);
peerManager.removeEventListener(PeerIdEvent.PEER_CONNECT,peerManagerPeerConnectHandler);
peerManager.removeEventListener(PeerIdEvent.PEER_CLOSE,peerManagerPeerCloseHandler);
peerManager.close();
}

if (listenerStream) {
listenerStream.close();
listenerStream=null;
}

if (netConnection) {
netConnection.removeEventListener(NetStatusEvent.NET_STATUS,netConnectionNetStatusHandler);
netConnection.close();
netConnection=null;
}
}

/**
* メッセージを受信
* コールバックオブジェクトのメソッドを呼び出す
*/
private function peerMessageHandler(event:PeerMessageEvent):void {
var args:Array=event.args;
args.unshift(event.peer);
client[event.handlerName].apply(null,args);
}

/**
* 接続を閉じる
*/
public function close():void {
dispose();

dispatchEvent(new Event(Event.CLOSE));
}

/**
* すべてのピアへメッセージを送信
* @param handlerName ハンドラの名前
* @param args ハンドラの引数
*/
public function sendToAll(handlerName:String,…args):void {
args.unshift(handlerName);

for each(var peer:Peer in _peers) {
peer.send.apply(null,args);
}
}

/**
* 同じグループのピアへメッセージを送信
* @param handlerName ハンドラの名前
* @param args ハンドラの引数
*/
public function sendToGroup(handlerName:String,…args):void {
args.unshift(handlerName);

for each(var peer:Peer in _peers) {
if (peer.group==_group) peer.send.apply(null,args);
}
}
}
}

Peer.as

package jp.sourceforge.aramaki.net {
import flash.events.EventDispatcher;
import flash.net.NetConnection;
import flash.net.NetStream;

/**
* ピア接続完了イベント
*
* @eventType jp.sourceforge.aramaki.events.PeerEvent.PEER_CONNECT
*/
[Event(name="peerConnect",type="jp.sourceforge.aramaki.events.PeerEvent")]
/**
* ピア切断イベント
*
* @eventType jp.sourceforge.aramaki.events.PeerEvent.PEER_CLOSE
*/
[Event(name="peerClose",type="jp.sourceforge.aramaki.events.PeerEvent")]
/**
* グループ変更イベント
*
* @eventType jp.sourceforge.aramaki.events.PeerChangeGroupEvent.PEER_CHANGE_GROUP
*/
[Event(name="peerChangeGroup",type="jp.sourceforge.aramaki.events.PeerChangeGroupEvent")]
/**
* メッセージ受信イベント
*
* @eventType jp.sourceforge.aramaki.events.PeerMessageEvent.PEER_MESSAGE
*/
[Event(name="peerMessage",type="jp.sourceforge.aramaki.events.PeerMessageEvent")]

public class Peer extends EventDispatcher {
/**
* @private
*/
private var _outgoingStream:NetStream;
/**
* @private
*/
private var _incomingStream:NetStream;
/**
* @private
*/
private var _id:String;
/**
* StratusへのNetConnection
*/
private var _netConnection:NetConnection;
/**
* @private
*/
private var _state:int=STATE_NOT_CONNECTED;
/**
* 未接続
*/
private const STATE_NOT_CONNECTED:int=0;
/**
* 接続処理中
*/
private const STATE_CONNECTING:int=1;
/**
* 接続中
*/
private const STATE_CONNECTED:int=2;

/**
* ピアへ接続
*
* @param netConnection Stratusへ接続したNetConnection
* @param id 接続先ピアのID
*/
public function connect(netConnection:NetConnection,id:String):void {
_id=id;
_netConnection=netConnection;
_state=STATE_CONNECTING;

_incomingStream=new NetStream(netConnection,id);
_incomingStream.client={message:peerMessageHandler,changeGroup:peerChangeGroup};
}

/**
* メッセージを送信
*
* @param handlerName ハンドラの名前
*/
public function send(handlerName:String,…args):void {
_outgoingStream.send("message",handlerName,args);
}

/**
* 出力ストリーム
*/
public function get outgoingStream():NetStream {
return _outgoingStream;
}

/**
* 入力ストリーム
*/
public function get incomingStream():NetStream {
return _incomingStream;
}
}
}

今日書いたコード:
Network.as

(ここから先は省略。記事のタイトルをクリックすると読めます。)
作りかけ

package {
import __AS3__.vec.Vector;

import flash.events.Event;
import flash.events.EventDispatcher;
import flash.events.NetStatusEvent;
import flash.net.NetConnection;
import flash.net.NetStream;

/**
* 接続成功イベント
*/
[Event(name=&quot;connectComplete&quot;,type=&quot;flash.events.Event&quot;)]

/**
* 接続失敗イベント
*/
[Event(name=&quot;connectFailed&quot;,type=&quot;flash.events.Event&quot;)]

/**
* 切断イベント
*/
[Event(name=&quot;connectClosing&quot;,type=&quot;flash.events.Event&quot;)]

/**
* 切断完了イベント
*/
[Event(name=&quot;connectClosed&quot;,type=&quot;flash.events.Event&quot;)]

/**
* ネットワーククラス
*/
public class Network extends EventDispatcher {
/**
* デベロッパーキー
*/
private const DEVELOPPER_KEY:String = &quot;6ea6f12c8cca3fc6293596f3-1724aff91113&quot;;
/**
* @private
*/
private var _netConnection:NetConnection;
/**
* 出力ストリーム
*/
private var outgoingStream:NetStream;
/**
* 入力ストリームの配列
*/
private var incomingSterams:Vector.&lt;netStream&gt;;
/**
* @private
*/
private var _group:String;
/**
* @private
*/
private var _client:Object;
/**
* 初期ピア管理クラス
*/
private var initPeerManager:InitPeerManager;

/**
* Adobe Stratusへの接続用NetConnection
*/
public function get netConnection():NetConnection {
return _netConnection;
}

/**
* 自分が属するグループ
*/
public function get group():String {
return _group;
}

/**
* @private
*/
public function set group(value:String):void {
_group=value;
//TODO 更新
}

/**
* コールバックメソッドが呼び出されるオブジェクト
*/
public function get client():Object {
return _client;
}

/**
* ネットワークへ接続
*/
public function connect():void {
_netConnection=new NetConnection;
_netConnection.addEventListener(NetStatusEvent.NET_STATUS,netConnectionNetStatusHandler);
_netConnection.connect(&quot;rtmfp://stratus.adobe.com/&quot;+DEVELOPPER_KEY);
}

/**
* NetConnectionのNetStatusEventハンドラ
*/
private function netConnectionNetStatusHandler(event:NetStatusEvent):void {
trace(&quot;Network: NetConnection:&quot;+event);

switch(event.info.code) {
//接続に成功
case &quot;NetConnection.Connect.Success&quot;: {
outgoingStream=new NetStream(netConnection,NetStream.DIRECT_CONNECTIONS);
outgoingStream.client={onPeerConnect:onPeerConnect};
outgoingStream.addEventListener(NetStatusEvent.NET_STATUS,outgoingStreamNetStatusHandler);
outgoingStream.publish(&quot;chat&quot;);

initPeerManager=new InitPeerManager;
initPeerManager.id=_netConnection.nearID;
initPeerManager.register();

break;
}
//接続に失敗
case &quot;NetConnection.Connect.Failed&quot;: {
_netConnection=null;
dispatchEvent(new Event(&quot;connectFailed&quot;));
break;
}
//切断
case &quot;NetConnection.Connect.Closed&quot;: {
break;
}
//ピアへの接続に成功
case &quot;NetStream.Connect.Success&quot;: {
break;
}
//ピアへの接続に失敗
case &quot;NetStream.Connect.Failed&quot;: {
break;
}
//ピアが切断
case &quot;NetStream.Connect.Closed&quot;: {
break;
}
}
}

/**
* 出力ストリームのNetStatusEventハンドラ
*/
private function outgoingStreamNetStatusEventHandler(event:NetStatusEvent):void {
trace(&quot;Network: outgoingStream: &quot;+event.toString());
}

/**
* ピアが出力ストリームに接続してきたときに呼ばれる
* @param subscriber ピアへの出力ストリーム
* @return trueで接続許可 falseで接続拒否
*/
private function onPeerConnect(subscriber:NetStream):Boolean {
for each(var stream:NetStream in incomingSterams) {
//受信ストリームがすでに作成されているかチェック
if (stream.farID==subscriber.farID) {
//接続完了
//TODO: dispatchEvent();

return true;
}
}

return true;
}

/**
* すべてのピアへメッセージを送信
* @param handlerName ハンドラの名前
* @param args 引数
*/
public function sendToAll(handlerName:String,…args):void {
args.unshift(handlerName);
outgoingStream.send.apply(outgoingStream,args);
}

/**
* 同じグループのピアへメッセージを送信
* @param handlerName ハンドラの名前
* @param args 引数
*/
public function sendToGroup(handlerName:String,…args):void {
args.unshift(handlerName);

for each(var stream:NetStream in outgoingStream.peerStreams) {
//TODO:実装
//if (_group==stream.client.group) {
}
}

/**
* 指定されたIDのピアへメッセージを送信
* @param peerId 送り先のピアのID
* @param handlerName ハンドラの名前
* @param args 引数
*/
public function sendToPeer(peerId:String,handlerName:String,…args):void {
args.unshift(handlerName);

for each(var stream:NetStream in outgoingStream.peerStreams) {
if (stream.farID==peerId) {
stream.send.apply(stream,args);
return;
}
}
}
}
}