[bvfromul]

Добрый вечер! Изучаю класс NetStream и ни как не удается заставить работать обработчик сообщений, отсылаемый в NetStream.send().

Сразу прошу прощения за возможные ошибки в формулировках, т.к. недавно начал изучать as3 и flex.

Прикладываю код, к-ый поможет понять суть проблемы.

mxml приложения:

<?xml version="1.0" encoding="utf-8"?>

<main:VideoChatApplication xmlns:fx="http://ns.adobe.com/mxml/2009"
                     xmlns:s="library://ns.adobe.com/flex/spark"
                     xmlns:mx="library://ns.adobe.com/flex/mx"
                     xmlns:main="main.*" minWidth="955" minHeight="600">
</main:VideoChatApplication>

класс для приложения:

package main
{
    import flash.events.Event;
    
    import mx.events.FlexEvent;
    
    import spark.components.Application;

    public class VideoChatApplication extends Application
    {
        private var applicationData:ApplicationData;
        private var netStreamManager:NetStreamManager;
        private var userInterface:UserInterface;
        private var userHttpManger:UserHttpManager;

        public function VideoChatApplication() 
        {
            addEventListener(FlexEvent.CREATION_COMPLETE, init);
        }

        private function init(event:FlexEvent):void
        {
            applicationData = new ApplicationData();
            netStreamManager = new NetStreamManager(applicationData._cirrusURL, applicationData._cirrusDeveloperKey);
            netStreamManager.addEventListener('PEERID_READY', pickupPeerId);

            createConnectionUi();
        }

        private function createConnectionUi():void
        {
            userInterface = new UserInterface(applicationData._hostList);
            userInterface.addEventListener('NICK_AND_HOST_READY', allDataReady);
            userInterface.addEventListener('TEXTAREA_MESSAGE_IS_READY', sendTextareaMessagetoUI);

            addElement(userInterface);
        }

        private function pickupPeerId(event:Event):void
        {
            applicationData._peerID = netStreamManager._peerId;
        }

        private function allDataReady(event:Event):void
        {
            applicationData._userNick = userInterface._userNick;
            applicationData._webServerUrl = userInterface._hostURL;

            userHttpManger = new UserHttpManager(applicationData._webServerUrl, applicationData._peerID, applicationData._userNick);
            userHttpManger.addEventListener('SUCCESS_CONNECT', connectionIsReady);
            userHttpManger.addEventListener('SUCCESS_GET_PEERS', peersIsReady);
            userHttpManger.addEventListener('USERSHTTP_ERROR', userHttpError);
        }

        private function userHttpError(event:Event):void
        {
            userInterface.showError(userHttpManger._errorString);
        }

        private function connectionIsReady(event:Event):void
        {
            applicationData.saveHost(userInterface._currentHostsList);
        }

        private function peersIsReady(event:Event):void
        {
            var isNewConnecion:Boolean = !(applicationData._peerList.length as Boolean);
            applicationData._peerList = userHttpManger._peersList;
            if (isNewConnecion)
            {
                showVideoAndChatUi(applicationData._peerList.length);
            }
            netStreamManager.initStreams(applicationData._peerList, isNewConnecion);
        }

        private function showVideoAndChatUi(peersCount:int):void
        {
            userInterface.showVideoAndChatUi(peersCount);
        }
        
        private function sendTextareaMessagetoUI(event:Event):void
        {
            userInterface.addChatMessage(netStreamManager._textareaMessage);
        }
        

        public function receiveSomeData(message:String):void
        {
            trace('recive '+ message);
        }
    }
}

код класса в котором есть NetStream.send():

package main
{
    import flash.events.Event;
    import flash.events.EventDispatcher;
    import flash.events.NetStatusEvent;
    import flash.net.NetConnection;
    import flash.net.NetStream;

    public class NetStreamManager extends EventDispatcher
    {
        private var textareaMessage:String;
        private var peerId:String;
        private var netConnection:NetConnection;
        private var sendStream:NetStream;
        private var recvStreams:Object = {};

        public function NetStreamManager(cirrusUrl:String, developerKey:String)
        {
            initNetConnection(cirrusUrl, developerKey);
        }

        private function initNetConnection(cirrusUrl:String, developerKey:String):void
        {
            netConnection = new NetConnection();
            netConnection.addEventListener(NetStatusEvent.NET_STATUS,netConnectionStatus);
            netConnection.connect(cirrusUrl + developerKey);
        }

        private function netConnectionStatus(event:NetStatusEvent):void
        {
            peerId = netConnection.nearID;
            dispatchEvent(new Event('PEERID_READY'));
        }

        public function get _peerId():String
        {
            return peerId;
        }

        public function initStreams(strangerPeers:Array, isNewConnecion:Boolean):void
        {
            if (isNewConnecion)
            {
                initSendStream();
            }
            initRecvStreams(strangerPeers);
        }

        private function initSendStream():void
        {
            sendStream = new NetStream(netConnection, NetStream.DIRECT_CONNECTIONS);
            sendStream.publish("media");

            var sendStreamClient:Object = {};

            sendStreamClient.onPeerConnect = function(callerns:NetStream):Boolean{
                var farPeerID:String = callerns.farID;
                
                trace("onPeerConnect "+farPeerID);
                return true;
            }

            sendStream.client = sendStreamClient;
        }

        private function initRecvStreams(strangerPeers:Array):void
        {
            var key:String;

            for (key in strangerPeers)
            {
                if (recvStreams[strangerPeers[key].id])
                {
                    recvStreams[strangerPeers[key].id].isUpdate = 1;
                }
                else
                {
                    var recvStream:NetStream = new NetStream(netConnection, strangerPeers[key].id);
                    recvStream.play("media");
                    recvStream.client = this;
                    recvStreams[strangerPeers[key].id] = {}
                    recvStreams[strangerPeers[key].id].recvStream = recvStream;
                    recvStreams[strangerPeers[key].id].nick = strangerPeers[key].nick;
                    recvStreams[strangerPeers[key].id].isConnected = 0;
                    recvStreams[strangerPeers[key].id].isUpdate = 1;
                }
            }
            deleteOldStreams();
            sendSomeData('/ping ' + peerId);
        }

        private function deleteOldStreams():void
        {
            var key:String;

            for (key in recvStreams)
            {
                if (recvStreams[key].isUpdate == 0)
                {
                    recvStreams.splice(recvStreams.indexOf(recvStreams[key]),1);
                }
                else
                {
                    recvStreams[key].isUpdate == 0;
                }
            }
        }

        public function receiveSomeData(message:String):void
        {
            trace('recive '+ message);
            textareaMessage = '';

            switch (message.substring(0, 5))
            {
                case '/ping':
                    var peer:String = message.substr(5, message.length);
                    if (recvStreams[peer])
                    {
                        recvStreams[peer].isConnected = 1;
                        textareaMessage = recvStreams[peer].nick + ' connected';
                    }
                break;
            }

            if (textareaMessage.length)
            {
                dispatchEvent(new Event('TEXTAREA_MESSAGE_IS_READY'));
            }
        }

        public function sendSomeData(message:String):void
        {
            trace('send '+ message);
            sendStream.send("receiveSomeData", message);
        }
        
        public function get _textareaMessage():String
        {
            return textareaMessage;
        }
    }
}

Соединение успешно устанавливается, о чем сигнализирует trace в NetStreamManager.initSendStream(), но не удается обменяться сообщениями. Функция receiveSomeData, почему-то не находятся ни в классе NetStreamManager, ни в классе
VideoChatApplication. Даже пытался создавать отдельный класс для recvStream.client, тоже не помогло:

recvStream.client = new test();

package main
{
    public class test
    {
        public function receiveSomeData(message:String):void
        {
            trace('recive '+ message);
        }
    }
}

Подскажите, пожалуйста, в чем проблема? Как заставить работать обработчик получения сообщения, отправленное при помощи NetStream.send()?

Добавлено через 71 час 48 минут
Нашел в чем проблема, оказывается я каждый раз заново инициализировал исходящий поток.