gibphone.cs

Gibphone is CSharp Program, it can tell you how to design p2p chat.

using System;
using System.Collections.Generic;
using System.Text;
using GPCore.Phones;
using GPCore.Protocols;
using GPCore;
using GPCore.Vocoders;
using GPCore.NetworkProtocols;
using System.Net;
using System.IO;
using System.Drawing;
using GPCore.Args;
using System.Drawing.Imaging;
using System.Reflection;

namespace GPPlugins
{
    /// <summary>
    /// A default implementation of the phone abstract class.
    /// </summary>
    [GPCore.Plugin("Gibphone", "1.0", "James Regan", "Gibphone", "A simple implementation of the Phone Class")]
    public class GibPhone : Phone, IMessage, IPresence, IBuddyIcon, IChat
    {
        private static readonly byte[] RequestPacket = { 0xAA };
        private static readonly byte[] DenyPacket = { 0x55 };
        private static readonly byte[] AcceptPacket = { 0x0F };
        private static readonly byte[] ClosePacket = { 0xF0 };
        private static readonly byte[] ChatPacket = { 0xDD };
        private static readonly byte[] AwayPacket = { 0x33 };
        private static readonly byte[] StatusPacket = { 0xE2 };
        private static readonly byte[] HerePacket = { 0x1D };
        private static readonly byte[] AskForProf = { 0xD1 };
        private static readonly byte[] ProfilePacket = { 0x2E };
        private static readonly byte[] IconPacket = { 0x54 };
        private static readonly byte[] ReqIconPacket = { 0x45 };

        private int samplesize = 16;
        private int samplerate = 16000;
        private int channels = 1;
        private bool chat, away, prof, icon;
        Set<IPAddress> ConnectedPeople = new Set<IPAddress>();
        string Profile = "No Profile";
        bool Available = true;
        String AwayMsg = "";
        string un;
        bool connected = false;
        static Image img = null;//Image.FromHbitmap(Core.Icon.Icon.Icon.ToBitmap().GetHbitmap());

        /// <summary>
        /// Starts talking to the given Username
        /// </summary>
        public override void StartTalking(SqlAccount Username)
        {
            nox.SendData(RequestPacket, Username.Username);
        }

        /// <summary>
        /// Initializes this phone.
        /// </summary>
        public override void Initialize(IVocoder vox, INetworkProtocol nox)
        {
            base.Initialize(vox, nox);
            vox.Initialize(samplerate);
            nox.Initialize(4751);

            foreach (SqlGib g in SqlGibList.Gibs)
            {
                try
                {
                    foreach (SqlAccount a in g.Accounts)
                    {
                        nox.SendData(StatusPacket, a.Username);
                        nox.SendData(HerePacket, a.Username);
                    }
                }
                catch (Exception e) { }
            }
            icon = chat = away = prof = false;
        }

        
        /* 
         * Vocoder has two parts: Encode and Decode
         * The data flows as follows:
         * sound_DataReceived(Phone.cs) -> Encode -> vox_DataEncoded(HERE) -> Send
         * nox_DataReceived(HERE) -> Decode -> vox_DataDecoded(Phone.cs) -> Play
         */
        protected override void nox_DataReceived(byte[] packetBytes, IPAddress sender)
        {
            if (packetBytes.Length == 1)
            {
                //Check what kind of request it was
                if (chat)
                {
                    chatReceived(sender, Encoding.ASCII.GetString(packetBytes));
                    chat = false;
                }
                else if (away)
                {
                    personAway(sender, Encoding.ASCII.GetString(packetBytes));
                    away = false;
                }
                else if (prof)
                {
                    gotProfile(sender, Encoding.ASCII.GetString(packetBytes));
                    prof = false;
                }
                else if (icon)
                {
                    gotIcon(sender, packetBytes);
                    icon = false;
                }
                else
                {
                    bool request = (packetBytes[0] == RequestPacket[0]),
                        deny = (packetBytes[0] == DenyPacket[0]),
                        accept = (packetBytes[0] == AcceptPacket[0]),
                        close = (packetBytes[0] == ClosePacket[0]),
                        here = (packetBytes[0] == HerePacket[0]),
                        status = (packetBytes[0] == StatusPacket[0]),
                        askprof = (packetBytes[0] == AskForProf[0]),
                        askicon = (packetBytes[0] == ReqIconPacket[0]);
                    chat = (packetBytes[0] == ChatPacket[0]);
                    away = (packetBytes[0] == AwayPacket[0]);
                    prof = (packetBytes[0] == ProfilePacket[0]);
                    icon = (packetBytes[0] == IconPacket[0]);

                    if (request) personRequesting(sender);
                    else if (deny) personDenied(sender);
                    else if (accept) personAccepted(sender);
                    else if (close) personClosed(sender);
                    else if (here) personHere(sender);
                    else if (status) sendStatus(sender);
                    else if (askprof) sendProfile(sender);
                    else if (askicon) sendIcon(sender);
                }
            }
            else
            {
                if (chat)
                {
                    chatReceived(sender, Encoding.ASCII.GetString(packetBytes));
                    chat = false;
                }
                else if (away)
                {
                    personAway(sender, Encoding.ASCII.GetString(packetBytes));
                    away = false;
                }
                else if (prof)
                {
                    gotProfile(sender, Encoding.ASCII.GetString(packetBytes));
                    prof = false;
                }
                else if (icon)
                {
                    gotIcon(sender, packetBytes);
                }
                else
                    messageReceived(sender, packetBytes);
            }
        }

        protected override void vox_DataEncoded(byte[] a)
        {
            try
            {
                foreach (IPAddress addr in ConnectedPeople)
                {
                    nox.SendData(a, addr);
                }
            }
            catch (InvalidOperationException) { }
        }

        private void messageReceived(object sender, byte[] a)
        {
            vox.Decode(a);
        }

        private void sendIcon(IPAddress sender)
        {
            MemoryStream ms = new MemoryStream();
            buddyicon.Save(ms, ImageFormat.Gif);
            nox.SendData(IconPacket, sender);
            nox.SendData(ms.ToArray(), sender);
        }

        private void gotIcon(IPAddress sender, byte[] packetBytes)
        {
            MemoryStream ms = new MemoryStream(packetBytes);
            Image i = Image.FromStream(ms);
            BuddyIcon.RecieveIcon.Fire(this, new BuddyIconEventArgs(i, sender.ToString()));
        }

        private void chatReceived(IPAddress sender, string p)
        {
            Message.MessageRecieved.Fire(this, new MessageArgs(p, sender.ToString()));
        }

        private void personAway(IPAddress sender, string p)
        {
            SqlAccount a = new SqlAccount(sender.ToString(), this);
            if (a.ID == -1) return;
            a.Status = "Away";
            a.AwayMessage = p;
        }

        private void gotProfile(IPAddress sender, string p)
        {
            SqlAccount a = new SqlAccount(sender.ToString(), this);
            if (a.ID == -1) return;
            a.Profile = p;
        }

        private void personRequesting(IPAddress sender)
        {
            Requested.Fire(this, new UsernameEventArgs(sender.ToString()));}

        private void personDenied(IPAddress sender)
        {
            Denied.Fire(this, new UsernameEventArgs(sender.ToString()));
        }

        private void personAccepted(IPAddress sender)
        {
            ConnectedPeople.Add(sender);
            if (ConnectedPeople.Count == 1)
                StartSound(samplesize, samplerate, channels);
            Accepted.Fire(this, new UsernameEventArgs(sender.ToString()));

        }

        private void personClosed(IPAddress sender)
        {
            ConnectedPeople.Remove(sender);
            Closed.Fire(this, new UsernameEventArgs(sender.ToString()));
        }

        private void personHere(IPAddress sender)
        {
            SqlAccount a = new SqlAccount(sender.ToString(), this);
            if (a.ID == -1) return;
            a.Status = "Available";
        }

        private void sendStatus(IPAddress sender)
        {
            if (Available)
                nox.SendData(HerePacket, sender);
            else
            {
                nox.SendData(AwayPacket, sender);
                nox.SendData(Encoding.ASCII.GetBytes(AwayMsg), sender);
            }
        }

        private void sendProfile(IPAddress sender)
        {
            nox.SendData(ProfilePacket, sender);
            nox.SendData(Encoding.ASCII.GetBytes(Profile), sender);
        }

        public override void StopTalking(SqlAccount Username)
        {
            IPAddress addr = Dns.GetHostAddresses(Username.Username)[0];
            ConnectedPeople.Remove(addr);
            if (ConnectedPeople.Count == 0)
                StopSound();
            nox.SendData(ClosePacket, addr);
        }

        public override string IsInCall(SqlAccount Username)
        {
            IPAddress addr = Dns.GetHostAddresses(Username.Username)[0];
            return (ConnectedPeople.Contains(addr) ?
                "In Call"
                : "Not In Call");
        }

        public override void Accept(string Username)
        {
            IPAddress addr = Dns.GetHostAddresses(Username)[0];
            nox.SendData(AcceptPacket, addr);
            ConnectedPeople.Add(addr);
            if (ConnectedPeople.Count == 1)
                StartSound(samplesize, samplerate, channels);
        }

        public override void Deny(string Username)
        {
            IPAddress addr = Dns.GetHostAddresses(Username)[0];
            nox.SendData(DenyPacket, addr);
        }

      
        public override SqlProtocolAccountList Accounts
        {
            get { return new SqlProtocolAccountList(this); }
        }

        public override string Username
        {
            get
            {
                return un;
            }
            set
            {
                un = value;
            }
        }

        public override string Version
        {
            get { return "1.0"; }
        }

        public override bool Connected
        {
            get { return true; }
        }

        static GibPhone()
        {
            Stream str = Assembly.GetExecutingAssembly().GetManifestResourceStream("GPPlugins.gibphone.gif");
            img = 
                Image.FromStream(str);
        }

        public override Image DefaultBuddyIcon
        {
            get { return img; }
        }

        #region IMessage Members

        public void SendMessage(string Username, string message)
        {
            nox.SendData(ChatPacket, Username);
            nox.SendData(ASCIIEncoding.ASCII.GetBytes(message), Username);
            Message.MessageRecieved.Fire(this, new MessageArgs(message, Username, MessageParams.Callback));
        }
       
        #endregion

        #region IPresence Members
        public string Status
        {
            get
            {
                return (!Available ? AwayMsg : "Available");
            }
            set
            {
                switch (value)
                {
                    case "Available":
                        Available = true;
                        foreach (SqlAccount a in Accounts)
                        {
                            nox.SendData(HerePacket, a.Username);
                        }
                        break;
                    default:
                        Available = false;
                        AwayMsg = value;
                        foreach (SqlAccount a in Accounts)
                        {
                            nox.SendData(AwayPacket, a.Username);
                            nox.SendData(Encoding.ASCII.GetBytes(value), a.Username);
                        }
                        break;
                }
            }
        }

        public string[] PresenceTypes
        {
            get { return new string[] { "Available", "Away" }; }
        }

        public void GetStatus(string Username)
        {
            nox.SendData(StatusPacket, Username);
        }

        #endregion

        #region IBuddyIcon Members

        public void RequestBuddyIcon(string Username)
        {
            nox.SendData(ReqIconPacket, Username);
        }
        private Image buddyicon;
        public void SetBuddyIcon(System.IO.FileInfo filename)
        {
            buddyicon = Image.FromFile(filename.FullName);
            MemoryStream ms = new MemoryStream();
            buddyicon.Save(ms, ImageFormat.Gif);
            byte[] arr = ms.ToArray();
            foreach (SqlAccount a in Accounts)
            {
                nox.SendData(IconPacket, a.Username);
                nox.SendData(arr, a.Username);
            }
        }

 

        #endregion

        #region IChat Members

        public void SendChat(int chatID, string msg)
        {
            throw new Exception("The method or operation is not implemented.");
        }

        public int CreateChat(string name)
        {
            //            throw new Exception("The method or operation is not implemented.");
            Console.WriteLine(name);
            return -1;
        }

        public void JoinChat(int chatID)
        {
            throw new Exception("The method or operation is not implemented.");
        }

        public void InvitePerson(int chatID, string username, string message)
        {
            throw new Exception("The method or operation is not implemented.");
        }

        public void InvitePerson(SqlAccount act, string name, string message)
        {
            throw new Exception("The method or operation is not implemented.");
        }

   
        #endregion

    }
}