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