//允许Objecy Replication
     groupSpecifier.objectReplicationEnabled = true; //onConnect() function中设置

//设置replicationStrategy
netGroup.replicationStrategy = NetGroupReplicationStrategy.LOWEST_FIRST;//onNetGroupConnect() function中设置

//netStatusHandler中注意以下事件处理，接收和发送文件块
 
case "NetGroup.Replication.Fetch.Result": // e.info.index, e.info.object
 
					//作为发布者已经接收的部分
					netGroup.addHaveObjects(e.info.index,e.info.index);
					if(e.info.code != "NetGroup.Replication.Fetch.Result"){
						break;
					}
 
					//接收文件
					p2pSharedObject.chunks[e.info.index] = e.info.object;
					updateStatus("正在接收第"+e.info.index+"块文件");
 
					if(e.info.index == 0){
						p2pSharedObject.packetLenght = Number(e.info.object.length);
						p2pSharedObject.name = e.info.object.name;
						updateStatus("要接收的文件有: "+p2pSharedObject.packetLenght+"块文件");
						receiveObject(1);
 
					}else{
						if(e.info.index+1<p2pSharedObject.packetLenght){
							receiveObject(e.info.index+1);
						}else{
							updateStatus("文件接收完毕");
							updateStatus("接收了: "+p2pSharedObject.packetLenght+"块文件");
 
							p2pSharedObject.data = new ByteArray();
							for(var i:int = 1;i<p2pSharedObject.packetLenght;i++){
								p2pSharedObject.data.writeBytes(p2pSharedObject.chunks[i]);
							}
 
							updateStatus("字节长度: "+p2pSharedObject.data.length);
 
							Alert.show("保存文件","文件下载完毕，是否保存?",Alert.YES|Alert.NO,null,saveFileHandelr)
 
						}
					}
 
					break;
                case "NetGroup.Replication.Request": // e.info.index, e.info.requestID
					//同时作为发布者
					netGroup.writeRequestedObject(e.info.requestID,p2pSharedObject.chunks[e.info.index])
					updateStatus("接收方ID: "+e.info.requestID+", 需要的文件块: "+e.info.index);
					break;

           /**
            *
            * NetStraeam链接到用户组后触发
            * */
            private function onNetStreamConnect():void
            {
            	//加载话筒
                netStream.client = this;
                var mic:Microphone = Microphone.getMicrophone();
                if(mic)
                {
                    mic.codec = SoundCodec.SPEEX;
                    mic.setSilenceLevel(0);
 
                    netStream.attachAudio(mic);
 
                    updateStatus("话筒设置完毕\n");
                }
                //加载视频，并发布视频和话筒
                publishVideo()
 
            }

            /**
            *
            * NetStraeam链接到用户组后触发
            * */
            private function onNetStreamConnect():void
            {
                netStream.client = this;
 
                if(null != video)
                {
                    videoDisplay.removeChild(video);
                    video = null;
                }
 
                video = new Video();
                video.smoothing = true;
                video.attachNetStream(netStream);
                videoDisplay.addChild(video);
 
                //播放视频
                netStream.play("stream");
                netStream.bufferTime = 1.0;
            }

//下面三个变量用来保存KEY_DOWN事件时键盘的状态
 
var shiftKey:Boolean;
 
var ctrlKey:Boolean;
 
var keyCode:int;
 
var messageInput:TextArea;
 
messageInput.addEventListener(KeyboardEvent.KEY_DOWN,onKeyDown);
 
messageInput.addEventListener(TextEvent.TEXT_INPUT,onTextInput);
 
private function onKeyDown(e:KeyboardEvent):void{
 
//如果按下Enter时还按下Shift/Ctrl，则换行
 
if( e.keyCode==Keyboard.ENTER && (e.shiftKey || e.ctrlKey) ){
 
callLater(function():void{ //注意这个callLater
 
var msg:String = messageInput.text;
 
var part1:String = msg.substring(0, messageInput.selectionBeginIndex);
 
var part2:String = msg.substring(messageInput.selectionEndIndex, 0x7fffffff);
 
var selIndex:int = messageInput.selectionBeginIndex + 1;
 
messageInput.text = part1 + "\n" + part2;
 
messageInput.setSelection(selIndex,selIndex);
 
});
 
keyCode = -1; //标识本次按键不需要TEXT_INPUT事件配合处理
 
return;
 
}
 
shiftKey = e.shiftKey;
 
ctrlKey = e.ctrlKey;
 
keyCode = e.keyCode;
 
}
 
private function onTextInput(evt:TextEvent):void{
 
if(keyCode == -1){
 
return;
 
}
 
if(keyCode==Keyboard.ENTER && !shiftKey && !ctrlKey){
 
evt.preventDefault();
 
callLater(function():void{
 
//sendMessage()即为发送消息的方法，它应该返回一个Boolean值，以此来决定是否清空消息框
 
if( sendMessage(messageInput.text) ){
 
messageInput.text = "";
 
messageInput.htmlText = "";
 
messageInput.setSelection(0,0);
 
}
 
});
 
}
 
}

@namespace s "library://ns.adobe.com/flex/spark";
@namespace mx "library://ns.adobe.com/flex/halo";
 
s|Button {
color: #FF0000;
}
 
mx|DateChooser {
color: #FF0000;
}

<?xml version="1.0" encoding="utf-8"?>
<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009" 
	xmlns:s="library://ns.adobe.com/flex/spark" 
	xmlns:mx="library://ns.adobe.com/flex/halo" 
	minWidth="1024" minHeight="768" preloader="mx.preloaders.DownloadProgressBar">
	<s:HGroup  gap="50" horizontalCenter="0" top="10"> 
	<s:Panel width="200" height="200" title="Spark Panel" >
	<s:layout>
		<s:HorizontalLayout paddingLeft="10" paddingTop="10" />
	</s:layout>	
		<s:Button label="Spark 按钮" /> 
	</s:Panel> 		
	</s:HGroup>  
</s:Application>

//呼叫对方的方法，现在是呼叫者角色
private function call():void{
 
if(callYou.label == "接受"){
accpetHandle();
callYou.label = "挂断"
return;
}else if(callYou.label == "挂断"){
outgoingStream.send("onHangup")
this.hangup()
 
return;
}
 
...............
 
//发送视频
publishVideo();
//发送音频
publishAudio()
 
..........
 
//监听onConnectSuccess事件，确定链接成功
i.onConnectSuccess = function(name:String):void
{
info.text += "与"+name + "链接成功n";
sendMessageBtn.enabled = true;
incomingStream.receiveAudio(true)
incomingStream.receiveAudio(true)
remoteVideo = new Video();
remoteVideo.width = 160;
remoteVideo.height = 120;
remoteVideo.attachNetStream(incomingStream);
remoteVideoDisplay.addChild(remoteVideo);
sendMessageBtn.enabled = true;
}
 
i.onHangup = function():void{
hangup()
}
 
incomingStream.client = i
 
callYou.label = "挂断"

private function initSendStream():void{
 
..........
 
//监听onPeerConnect事件
var o:Object = new Object();
o.onPeerConnect = function(subscriberStream:NetStream):Boolean
{
..........
 
incomingStream.receiveAudio(false)
incomingStream.receiveAudio(false)
..........
 
//监听onIncomingCall事件，用于确定链接成功
i.onIncomingCall = function(name:String):void
{
//显示链接成功后，对呼叫者发布我的信息流，名称为callee
info.text += name + " 正在呼叫你n";
callYou.label = "接受"
}
 
i.onHangup = function():void{
hangup()
}
incomingStream.client = i;
 
return true;
}
 
myStream.client = o;
}

//同意链接后，发送stream到呼叫端，包括音频，视频的发送。 同时播放呼叫端发出的视频，音频
private function accpetHandle():void{
//向呼叫端发送信息流
outgoingStream = new NetStream(netConnection, NetStream.DIRECT_CONNECTIONS);
outgoingStream.addEventListener(NetStatusEvent.NET_STATUS, outgoingStreamHandler);
outgoingStream.publish("callee");
//将视频，音频附加到outgoingStream
publishAudio();
publishVideo()
 
//播放接受到的视频，音频
incomingStream.receiveAudio(true)
incomingStream.receiveAudio(true)
remoteVideo = new Video();
remoteVideo.width = 160;
remoteVideo.height = 120;
remoteVideo.attachNetStream(incomingStream);
remoteVideoDisplay.addChild(remoteVideo);
//链接成功事件，呼叫端响应
outgoingStream.send("onConnectSuccess",userName.text);
sendMessageBtn.enabled = true;
}

//挂断电话，清空所有stream，只保持于stratus的链接
public function hangup():void{
if (incomingStream){
incomingStream.close();
incomingStream.removeEventListener(NetStatusEvent.NET_STATUS, incomingStreamHandler);
}
 
if (outgoingStream){
outgoingStream.close();
outgoingStream.removeEventListener(NetStatusEvent.NET_STATUS, outgoingStreamHandler);
}
 
if (controlStream){
controlStream.close();
controlStream.removeEventListener(NetStatusEvent.NET_STATUS, netStreamHandler);
}
 
incomingStream = null;
outgoingStream = null;
controlStream = null;
if(localVideo != null){
localVideo.attachCamera(null)
}
 
if(remoteVideo != null){
remoteVideo.attachCamera(null)
}
 
info.text += "挂机！"
callYou.label = "呼叫"
sendMessageBtn.enabled = false;
}

//发送视频
private function publishVideo():void{
var cameras:Array = Camera.names;
var camera:Camera;
var findDefaultCamera:Boolean = false
if (cameras && cameras.length >0){
for(var j:int=0; j<cameras.length; j++){
if(cameras[j].toString() == "USB Video Class Video"){
camera = Camera.getCamera(j.toString())
outgoingStream.attachCamera(camera);
findDefaultCamera = true
}
}
if(!findDefaultCamera){
camera = Camera.getCamera()
outgoingStream.attachCamera(camera)
}
camera.setQuality(0,90)
 
localVideo = new Video();
localVideo.width = 160;
localVideo.height = 120;
localVideo.attachCamera(camera)
localVideoDisplay.addChild(localVideo);
}
}
//发送音频
private function publishAudio():void{
var mics:Array = Microphone.names;
if (mics && mics.length >0){
outgoingStream.attachAudio(Microphone.getMicrophone(0))
}
}

//链接Adobe stratus 服务器
private const StratusAddress:String = "rtmfp://stratus.adobe.com";
 
//Developer Key,如果没有请根据Flex 迷你教程 -- 基于Stratus的P2P网络电话 (1)中的提示申请
private const DeveloperKey:String = "xxxxxx";
 
//我们需要一个nectConnetion与stratus 服务器链接
private var netConnection:NetConnection;
 
//用于对外发布自己的身份信息流
private var myStream:NetStream;
 
//用于链接后对外发布自己的信息流，比如音频，视频，文字
private var outgoingStream:NetStream;
 
//进入的信息流，这个流对应呼叫者的outgoingStream，用这个流尝试播放发布者发布的信息，比如音频，视频，文字
private var incomingStream:NetStream;
 
//用于尝试播放被呼叫者的身份信息流myStream发送的信息，被呼叫者在发送自己的身份信息流时会监听呼叫者对myStream的播放请求
private var controlStream:NetStream;

//链接 adobe stratus 服务器
private function init():void{
 
	if(userName.text == "")
	{
		Alert.show("请输入任意用户名","错误")
		return
	}
	netConnection = new NetConnection();
	netConnection.addEventListener(NetStatusEvent.NET_STATUS, netConnectionHandler);
	netConnection.connect(StratusAddress + "/" + DeveloperKey); //服务器地址里需要开发者Key
}

private function initSendStream():void{
 
	//这三行表示我对外发布一个名称为netConnection.nearID的流，呼叫者通过我的nearID与我链接后，如果播放
	//这个名称为netConnection.nearID的流，会出发onPeerConnect事件，这样我就知道有人链接我
	myStream = new NetStream(netConnection, NetStream.DIRECT_CONNECTIONS);
	myStream.addEventListener(NetStatusEvent.NET_STATUS, netStreamHandler);
	myStream.publish(netConnection.nearID);
 
	//监听onPeerConnect事件
	var o:Object = new Object();
	o.onPeerConnect = function(subscriberStream:NetStream):Boolean
	{
		//当我收到呼叫者的链接请求后，尝试播放呼叫者的流名为"caller"的流，farID代表呼叫者的唯一ID，也就是前面提到的nearID
		//我通过farID找到呼叫者
	    incomingStream = new NetStream(netConnection,subscriberStream.farID);
        incomingStream.addEventListener(NetStatusEvent.NET_STATUS, incomingStreamHandler);
        incomingStream.play("caller");
 
        //监听onIm事件，用于收取文字信息
        var i:Object = new Object;
        i.onIm = function(name:String, value:String):void
        {
            info.text += name + ": " + value + "\n";
        }
        //监听onIncomingCall事件，用于确定链接成功
        i.onIncomingCall = function(name:String):void
        {
        	//显示链接成功后，对呼叫者发布我的信息流，名称为callee
            info.text += name + " 已经与你链接\n";
            outgoingStream = new NetStream(netConnection, NetStream.DIRECT_CONNECTIONS);
	        outgoingStream.addEventListener(NetStatusEvent.NET_STATUS, outgoingStreamHandler);
	        outgoingStream.publish("callee");
	        outgoingStream.send("onConnectSuccess",userName.text);
 
        }
        incomingStream.client = i;
 
        return true;
	}
 
	myStream.client = o;
}

private function call():void{
 
    //通过对方的peerId链接被呼叫者，播放对方的身份信息流
    controlStream = new NetStream(netConnection,peerId.text);
    controlStream.addEventListener(NetStatusEvent.NET_STATUS, netStreamHandler);
    controlStream.play(peerId.text);
 
    //同时对外发布呼叫者的信息流
    outgoingStream = new NetStream(netConnection, NetStream.DIRECT_CONNECTIONS);
    outgoingStream.addEventListener(NetStatusEvent.NET_STATUS, outgoingStreamHandler);
    outgoingStream.publish("caller");
 
    //尝试播放被呼叫者的信息流
    incomingStream = new NetStream(netConnection, peerId.text);
    incomingStream.addEventListener(NetStatusEvent.NET_STATUS, incomingStreamHandler);
    incomingStream.play("callee");
    info.text += "正在呼叫，请稍候...... \n\n"
 
    //监听信息发布事件
    var i:Object = new Object;
    i.onIm = function(name:String, value:String):void
    {
        info.text += name + ": " + value + "\n";
    }
    //监听onConnectSuccess事件，确定链接成功
     i.onConnectSuccess = function(name:String):void
    {
        info.text += "与"+name + "链接成功\n";
    } 
 
    incomingStream.client = i
 
}

o.onPeerConnect = function(subscriberStream:NetStream):Boolean
{
	//当我收到呼叫者的链接请求后，尝试播放呼叫者的流名为"caller"的流，farID代表呼叫者的唯一ID，也就是前面提到的nearID
	//我通过farID找到呼叫者
    incomingStream = new NetStream(netConnection,subscriberStream.farID);
    incomingStream.addEventListener(NetStatusEvent.NET_STATUS, incomingStreamHandler);
    incomingStream.play("caller");
 
    //监听onIm事件，用于收取文字信息
    var i:Object = new Object;
    i.onIm = function(name:String, value:String):void
    {
        info.text += name + ": " + value + "\n";
    }
    //监听onIncomingCall事件，用于确定链接成功
    i.onIncomingCall = function(name:String):void
    {
    	//显示链接成功后，对呼叫者发布我的信息流，名称为callee
        info.text += name + " 已经与你链接\n";
        outgoingStream = new NetStream(netConnection, NetStream.DIRECT_CONNECTIONS);
        outgoingStream.addEventListener(NetStatusEvent.NET_STATUS, outgoingStreamHandler);
        outgoingStream.publish("callee");
        outgoingStream.send("onConnectSuccess",userName.text);
 
    }
    incomingStream.client = i;
 
    return true;
}

//监听onConnectSuccess事件，确定链接成功
i.onConnectSuccess = function(name:String):void
{
    info.text += "与"+name + "链接成功\n";
}

//用outgoingStream对外发布信息流
private function send():void{
   info.text += userName.text + ": " + message.text + "\n";
    outgoingStream.send("onIm",userName.text,message.text);
}
 
//监听信息发布事件
var i:Object = new Object;
i.onIm = function(name:String, value:String):void
{
    info.text += name + ": " + value + "\n";
}