Pouze tento týden sleva až 80 % na e-learning týkající se C# .NET. Zároveň využij akci až 30 % zdarma při nákupu e-learningu - Více informací.
Hledáme nové posily do ITnetwork týmu. Podívej se na volné pozice a přidej se do nejagilnější firmy na trhu - Více informací.

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

Tento výukový obsah pomáhají rozvíjet následující firmy, které dost možná hledají právě tebe!

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;
            }
        }
    }
}

 

Předchozí článek
Třída pro práci s ICQ#, ICQ kontakt - ISIM
Všechny články v sekci
Programujeme vlastní Instant Messenger ::ISIM::
Přeskočit článek
(nedoporučujeme)
Multilingual (vícejazyková) aplikace
Článek pro vás napsal David Jančík
Avatar
Uživatelské hodnocení:
Ještě nikdo nehodnotil, buď první!
Autor je vášnivý programátor. Nezná slovo "nelze", nebojí se zkoušet nepoznané a pronikat do nových technologií.
Aktivity

 

 

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í!