phone.cs

实现了windows mobile下对短信进行加密发送

using System;
using System.Text;
using System.Runtime.InteropServices;
using System.Threading;
using System.Windows.Forms;

namespace SMS {
	/// <summary>
	/// Identifies the phone number type specified.
	/// </summary>
	public enum AddressType {
		/// <summary>Unknown phone number type.</summary>
		Unknown,
		/// <summary>International phone number.</summary>
		International,
		/// <summary>National phone number.</summary>
		National,
		/// <summary>Network-specific phone number.</summary>
		NetworkSpecific,
		/// <summary>Subscriber phone number.</summary>
		Subscriber,
		/// <summary>Alphanumeric phone number.</summary>
		Alphanumeric,
		/// <summary>Abbreviated phone number.</summary>
		Abbreviated
	}

	/// <summary>
	/// Information about the phone number.
	/// </summary>
	public struct PhoneAddress {
		/// <summary>The address type.</summary>
		public AddressType AddressType;
		/// <summary>The phone number in string format.</summary>
		public String Address;
	}

	/// <summary>
	/// Short Message Service.
	/// </summary>
	public unsafe class SMSSender {
		private static string	SMS_MSGTYPE_TEXT				= "Microsoft Text SMS Protocol";
        private static long     SMS_MODE_RECEIVE                = 0x00000001;
		private static long		SMS_MODE_SEND					= 0x00000002;
		private static long		SMS_OPTION_DELIVERY_NONE		= 0x00000000;
		private static long		SMS_OPTION_DELIVERY_NO_RETRY	= 0x00000001;
		//private static long		PS_MESSAGE_OPTION_NONE          = 0x00000000;
        //private static long     PS_MESSAGE_OPTION_STATUSREPORT  = 0x00000001;

        private static int PS_MESSAGE_OPTION_NONE = 0;
        private static int PS_MESSAGE_OPTION_STATUSREPORT = 2;
        private IntPtr hSms = IntPtr.Zero;

        private long delivery = SMS_MODE_SEND;
        private bool bStop = false;

        private TEXT_PROVIDER_SPECIFIC_DATA txtProviderDate = new TEXT_PROVIDER_SPECIFIC_DATA();

        public SMSSender()
        {
            txtProviderDate.psMessageClass = PROVIDER_SPECIFIC_MESSAGE_CLASS.PS_MESSAGE_CLASS1;
            txtProviderDate.psReplaceOption = PROVIDER_SPECIFIC_REPLACE_OPTION.PSRO_NONE;
            txtProviderDate.dwMessageOptions = PS_MESSAGE_OPTION_NONE;
        }

		private enum SMS_DATA_ENCODING {
			SMSDE_OPTIMAL=0,
			SMSDE_GSM,
			SMSDE_UCS2,
		}

		private enum PROVIDER_SPECIFIC_MESSAGE_CLASS {
            PS_MESSAGE_CLASS0 = 0, //立即显示但不存储
            PS_MESSAGE_CLASS1 = 1, 
			PS_MESSAGE_CLASS2 = 2,
			PS_MESSAGE_CLASS3  =3,
		}

		private enum PROVIDER_SPECIFIC_REPLACE_OPTION {
			PSRO_NONE = 0,
			PSRO_REPLACE_TYPE1,
			PSRO_REPLACE_TYPE2,
			PSRO_REPLACE_TYPE3,
			PSRO_REPLACE_TYPE4,
			PSRO_REPLACE_TYPE5,
			PSRO_REPLACE_TYPE6,
			PSRO_REPLACE_TYPE7,
			PSRO_RETURN_CALL,
			PSRO_DEPERSONALIZATION,
		}

		private struct TEXT_PROVIDER_SPECIFIC_DATA {
            public int dwMessageOptions;
            //public long dwMessageOptions;
			public PROVIDER_SPECIFIC_MESSAGE_CLASS psMessageClass;
			public PROVIDER_SPECIFIC_REPLACE_OPTION psReplaceOption;
		}
private struct SMSREGISTRATIONDATA {
    public int cbSize;
    public string   tszAppName;//[260];
    public string   tszParams;//[260];
    public string   tszProtocolName;//[260];
} ;

		[DllImport("sms.dll")]
		private static extern IntPtr SmsOpen(String ptsMessageProtocol, IntPtr dwMessageModes, ref IntPtr psmshHandle, IntPtr phMessageAvailableEvent);

		[DllImport("sms.dll")]
		private static extern IntPtr SmsSendMessage(IntPtr smshHandle, IntPtr psmsaSMSCAddress, IntPtr psmsaDestinationAddress, IntPtr pstValidityPeriod, byte[] pbData, IntPtr dwDataSize,
            ref TEXT_PROVIDER_SPECIFIC_DATA pbProviderSpecificData, IntPtr dwProviderSpecificDataSize, SMS_DATA_ENCODING smsdeDataEncoding,
			IntPtr dwOptions,  IntPtr psmsmidMessageID);

		[DllImport("sms.dll")]
		private static extern IntPtr SmsClose(IntPtr smshHandle);

		[DllImport("sms.dll")]
		private static extern IntPtr SmsGetMessageSize(IntPtr smshHandle, ref int pdwDataSize);
        [DllImport("sms.dll")]
        private static extern IntPtr SmsSetMessageNotification( IntPtr regData);


        [DllImport("sms.dll")]
		private static extern IntPtr SmsReadMessage(IntPtr smshHandle, IntPtr psmsaSMSCAddress, IntPtr psmsaDestinationAddress, 
            IntPtr pstValidityPeriod,ref byte[] pbData, int  dwDataSize,
            ref TEXT_PROVIDER_SPECIFIC_DATA pbProviderSpecificData, int dwProviderSpecificDataSize, ref int pdwBytesRead);
        /*
		private static extern IntPtr SmsReadMessage(IntPtr smshHandle, ref IntPtr psmsaSMSCAddress, ref IntPtr psmsaDestinationAddress, 
            ref IntPtr pstValidityPeriod,ref byte[] pbData, IntPtr dwDataSize,
            ref TEXT_PROVIDER_SPECIFIC_DATA pbProviderSpecificData, IntPtr dwProviderSpecificDataSize, ref IntPtr pdwBytesRead);
        */
        [DllImport("Coredll.dll")]
        private static extern IntPtr CreateEvent(IntPtr lpEventAttributes, UInt32 bManualReset, UInt32 bInitialState, IntPtr lpName);

        [DllImport("Coredll.dll")]
        private static extern UInt32 WaitForSingleObject(IntPtr lpEventHandle, UInt32 timeout);
        unsafe public bool InstallNotify()
        {
            SMSREGISTRATIONDATA dataStruct;
            dataStruct.tszAppName = "mytest";

            Byte[] data = new Byte[260 * 3 + 4];
            fixed (byte* pAddr = data)
                {
                    int place = 0;
                    Buffer.BlockCopy(BitConverter.GetBytes(data.Length), 0, data, place, 4);
                    place += 4;
                    byte[] tmp = Encoding.ASCII.GetBytes(dataStruct.tszAppName);
                    Buffer.BlockCopy(tmp, 0, data, place, tmp.Length);
                    place += 260;
                    //Buffer.BlockCopy(BitConverter.GetBytes(Sequence), 0, data, place, 2);
                    place += 260;
                    tmp = Encoding.ASCII.GetBytes(SMS_MSGTYPE_TEXT);
                    Buffer.BlockCopy(tmp, 0, data, place, tmp.Length);
                    /*byte* pCurrent = pAddr;
                    Marshal.WriteInt32((IntPtr)pCurrent, bDest.Length);
                    pCurrent += 4;

                    foreach (byte b in Encoding.Unicode.GetBytes(data.tszAppName))
                    {
                        Marshal.WriteByte((IntPtr)pCurrent, b);
                        pCurrent++;
                    }*/
                   IntPtr rc=SmsSetMessageNotification((IntPtr)pAddr);
                    
                    if ( rc!= IntPtr.Zero)
                        return false;

                    return true;
                }

        }


		unsafe public bool SendMessage(string sPhoneNumber, byte[] bMessage/*string sMessage*/) 
        {
			

				Byte[] bDest = new Byte[516];
                fixed (byte* pAddr = bDest)
                {
                    byte* pCurrent = pAddr;
                    Marshal.WriteInt32((IntPtr)pCurrent, (int)AddressType.Unknown);
                    pCurrent += 4;

                    foreach (byte b in Encoding.Unicode.GetBytes(sPhoneNumber))
                    {
                        Marshal.WriteByte((IntPtr)pCurrent, b);
                        pCurrent++;
                    }
                    


                    //byte[] bMessage = Encoding.Unicode.GetBytes(sMessage);
                    int nMsgSize = bMessage.Length;


                    /*if (SmsSendMessage(hSms, IntPtr.Zero, (IntPtr)pAddr, IntPtr.Zero, bMessage, (IntPtr)nMsgSize,
                        ProvData, (IntPtr)ProvData.Length, SMS_DATA_ENCODING.SMSDE_OPTIMAL, (IntPtr)SMS_OPTION_DELIVERY_NONE, IntPtr.Zero) != IntPtr.Zero)
                        return false;*/


                    if (SmsSendMessage(hSms, IntPtr.Zero, (IntPtr)pAddr, IntPtr.Zero, bMessage, (IntPtr)nMsgSize,
                        ref txtProviderDate, (IntPtr)(sizeof(TEXT_PROVIDER_SPECIFIC_DATA)), SMS_DATA_ENCODING.SMSDE_OPTIMAL, (IntPtr)SMS_OPTION_DELIVERY_NONE, IntPtr.Zero) != IntPtr.Zero)
                        return false;
                }
                return true;
		}


        unsafe public void SetSendState(bool isSave,bool isDelivery)
        {
            if (isSave)
            {
                txtProviderDate.psMessageClass = PROVIDER_SPECIFIC_MESSAGE_CLASS.PS_MESSAGE_CLASS0;
            }
            if (isDelivery)
            {             
                txtProviderDate.dwMessageOptions = PS_MESSAGE_OPTION_STATUSREPORT;
            }
        }


        unsafe public bool OpenDevice()
        {
            try
            {
                //if (SmsOpen(SMS_MSGTYPE_TEXT, (IntPtr)(SMS_MODE_RECEIVE + SMS_MODE_SEND), ref hSms, IntPtr.Zero) != IntPtr.Zero)
                    if (SmsOpen(SMS_MSGTYPE_TEXT, (IntPtr)SMS_MODE_SEND, ref hSms, IntPtr.Zero) != IntPtr.Zero)
                    return false;
                return true;
            }
            catch
            {
                return false;
            }
        }
        unsafe public void CloseDevice()
        {
            SmsClose(hSms);
        }
        public void ReceiveFunc()
        {
            try
            {
                IntPtr smshHandle = IntPtr.Zero;
               IntPtr hEvent = CreateEvent(IntPtr.Zero, 0, 0, IntPtr.Zero);
               if (hEvent == IntPtr.Zero)
                    return ;
               // MessageBox.Show("ｂｅopen", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button1);
                if (SmsOpen(SMS_MSGTYPE_TEXT, (IntPtr)(SMS_MODE_RECEIVE + SMS_MODE_SEND), ref smshHandle, hEvent) != IntPtr.Zero)
                    return ;
                MessageBox.Show("befroe read", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button1);
                while (bStop)
                {
                    int dwSize=0;
                    byte[] pbData = new byte[512];
                    if( WaitForSingleObject(hEvent, 10000)==0)
                    {
                        if (SmsReadMessage(smshHandle, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, ref pbData, pbData.Length,
                        ref txtProviderDate, (sizeof(TEXT_PROVIDER_SPECIFIC_DATA)), ref dwSize) != IntPtr.Zero)
                            MessageBox.Show("sdfsfd", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button1);


                    }
   
                }
                return;
            }
            catch
            {
                return ;
            }

        }
        unsafe public void InstallReceiver()
        {
            Thread myThread = new Thread(new ThreadStart(ReceiveFunc));
            myThread.Start();
            MessageBox.Show("安装成功", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation, MessageBoxDefaultButton.Button1);

        }
        unsafe public void Stop()
        {
            bStop = false;

        }


	}
}