12. díl - Třída pro práci se SkypeKit, Skype kontakt - ISIM

C# .NET Pro pokročilé Instant Messenger Třída pro práci se SkypeKit, Skype kontakt - ISIM

U Skype to bude větší sranda. Je tam navíc potřeba si koupit SkypeKit. Viz. http://developer.skype.com/

public class SkypeClass
{
        SktSkype skype;
        SktAccount account;

        private readonly object locker = new object();

        public SkypeClass()
        {
                X509Certificate2 cert = new X509Certificate2(Login.Skype.keypairPath, Login.Skype.keypairPass);

                skype = new SktSkype(cert);

                skype.events.OnConnect += OnConnect;
                skype.events.OnAccountStatus += OnAccountStatus;
                skype.events.OnSkypeMessage += OnSkypeMessage;

                skype.events.OnContactAvailability += new SktEvents.OnContactAvailabilityHandler(OnContactAvailability);
                skype.events.OnContactGroupChange += OnContactGroupChange;

                skype.events.OnParticipantTextStatus += new SktEvents.OnParticipantTextStatusHandler(events_OnParticipantTextStatus);
                skype.events.OnMessageBodyXml += new SktEvents.OnMessageBodyXmlHandler(events_OnMessageBodyXml);
        }

        /// <summary>
        /// Editace zprávy - kontakt editoval zprávu -> přidá zprávu s prefixem EDIT:
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void events_OnMessageBodyXml(SktMessage sender, SktEvents.OnMessageBodyXmlArgs e)
        {
                Safe.Lock(locker, 500, () =>
                {
                        Console.WriteLine(e.sender.P_AUTHOR + e.sender.P_BODY_XML);

                        if ((e.sender.P_EDITED_BY != null) && (e.sender.P_AUTHOR != account.P_SKYPENAME) && (e.sender.P_TYPE == SktMessage.TYPE.POSTED_TEXT))
                        {
                                Global.OpenForms.mainForm.Invoke(new System.Windows.Forms.MethodInvoker(() =>
                                {
                                        ISIMContact contact;
                                        if (Global.OpenForms.mainForm.contactListView.Items.ContainsKey(e.sender.P_AUTHOR))
                                                contact = (Global.OpenForms.mainForm.contactListView.Items[e.sender.P_AUTHOR] as ContactListViewItem).contact;
                                        else
                                                contact = new SkypeContact(skype.GetContact(e.sender.P_AUTHOR), skype.GetConversationByIdentity(e.sender.P_AUTHOR));

                                        Global.ISIMFunctions.AddChatMessage(contact, "EDIT: " + TextEdit.DecodeHtmlEntities(TextEdit.StripHtmlTags(e.sender.P_BODY_XML)), e.sender.P_EDIT_TIMESTAMP, e.sender.P_AUTHOR_DISPLAYNAME);
                                }));
                        }
                });
        }

        /// <summary>
        /// Kontakt začal psát
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void events_OnParticipantTextStatus(SktParticipant sender, SktEvents.OnParticipantTextStatusArgs e)
        {
                Safe.Lock(locker, 500, () =>
                {
                        if (e.sender.P_IDENTITY == account.P_SKYPENAME) return;

                        if ((e.sender.P_TEXT_STATUS == SktParticipant.TEXT_STATUS.WRITING) || (e.sender.P_TEXT_STATUS == SktParticipant.TEXT_STATUS.WRITING_AS_ANGRY) || (e.sender.P_TEXT_STATUS == SktParticipant.TEXT_STATUS.WRITING_AS_CAT))
                        {
                                // kontakt píše zprávu
                        }
                });
        }

        /// <summary>
        /// Při připojení se ke skypekitu -> načtení daného účtu
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void OnConnect(object sender, SktEvents.OnConnectArgs e)
        {
                if (e.success)
                {
                        Safe.Lock(locker, 2500, () =>
                        {
                                // abych mohl používat apache
                                skype.SetInt(SktSetup.LocalMachine.DISABLE_PORT80, 1);
                                account = skype.GetAccount(Login.Skype.username);
                                account.LoginWithPassword(Login.Skype.password, false, false);
                                account.SetAvailability(SktContact.AVAILABILITY.ONLINE);
                                Console.WriteLine("connected to skype");
                        });
                }
                else
                        Console.WriteLine("IPC handshake failed");
        }

        /// <summary>
        /// Změna dostupnosti mě, jakožto přihlášenýho
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void OnAccountStatus(SktAccount sender, SktEvents.OnAccountStatusArgs e)
        {
                Console.WriteLine("skype" + e.value.ToString());

                if (e.value == SktAccount.STATUS.LOGGED_IN)
                {
                        Safe.Lock(locker, 10000, () =>
                        {
                                Console.WriteLine("skype: Logged in");
                                // identifikace isimu
                                if (!account.P_ABOUT.Contains("::ISIM::"))
                                        account.SetStrProperty((int)SktAccount.PropKeys.P_ABOUT, account.P_ABOUT + "\nClient ::ISIM::, ( www.devbook.cz )");

                                Global.OpenForms.mainForm.contactListView.Invoke(new System.Windows.Forms.MethodInvoker(() =>
                                {
                                        Global.OpenForms.mainForm.contactListView.BeginUpdate();
                                }));

                                // projedou se kámoši a přidaj se
                                foreach (SktContact contact in skype.GetHardwiredContactGroup(SktContactGroup.TYPE.ALL_BUDDIES).GetContacts())
                                {
                                        Global.ISIMFunctions.AddContact(new SkypeContact(contact, null));
                                        Console.WriteLine("contact: " + contact.P_DISPLAYNAME);
                                }

                                Global.OpenForms.mainForm.contactListView.Invoke(new System.Windows.Forms.MethodInvoker(() =>
                                {
                                        Global.OpenForms.mainForm.contactListView.EndUpdate();
                                }));

                                // projedou se nevyřízené autorizace
                                foreach (SktContact contact in skype.GetHardwiredContactGroup(SktContactGroup.TYPE.CONTACTS_WAITING_MY_AUTHORIZATION).GetContacts())
                                {
                                        AuthorizeContact(contact);
                                }
                        });
                }

                if (e.value == SktAccount.STATUS.LOGGED_OUT)
                {
                        Console.WriteLine("SKype: Login failed");

                        MessageBox.Show("Skype: Připojení selhalo");
                }
        }

        /// <summary>
        /// Připojení ke skype. Spuštění runtime a connect.
        /// </summary>
        public void connect()
        {
                Safe.Lock(locker, 10000, () =>
                {
                        skype.LaunchRuntime(Login.Skype.runtimePath, true);
                        Thread.Sleep(500);
                        try
                        {
                                skype.Connect();
                        }
                        catch (Exception)
                        {
                                Console.WriteLine("cannot launch skype runtime");
                        }
                        Thread.Sleep(1000);

                });
        }

        /// <summary>
        /// Odhlášení se od skype protokolu
        /// </summary>
        public void disconnect()
        {
                Safe.Lock(locker, 1500, () =>
                {
                        skype.Disconnect();
                });
                Console.WriteLine("dissconnected from skypekit");
        }

        /// <summary>
        /// ZMěna skupin - čekování příchozí autorizace
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void OnContactGroupChange(SktContactGroup sender, SktEvents.OnContactGroupChangeArgs e)
        {
                Safe.Lock(locker, 1000, () =>
                {
                        Console.WriteLine("skype contact group change: " + sender.P_TYPE + sender.P_GIVEN_DISPLAYNAME);
                        // zčekne příchozí autorizace
                        if (sender.P_TYPE == SktContactGroup.TYPE.CONTACTS_WAITING_MY_AUTHORIZATION)
                        {
                                if (!e.contact.IsMemberOfHardwiredGroup(SktContactGroup.TYPE.ALL_BUDDIES))
                                        AuthorizeContact(e.contact);
                                else
                                        e.contact.SetBuddyStatus(true);
                        }
                });
        }

        /// <summary>
        /// Autorizace - nastaví kámoše jakože jó nebo né
        /// </summary>
        /// <param name="contact"></param>
        private void AuthorizeContact(SktContact contact)
        {
                if (MessageBox.Show("Žádost o autorizaci: " + contact.P_SKYPENAME + "(" + contact.P_DISPLAYNAME + ")\n" + contact.P_RECEIVED_AUTHREQUEST + "\nPřijímout?", "Žádost o autorizaci " + contact.P_FULLNAME, MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button1) == DialogResult.Yes)
                {
                        try
                        {
                                Safe.Lock(locker, 1000, () =>
                                {
                                        contact.SetBuddyStatus(true);
                                });
                        }
                        catch (Exception ex)
                        {
                                Console.WriteLine("auth error: " + ex.Message);
                        }
                }
                else
                {
                        try
                        {
                                Safe.Lock(locker, 1000, () =>
                                {
                                        contact.SetBuddyStatus(false);
                                });
                        }
                        catch (Exception ex)
                        {
                                Console.WriteLine("auth error: " + ex.Message);
                        }
                }
        }

        /// <summary>
        /// Zpracování zprávy - taj je zpráva všechno co se hne, tzn zpracování hovorů, přenosu souborů, upozornění etc.. jo a taky zpráv
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void OnSkypeMessage(SktSkype sender, SktEvents.OnSkypeMessageArgs e)
        {
                Safe.Lock(locker, 1000, () =>
                {
                        Console.WriteLine("message from: " + e.message.P_AUTHOR_DISPLAYNAME + e.message.P_BODY_XML);

                        ISIMContact contact = null;
                        Global.OpenForms.mainForm.Invoke(new System.Windows.Forms.MethodInvoker(() =>
                        {
                                if (Global.OpenForms.mainForm.contactListView.Items.ContainsKey(e.message.P_AUTHOR))
                                        contact = (Global.OpenForms.mainForm.contactListView.Items[e.message.P_AUTHOR] as ContactListViewItem).contact;
                                else
                                        contact = new SkypeContact(skype.GetContact(e.message.P_AUTHOR), e.conversation);
                        }));

                        switch (e.message.P_TYPE)
                        {
                                // normální zpráva
                                case SktMessage.TYPE.POSTED_TEXT:
                                        if (e.message.P_AUTHOR != account.P_SKYPENAME)
                                                Global.ISIMFunctions.AddChatMessage(contact, TextEdit.DecodeHtmlEntities(TextEdit.StripHtmlTags(e.message.P_BODY_XML)), e.message.P_TIMESTAMP, e.message.P_AUTHOR_DISPLAYNAME);
                                        break;

                                // další
                                default:
                                        Console.WriteLine("Default P_message type:" + e.message.P_TYPE);
                                        Global.ISIMFunctions.AddChatMessage(contact, "Undefined operation:" + e.message.P_TYPE.ToString(), e.message.P_TIMESTAMP, e.message.P_AUTHOR_DISPLAYNAME);
                                        break;
                        }
                });
        }

        /// <summary>
        /// Změna dostupnosti kontaktu
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void OnContactAvailability(SktContact sender, SktEvents.OnContactAvailabilityArgs e)
        {
                // moooooc komba bž xD - no už to nejsou takový komba jako dřív tak nepodělávé
                Safe.Lock(locker, 1500, () =>
                {
                        if (sender.P_SKYPENAME == account.P_SKYPENAME) return;

                        if (!sender.IsMemberOfHardwiredGroup(SktContactGroup.TYPE.ALL_BUDDIES))
                        {
                                sender.SetBuddyStatus(false);
                                return;
                        }


                        if (!Global.Converter.AvatarExists(sender.P_SKYPENAME))
                        {
                                byte[] contactAvatar = sender.P_AVATAR_IMAGE;
                                if (contactAvatar != null)
                                {
                                        MemoryStream ms = new MemoryStream(contactAvatar);
                                        Global.ISIMFunctions.SaveAvatar(Image.FromStream(ms), sender.P_SKYPENAME);
                                }
                        }

                        Global.OpenForms.mainForm.contactListView.BeginInvoke(new System.Windows.Forms.MethodInvoker(() =>
                        {
                                if (Global.OpenForms.mainForm.contactListView.Items.ContainsKey(sender.P_SKYPENAME))
                                        Global.ISIMFunctions.EditContactAvailability(sender.P_SKYPENAME, Global.Converter.GetContactAvailability(sender));
                                else
                                        Global.ISIMFunctions.AddContact(new SkypeContact(sender, null));
                        }));
                });

                Console.WriteLine("sender - av:" + sender.P_DISPLAYNAME + sender.P_AVAILABILITY);
        }

        /// <summary>
        /// Vrátí avatar kontaktu
        /// </summary>
        /// <param name="conv"></param>
        /// <returns></returns>
        public Image getAvatarFromConversation(SktConversation conv)
        {
                Image _avatar = null;
                Safe.Lock(locker, 1000, () =>
                {
                        if (conv.GetParticipants().Count == 2)
                        {
                                byte[] contactAvatar = skype.GetContact(conv.P_IDENTITY).P_AVATAR_IMAGE;
                                if (contactAvatar != null)
                                {
                                        MemoryStream imageStream = new MemoryStream(contactAvatar);

                                        Image avatar = Image.FromStream(imageStream);

                                        Global.ISIMFunctions.SaveAvatar(avatar, conv.P_IDENTITY);

                                        _avatar = avatar;
                                }
                        }
                });
                if (_avatar != null)
                        return _avatar;
                else
                        return Global.Converter.GetContactAvatar(conv.P_IDENTITY);
        }

        /// <summary>
        /// Změna dostupnosti
        /// </summary>
        /// <param name="availability"></param>
        public void changeMyAvailability(SktContact.AVAILABILITY availability)
        {
                Safe.Lock(locker, 1000, () =>
                {
                        account.SetAvailability(availability);
                });
        }

        /// <summary>
        /// Odeslání zprávy
        /// </summary>
        /// <param name="conv"></param>
        /// <param name="message"></param>
        public void sendMessage(SktConversation conv, string message)
        {
                Safe.Lock(locker, 1000, () =>
                {
                        conv.PostText(message, false);
                });
        }

        /// <summary>
        /// Smaže kontakt
        /// </summary>
        /// <param name="contact"></param>
        public void removeContact(SktContact contact)
        {
                Safe.Lock(locker, 1000, () =>
                {
                        contact.SetBuddyStatus(false);
                });
        }

        /// <summary>
        /// Odešle info danému kontaktu o tom, že píšu zprávu
        /// </summary>
        /// <param name="conv"></param>
        public void imTypingMessage(SktConversation conv)
        {
                Safe.Lock(locker, 500, () =>
                {
                        conv.SetMyTextStatusTo(SktParticipant.TEXT_STATUS.WRITING_AS_CAT);
                });
        }

        /// <summary>
        /// Odeslání žádosti o autorizaci
        /// </summary>
        /// <param name="skypename"></param>
        /// <returns></returns>
        public bool requestContactAuth(string skypename, string authText)
        {
                bool success = false;
                Safe.Lock(locker, 1000, () =>
                {
                        try
                        {
                                SktContact contact = skype.GetContact(skypename);
                                contact.SetBuddyStatus(true, true);
                                contact.SendAuthRequest(authText);
                                success = true;
                        }
                        catch
                        {
                                success = false;
                        }
                });
                return success;
        }

        /// <summary>
        /// Nastaví stav uživatele - krátký text
        /// </summary>
        /// <param name="status"></param>
        public void SetMyMoodStatus(string status)
        {
                Safe.Lock(locker, 500, () =>
                {
                        account.SetStrProperty((int)SktAccount.PropKeys.P_MOOD_TEXT, status);
                });
        }

        public SktSkype GetSkypeInstance()
        {
                return skype;
        }

        public SktAccount GetAccountInstance()
        {
                return account;
        }
}

Tady je pěkně vidět ten Adapter Wrapper

public class SkypeContact : ISIMContact
{
        public SktContact skypeContact;
        ContactObject _contactObject;

        public SkypeContact(SktContact skypeContact, SktConversation conversation)
        {
                this.skypeContact = skypeContact;
                availability = Global.Converter.GetContactAvailability(skypeContact);
                _contactObject = new ContactObject(skypeContact, conversation);
        }

        public string id
        {
                get { return skypeContact.P_SKYPENAME; }
        }

        public string name
        {
                get { return skypeContact.P_DISPLAYNAME; }
                set { }
        }

        public Global.Availability availability
        {
                get;
                set;
        }

        public object contactObject
        {
                get { return _contactObject; }
        }

        public string protocol
        {
                get { return "skype"; }
        }

        public bool unreadedMessage { get; set; }

        public class ContactObject
        {
                private SktContact skypeContact;
                private SktConversation _conversation;
                SktSkype skypeInstance;

                public ContactObject(SktContact skypeContact, SktConversation conversation)
                {
                        this.skypeContact = skypeContact;
                        _conversation = conversation;
                }

                public SktContact contact
                {
                        get { return skypeContact; }
                }

                public SktConversation conversation
                {
                        get
                        {
                                if (_conversation == null)
                                        return skypeContact.OpenConversation();
                                else
                                        return _conversation;
                        }
                }

                public SktSkype skype
                {
                        get
                        {
                                Global.OpenForms.mainForm.Invoke(new System.Windows.Forms.MethodInvoker(() =>
                                {
                                        skypeInstance = Global.OpenForms.mainForm.skype.GetSkypeInstance();
                                }));
                                return skypeInstance;
                        }
                }
        }
}

 

  Aktivity (1)

Článek pro vás napsal David Jančík [sczdavos]
Avatar
Autor je vášnivý programátor v .NET C# a PHP. Nezná slovo "nelze", nebojí se zkoušet nepoznané a pronikat do nových technologií.

Jak se ti líbí článek?
Ještě nikdo nehodnotil, buď první!


 



 

 

Komentáře

Děláme co je v našich silách, aby byly zdejší diskuze co nejkvalitnější. Proto do nich také mohou přispívat pouze registrovaní členové. Pro zapojení do diskuze se přihlas. Pokud ještě nemáš účet, zaregistruj se, je to zdarma.

Zatím nikdo nevložil komentář - buď první!