Beispiel #1
0
        ///<summary>
        ///	Constructor
        /// Creates a ChatWindow and a conversation according to the type requested
        ///</summary>
        public ChatWindow(Person person, ProviderUser providerUser, ChatType type) :
            base(WindowType.Toplevel)
        {
            Logger.Debug("ChatWindow is being created with the ChatType: {0}", type.ToString());
            this.chatType = type;
            conv          = ConversationManager.Create(providerUser);

            /*
             * switch(chatType) {
             *      case ChatType.Text:
             *              conv.AddTextChannel();
             *              break;
             *      case ChatType.Audio:
             *              conv.AddAudioChannel();
             *              //conv.AddTextChannel();
             *              break;
             *      case ChatType.Video:
             *              conv.AddAudioVideoChannels();
             *              //conv.AddTextChannel();
             *              break;
             * }
             */

            peerPerson       = person;
            peerProviderUser = providerUser;

            InitWindow();
        }
Beispiel #2
0
 ///<summary>
 ///	WindowDeleted
 /// Cleans up the conversation object with the ConversationManager
 ///</summary>
 private void WindowDeleted(object sender, DeleteEventArgs args)
 {
     if (conv != null)
     {
         Logger.Debug("Window was destroyed, calling ConversationManager.Destroy on conversation");
         TearDownConversationEvents();
         ConversationManager.Destroy(conv);
         conv = null;
     }
 }
        /// <summary>
        /// CleanUpConversation
        /// Removes all event handlers and optionally destroys the conversation
        /// </summary>
        private void CleanUpConversation(Conversation conversation, bool destroyit)
        {
            conversation.MessageReceived    -= OnTextAdditionalMessageReceived;
            conversation.MediaChannelOpened -= OnMediaChannelOpened;
            conversation.MediaChannelClosed -= OnMediaChannelClosed;
            conversation.TextChannelOpened  -= OnTextChannelOpened;
            if (pendingData.ContainsKey(conversation.PeerUser.ID))
            {
                pendingData.Remove(conversation.PeerUser.ID);
            }

            if (destroyit)
            {
                ConversationManager.Destroy(conversation);
            }
        }
        /// <summary>
        ///	Method called from Account when a new channel is created
        /// </summary>
        internal static void ProcessNewChannel(
            Account account,
            ObjectPath channelPath,
            string channelType,
            HandleType handleType,
            uint handle,
            bool suppressHandler)
        {
            Logger.Debug ("ConversationManager::ProcessNewChannel - called");
            bool createdNewConversation = false;
            Conversation conversation = null;
            ChatType chattype = ChatType.Text;
            ProviderUser peerUser = null;

            switch (channelType)
            {
                case "org.freedesktop.Telepathy.Channel.Type.Text":
                {
                    IChannelText txtChannel = null;
                    if (handle == 0) return;

                    // Check if we have an existing conversation with the peer user
                    try {
                        peerUser = ProviderUserManager.GetProviderUser (handle);
                        if (peerUser == null) return;

                        txtChannel =
                            Bus.Session.GetObject<IChannelText> (
                                account.BusName,
                                channelPath);

                        conversation = ConversationManager.GetExistingConversation (peerUser);
                        if (conversation.ActiveTextChannel == false) {
                            conversation.AddTextChannel (txtChannel);
                            conversation.IndicateReceivedMessages ();
                        }
                    } catch (Exception ex) {
                        Logger.Debug (ex.Message);
                    }

                    if (conversation == null) {
                        try
                        {
                            Logger.Debug ("creating conversation object");
                            conversation =
                                new Conversation (account, peerUser, channelPath, txtChannel);
                            conversations.Add (conversation);
                            createdNewConversation = true;
                            Logger.Debug ("created new conversation object");
                        }
                        catch (Exception es)
                        {
                            Logger.Debug (es.Message);
                            Logger.Debug (es.StackTrace);
                        }
                    }
                    break;
                }

                case "org.freedesktop.Telepathy.ChannelType.StreamedMedia":
                {
                    // Check if we have an existing conversation with the peer user
                    IChannelStreamedMedia mediaChannel = null;
                    try {
                        mediaChannel =
                            Bus.Session.GetObject<IChannelStreamedMedia> (
                                account.BusName,
                                channelPath);

                        peerUser = ProviderUserManager.GetProviderUser (mediaChannel.Members[0]);
                        if (peerUser == null) return;

                        mediaChannel.AddMembers (mediaChannel.LocalPendingMembers, String.Empty);
                        conversation = ConversationManager.GetExistingConversation (peerUser);
                        conversation.AddMediaChannel (channelPath, mediaChannel);

                        chattype = ChatType.Audio;
                        StreamInfo[] streams = mediaChannel.ListStreams ();

                        Logger.Debug ("#streams: {0}", streams.Length);
                        foreach (StreamInfo si in streams)
                            if (si.Type == StreamType.Video) {
                                chattype = ChatType.Video;
                                break;
                            }

                        // FIXME::Pump conversation to create the channel
                        Logger.Debug (
                            "An existing conversation with {0} already exists",
                            peerUser.Uri);
                    } catch{}

                    if (peerUser == null) return;

                    if (conversation == null) {
                        try
                        {
                            Logger.Debug ("creating conversation object");
                            conversation =
                                new Conversation (account, peerUser, channelPath, mediaChannel);
                            conversations.Add (conversation);
                            chattype = ChatType.Audio;
                            StreamInfo[] streams = mediaChannel.ListStreams ();

                            Logger.Debug ("#streams: {0}", streams.Length);
                            foreach (StreamInfo si in streams)
                                if (si.Type == StreamType.Video) {
                                    chattype = ChatType.Video;
                                    break;
                                }

                            createdNewConversation = true;
                            Logger.Debug ("created new conversation object");
                        }
                        catch (Exception es)
                        {
                            Logger.Debug (es.Message);
                            Logger.Debug (es.StackTrace);
                        }
                    }
                    break;

                    /*
                    if(ichannel.Members.Length > 0) {
                        foreach(uint ch in ichannel.Members) {
                            Logger.Debug("Member in ichannel.Members {0}", ch);
                        }

                    }
                    if(ichannel.Members.Length > 0) {
                        peerHandle = ichannel.Members[0];
                    }
                    else
                        return;
                    */

                    /*
                    if (handle == 0) {

                        if (ichannel.LocalPendingMembers.Length > 0) {
                            Logger.Debug ("Incoming media conversation");
                            handle = ichannel.LocalPendingMembers[0];
                        } else if (ichannel.RemotePendingMembers.Length > 0) {
                            handle = ichannel.RemotePendingMembers[0];
                            Logger.Debug ("Pulled the handle from ichannel.RemotePendingMembers");
                            return;
                        } else if (ichannel.Members.Length > 0) {
                            handle = ichannel.Members[0];
                            Logger.Debug ("Pulled the handle from ichannel.Members");
                            return;
                        } else {
                            Logger.Debug ("Could not resolve the remote handle");
                            return;
                        }
                    } else {
                        Logger.Debug ("Handle was non-zero {0} - returning", handle);
                        return;
                    }

                    if (handle == this.tlpConnection.SelfHandle) {
                        Logger.Debug ("Handle was me - yay");
                        uint[] meHandles = {handle};

                        uint[] ids = {ichannel.Members[0]};

                        // Check if we have an existing conversation with the peer user
                        ProviderUser puMe = null;
                        ProviderUser puPeer = null;

                        try {
                            puMe = ProviderUserManager.GetProviderUser (handle);
                            puPeer = ProviderUserManager.GetProviderUser(peerHandle);
                        } catch{}

                        if (puMe == null) return;
                        if (puPeer == null) return;

                        if (ConversationManager.Exist (puPeer) == true) {
                            Logger.Debug ("An existing conversation with {0} already exists", puPeer.Uri);
                            return;
                        }

                        ichannel.AddMembers(meHandles, String.Empty);

                        Logger.Debug ("Peer: {0}", peer.Id);
                        Logger.Debug ("Peer Name: {0}", peer.DisplayName);

                        try
                        {
                            Logger.Debug ("creating conversation object");
                            conversation = ConversationManager.Create (this, peer, false);
                            IChannelText txtChannel =
                                Bus.Session.GetObject<IChannelText> (busName, channelPath);

                            conversation.SetTextChannel (txtChannel);
                            conversation.SetMediaChannel (ichannel, channelPath);
                            Logger.Debug ("created new conversation object");

                            conversation.SetPreviewWindow (cw.PreviewWindowId);
                            conversation.SetPeerWindow (cw.VideoWindowId);
                            conversation.StartVideo (false);
                        }
                        catch (Exception es)
                        {
                            Logger.Debug (es.Message);
                            Logger.Debug (es.StackTrace);
                        }
                    }

                    break;
                    */
                }

                default:
                    break;
            }

            // If successfully created a conversation and have registered consumers
            // of the callback event - fire the rocket
            if (conversation != null)
            {
                if (createdNewConversation == true && NewIncomingConversation != null)
                    NewIncomingConversation (conversation, chattype);
                else if (chattype == ChatType.Audio) {
                    conversation.IndicateAudioCall ();
                } else if (chattype == ChatType.Video) {
                    conversation.IndicateVideoCall ();
                }
            }
        }