bthconnector.cs

通过手机蓝牙控制个人电脑上的幻灯片的播放

#region Using directives
using System;
using System.Text;
using System.Data;
using System.ComponentModel;
using System.Collections;
using System.Runtime.InteropServices;
using System.Threading;
using InTheHand.Net.Sockets;
using InTheHand.Net.Bluetooth;
using InTheHand.Net;
#endregion

namespace BTHWrapper
{
    /// <summary>
    /// Summary description for BTHMethods.
    /// </summary>
    public class BTHConnector : IDisposable
    {
        private IntPtr _socket;
        private BluetoothDeviceInfo[] bthDeviceInfo;
        private BluetoothClient bthClient;
        private bool Disconnected;
        public struct DeviceDataSet
        {
            public string DeviceName;
            public UInt64 btAddr;
        }

        public BTHConnector()
        {
            IntPtr _socket = Ws2Consts.INVALID_SOCKET;
            bthClient = new BluetoothClient();
            Disconnected = true;
        }

        ~BTHConnector()
        {
            //TerminateWinsock();
            TerminateSocket();
            //TerminateBluetooth();
        } 
        public bool InitialiseBluetooth()
        {
            if (Ws2Interop.BthSetMode((int)Ws2Consts.BTH_RADIO_MODE.BTH_DISCOVERABLE) == Ws2Consts.ERROR_SUCCESS)
            {
                System.Threading.Thread.Sleep(2000);
                return true;
            }
            return false;
        }

        public string TerminateBluetooth()
        {
            if (Ws2Interop.BthSetMode((int)Ws2Consts.BTH_RADIO_MODE.BTH_POWER_OFF) == Ws2Consts.ERROR_SUCCESS)
            {
                System.Threading.Thread.Sleep(2000);
                return "BthSetMode() success";
            }
            return "BthSetMode() error";
        }

        public string InitialiseWinsock()
        {
            Ws2Structs.WSAData wsd = new Ws2Structs.WSAData();
            wsd.wHighVersion = 2;
            wsd.wVersion = 2;
            if (Ws2Interop.WSAStartup((short)0x0202, out wsd) != 0)
            {
                return "WSAStartup() Error";
            }
            return "WSAStartup() Success";
        }

        public string InitialiseSocket()
        {
            _socket = Ws2Interop.socket(Ws2Consts.AF_BTH, Ws2Consts.SOCK_STREAM, Ws2Consts.BTHPROTO_RFCOMM);
            if (_socket == Ws2Consts.INVALID_SOCKET)
            {
                return "Socket() error";
            }
            return "Socket() Success";
        }

        public string TerminateSocket()
        {
            Ws2Interop.shutdown(_socket, Ws2Consts.SD_BOTH);
            if (_socket != Ws2Consts.INVALID_SOCKET)
            {
                Ws2Interop.closesocket(_socket);
                _socket = Ws2Consts.INVALID_SOCKET;
            }
            return "Closesocket() Success";
        }

        public bool IsSocketValid()
        {
            if (_socket == Ws2Consts.INVALID_SOCKET)
            {
                return false;
            }
            return true;
        }

        public ArrayList FindDevice()
        {
            ArrayList DeviceList = new ArrayList();
            bthDeviceInfo = bthClient.DiscoverDevices(10);
            int deviceNum = bthDeviceInfo.Length;
            string strTmp = "";

            for (int i = 0; i < deviceNum; i++)
            {
                strTmp = BTHUtil.ToStandardlizeAddress(bthDeviceInfo[i].DeviceAddress.ToString());
                DeviceItem dItem = new DeviceItem(bthDeviceInfo[i].DeviceName.ToString(), strTmp);
                DeviceList.Add(dItem);
            }
            return DeviceList;
        }

        public string Connect(string strAddr)
        {
            return Connect(BTHUtil.ToBT_ADDR(strAddr));
        }

        public string Connect(UInt64 deviceAddr)
        {
            string strReturnMsg = "";
            int intChannel=0;
            Ws2Structs.SOCKADDR_BTH addr = new Ws2Structs.SOCKADDR_BTH();
            addr.addressFamily = (Int16)Ws2Consts.AF_BTH;
            addr.port = 0;
            addr.btAddr = deviceAddr;
            for (int i = 0; i <= 30; i++)
            {
                
                intChannel = i;
                addr.port = i;
                if ((Ws2Interop.connect(_socket, ref addr, Ws2Consts.SOCKADDR_BTH_SIZE))!=0)
                {
                    strReturnMsg = "Connected failed";
                }
                else
                {
                    Disconnected = false;
                    strReturnMsg = "Connected on channel: ";
                    strReturnMsg += Convert.ToString(i);
                    break;
                }
            }
            if (intChannel >= 30)
            {
                Disconnected = true;
                strReturnMsg = "Could not Connect";
            }
            return strReturnMsg;
        }

        public string Send(byte[] strMsg)
        {
            int intLen = Ws2Interop.send(_socket, strMsg,strMsg.Length, 0);
            if (intLen == -1)
            {
                Disconnected = true;
            }
            if (intLen != strMsg.Length)
            {
                Disconnected = true;
                return "Send() Error";
            }
            return "Send() Success";
        }

        private string Send(string strMsg)
        {
            byte[] buffer = BTHUtil.StringToByteArray(strMsg);
            return Send(buffer);
        }

        private string Recv()
        {
            byte[] buffer = new byte[Ws2Consts.RECV_BUFFER];
            int intLen = Ws2Interop.recv(_socket, buffer, Ws2Consts.RECV_BUFFER, 0);
            IntPtr pLen = new IntPtr(intLen);
            if (pLen == Ws2Consts.SOCKET_ERROR)
            {
                Disconnected = true;
                return "";
            }
            return BTHUtil.ByteArrayToString(buffer);
        }
        private string RecvB64()
        {
            byte[] buffer = new byte[Ws2Consts.RECV_BUFFER];
            int intLen = Ws2Interop.recv(_socket, buffer, Ws2Consts.RECV_BUFFER, 0);
            IntPtr pLen = new IntPtr(intLen);
            if (pLen == Ws2Consts.SOCKET_ERROR)
            {
                Disconnected = true;
                return "";
            }
            return Encoding.ASCII.GetString(buffer, 0, Ws2Consts.RECV_BUFFER);
        }

        public string Recieve()
        {
            return this.Recv();
        }

        private string Recv(int PacketSize)
        {
            byte[] buffer = new byte[PacketSize];
            int intLen = Ws2Interop.recv(_socket, buffer, PacketSize, 0);
            IntPtr pLen = new IntPtr(intLen);
            if (pLen == Ws2Consts.SOCKET_ERROR)
            {
                Disconnected = true;
                return "";
            }
            return BTHUtil.ByteArrayToString(buffer);
        }
        
        public bool SendMessage(string strMsg)
        {
            byte[] tmpByte = Encoding.Unicode.GetBytes(strMsg);
            string strB64Msg = Convert.ToBase64String(tmpByte, 0, tmpByte.GetLength(0));
            int len = strB64Msg.Length ;
            int SendNum = len / Ws2Consts.RECV_BUFFER;
            int LastPktSize = len - ((SendNum) * Ws2Consts.RECV_BUFFER) ;
            string strTmp="";
            string strPackInfo = "";
            strPackInfo = Convert.ToString(SendNum);
            strPackInfo += "|" + Convert.ToString(LastPktSize).PadLeft(2) ;

            if (len <= 45)
            {
                strPackInfo += "|" + strB64Msg.PadRight(45);
                Send(strPackInfo);
                return true;
            }
            Send(strPackInfo);
            while ((SendNum > 0)&&(!IsDisconnected())) 
            {
                strTmp = strB64Msg.Substring(0,Ws2Consts.RECV_BUFFER);
                Send(strTmp);
                if(IsDisconnected())
                {
                    break;
                }
                strB64Msg = strB64Msg.Remove(0,Ws2Consts.RECV_BUFFER);
                SendNum--;
            }

            if(IsDisconnected())
            {
                return false;
            }
            if ((strB64Msg.Length > 0) && (!IsDisconnected()))
            {
                Send(strB64Msg);
            }
            return true;
        }

        public bool SendLoginMessage(string strMsg)
        {
            byte[] tmpByte = Encoding.ASCII.GetBytes(strMsg);
            string strB64Msg = Convert.ToBase64String(tmpByte, 0, tmpByte.GetLength(0));
            int len = strB64Msg.Length;
            int SendNum = len / Ws2Consts.RECV_BUFFER;
            int LastPktSize = len - ((SendNum) * Ws2Consts.RECV_BUFFER);
            string strTmp = "";
            string strPackInfo = "";
            strPackInfo = Convert.ToString(SendNum);
            strPackInfo += "|" + Convert.ToString(LastPktSize).PadLeft(2);

            if (len <= 45)
            {
                strPackInfo += "|" + strB64Msg.PadRight(45);
                Send(strPackInfo);
                return true;
            }
            Send(strPackInfo);
            while ((SendNum > 0) && (!IsDisconnected()))
            {
                strTmp = strB64Msg.Substring(0, Ws2Consts.RECV_BUFFER);
                Send(strTmp);
                if (IsDisconnected())
                {
                    break;
                }
                strB64Msg = strB64Msg.Remove(0, Ws2Consts.RECV_BUFFER);
                SendNum--;
            }

            if (IsDisconnected())
            {
                return false;
            }
            if ((strB64Msg.Length > 0) && (!IsDisconnected()))
            {
                Send(strB64Msg);
            }
            return true;
        }

        public string RecvMessage()
        {
            char[] sperator = new char[1];
            sperator[0] = '|';
            string[] strPackInfo;
            string strB64RecvMsg = "";
            string strB64Msg = "";
            string strMsg = "";
            string strLastPack = "";
            int RecvNum = 0;
            int LastPack = 0;
            byte[] B64byte;
            strB64RecvMsg = Recv();
            if (strB64RecvMsg.Length == 0)
            {
                return "";
            }
            if (strB64RecvMsg.Equals("term"))
            {
                return "";
            }
            strPackInfo = strB64RecvMsg.Split(sperator);
            try
            {
                RecvNum = Convert.ToInt32(strPackInfo[0]);
                LastPack = Convert.ToInt32(strPackInfo[1]);
            }
            catch
            {
                return "";
            }

            if ((RecvNum == 0) && (LastPack <= 45))
            {
                try
                {
                    B64byte = Convert.FromBase64String(strB64RecvMsg.Substring(5, LastPack));
                    strMsg = System.Text.Encoding.Unicode.GetString(B64byte, 0, B64byte.GetLength(0));
                }
                catch
                {
                    strMsg = "";
                }
                return strMsg;
            }
            while ((RecvNum > 0) && (!IsDisconnected()))
            {
                strB64RecvMsg = Recv();
                if (strB64RecvMsg.Length == 0)
                {
                    return "";
                }

                if (strB64RecvMsg.Equals("term"))
                {
                    return "";
                }

                strB64Msg += strB64RecvMsg;
                RecvNum--;
            }
            if (IsDisconnected())
            {
                return "";
            }
            if (LastPack > 0)
            {
                strLastPack = Recv();
                if (strLastPack.Equals("term"))
                {
                    return "";
                }
                strB64Msg += strLastPack.Substring(0, LastPack);
            }

            if (strB64Msg.Length == 0)
            {
                return "";
            }
            try
            {
                B64byte = Convert.FromBase64String(strB64Msg);
                strMsg = System.Text.Encoding.Unicode.GetString(B64byte, 0, B64byte.GetLength(0));
            }
            catch
            {
                strMsg = "";
            }
            return strMsg;
        }
        
        public string RecvData()
        {
            char[] sperator = new char[1];
            sperator[0] = '|';
            string[] strPacketInfo;
            string strRecv = "";
            int RecvNum = 0;
            int LastPack = 0;
            string strPackNum = "";
            string strLastPack = "";
            strPackNum = Recv();
            strPacketInfo = strPackNum.Split(sperator);
            try
            {
                RecvNum = Convert.ToInt32(strPacketInfo[0]);
                LastPack = Convert.ToInt32(strPacketInfo[1]);
            }
            catch
            {
                return strPackNum;
            }
            while ((RecvNum > 0) && (!IsDisconnected()))
            {
                strRecv += RecvB64();
                RecvNum--;
            }
            if (IsDisconnected())
            {
                return "Error Message";
            }

            if ((LastPack > 0) && (!IsDisconnected()))
            {
                strLastPack = RecvB64();
                strRecv += strLastPack.Substring(0, LastPack);
            }
            return strRecv;
        }

        public bool IsDisconnected()
        {
            return Disconnected;
        }
        public void Dispose()
        {
            Disconnected = true;
            Ws2Interop.closesocket(this._socket);
            bthClient.Dispose();
            GC.SuppressFinalize(this);
        }
    }
}