//
//-
#define RADIO_MODESSS
//
using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using InTheHand.Net.Sockets;
using InTheHand.Net.Bluetooth;
using InTheHand.Net;
using System.Threading;
using System.Diagnostics;
using Console = System.ValueType; // Block the use of Console, must use "console".
using System.Reflection;
using InTheHand.Net.Bluetooth.AttributeIds;
using System.Runtime.InteropServices;
using Microsoft.Win32;
using System.Globalization;
using System.Net;
using System.ComponentModel;
#if !ANDROID
using System.IO.Ports;
#endif
using InTheHand.Net.Bluetooth.Factory;

namespace ConsoleMenuTesting
{
    partial class BluetoothTesting
    {
        public MenuSystem console; //HACK public MenuSystem console;
        Stream _peer;

        public BluetoothTesting()
        {
        }

        //----

        WeakReferenceT<BluetoothClient> _cli;

        class WeakReferenceT<T> : WeakReference
        {
            public WeakReferenceT(T target)
                : base(target)
            {
            }

            public new T Target
            {
                get { return (T)base.Target; }
                set { base.Target = value; }
            }
        }

        //--------

#if false && ANDROID
        [MenuItem, SubMenu("PLAYING")]
        public void CheckAndroidNetworkStream()
        {
            var tmp = new MemoryStream();
            var ns = new InTheHand.Net.Bluetooth.Droid.AndroidBthClient.AndroidNetworkStream(tmp);
            console.WriteLine("Done create AndroidNetworkStream.");
            ns.WriteByte(11);
            console.WriteLine("Done write to AndroidNetworkStream.");
            ns.Position = 0;
            var bi = ns.ReadByte();
            console.WriteLine("Done read from AndroidNetworkStream.");
        }
#endif

#if true || DEBUG
        [MenuItem, SubMenu("TEST")]
        public void TestPause()
        {
            console.WriteLine("1111");
            console.WriteLine("2222");
            console.WriteLine("3333");
            console.WriteLine("4444");
            console.WriteLine("55555");
            console.WriteLine("Before Pause");
            console.Pause("Message");
            console.WriteLine("After Pause");
        }

        [MenuItem, SubMenu("TEST")]
        public void TestReadLine()
        {
            var i = console.ReadLine("foo\r\nbar");
            if (i == null) {
                console.WriteLine("you input: <null>");
            } else {
                console.WriteLine("you input: [[{0}]], len: {1}", i, i.Length);
            }
        }

        [MenuItem, SubMenu("TEST")]
        public void TestReadBluetoothAddress()
        {
            var a = console.ReadBluetoothAddress("foo\r\nbar");
            if (a == null) {
                console.WriteLine("you input: <null>");
            } else {
                console.WriteLine("you input: [[{0}]]", a);
            }
        }

        [MenuItem, SubMenu("TEST")]
        public void TestReadOptionalBluetoothAddress()
        {
            var a = console.ReadOptionalBluetoothAddress("foo\r\nbar");
            if (a == null) {
                console.WriteLine("you input: <null>");
            } else {
                console.WriteLine("you input: [[{0}]]", a);
            }
        }

        [MenuItem, SubMenu("TEST")]
        public void TestReadOptionalInteger()
        {
            var i = console.ReadOptionalInteger("foobar");
            if (i == null) {
                console.WriteLine("you input: <null>");
            } else {
                console.WriteLine("you input: [[{0}]]", i.Value);
            }
        }

        [MenuItem, SubMenu("TEST")]
        public void TestReadYesNo()
        {
            bool i = console.ReadYesNo("foobarYN (default: true)", true);
            console.WriteLine("you input: {0}", i);
            i = console.ReadYesNo("foobarYN (default: false)", false);
            console.WriteLine("you input: {0}", i);
        }

        [MenuItem, SubMenu("TEST")]
        public void TestReadYesNoCancel()
        {
            bool? i = console.ReadYesNoCancel("foobarYNC (default: true)", true);
            console.WriteLine("you input: {0}", i);
            i = console.ReadYesNoCancel("foobarYNC (default: false)", false);
            console.WriteLine("you input: {0}", i);
            i = console.ReadYesNoCancel("foobarYNC (default: cancel)", null);
            console.WriteLine("you input: {0}", i);
        }

        [MenuItem, SubMenu("TEST")]
        public void TestGetFilename()
        {
            var a = console.GetFilename();
            if (a == null) {
                console.WriteLine("you input: <null>");
            } else {
                console.WriteLine("you input: [[{0}]]", a);
            }
        }
#endif

        [MenuItem, SubMenu("Playing")]
        public void DoBthReadRemoteVersion()
        {
            var addr = console.ReadBluetoothAddress("remote");
            var ba = addr.ToByteArray();
            //
            byte lmpVersion;
            ushort lmpSubVersion, manuf0;
            byte[] lmpFeatures = new byte[20];
            int ret = BthReadRemoteVersion(ba,
                out lmpVersion, out lmpSubVersion, out manuf0, lmpFeatures);
            console.WriteLine("ret: {0}=0x{0:X}", ret);
            var manuf = (Manufacturer)manuf0;
            console.WriteLine("lmpVersion: {0}, lmpSubVersion: {1},"
                + " manuf {2} {3}, lmpFeatures[0]: 0x{4:X}",
                lmpVersion, lmpSubVersion, manuf, manuf, lmpFeatures[0]);
        }

        private const string btdrtDll = "btdrt.dll";
        [DllImport(btdrtDll, SetLastError = true)]
        public static extern int BthReadRemoteVersion(byte[] pba, out byte plmp_version,
            out ushort plmp_subversion, out ushort pmanufacturer, byte[] plmp_features);


        [MenuItem, SubMenu("BtLsnr")]
        public void SomeCustomUuids()
        {
            var list = new Guid[] {
                new Guid("{7630F141-6361-4e60-A8EE-237180DA9CE8}"),
                new Guid("{C7CB927D-8DBE-44f2-B671-3DF8D50C4E2F}"),
                new Guid("{59438E67-6094-4bbc-B500-511DE96BB535}"),
                new Guid("{C50AFF29-3C38-4fb7-AB32-D541AD835C34}"),
            };
            foreach (var g in list) {
                console.WriteLine(g);
            }
        }

        //[MenuItem, SubMenu("TEST")]
        //TODO public void ExceptionNative()
        //{
        //    IntPtr p = new IntPtr(1);
        //    var o = Marshal.PtrToStructure(p, typeof(Int64));
        //}

        [MenuItem, SubMenu("TEST")]
        public void ExceptionManaged()
        {
            if (!console.ReadYesNo("Throw exception", false)) return;
            throw new RankException("test");
        }

        [MenuItem, SubMenu("TEST")]
        public void ExceptionManagedOnDelegateAsyncInvoke()
        {
            Action<Version> dlgt = delegate(Version fake)
            {
                console.WriteLine("(Thread gonna throw...)");
                throw new RankException("test");
            };
            if (!console.ReadYesNo("Throw exception", false)) return;
            var ar = DelegateExtension.BeginInvoke(dlgt, null, null, null);
            DelegateExtension.EndInvoke(dlgt, ar);
        }

        //----
        [MenuItem, SubMenu("Playing")]
        public void Base64Decode()
        {
            string s = console.ReadLine("Base64 string");
            console.WriteLine("Input Base64 string: '{0}'", s);
            byte[] arr = Convert.FromBase64String(s);
            var asStr = GetEncoding_forHTC().GetString(arr, 0, Math.Min(20, arr.Length));
            console.WriteLine("asStr: '{0}'", asStr);
        }

        private static Encoding GetEncoding_forHTC()
        {
            var enc = (Encoding)Encoding.ASCII.Clone();
#if !NETCF
            enc.DecoderFallback = new System.Text.DecoderReplacementFallback(".");
            enc.EncoderFallback = new System.Text.EncoderReplacementFallback(".");
#endif
            return enc;
        }

        [MenuItem, SubMenu("Playing")]
        public void Base64Encode()
        {
            string s = console.ReadLine("Input String");
            console.WriteLine("Input string: '{0}'", s);
            var arr = GetEncoding_forHTC().GetBytes(s);
            var b64str = Convert.ToBase64String(arr);
            console.WriteLine("b64str: '{0}'", b64str);
        }

        //----
        [MenuItem, SubMenu("Device Discovery")]
        public void Ebap_NotImplHandlers()
        {
            var bco2 = new BluetoothComponent();
            bco2.DiscoverDevicesComplete += new EventHandler<DiscoverDevicesEventArgs>(bco2_DiscoverDevicesComplete);
            bco2.DiscoverDevicesProgress += new EventHandler<DiscoverDevicesEventArgs>(bco2_DiscoverDevicesProgress);
            bco2.DiscoverDevicesAsync(255, true, true, true, false, null);
        }

        void bco2_DiscoverDevicesProgress(object sender, DiscoverDevicesEventArgs e)
        {
            throw new NotImplementedException();
        }

        void bco2_DiscoverDevicesComplete(object sender, DiscoverDevicesEventArgs e)
        {
            throw new NotImplementedException();
        }

        [MenuItem, SubMenu("Device Discovery")]
        public void _EbapAsyncDiscoDevices()
        {
            bool discoOnly, auth, rembd, unk;
            GetDiscoveryFlags(console, out discoOnly, out auth, out rembd, out unk);
            //
            var cli = Create_BluetoothClient();
            //cli.InquiryLength = TimeSpan.FromMinutes(1);
            BluetoothComponent bco = new BluetoothComponent(cli);
#if NETCF
            //bco.SetSynchronizeInvoke((System.Windows.Forms.Control)console.InvokeeControl);
#endif
            bco.DiscoverDevicesProgress += _DiscoDevicesAsync_ProgressCallback;
            bco.DiscoverDevicesComplete += _DiscoDevicesAsync_CompleteCallback;
            EventHandler startAction = delegate
            {
                bco.DiscoverDevicesAsync(255, auth, rembd, unk, discoOnly, 99);
            };
            bool startOnUi = console.ReadYesNo("Start from UI thread", true);
            if (startOnUi) {
                console.UiInvoke(startAction);
            } else {
                startAction(null, EventArgs.Empty);
            }
            console.WriteLine("Started at {0} (UTC {1}).", GetTimeWallclockHR(), DateTime.UtcNow.ToLongTimeString());
            console.Pause("After completion un-pause to continue");
        }

        void _DiscoDevicesAsync_CompleteCallback(object sender, DiscoverDevicesEventArgs e)
        {
            Debug.Assert((int)e.UserState == 99);
            CheckSyncCtx();
            console.WriteLine("At {0} {1}, ", GetTimeWallclockHR(), "Complete");
            if (WriteAsyncCompletedState("DiscoDevicesAsync", e)) {
                console.WriteLine("DiscoDevicesAsync found {0} devices.", e.Devices.Length);
                _DiscoDevicesAsync_ShowDevices(e);
            }
            console.WriteLine("Complete.");
        }

        void _DiscoDevicesAsync_ProgressCallback(object sender, DiscoverDevicesEventArgs e)
        {
            var nowUtc = DateTime.UtcNow;
            Debug.Assert((int)e.UserState == 99);
            CheckSyncCtx();
            console.WriteLine("At {0}, {1}, {2} devices:",
                GetTimeWallclockHR(), "async progress",
                e.Devices.Length);
            _DiscoDevicesAsync_ShowDevices(e);
        }

        private void _DiscoDevicesAsync_ShowDevices(DiscoverDevicesEventArgs e)
        {
            foreach (var dev in e.Devices) {
                console.WriteLine("* {0} {1}, last seen: {2}", dev.DeviceAddress, ToStringQuotedOrNull(dev.DeviceName),
                    dev.LastSeen == DateTime.MinValue ? "NEVER" : dev.LastSeen.ToString("o"));
            }
        }

        private bool WriteAsyncCompletedState(string name,
            AsyncCompletedEventArgs e)
        {
            if (e.Cancelled) {
                console.WriteLine("Cancelled: " + name);
            } else if (e.Error != null) {
                console.WriteLine("Error in: " + name + ", error: {0}.", Exception_FirstLine(e.Error));
            } else {
                console.WriteLine("Successful Completion of: " + name);
                return true;
            }
            return false;
        }

        private void CheckSyncCtx()
        {
            bool? bad = console.InvokeRequired;
            if (bad == true) {
                console.WriteLine("Event not called on the UI thread!!!!");
            }
        }

        //--------

        BluetoothRadio m_factoryRadio;
        BluetoothPublicFactory m_factory;

        // TODO Should BluetoothPublicFactory have a Primary/AllRadios property?
        /// <summary>
        /// --can return null--
        /// </summary>
        /// <returns></returns>
        BluetoothRadio Get_BluetoothRadio()
        {
            if (m_factory == null)
                return BluetoothRadio.GetPrimaryRadio();
            BluetoothRadio radio = m_factoryRadio;
            if (radio == null)
                throw new InvalidOperationException("No active radios.");
            //ClassOfDevice checkNonNull = radio.ClassOfDevice;
            return radio;
        }

        BluetoothDeviceInfo Create_BluetoothDeviceInfo(BluetoothAddress addr)
        {
            if (m_factory == null)
                return new BluetoothDeviceInfo(addr);
            return m_factory.CreateBluetoothDeviceInfo(addr);
        }

        BluetoothClient Create_BluetoothClient()
        {
            if (m_factory == null)
                return new BluetoothClient();
            return m_factory.CreateBluetoothClient();
        }

        private BluetoothClient Create_BluetoothClient(BluetoothEndPoint localEndPoint)
        {
            if (m_factory == null)
                return new BluetoothClient(localEndPoint);
            return m_factory.CreateBluetoothClient(localEndPoint);
        }

        BluetoothListener Create_BluetoothListener(Guid svc)
        {
            if (m_factory == null)
                return new BluetoothListener(svc);
            return m_factory.CreateBluetoothListener(svc);
        }

        BluetoothListener Create_BluetoothListener(Guid svc, ServiceRecord record)
        {
            if (m_factory == null)
                return new BluetoothListener(svc, record);
            return m_factory.CreateBluetoothListener(svc, record);
        }

        BluetoothListener Create_BluetoothListener(BluetoothEndPoint ep)
        {
            if (m_factory == null)
                return new BluetoothListener(ep);
            return m_factory.CreateBluetoothListener(ep);
        }

        BluetoothListener Create_BluetoothListener(BluetoothEndPoint ep, ServiceRecord record)
        {
            if (m_factory == null)
                return new BluetoothListener(ep, record);
            return m_factory.CreateBluetoothListener(ep, record);
        }

        ObexWebRequest Create_ObexWebRequest(Uri requestUri)
        {
            if (m_factory == null)
                return new ObexWebRequest(requestUri);
            return m_factory.CreateObexWebRequest(requestUri);
        }

        ObexWebRequest Create_ObexWebRequest(string scheme, BluetoothAddress target, string path)
        {
            if (m_factory == null)
                return new ObexWebRequest(target, path);
            return m_factory.CreateObexWebRequest(scheme, target, path);
        }

        ObexListener Create_ObexListener_Bluetooth()
        {
            if (m_factory == null)
                return new ObexListener(ObexTransport.Bluetooth);
            return m_factory.CreateObexListener();
        }

#if !ANDROID
        L2CapListener Create_L2CapListener(Guid svc)
        {
            //if (m_factory == null)
            return new L2CapListener(svc);
            //return m_factory.CreateL2CapListener(svc);
        }

        private L2CapListener Create_L2CapListener(BluetoothEndPoint localEndPoint)
        {
            //if (m_factory == null)
            return new L2CapListener(localEndPoint);
            //return m_factory.CreateL2CapListener(localEndPoint);
        }
#endif


        [MenuItem]
        public void SetStack_Factory()
        {
            BluetoothRadio[] list = BluetoothRadio_GetAllAndDump();
            if (list.Length == 0) {
                console.WriteLine("No radios found!");
                m_factory = null;
                m_factoryRadio = null;
            }
            int? choice;
            do {
                choice = console.ReadOptionalInteger(string.Format("Which stack for factory (1-{0}), 0 for \"new\"-direct", list.Length));
                if (choice == null) choice = 0;
            } while (choice < 0 || choice > list.Length);
            if (choice == 0) {
                m_factory = null;
                m_factoryRadio = null;
                console.WriteLine("Selected #{0} 'new-direct'.", choice);
            } else {
                m_factoryRadio = list[choice.Value - 1];
                m_factory = m_factoryRadio.StackFactory;
                console.WriteLine("Selected #{0}, stack: '{1}' address: {2}.", choice,
                    m_factoryRadio.SoftwareManufacturer, m_factoryRadio.LocalAddress);
            }
        }


        //--------
        private string GetTimeWallclockHR()
        {
            return DateTime.Now.TimeOfDay.ToString();
        }

        private string GetTime()
        {
            return Environment.TickCount.ToString();
        }

        void ErrorFromMiscCallback(IAsyncResult ar)
        {
            MiscCallback(ar);
            throw new RankException();
        }

        void MiscCallback(IAsyncResult ar)
        {
            console.WriteLine("{1}: Callback called for \"{0}\"", ar.AsyncState, GetTime());
        }

        void EmptyCallback(IAsyncResult ar)
        {
            if (ar.CompletedSynchronously) {
            } else {
            }
        }

        bool VerifyConnectionWrite()
        {
            if (_peer == null) {
                console.WriteLine("No connection!");
                return false;
            }
            if (!_peer.CanWrite) {
                if (!console.ReadYesNo("NOT CanWrite, do operation anyway", false))
                    return false;
            }
            return true;
        }

        bool VerifyConnectionRead()
        {
            if (_peer == null) {
                console.WriteLine("No connection!");
                return false;
            }
            if (!_peer.CanRead) {
                if (!console.ReadYesNo("NOT CanRead, do operation anyway", false))
                    return false;
            }
            return true;
        }

        //--------
        [MenuItem, SubMenu("Data")]
        public void PrintStreamState()
        {
            if (_peer == null) {
                console.WriteLine("Stream is null.");
            } else {
                console.WriteLine("Stream has CanRead: {0}, CanWrite: {1}.",
                    _peer.CanRead, _peer.CanWrite);
            }
            if (_cli == null) {
                console.WriteLine("BtClient is null.");
            } else {
                var cli = _cli.Target;
                if (cli == null) {
                    console.WriteLine("BtClient has been GC'd away.");
                } else {
                    console.WriteLine("BtClient has Connected: {0}.",
                        cli.Connected);
                }
            }
        }

        [MenuItem, SubMenu("Data")]
        public void CloseStream()
        {
            if (_peer != null) {
                _peer.Close();
                _peer = null;
            }
        }

        [MenuItem, SubMenu("Data")]
        public void CloseStream_ButDontNullIt()
        {
            if (_peer != null) {
                _peer.Close();
            }
        }

        [MenuItem, SubMenu("Data")]
        public void NullStreamAndClient()
        {
            _peer = null;
            _cli = null;
        }

        [MenuItem, SubMenu("Data")]
        public void CloseClientIfExists()
        {
            if (_cli != null) {
                BluetoothClient cli = _cli.Target;
                if (cli != null) {
                    cli.Close();
                    _cli = null;
                } else {
                    console.WriteLine("The reference has been GC'd.");
                }
            }
        }

        private BluetoothListener ListenInit()
        {
            Guid svcClass = BluetoothService.Wap;
            console.WriteLine("Default UUID : {0}", svcClass);
            Guid? inputGuid = console.ReadOptionalBluetoothUuid("UUID", svcClass);
            if (inputGuid.HasValue)
                svcClass = inputGuid.Value;
            int? port = console.ReadOptionalInteger("Port number");
            bool auth = console.ReadYesNo("Authenticate", false);
            bool encpt = console.ReadYesNo("Encrypt", false);
            bool setPin1, setPin2;
            string passcode;
            BluetoothAddress pinAddr;
            PromptForSetPin(console, out setPin1, out setPin2, out passcode, out pinAddr);
            string svcName = console.ReadLine("Service Name (optional)");
            if (svcName != null && svcName.Length == 0)
                svcName = null;
            //
            BluetoothEndPoint lep;
            if (port == null)
                lep = new BluetoothEndPoint(BluetoothAddress.None, svcClass);
            else
                lep = new BluetoothEndPoint(BluetoothAddress.None, svcClass, port.Value);
            console.WriteLine("Going to listen on: {0}:{1}:{2}; auth: {3}, encrypt: {4}.",
                lep.Address, lep.Service, lep.Port, auth, encpt);
            //
            ServiceRecord sr = null;
            if (lep.Service == BluetoothService.DialupNetworking) {
                var bldr = new ServiceRecordBuilder();
                bldr.AddServiceClass(lep.Service);
                bldr.AddServiceClass(BluetoothService.GenericNetworking);
                bldr.AddBluetoothProfileDescriptor(lep.Service, 1, 0);
                sr = bldr.ServiceRecord;
                console.WriteLine("Adding custom record: "
                    + ServiceRecordUtilities.Dump(sr));
            }
            BluetoothListener lsnr;
            if (sr == null) {
                lsnr = Create_BluetoothListener(lep);
            } else {
                lsnr = Create_BluetoothListener(lep, sr);
            }
            if (svcName != null)
                lsnr.ServiceName = svcName;
            // Assume false by default, so if NotImpl fails only if user says true.
            if (auth)
                lsnr.Authenticate = true;
            if (encpt)
                lsnr.Encrypt = true;
            if (setPin1) {
                Debug.Assert(pinAddr == null, "pinAddr == null");
                //lsnr.SetPin(passcode);
                console.WriteLine("Soooorrrrry we don't support SetPin(String) on listener!!!!");
                throw new NotSupportedException("MenuTesting");
            } else if (setPin2) {
                Debug.Assert(pinAddr != null, "pinAddr != null");
                lsnr.SetPin(pinAddr, passcode);
            }
            console.WriteLine("Starting Listener...");
            lsnr.Start();
            BluetoothEndPoint lepLsnr = (BluetoothEndPoint)lsnr.LocalEndPoint;
            console.WriteLine("Listening on endpoint: {0}", lepLsnr);
            return lsnr;
        }

        //[MenuItem, SubMenu("BtLsnr")]
        //public void ListenStartStopStart()
        //{
        //    Guid svcClass = BluetoothService.Wap;
        //    console.WriteLine("Default UUID : {0}", svcClass);
        //    Guid? inputGuid = console.ReadOptionalBluetoothUuid("UUID");
        //    if (inputGuid.HasValue)
        //        svcClass = inputGuid.Value;
        //    BluetoothListener lsnr = Create_BluetoothListener(svcClass);
        //    lsnr.Start();
        //    lsnr.Stop();
        //    lsnr.Start();
        //    //
        //    lsnr = null;
        //    GC.Collect();
        //    GC.Collect();
        //    GC.WaitForPendingFinalizers();
        //}

        [MenuItem, SubMenu("BtLsnr")]
        public void Listen()
        {
            BluetoothListener lsnr = ListenInit();
            BluetoothClient cli;
            bool startStopStartEtc = console.ReadYesNo("Start-Stop-Start-Stop-Start-Finalize", false);
            if (startStopStartEtc) {
                lsnr.Stop();
                lsnr.Start();
                console.WriteLine("Stopped and restarted.");
            }
            bool @async = console.ReadYesNo("Async Accept", false);
            if (!@async) {
                bool callPending = console.ReadYesNo("Loop on Pending()", false);
                if (callPending) {
                    int i = 0;
                    while (!lsnr.Pending()) {
                        console.WriteLine("Not Pending" + new string('.', (i + 3) % 3));
                        const int HalfSecond = 500;
                        Thread.Sleep(HalfSecond);
                        ++i;
                    }
                    console.WriteLine("Is Pending...");
                }
                //bool closeNow = console.ReadYesNo("Hit return to proceed to EndConnect.  Enter Y to call Close first.", false);
                console.WriteLine("calling Accept...");
                cli = lsnr.AcceptBluetoothClient();
            } else {
                console.WriteLine("Waiting for connection...");
                IAsyncResult ar = lsnr.BeginAcceptBluetoothClient(MiscCallback, "BeginAcceptBluetoothClient");
                console.WriteLine("(BeginAccept returned)");
                bool startStopStartEtcAfter = console.ReadYesNo("Start-Stop-Start-Stop-Start-Finalize (will break *us*)", false);
                if (startStopStartEtcAfter) {
                    lsnr.Stop();
                    lsnr.Start();
                    console.WriteLine("Stopped and restarted.");
                }
#if !NETCF
                ManualResetEvent quit = console.NewManualResetEvent(false);
                int signalledIdx = WaitHandle.WaitAny(new WaitHandle[] { ar.AsyncWaitHandle, quit });
                if (signalledIdx == 1) {
                    // ?Do we want to test disposal or Finalization here?
                    // lsnr.Stop()
                    _peer = null;
                    return;
                }
#endif
                cli = lsnr.EndAcceptBluetoothClient(ar);
            }
            //
            _peer = cli.GetStream();
            _cli = new WeakReferenceT<BluetoothClient>(cli);
            console.WriteLine("Got connection from: '{0}' {1}", cli.RemoteMachineName, cli.RemoteEndPoint);
            PrintLocalEndpointIfAvailable(cli);
            console.Pause("Un-pause to continue; and close listener");
            if (!startStopStartEtc) {
                lsnr.Stop();
            } else {
                lsnr.Stop();
                lsnr.Start();
                //
                bool x = console.ReadYesNo("Do Async Accept (before Finalization)", false);
                IAsyncResult arLast = null;
                if (x) {
                    arLast = lsnr.BeginAcceptBluetoothClient(MiscCallback, "BeginAcceptBluetoothClient");
                    console.WriteLine("(BeginAccept returned)");
                }
                lsnr = null;
                GC.Collect();
                GC.Collect();
                GC.WaitForPendingFinalizers();
                console.WriteLine("Stopped, restarted, and Finalized.");
                if (arLast != null) {
                    console.WriteLine("arLastL: {0}", arLast.IsCompleted);
                    // Can't call EndAccept as no lsnr reference!
                }
            }
        }

        [MenuItem, SubMenu("BtLsnr")]
        public void ListenAndImmediatelyClose()
        {
            ListenAndImmediatelySendAndClose_(null);
        }

        [MenuItem, SubMenu("BtLsnr")]
        public void ListenAndImmediatelySendOneByteAndClose()
        {
            ListenAndImmediatelySendAndClose_(new byte[] { (byte)'a' });
        }

        void ListenAndImmediatelySendAndClose_(byte[] data)
        {
            BluetoothListener lsnr = ListenInit();
            console.WriteLine("Waiting for connection...");
            BluetoothClient cli = lsnr.AcceptBluetoothClient();
            console.WriteLine("Got connection from: {0}!", cli.RemoteMachineName);
            _peer = cli.GetStream();
            if (data != null)
                _peer.Write(data, 0, data.Length);
            _peer.Close();
            _peer = null;
            console.WriteLine("Got connection from ({2}and closed it!): '{0}' {1}",
                cli.RemoteMachineName, cli.RemoteEndPoint,
                (data != null ? "sent " : string.Empty));
            lsnr.Stop();
        }

        [MenuItem, SubMenu("Data")]
        public void SendOneByteAndImmediatelyClose()
        {
            if (!VerifyConnectionWrite())
                return;
            byte[] data = { (byte)'a' };
            _peer.Write(data, 0, data.Length);
            _peer.Close();
        }

        [MenuItem, SubMenu("BtLsnr")]
        public void ListenAcceptMultiple()
        {
            BluetoothListener lsnr = ListenInit();
            ManualResetEvent quit = console.NewManualResetEvent(false);
            ListenAcceptMultipleState state = new ListenAcceptMultipleState();
            state.lsnr = lsnr;
            state.quit = quit;
            bool keepOpen = console.ReadYesNo("Keep reference to all connections?", false);
            state.KeepAllConnections = keepOpen;
            state.ReadToEnd = console.ReadYesNo("ReadToEnd of all connections?", false);
            lsnr.BeginAcceptBluetoothClient(ListenAcceptMultiple_Callback, state);
            console.Pause("Un-pause to stop accepting");
            quit.Set();
            lsnr.Stop();
        }
        struct ListenAcceptMultipleState
        {
            public BluetoothListener lsnr;
            public ManualResetEvent quit;
            public int num;
            //
            bool storeAllConnections;
            public List<BluetoothClient> connList;
            public bool ReadToEnd;

            public bool KeepAllConnections
            {
                get { return storeAllConnections; }
                set
                {
                    storeAllConnections = value;
                    if (storeAllConnections && connList == null) {
                        connList = new List<BluetoothClient>();
                    }
                }
            }
        }

        struct ListenAcceptMultipleConnectionState
        {
            public BluetoothClient Cli;
            public int Id;
        }

        void ListenAcceptMultiple_Callback(IAsyncResult arCb)
        {
            ListenAcceptMultipleState state = (ListenAcceptMultipleState)arCb.AsyncState;
            BluetoothClient cli;
            try {
                cli = state.lsnr.EndAcceptBluetoothClient(arCb);
                if (state.KeepAllConnections) {
                    state.connList.Add(cli);
                }
            } catch (ArgumentException ex) {
                console.WriteLine("Accept failed, due to quit?  Exiting.  "
                    + Exception_FirstLine(ex));
                return;
            } catch (ObjectDisposedException ex) {
                console.WriteLine("Accept failed, due to quit?  Exiting.  "
                    + Exception_FirstLine(ex));
                return;
            }
            Stream peer = cli.GetStream();
            console.WriteLine("At " + DateTime.Now.ToLongTimeString() + " got connection #" + (state.num + 1) + " from: '{0}' {1}", cli.RemoteMachineName, cli.RemoteEndPoint);
            ++state.num;
            if (!IsSet(state.quit))
                state.lsnr.BeginAcceptBluetoothClient(ListenAcceptMultiple_Callback, state);
            if (state.ReadToEnd) {
                ThreadPool.QueueUserWorkItem(ReadToEnd_Runner,
                    new ListenAcceptMultipleConnectionState { Cli = cli, Id = state.num });
            }
            if (_peer == null) {
                _peer = peer;
                console.WriteLine("Connection now active.");
            }
        }

        void ReadToEnd_Runner(object state)
        {
            var state2 = (ListenAcceptMultipleConnectionState)state;
            var conn = state2.Cli.GetStream();
            var buf = new byte[1000];
            while (true) {
                try {
                    int readLen = conn.Read(buf, 0, buf.Length);
                    console.WriteLine("Conn#{0}: Read '{1}' bytes",
                        state2.Id, readLen);
                    if (readLen == 0)
                        break;
                } catch (Exception ex) {
                    console.WriteLine("Conn#{0}: exception: {1}",
                        state2.Id, Exception_FirstLine(ex));
                    break;
                }
            }//while
            console.WriteLine("Conn#{0}: Exit at {1}",
                state2.Id, DateTime.Now.ToLongTimeString());
        }


        [MenuItem, SubMenu("SmokeTest")]
        public void NewBt_Endpoint()
        {
            var ep = new BluetoothEndPoint(BluetoothAddress.None, Guid.Empty);
            console.WriteLine("BluetoothEndPoint created successfully.");
        }

        [MenuItem, SubMenu("SmokeTest")]
        public void NewBtEndpoint_fromSocketAddress()
        {
            var ep = new BluetoothEndPoint(BluetoothAddress.Parse("002233445566"), BluetoothService.AttProtocol);
            console.WriteLine("BluetoothEndPoint created successfully.");
            var sa = ep.Serialize();
            console.WriteLine("SocketAddress created successfully.");
            var ep2 = ep.Create(sa);
            console.WriteLine("BluetoothEndPoint created successfully.");
        }

        [MenuItem, SubMenu("SmokeTest")]
        public void NewBt_Cli()
        {
            using (BluetoothClient cli = Create_BluetoothClient()) {
                console.WriteLine("BluetoothClient created successfully.");
                console.ReadLine("BluetoothClient created.  Continue to dispose");
            }
        }

        [MenuItem, SubMenu("SmokeTest")]
        public void NewBt_Lsnr()
        {
            BluetoothListener lsnr = Create_BluetoothListener(BluetoothService.Wap);
            try {
                console.WriteLine("BluetoothListener created, now calling Start.");
                lsnr.Start();
                console.ReadLine("Started.  Continue to dispose");
            } finally {
                if (lsnr != null)
                    lsnr.Stop();
            }
        }

        BluetoothAddress _simpleConnectAddress;

        [MenuItem, SubMenu("BtClient")]
        public void Connect_SimpleClosingFirst()
        {
            if (_peer != null && console.ReadYesNo("Close (possible) connection first", false)) {
                CloseStream();
            }
            //
            BluetoothAddress addr;
            if (_simpleConnectAddress != null
                    && console.ReadYesNo("Use server address: " + _simpleConnectAddress, true)) {
                addr = _simpleConnectAddress;
            } else {
                addr = console.ReadBluetoothAddress("Server's BluetoothAddress");
            }
            ConnectSimpleClosingFirstPart2(addr);
        }

        void ConnectSimpleClosingFirstPart2(BluetoothAddress addr)
        {
            Guid svcClass = BluetoothService.Wap;
            BluetoothEndPoint rep = new BluetoothEndPoint(addr, svcClass);
            BluetoothClient cli = Create_BluetoothClient();
            _simpleConnectAddress = addr;
            //
            console.WriteLine("Connecting to: {0}:{1}:{2} ...", rep.Address, rep.Service, rep.Port);
            cli.Connect(rep);
            console.WriteLine("Connected to : '{0}' {1}", cli.RemoteMachineName, cli.RemoteEndPoint);
            PrintLocalEndpointIfAvailable(cli);
            _peer = cli.GetStream();
            _cli = new WeakReferenceT<BluetoothClient>(cli);
        }

        [MenuItem, SubMenu("BtClient")]
        public void Connect()
        {
            BluetoothClient cli;
            Connect_(out cli);
            _peer = cli.GetStream();
            _cli = new WeakReferenceT<BluetoothClient>(cli);
        }

#if NETCF
        [MenuItem, SubMenu("Playing")]
        public void BtpsScoWith_Connect()
        {
            var p = new InTheHand.Net.Bluetooth.StonestreetOne.BluetopiaPlaying();
            Action<BluetoothAddress> makeConnect = delegate(BluetoothAddress address) {
                p.HciCreateConnection(address);
            };
            //
            BluetoothClient cli;
            Connect_(out cli, makeConnect);
            _peer = cli.GetStream();
            _cli = new WeakReferenceT<BluetoothClient>(cli);
            ThreadPool.QueueUserWorkItem(state => Read_(40, false));
            //
            p.HciAddScoConnection();
            //
            var buf = Encoding.ASCII.GetBytes("ATD 07981152473\r");
            _peer.Write(buf, 0, buf.Length);
        }

        [MenuItem, SubMenu("Playing")]
        public void BtpsRawHci()
        {
            var p = new InTheHand.Net.Bluetooth.StonestreetOne.BluetopiaPlaying();
            Byte ogf = 0x3f;
            ushort ocf = 0;
            const byte FirstFragment = 0x80;
            const byte LastFragment = 0x40;
            const byte BccmdChannelId = 2;
            const byte PayloadDescriptor = BccmdChannelId | FirstFragment | LastFragment;
            //
            //const ushort xxBccmdGetReqxx = 0x0000;
            //const ushort xxBuildIdxx = 0x28_19;
            //const ushort xxBuildIdLoaderxx = 0x28_38;
            //
            int seqNum = Interlocked.Increment(ref csrSeqNum);
            Byte[] command = { PayloadDescriptor, 
                //cmd
                0x00, 0x00,
                //len
                16,0,
                //SeqNum
                (byte)seqNum,0,
                // VarId
                0x19,0x28,
                // Status
                0,0,
                // Payload
                0,0,0,0, 0,0,0,0,
            };
            Byte lenCommand = checked((byte)command.Length);
            //
            int ret = p.HciSendRawCommand(ogf, ocf, lenCommand, command);
            console.WriteLine("HCI_Send_Raw_Command ret: {0}", ret);
            /*
                Frame 1: 23 bytes on wire (184 bits), 23 bytes captured (184 bits)
                01:00:fc:13!c2:00:00:10: 00:01:00:19:28:00:00:00:
                00:00:00:00:00:00:00

                Frame 2: 36 bytes on wire (288 bits), 36 bytes captured (288 bits)
                04:ff:21!c2:01:00:10:00: 01:00:19:28:00:00:7e:0d:
                00:00:00:00:00:00:00:00: 00:00:00:00:00:00:00:00:
                00:00:00:00
             * Status = 0
             * BuildID = 0x0d7e = 3454
             * Which is the same as the value reported in Radio info. :-)
             */
        }

        static int csrSeqNum;
#endif

        readonly TimeSpan ConnectDuringDiscoveryPreConnectDelayMs
            = TimeSpan.FromSeconds(4);

        [MenuItem, SubMenu("BtClient")]
        public void Connect_WithInquiryRunning_APM()
        {
            TimeSpan delay = ConnectDuringDiscoveryPreConnectDelayMs;
            var givenDelay = console.ReadTimeSecondsOptional(" (default " + delay + ")");
            if (givenDelay != null) {
                delay = givenDelay.Value;
            }
            BluetoothClient cliDD = Create_BluetoothClient();
            IAsyncResult arDD = null;
            Action<BluetoothAddress> startDisco = delegate
            {
                arDD = cliDD.BeginDiscoverDevices(255, false, false, false, true,
                    MiscCallback, "BeginDiscoverDevices");
                Thread.Sleep(delay.Seconds);
            };
            BluetoothClient cli;
            DateTime startT = DateTime.UtcNow;
            try {
                Connect_(out cli, startDisco);
                _peer = cli.GetStream();
                _cli = new WeakReferenceT<BluetoothClient>(cli);
            } finally {
                DateTime connectedT = DateTime.UtcNow;
                console.WriteLine("Started at: {0}", startT);
                console.WriteLine("Connect completed at: {0}, waiting for device discovery...", connectedT);
                var devices = cliDD.EndDiscoverDevices(arDD);
                DateTime endDdT = DateTime.UtcNow;
                console.WriteLine("End of DD at: {0}, with {1} devices.", endDdT, devices.Length);
            }
        }

        [MenuItem, SubMenu("BtClient")]
        public void Connect_WithInquiryRunning_EBAP()
        {
            TimeSpan delay = ConnectDuringDiscoveryPreConnectDelayMs;
            var givenDelay = console.ReadTimeSecondsOptional(" (default " + delay + ")");
            if (givenDelay != null) {
                delay = givenDelay.Value;
            }
            BluetoothClient cliDD = Create_BluetoothClient();
            var ddComplete = new ManualResetEvent(false);
            var btco = new BluetoothComponent(cliDD);
            btco.DiscoverDevicesProgress += _DiscoDevicesAsync_ProgressCallback;
            btco.DiscoverDevicesComplete += _DiscoDevicesAsync_CompleteCallback;
            btco.DiscoverDevicesComplete += (s, e) => ddComplete.Set();
            Action<BluetoothAddress> startDisco = delegate
            {
                btco.DiscoverDevicesAsync(255, false, false, false, true, 99);
                Thread.Sleep(delay.Seconds);
            };
            BluetoothClient cli;
            DateTime startT = DateTime.UtcNow;
            try {
                Connect_(out cli, startDisco);
                _peer = cli.GetStream();
                _cli = new WeakReferenceT<BluetoothClient>(cli);
            } finally {
                DateTime connectedT = DateTime.UtcNow;
                console.WriteLine("Started at: {0}", startT);
                console.WriteLine("Connect completed at: {0}, waiting for device discovery...", connectedT);
                ddComplete.WaitOne();
                DateTime endDdT = DateTime.UtcNow;
                //console.WriteLine("End of DD at: {0}, with {1} devices.", endDdT, devices.Length);
                console.WriteLine("End of DD at: {0}.", endDdT);
                ddComplete.Close();
            }
        }

        [MenuItem, SubMenu("BtClient")]
        public void Connect_FromInquiryCallback()
        {
            BluetoothClient cliDd = Create_BluetoothClient();
            cliDd.BeginDiscoverDevices(255, true, true, true, false,
                Connect_FromInquiryCallback_DdCallback, cliDd);
            console.WriteLine("Running async DiscoverDevices...");
        }

        void Connect_FromInquiryCallback_DdCallback(IAsyncResult ar)
        {
            console.WriteLine("DiscoverDevices completed...");
            BluetoothClient cliDd = (BluetoothClient)ar.AsyncState;
            cliDd.EndDiscoverDevices(ar);
            //
            try {
                BluetoothClient cli;
                Connect_(out cli);
                _peer = cli.GetStream();
                _cli = new WeakReferenceT<BluetoothClient>(cli);
            } catch (Exception ex) {
                console.WriteLine("Connect_FromInquiryCallback error: " + ex);
            }
        }

#if TEST_EARLY
        [MenuItem, SubMenu("BtClient")]
        public void Connect_GetStream2()
        {
            BluetoothClient cli;
            Connect_(out cli);
            peer = cli.GetStream2();
            s_cli = new WeakReferenceT<BluetoothClient>(cli);
        }
#endif

        [MenuItem, SubMenu("BtClient")]
        public void ConnectSuccessfullyAnd_ImmediatelyClose()
        {
            ConnectSuccessfullyAndImmediatelySendAndClose_(null);
        }

        [MenuItem, SubMenu("BtClient")]
        public void ConnectSuccessfullyAndImmediatelySend_OneByteAndClose()
        {
            ConnectSuccessfullyAndImmediatelySendAndClose_(new byte[] { (byte)'b' });
        }

        void ConnectSuccessfullyAndImmediatelySendAndClose_(byte[] data)
        {
            BluetoothClient cli;
            Connect_(out cli);
            _peer = cli.GetStream();
            if (data != null)
                _peer.Write(data, 0, data.Length);
            _peer.Close();
            _peer = null;
            _cli = null;
        }

        [MenuItem, SubMenu("BtClient")]
        public void ConnectMultiple_Devices()
        {
            int num = console.ReadInteger("How many connects?");
            bool oaat = console.ReadYesNo("Do one-at-a-time (e.g. Widcomm SDP sync)?", false);
            BluetoothAddress[] addrList = new BluetoothAddress[num];
            Guid[] svcClassList = new Guid[num];
            int?[] portList = new int?[num];
            BluetoothClient[] cliList = new BluetoothClient[num];
            IAsyncResult[] arList = new IAsyncResult[num];
            //
            for (int i = 0; i < num; ++i) {
                addrList[i] = console.ReadBluetoothAddress("Server #" + (i + 1) + "'s BluetoothAddress");
                svcClassList[i] = BluetoothService.Wap;
                Guid? inputGuid = console.ReadOptionalBluetoothUuid("UUID", svcClassList[i]);
                if (inputGuid.HasValue)
                    svcClassList[i] = inputGuid.Value;
                portList[i] = console.ReadOptionalInteger("Port number");
            }
            //
            IAsyncResult waitForLast = null;
            for (int i = 0; i < num; ++i) {
                if (waitForLast != null) {
                    console.Write("Waiting previous.  ");
                    bool signalled = waitForLast.AsyncWaitHandle.WaitOne(60 * 1000, false);
                    if (!signalled) {
                        throw new InvalidOperationException("Timed-out waiting for previous connect to complete.");
                    }
                }
                BluetoothEndPoint rep;
                if (portList[i] == null)
                    rep = new BluetoothEndPoint(addrList[i], svcClassList[i]);
                else
                    rep = new BluetoothEndPoint(addrList[i], svcClassList[i], portList[i].Value);
                console.WriteLine("{4}: Connecting #{3} to: {0}:{1}:{2} ...", rep.Address, rep.Service, rep.Port,
                    (i + 1), GetTime());
                //
                cliList[i] = Create_BluetoothClient();
                try {
                    arList[i] = cliList[i].BeginConnect(rep,
                        MiscCallback, "BeginConnect #" + (i + 1));
                    console.WriteLine("{0}: (BeginConnect returned)", GetTime());
                    if (oaat) {
                        waitForLast = arList[i];
                    }
                } catch (System.Net.Sockets.SocketException ex) {
                    console.WriteLine("{0}: BeginConnect failed: {1}", GetTime(), Exception_FirstLine(ex));
                }
            }//for
            //
            WaitAll(arList);
            console.WriteLine("All signalled");
            //
            for (int i = 0; i < cliList.Length; i++) {
                try {
                    cliList[i].EndConnect(arList[i]);
                } catch (Exception ex) {
                    console.WriteLine("Error for #{3}: ", (i + 1), Exception_FirstLine(ex));
                }
            }
            console.WriteLine("All completed");
        }

        private void WaitAll(IList<IAsyncResult> arList)
        {
            WaitHandle[] whList = GetWaitHandles(arList);
#if !NETCF
            bool signalled = WaitHandle.WaitAll(whList);
#else
            bool signalled = WaitHandle_WaitAll_Hack(whList);
#endif
            Debug.Assert(signalled, "Given infinite timeout, but returned NON-signalled!?!");
        }

        private WaitHandle[] GetWaitHandles(IList<IAsyncResult> arList)
        {
            Debug.Assert(arList != null, "ArgNullEx");
            List<WaitHandle> output = new List<WaitHandle>(arList.Count);
            for (int i = 0; i < arList.Count; ++i) {
                if (arList[i] != null)
                    output.Add(arList[i].AsyncWaitHandle);
            }
            return output.ToArray();
        }

#if NETCF
        bool WaitHandle_WaitAll_Hack(WaitHandle[] list)
        {
            bool sum = true;
            foreach (WaitHandle cur in list) {
                bool signalled = cur.WaitOne();
                Debug.Assert(signalled, "NOT signalled");
                sum = sum && signalled;
            }
            Debug.Assert(sum, "NOT signalled->sum");
            return sum;
        }
#endif

        void Connect_(out BluetoothClient cli)
        {
            Connect_(out cli, null);
        }

        void Connect_(out BluetoothClient cli, Action<BluetoothAddress> codeToRunJustBeforeConnect)
        {
            BluetoothAddress addr = console.ReadBluetoothAddress("Server's BluetoothAddress");
            Guid svcClass = BluetoothService.Wap;
            Guid? inputGuid = console.ReadOptionalBluetoothUuid("UUID", svcClass);
            if (inputGuid.HasValue)
                svcClass = inputGuid.Value;
            int? port = console.ReadOptionalInteger("Port number");
            bool auth = console.ReadYesNo("Authenticate", false);
            bool encpt = console.ReadYesNo("Encrypt", false);
            bool setPin1, setPin2;
            string passcode;
            BluetoothAddress pinAddr;
            PromptForSetPin(console, out setPin1, out setPin2, out passcode, out pinAddr);
            //
            BluetoothEndPoint lep;
            BluetoothAddress localAddrOptional = console.ReadOptionalBluetoothAddress("Local Bind() BluetoothAddress");
            if (localAddrOptional != null) {
                const int DefaultLocalPort = 0;
                var localPort = console.ReadOptionalInteger("Local port (default: " + DefaultLocalPort + ")");
                if (!localPort.HasValue) { localPort = DefaultLocalPort; }
                lep = new BluetoothEndPoint(localAddrOptional, BluetoothService.Empty, localPort.Value);
            } else {
                lep = null;
            }
            //
#if FX4
            bool taskAsync = console.ReadYesNo("Task-Async Connect?", false);
#else
            bool taskAsync = false;
#endif
            bool @async = taskAsync ? false : console.ReadYesNo("Async (APM) Connect?", false);
            bool asyncCallback = true;//not used but init anyway
            if (taskAsync || @async) {
                asyncCallback = console.ReadYesNo("Async Callback?", true);
            }
            //
            BluetoothEndPoint rep;
            if (port == null)
                rep = new BluetoothEndPoint(addr, svcClass);
            else
                rep = new BluetoothEndPoint(addr, svcClass, port.Value);
            console.WriteLine("Connecting to: {0}:{1}:{2} ...", rep.Address, rep.Service, rep.Port);
            //
            if (lep != null) {
                console.WriteLine("Binding to: {0}::{2} ...", lep.Address, lep.Service, lep.Port);
                cli = Create_BluetoothClient(lep);
            } else {
                cli = Create_BluetoothClient();
            }
            //
            // For Auth & Encrypt assume false by default, so if NotImpl fails only if user says true.
            if (auth)
                cli.Authenticate = true;
            if (encpt)
                cli.Encrypt = true;
            if (setPin1) {
                Debug.Assert(pinAddr == null, "pinAddr == null");
                cli.SetPin(passcode);
            } else if (setPin2) {
                Debug.Assert(pinAddr != null, "pinAddr != null");
                cli.SetPin(pinAddr, passcode);
            }
            if (codeToRunJustBeforeConnect != null) {
                codeToRunJustBeforeConnect(addr);
                console.WriteLine("(Have run the code before connect).");
            }
            if (taskAsync) {
#if FX4
                var task = cli.ConnectAsync(rep, "ConnectAsync");
                if (asyncCallback)
                    task.ContinueWith(MiscCallback);
                console.WriteLine("(ConnectAsync returned)");
                bool closeNow = console.ReadYesNo("Respond when we should proceed to Wait.  Enter Y to call Close first.", false);
                if (closeNow) {
                    cli.Close();
                }
                task.Wait();
#else
                throw new NotSupportedException("Task is FX4");
#endif
            } else if (@async) {
                AsyncCallback cb = null;
                if (asyncCallback)
                    cb = MiscCallback;
                IAsyncResult ar = cli.BeginConnect(rep,
                    cb, "BeginConnect");
                console.WriteLine("(BeginConnect returned)");
#if NETCF // ReadYesNo will block the screen. :-(
                console.Pause("Paused after BeginConnect");
#endif
                bool closeNow = console.ReadYesNo("Respond when we should proceed to EndConnect.  Enter Y to call Close first.", false);
                if (closeNow) {
                    cli.Close();
                }
                cli.EndConnect(ar);
            } else {
                cli.Connect(rep);
            }
            console.WriteLine("Connected to : '{0}' {1}", cli.RemoteMachineName, cli.RemoteEndPoint);
            PrintLocalEndpointIfAvailable(cli);
        }

        private void PrintLocalEndpointIfAvailable(BluetoothClient cli)
        {
            System.Net.Sockets.Socket sock = null;
            try {
                sock = cli.Client;
            } catch (NotSupportedException) {
            } catch (NotImplementedException) {
            }
            if (sock != null) {
                console.WriteLine("Local endpoint : {0}", sock.LocalEndPoint);
            }
        }

        private void PromptForSetPin(MenuSystem console, out bool setPin1, out bool setPin2,
            out string passcode, out BluetoothAddress pinAddr)
        {
            passcode = null;
            pinAddr = null;
            setPin1 = console.ReadYesNo("SetPin(string) [not for BtLsnr!]", false);
            if (setPin1) {
                setPin2 = false;
            } else {
                setPin2 = console.ReadYesNo("SetPin(address,string)", false);
            }
            if (setPin1 || setPin2) {
                passcode = console.ReadLine("Passcode");
            }
            if (setPin2) {
                pinAddr = console.ReadBluetoothAddress("PIN address");
            }
        }

        [MenuItem, SubMenu("BtClient")]
        public void ConnectMultiple_Times()
        {
            BluetoothAddress addr = console.ReadBluetoothAddress("Server's BluetoothAddress");
            Guid svcClass = BluetoothService.Wap;
            Guid? inputGuid = console.ReadOptionalBluetoothUuid("UUID", svcClass);
            if (inputGuid.HasValue)
                svcClass = inputGuid.Value;
            int? port = console.ReadOptionalInteger("Port number");
            //
            BluetoothEndPoint rep;
            if (port == null)
                rep = new BluetoothEndPoint(addr, svcClass);
            else
                rep = new BluetoothEndPoint(addr, svcClass, port.Value);
            console.WriteLine("Will connect to: {0}:{1}:{2} ...", rep.Address, rep.Service, rep.Port);
            //
            int count = console.ReadInteger("Connect how many times");
            int? delay = console.ReadOptionalInteger("Delay between each (ms)");
            //
            BluetoothClient cli = null;
            byte[] buf = { 0x61, 0x62, 0x63, 0x64 };
            int countSuccess = 0;
            int countFail = 0;
            for (int i = 0; i < count; ++i) {
                try {
                    if (delay.HasValue) {
                        Thread.Sleep(delay.Value);
                    }
                    console.Write("Connecting #" + (i + 1) + "...");
                    cli = Create_BluetoothClient();
                    cli.LingerState = new System.Net.Sockets.LingerOption(true, 10);
                    cli.Connect(rep);
                    ++countSuccess;
                    console.WriteLine("Connected");
                    using (Stream peerA = cli.GetStream()) {
                        peerA.Write(buf, 0, buf.Length);
                    }
                } catch (Exception ex) {
                    ++countFail;
                    console.Write("Failed: " + Exception_FirstLine(ex));
                    Debug.WriteLine("ConnMulti: " + ex);
                    var exitOnError = false;
                    if (exitOnError) {
                        break;
                    }
                } finally {
                    if (cli != null) {
                        cli.Close();
                    }
                }
            }//for
            console.WriteLine("Count success: {0}, fail {1}",
                countSuccess, countFail);
        }

        [MenuItem, SubMenu("Data")]
        public void SendForever()
        {
            if (!VerifyConnectionWrite())
                return;
            int interSendPeriod = console.ReadInteger("Inter-send period in milliseconds");
            byte[] buf = Encoding.ASCII.GetBytes("____abcdefghijklmnopqrstuvwxyz");
            ManualResetEvent quit = console.NewManualResetEvent(false);
            Action<Stream> send = delegate(Stream peer2)
            {
                int num = 0;
                while (true) {
                    if (IsSet(quit))
                        break;
                    string numString = num.ToString("d4");
                    Debug.Assert(numString.Length == 4, "numString.Length: " + numString.Length);
                    unchecked {
                        buf[0] = (byte)numString[0];
                        buf[1] = (byte)numString[1];
                        buf[2] = (byte)numString[2];
                        buf[3] = (byte)numString[3];
                    }
                    peer2.Write(buf, 0, buf.Length);
                    console.Write(".");
                    if (IsSet(quit))
                        break;
                    Thread.Sleep(interSendPeriod);
                    ++num;
                }//while
            };
            IAsyncResult ar = DelegateExtension.BeginInvoke(send, _peer, null, null);
            console.Pause("Un-pause to stop sending");
            quit.Set();
            DelegateExtension.EndInvoke(send, ar);
        }

        [MenuItem, SubMenu("Data")]
        public void ZeroLengthSend()
        {
            if (_peer == null)
                return;
            byte[] buf = new byte[2];
            _peer.Write(buf, 0, 0);
            console.WriteLine("ZeroLengthSend");
        }

        [MenuItem, SubMenu("Data")]
        public void ZeroLengthRead()
        {
            if (_peer == null)
                return;
            byte[] buf = new byte[2];
            IAsyncResult ar = null;
            bool doNormalReadFirst = console.ReadYesNo("Do normal async read first", false);
            if (doNormalReadFirst)
                ar = _peer.BeginRead(buf, 0, 1, null, null);
            int readLen = _peer.Read(buf, 0, 0);
            console.WriteLine("Did ZeroLengthRead, got length: {0}", readLen);
            if (ar != null) {
                int readLen0 = _peer.EndRead(ar);
                console.WriteLine("The first read got {0} bytes.", readLen0);
            }
        }

        [MenuItem, SubMenu("Data")]
        public void Flush()
        {
            if (_peer == null)
                return;
            _peer.Flush();
        }

        [MenuItem, SubMenu("Data")]
        public void SendOneAtATime()
        {
            if (!VerifyConnectionWrite())
                return;
            byte[] buf = Encoding.ASCII.GetBytes("____abcdefghijklmnopqrstuvwxyz");
            Action<Stream> send = delegate(Stream peer2)
            {
                int num = 0;
                while (true) {
                    string numString = num.ToString("d4");
                    Debug.Assert(numString.Length == 4, "numString.Length: " + numString.Length);
                    unchecked {
                        buf[0] = (byte)numString[0];
                        buf[1] = (byte)numString[1];
                        buf[2] = (byte)numString[2];
                        buf[3] = (byte)numString[3];
                    }
                    peer2.Write(buf, 0, buf.Length);
                    console.Write(".");
                    if (!console.ReadYesNo("Send another", true))
                        break;
                }//while
            };
            send.Invoke(_peer);
        }

        private static bool IsSet(ManualResetEvent quit)
        {
            bool signalled = quit.WaitOne(0, false);
            return signalled;
        }

        [MenuItem, SubMenu("Data")]
        public void SendCrLf()
        {
            if (_peer == null || !_peer.CanWrite) {
                console.WriteLine("No connection!");
                return;
            }
            byte[] buf = Encoding.ASCII.GetBytes("\r\n");
            _peer.Write(buf, 0, buf.Length);
        }

        [MenuItem, SubMenu("Playing")]
        public void Write_HCI_ReadLocalName_toStream()
        {
            byte[] ReadLocalName = { 0x01, /*hci*/ 0x14, 0x0c, 0x00 };
            if (_peer == null || !_peer.CanWrite) {
                console.WriteLine("No connection!");
                return;
            }
            byte[] buf = ReadLocalName;
            _peer.Write(buf, 0, buf.Length);
        }



        [MenuItem, SubMenu("Data")]
        public void SendAmountOneAtATime()
        {
            if (!VerifyConnectionWrite())
                return;
            byte[] srcBuf = Encoding.ASCII.GetBytes("____abcdefghijklmnopqrstuvwxyz");
            Action<Stream> send = delegate(Stream peer2)
            {
                int num = 0;
                int lastAmount = 4096;
                byte[] buf = new byte[0];
                while (true) {
                    int? amount = console.ReadOptionalInteger("How big send (default: " + lastAmount + ")");
                    amount = amount ?? lastAmount;
                    lastAmount = amount.Value;
                    //
                    if (buf.Length < amount) {
                        buf = new byte[amount.Value];
                    }
                    //
                    string numString = num.ToString("d4");
                    Debug.Assert(numString.Length == 4, "numString.Length: " + numString.Length);
                    unchecked {
                        buf[0] = (byte)numString[0];
                        buf[1] = (byte)numString[1];
                        buf[2] = (byte)numString[2];
                        buf[3] = (byte)numString[3];
                    }
                    peer2.Write(buf, 0, amount.Value);
                    console.Write(".");
                    if (!console.ReadYesNo("Send another", true))
                        break;
                }//while
            };
            send.Invoke(_peer);
        }

        //--------
        [MenuItem, SubMenu("Data")]
        public void Read()
        {
            if (!VerifyConnectionRead())
                return;
            int? dumpTruncate = console.ReadOptionalInteger("Dump how much of receive (default None)");
            bool binary = false;
            if (dumpTruncate == null) {
                dumpTruncate = 0;
            }
            if (dumpTruncate > 0) {
                binary = console.ReadYesNo("Dump in hex", false);
            }
            Read_(dumpTruncate, binary);
        }

        void Read_(int? dumpTruncate, bool binary)
        {
            byte[] buf = new byte[100];
            ManualResetEvent quit = console.NewManualResetEvent(false);
            object lastReturn = "-never set-";
            int totalRead = 0;
            Action<Stream> dlgt = delegate(Stream peer2)
            {
                while (true) {
                    if (IsSet(quit))
                        break;
                    bool success = false;
                    try {
                        int readLen = peer2.Read(buf, 0, buf.Length);
                        console.Write(" len='{0}'", readLen);
                        success = true;
                        lastReturn = readLen;
                        totalRead += readLen;
                        if (readLen == 0) {
                            console.WriteLine(" EoS.");
                            break;
                        }
                        if (dumpTruncate > 0) {
                            string txt;
                            if (!binary) {
                                txt = Encoding.ASCII.GetString(buf, 0,
                                    Math.Min(readLen, dumpTruncate.Value));
                            } else {
                                txt = BitConverter.ToString(buf, 0,
                                    Math.Min(readLen, dumpTruncate.Value));
                                txt = txt.Substring(0,
                                    Math.Min(txt.Length, dumpTruncate.Value));
                            }
                            console.WriteLine("\"{0}\"", txt);
                        }
                    } finally {
                        if (!success) {
                            lastReturn = "Error";
                            console.WriteLine("Completed by Error!!!");
                        }
                    }
                }//while
            };
            IAsyncResult ar = DelegateExtension.BeginInvoke(dlgt, _peer, null, null);
            console.Pause("Un-pause to stop after next Read");
            quit.Set();
            DelegateExtension.EndInvoke(dlgt, ar);
            console.WriteLine("Last read returned: {0}", lastReturn);
            console.WriteLine("Total read : {0}", totalRead);
        }

        [MenuItem, SubMenu("Data")]
        public void ReadAndReflect()
        {
            if (!VerifyConnectionRead())
                return;
            byte[] buf = new byte[100];
            byte[] rsp = new byte[100];
            ManualResetEvent quit = console.NewManualResetEvent(false);
            Action<Stream> dlgt = delegate(Stream peer2)
            {
                while (true) {
                    if (IsSet(quit))
                        break;
                    int readLen = peer2.Read(buf, 0, buf.Length);
                    console.Write(" len='{0}'", readLen);
                    if (readLen == 0) {
                        console.WriteLine(" EoS.");
                        break;
                    }
                    SwapCase(buf, rsp, readLen);
                    peer2.Write(rsp, 0, readLen);
                }//while
            };
            IAsyncResult ar = DelegateExtension.BeginInvoke(dlgt, _peer, null, null);
            console.Pause("Un-pause to stop after next Read");
            quit.Set();
            DelegateExtension.EndInvoke(dlgt, ar);
        }

        private static void SwapCase(byte[] src, byte[] dst, int len)
        {
            for (int i = 0; i < len; ++i) {
                byte b = src[i];
                char ch = (char)b;
                char upper = char.ToUpper(ch, System.Globalization.CultureInfo.InvariantCulture);
                char lower = char.ToLower(ch, System.Globalization.CultureInfo.InvariantCulture);
                char upperBack = char.ToLower(ch, System.Globalization.CultureInfo.InvariantCulture);
                char lowerBack = char.ToUpper(ch, System.Globalization.CultureInfo.InvariantCulture);
                if (lowerBack != ch && upperBack != ch) {
                    // didn't round-trip, not a displayable(?) char, return as is.
                    dst[i] = (byte)ch;
                } else if (lower == ch && upper == ch) {
                    // didn't change, not a alphabetical char, return as is.
                    dst[i] = (byte)ch;
                } else if (lower == ch) { // Is lower case, so return as upper case
                    Debug.Assert(upper != ch, ((ushort)upper).ToString("X") + " != " + ((ushort)ch).ToString("X"));
                    dst[i] = (byte)upper;
                } else {
                    Debug.Assert(upper == ch);
                    Debug.Assert(lower != ch, ((ushort)upper).ToString("X") + " != " + ((ushort)ch).ToString("X"));
                    dst[i] = (byte)lower;
                }
            }//for
        }

        [MenuItem, SubMenu("Data")]
        public void SendObexPutInOnePacket()
        {
            if (!VerifyConnectionWrite())
                return;
            byte[] bufValid = {
                /*PutFinal*/0x82,  0,41,
                   /*Name*/0x01, 0,19, 0,(byte)'a', 0,(byte)'a', 0,(byte)'a', 
                        0,(byte)'.', 0,(byte)'t', 0,(byte)'x', 0,(byte)'t', 0,0,
                   /*EoB*/0x49, 0,19, 0,(byte)'a', 0,(byte)'a', 0,(byte)'a', 
                        0,(byte)'.', 0,(byte)'t', 0,(byte)'x', 0,(byte)'t', 0,0
            };
            byte[] bufTruncatedInFront = {
                /*PutFinal*/0x82,  0, // !!!!
            };
            byte[] bufTruncatedInRear = {
                /*PutFinal*/0x82,  0,41,
                   /*Name*/0x01, 0,19, 0,(byte)'a', // !!!!!
            };
            byte[] bufTruncateBeforeFinal = {
                /*Put-NON-Final*/0x02,  0,41,
                   /*Name*/0x01, 0,19, 0,(byte)'a', 0,(byte)'a', 0,(byte)'a', 
                        0,(byte)'.', 0,(byte)'t', 0,(byte)'x', 0,(byte)'t', 0,0,
                   /*Body*/0x48, 0,19, 0,(byte)'a', 0,(byte)'a', 0,(byte)'a', 
                        0,(byte)'.', 0,(byte)'t', 0,(byte)'x', 0,(byte)'t', 0,0
            };
            int? choice;
            while (true) {
                choice = console.ReadOptionalInteger(
                    "1. Complete (one packet), 2. Truncated in front, 3. Truncated in back, 4. Truncated before final packet");
                if (!choice.HasValue || (choice.Value >= 1 && choice.Value <= 4))
                    break;
                console.WriteLine("Invalid selection.");
            }
            byte[] buf;
            switch (choice) {
                case null:
                case 1:
                    buf = bufValid;
                    break;
                case 2:
                    buf = bufTruncatedInFront;
                    break;
                case 3:
                    buf = bufTruncatedInRear;
                    break;
                case 4:
                    buf = bufTruncateBeforeFinal;
                    break;
                default:
                    throw new ArgumentException("Invalid selection: " + choice);
            }
            _peer.Write(buf, 0, buf.Length);
            _peer.Flush(); // just in case
            console.ReadLine("Waiting before closing the connection");
            _peer.Close();
        }

        //----
        [MenuItem, SubMenu("Device Discovery")]
        public void AllDiscover()
        {
            BluetoothClient cli = Create_BluetoothClient();
            DateTime startTime = DateTime.Now;
            BluetoothDeviceInfo[] devices = cli.DiscoverDevices();
            DateTime endTime = DateTime.Now;
            DumpDeviceInfo(devices, startTime, endTime);
        }

        [MenuItem, SubMenu("Device Discovery")]
        public void AllApmDiscover()
        {
            BluetoothClient cli = Create_BluetoothClient();
            const int DefaultTimeout = 30;
            TimeSpan? timeout = console.ReadTimeSecondsOptional("Set InquiryLength (default " + DefaultTimeout + "secs)");
            if (timeout == null) {
                timeout = TimeSpan.FromSeconds(DefaultTimeout);
            }
            cli.InquiryLength = timeout.Value;
            EventHandler dlgt = delegate
            {
                DateTime startTime = DateTime.Now;
                DiscoState1 state = new DiscoState1(cli, startTime);
                IAsyncResult ar = cli.BeginDiscoverDevices(255,
                    true, true, true, false,
                    RestartDiscoCallback, state);
            };
#if NETCF
            bool fromUi = console.ReadYesNo("Start first discovery from UI thread?", false);
#else
            bool fromUi = false;
#endif
            if (fromUi) {
                console.UiInvoke(dlgt);
            } else {
                dlgt(null, null);
            }
            //
            console.Pause("Un-pause when discovery has completed");
        }

        class DiscoState1
        {
            public readonly BluetoothClient cli;
            public readonly DateTime startTime;

            public DiscoState1(BluetoothClient cli, DateTime startTime)
            {
                this.cli = cli;
                this.startTime = startTime;
            }
        }

        void SimpleDiscoCallback(IAsyncResult ar)
        {
            DiscoState1 state = (DiscoState1)ar.AsyncState;
            try {
                BluetoothDeviceInfo[] devices = state.cli.EndDiscoverDevices(ar);
                DateTime endTime = DateTime.Now;
                DumpDeviceInfoBrief(devices, state.startTime, endTime);
            } catch (Exception ex) {
                console.WriteLine("Discovery failed with: " + ex);
            }
        }

        void RestartDiscoCallback(IAsyncResult ar)
        {
            SimpleDiscoCallback(ar);
            bool startAgainInCallback = console.ReadYesNo("Start discovery again from callback", false);
            if (startAgainInCallback) {
                DiscoState1 state0 = (DiscoState1)ar.AsyncState;
                DiscoState1 state = new DiscoState1(state0.cli, DateTime.Now);
                IAsyncResult ar2 = state.cli.BeginDiscoverDevices(255,
                    true, true, true, false,
                    SimpleDiscoCallback, state);
            }
        }

        [MenuItem, SubMenu("Device Discovery")]
        public void ConcurrentlyTwoDiscoverApm()
        {
            var cli1 = Create_BluetoothClient();
            var cli2 = Create_BluetoothClient();
            IAsyncResult ar1 = cli1.BeginDiscoverDevices(255, true, true, true, false, null, null);
            IAsyncResult ar2 = cli2.BeginDiscoverDevices(255, true, true, true, false, null, null);
            console.WriteLine("Two started...");
            bool signalled = _WaitAll(new WaitHandle[] { ar1.AsyncWaitHandle, ar2.AsyncWaitHandle }, 30 * 1000);
            if (!signalled) {
                console.WriteLine("Something horrible happened, at least one never/took too long to complete.");
            } else {
                var rslt1 = cli1.EndDiscoverDevices(ar1);
                var rslt2 = cli2.EndDiscoverDevices(ar2);
                console.WriteLine("They returned respectively: {0} and {1} devices.",
                    rslt1.Length, rslt2.Length);
            }
        }

        [MenuItem, SubMenu("Device Discovery")]
        public void _RememberedDiscover()
        {
            BluetoothClient cli = Create_BluetoothClient();
            DateTime startTime = DateTime.Now;
            BluetoothDeviceInfo[] devices = cli.DiscoverDevices(255, false, true, false);
            DateTime endTime = DateTime.Now;
            DumpDeviceInfo(devices, startTime, endTime);
        }

        [MenuItem, SubMenu("Device Discovery")]
        public void _FlagsDiscover()
        {
            DiscoverFlags_(false);
        }

        [MenuItem, SubMenu("Device Discovery")]
        void FlagsA_pmDiscover()
        {
            DiscoverFlags_(true);
        }

        private void GetDiscoveryFlags(MenuSystem console, out bool discoOnly, out bool auth, out bool rembd, out bool unk)
        {
            console.WriteLine("Discover which type of remote devices?");
            discoOnly = console.ReadYesNo("discoverableOnly", false);
            unk = console.ReadYesNo("Unknown", false);
            rembd = console.ReadYesNo("Remembered", false);
            auth = console.ReadYesNo("Authenticated", false);
        }

        public void DiscoverFlags_(bool @async)
        {
            BluetoothClient cli = Create_BluetoothClient();
            bool discoOnly, auth, rembd, unk;
            GetDiscoveryFlags(console, out discoOnly, out auth, out rembd, out unk);
            BluetoothDeviceInfo[] devices;
            //
            TimeSpan? timeout = console.ReadTimeSecondsOptional("InquiryLength");
            if (timeout != null) {
                cli.InquiryLength = timeout.Value;
            }
            console.WriteLine("cli.InquiryLength is: {0}", cli.InquiryLength);
            int? maxDevices = console.ReadOptionalInteger("maxDevices (default 255)");
            if (maxDevices == null) maxDevices = 255;
            console.WriteLine("maxDevices is: {0}", maxDevices);
            //
            DateTime startTime = DateTime.Now;
            if (@async) {
                bool doPause = console.ReadYesNo("Pause after BeginDD", false);
                bool errorCallback = console.ReadYesNo("Throw an Error from the Callback", false);
                AsyncCallback cb = errorCallback ? new AsyncCallback(ErrorFromMiscCallback) : MiscCallback;
                IAsyncResult ar = cli.BeginDiscoverDevices(255, auth, rembd, unk, discoOnly,
                    cb, "BeginDiscoverDevices");
                console.WriteLine("(BeginDiscoverDevices returned)");
                if (doPause) console.Pause("Un-pause to continue to EndDD");
                devices = cli.EndDiscoverDevices(ar);
            } else {
                devices = cli.DiscoverDevices(maxDevices.Value, auth, rembd, unk, discoOnly);
            }
            DateTime endTime = DateTime.Now;
            DumpDeviceInfo(devices, startTime, endTime);
            bool dispose = console.ReadYesNo("Dispose BtCli", true);
            if (dispose && cli != null) {
                cli.Dispose();
            }
        }

        [MenuItem, SubMenu("Device Discovery")]
        public void _RunAllFlagCombinations()
        {
            BluetoothClient cli = Create_BluetoothClient();
            DateTime startTime = DateTime.Now;
            bool discoOnly, authenticated, remembered, unknown;
            int flagSource = 0;
            while (true) {
                authenticated = (flagSource & 1) != 0;
                remembered = (flagSource & 2) != 0;
                unknown = (flagSource & 4) != 0;
                discoOnly = (flagSource & 8) != 0;
                //
                BluetoothDeviceInfo[] devices = cli.DiscoverDevices(255,
                    authenticated, remembered, unknown, discoOnly);
                console.WriteLine("Got {0} results", devices.Length);
                //
                if (authenticated && remembered && unknown && discoOnly)
                    break; // Have tested all cases of the original four flags.
                ++flagSource;
                Thread.Sleep(2000); // This sequence hangs on my W2k+Widcomm box -- does delaying help...?
            }//while
            //DateTime endTime = DateTime.Now;
            //DumpDeviceInfo(devices, startTime, endTime);
            console.WriteLine("All DiscoverDevices flag combinations run.");
        }

        const string vbCrLf = "\r\n";
        void DumpDeviceInfo(BluetoothDeviceInfo[] devices,
            DateTime startTime, DateTime endTime)
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder();
            DateTime localTime = startTime.ToLocalTime();
            sb.AppendFormat(System.Globalization.CultureInfo.InvariantCulture,
                "Discovery process started at {0} UTC, {1} local, and ended at {2} UTC.",
                startTime, localTime, endTime);
            sb.Append(vbCrLf + vbCrLf);
            console.WriteLine(sb.ToString());
            foreach (BluetoothDeviceInfo curDevice in devices) {
                sb.Length = 0;
                DumpDeviceInfo(sb, curDevice);
                console.WriteLine(sb.ToString());
            }
        }

        void DumpDeviceInfoBrief(BluetoothDeviceInfo[] devices,
            DateTime startTime, DateTime endTime)
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder();
            DateTime localTime = startTime.ToLocalTime();
            sb.AppendFormat(System.Globalization.CultureInfo.InvariantCulture,
                "Discovery process started at {0} UTC, {1} local, and ended at {2} UTC.",
                startTime, localTime, endTime);
            console.WriteLine(sb.ToString());
            foreach (BluetoothDeviceInfo curDevice in devices) {
                sb.Length = 0;
                DumpDeviceInfoBrief(sb, curDevice);
                console.WriteLine(sb.ToString());
            }
        }

        private static void DumpDeviceInfoBrief(StringBuilder sb, BluetoothDeviceInfo curDevice)
        {
            sb.AppendFormat(System.Globalization.CultureInfo.InvariantCulture,
                "* {0}", ToStringQuotedOrNull(curDevice.DeviceName));
            sb.AppendFormat(System.Globalization.CultureInfo.InvariantCulture,
                ", Address: {0}", curDevice.DeviceAddress);
        }

        private static string DumpDeviceInfoBrief(BluetoothDeviceInfo curDevice)
        {
            System.Text.StringBuilder sb = new StringBuilder();
            DumpDeviceInfoBrief(sb, curDevice);
            return sb.ToString();
        }

        private static void DumpDeviceInfo(System.Text.StringBuilder sb, BluetoothDeviceInfo curDevice)
        {
            sb.AppendFormat(System.Globalization.CultureInfo.InvariantCulture,
                "* {0}", ToStringQuotedOrNull(curDevice.DeviceName));
            sb.Append(vbCrLf);
            sb.AppendFormat(System.Globalization.CultureInfo.InvariantCulture,
                "Address: {0}", curDevice.DeviceAddress);
            sb.Append(vbCrLf);
            sb.AppendFormat(System.Globalization.CultureInfo.InvariantCulture,
                "Remembered: {2}, Authenticated: {0}, Connected: {1}",
                curDevice.Authenticated, curDevice.Connected, curDevice.Remembered);
            sb.Append(vbCrLf);
            sb.AppendFormat(System.Globalization.CultureInfo.InvariantCulture,
                "LastSeen: {0} ({2}), LastUsed: {1} ({3})",
                curDevice.LastSeen, curDevice.LastUsed,
                curDevice.LastSeen.Kind, curDevice.LastUsed.Kind);
            sb.Append(vbCrLf);
            DumpCodInfo(curDevice.ClassOfDevice, sb);
            Int32 rssi = curDevice.Rssi;
            if (rssi != Int32.MinValue) {
                sb.AppendFormat(System.Globalization.CultureInfo.InvariantCulture,
                    "Rssi: {0} (0x{0:X})", rssi);
            } else {
                sb.AppendFormat(System.Globalization.CultureInfo.InvariantCulture,
                    "Rssi: failed");
            }
            sb.Append(vbCrLf);
        }

        private static string DumpDeviceInfo(BluetoothDeviceInfo curDevice)
        {
            System.Text.StringBuilder sb = new StringBuilder();
            DumpDeviceInfo(sb, curDevice);
            return sb.ToString();
        }

        static void DumpCodInfo(ClassOfDevice cod, System.Text.StringBuilder sb)
        {
            sb.AppendFormat(System.Globalization.CultureInfo.InvariantCulture,
                "CoD: (0x{0:X6})", cod.Value, cod);
            sb.Append(vbCrLf);
            sb.AppendFormat(System.Globalization.CultureInfo.InvariantCulture,
                " Device:  {0} (0x{1:X2}) / {2} (0x{3:X4})", cod.MajorDevice, (int)cod.MajorDevice, cod.Device, (int)cod.Device);
            sb.Append(vbCrLf);
            sb.AppendFormat(System.Globalization.CultureInfo.InvariantCulture,
                " Service: {0} (0x{1:X2})", cod.Service, (int)cod.Service);
            sb.Append(vbCrLf);
        }

#if !NO_WINFORMS
        [MenuItem, SubMenu("Device Discovery")]
        public void UiDiscovery()
        {
            bool discoOnly, auth, rembd, unk;
            GetDiscoveryFlags(console, out discoOnly, out auth, out rembd, out unk);
            InTheHand.Windows.Forms.SelectBluetoothDeviceDialog dlg = new InTheHand.Windows.Forms.SelectBluetoothDeviceDialog();
            dlg.ShowAuthenticated = auth;
            dlg.ShowRemembered = rembd;
            dlg.ShowUnknown = unk;
            dlg.ShowDiscoverableOnly = discoOnly;
            if (console.ReadYesNo("set filter (always returns true)", false)) {
                dlg.DeviceFilter = FilterDevice;
                if (console.ReadYesNo("set filter to null now(!)", false)) {
                    dlg.DeviceFilter = null;
                }
            }
            System.Windows.Forms.DialogResult rslt = System.Windows.Forms.DialogResult.None;
            EventHandler action = delegate
            {
                rslt = dlg.ShowDialog();
            };
            console.UiInvoke(action);
            console.WriteLine("DialogResult: {0}, Selected: {1}", rslt,
                dlg.SelectedDevice == null ? "(null)" : ("'" + dlg.SelectedDevice.DeviceName + "' " + dlg.SelectedDevice.DeviceAddress.ToString("C")));
        }

        void X()
        {
            var dlg = new InTheHand.Windows.Forms.SelectBluetoothDeviceDialog();
            dlg.DeviceFilter = FilterDevice;
            var rslt = dlg.ShowDialog();
            //......
        }

        bool FilterDevice(BluetoothDeviceInfo dev)
        {
            var ret = true;
            ret = console.ReadYesNo("Include this device " + dev.DeviceAddress + " " + dev.DeviceName, ret);
            return ret;
        }
#endif


        //----
#if TEST_EARLY
        [MenuItem, SubMenu("SDP")]
        public void HackServiceDiscovery()
        {
            BluetoothAddress addr = console.ReadBluetoothAddress("SDP server BluetoothAddress");
            try {
                BluetoothClient cli0 = new BluetoothClient();
                // Don't dispose this to check its Finalization.
                InTheHand.Net.Bluetooth.Widcomm.ISdpDiscoveryRecordsBuffer recs
                    = cli0.WidcommHack__GetServiceRecordsUnparsed(addr, BluetoothService.L2CapProtocol);
                console.WriteLine("recordCount: {0}", recs.RecordCount);
                //
                int[] ports = recs.Hack_GetPorts();
#if !NETCF
                string[] txtArr = Array.ConvertAll<int, string>(ports,
                    delegate(int cur) { return cur.ToString(); });
#else
                string[] txtArr = new string[ports.Length];
                for (int i = 0; i < ports.Length; ++i)
                    txtArr[i] = ports[i].ToString();
#endif
                string txt = string.Join(", ", txtArr);
                console.WriteLine("Ports: {0}", txt);
                //
                ServiceRecord[] recordArr = recs.GetServiceRecords();
                foreach (ServiceRecord cur in recordArr) {
                    console.WriteLine(
                        ServiceRecordUtilities.Dump(cur));
                }
            } catch (Exception ex) {
                console.WriteLine(ex);
            }
        }
#endif

        [MenuItem, SubMenu("SDP")]
        public void Sdp_Query()
        {
            SdpQuery_();
        }

        void SdpQuery_()
        {
            BluetoothAddress addr = console.ReadBluetoothAddress("SDP server BluetoothAddress");
            Guid? svcClass1 = console.ReadOptionalBluetoothUuid("Search UUID (default L2CAP->all)", null);
            if (svcClass1 == null) {
                svcClass1 = BluetoothService.L2CapProtocol;
            }
#if FX4
            bool taskAsync = console.ReadYesNo("Task-Async Get", false);
#else
            bool taskAsync = false;
#endif
            bool @async = taskAsync ? false : console.ReadYesNo("Async Get", false);
            //
            BluetoothDeviceInfo bdi = Create_BluetoothDeviceInfo(addr);
            ServiceRecord[] recordArr;
            var svcClassList = new List<Guid> { (Guid)svcClass1 };
            var foo = false;
            if (foo) {
                var from = 0x1000;
                var to = 0x1100;
                svcClassList.Clear();
                for (int cur = from; cur <= to; ++cur) {
                    svcClassList.Add(BluetoothService.CreateBluetoothUuid(cur));
                }
            }
            foreach (var svcClass in svcClassList) {
                string target = string.Format(CultureInfo.InvariantCulture,
                    "{0} on {1}", (Guid)svcClass, bdi.DeviceAddress);
                if (taskAsync) {
#if FX4
                    var task = bdi.GetServiceRecordsAsync((Guid)svcClass, "GetServiceRecordsAsync");
                    task.ContinueWith(MiscCallback);
                    console.WriteLine("(GetServiceRecordsAsync returned)");
                    console.Pause("Un-pause when should continue to get Result");
                    recordArr = task.Result;
                    task.Wait();
#else
                    throw new NotSupportedException("Task is FX4");
#endif
                } else if (@async) {
                    console.WriteLine("Calling BeginGetServiceRecords for " + target);

                    IAsyncResult ar = bdi.BeginGetServiceRecords((Guid)svcClass,
                            MiscCallback, "BeginGetServiceRecords");
                    console.WriteLine("BeginGetServiceRecords returned");
                    console.Pause("Un-pause when should continue to EndGetServiceRecords");
                    recordArr = bdi.EndGetServiceRecords(ar);
                } else {
                    console.WriteLine("Calling GetServiceRecords for " + target);
                    recordArr = bdi.GetServiceRecords((Guid)svcClass);
                }
                //
                SdpRecordDump(recordArr);
            }
        }

        private void SdpRecordDump(ICollection<ServiceRecord> recordArr)
        {
            console.WriteLine("recordCount: {0}", recordArr.Count);
            int i = 1;
            foreach (ServiceRecord cur in recordArr) {
                console.WriteLine("{0})", i);
                try {
                    console.WriteLine(
                        ServiceRecordUtilities.Dump(cur));
                } catch (Exception ex) {
                    console.WriteLine("Error in Dump, trying DumpRaw ({0})", ex);
                    console.WriteLine(
                        ServiceRecordUtilities.DumpRaw(cur));
                }
                console.WriteLine("----");
                ++i;
            }
        }

        [MenuItem, SubMenu("SDP")]
        public void SdpQuery_Repeatedly()
        {
            BluetoothAddress addr = console.ReadBluetoothAddress("SDP server BluetoothAddress");
            Guid? svcClass = console.ReadOptionalBluetoothUuid("Search UUID (default L2CAP->all)", null);
            if (svcClass == null) {
                svcClass = BluetoothService.L2CapProtocol;
            }
            //
            BluetoothDeviceInfo bdi = Create_BluetoothDeviceInfo(addr);
            string target = string.Format(CultureInfo.InvariantCulture,
                "{0} on {1}", (Guid)svcClass, bdi.DeviceAddress);
            int InterDelay = 500;
            //
            MyAction startQuery = null;
            bool stop = false;
            AsyncCallback _Callback = delegate(IAsyncResult ar)
            {
                try {
                    bdi.EndGetServiceRecords(ar);
                    console.Write("|");
                    Thread.Sleep(InterDelay);
                    if (stop) {
                        console.WriteLine("]");
                    } else {
                        startQuery();
                    }
                } catch (Exception ex) {
                    console.WriteLine(ex);
                }
            };
            startQuery = delegate
            {
                bdi.BeginGetServiceRecords((Guid)svcClass,
                    _Callback, null);
                console.Write("-");
            };
            //
            console.WriteLine("Calling first BeginGetServiceRecords for " + target);
            while (true) {
                stop = false;
                startQuery();
                console.Pause("When to stop");
                stop = true;
                var startAgain = console.ReadYesNo("Start again?", false);
                if (!startAgain) {
                    break;
                }
            }
        }

        [MenuItem, SubMenu("SDP")]
        public void SdpQuery_Concurrent()
        {
            BluetoothAddress addrA = console.ReadBluetoothAddress("SDP server BluetoothAddress");
            BluetoothAddress addrB;
            var another = console.ReadYesNoCancel("Different device | dupl. DBI | same BDI", null);
            BluetoothDeviceInfo bdiA = Create_BluetoothDeviceInfo(addrA);
            BluetoothDeviceInfo bdiB;
            if (another == true) {
                console.Write("Another target. ");
                addrB = console.ReadBluetoothAddress("SDP server BluetoothAddress");
                bdiB = Create_BluetoothDeviceInfo(addrB);
            } else if (another == false) {
                console.Write("Dupl.BDI. ");
                bdiB = Create_BluetoothDeviceInfo(addrA);
            } else {
                console.Write("Same BDI. ");
                bdiB = bdiA;
            }
            //
            Guid? svcClass = console.ReadOptionalBluetoothUuid("Search UUID (default L2CAP->all)", null);
            if (svcClass == null) {
                svcClass = BluetoothService.L2CapProtocol;
            }
            //
            string target = string.Format(CultureInfo.InvariantCulture,
                "{0} on {1} and {2}", (Guid)svcClass, bdiA.DeviceAddress, bdiB.DeviceAddress);
            console.WriteLine(target);
            //
            bool repeat;
            do {
                console.Write("Starting...");
                IAsyncResult arA, arB;
                try {
                    arA = bdiA.BeginGetServiceRecords(svcClass.Value, MiscCallback, "A");
                } catch (Exception ex) {
                    arA = null;
                    console.WriteLine("A @Begin " + " ex: " + ex);
                }
                try {
                    arB = bdiB.BeginGetServiceRecords(svcClass.Value, MiscCallback, "B");
                } catch (Exception ex) {
                    arB = null;
                    console.WriteLine("B @Begin " + " ex: " + ex);
                }
                console.Pause("when complete");
                MyFunc<IAsyncResult, string> doGetIsCompleted = delegate(IAsyncResult arX)
                {
                    if (arX == null) return "NULL";
                    return arX.IsCompleted.ToString();
                };
                console.WriteLine("IsCompleted: A: {0}, B: {1}",
                    doGetIsCompleted(arA), doGetIsCompleted(arB));
                //--
                MyAction<string, BluetoothDeviceInfo, IAsyncResult> doComplete
                    = delegate(string name, BluetoothDeviceInfo devX, IAsyncResult arX)
                {
                    ServiceRecord[] rs;
                    try {
                        rs = devX.EndGetServiceRecords(arX);
                        console.WriteLine(name + " #r: " + rs.Length);
                    } catch (Exception ex) {
                        console.WriteLine(name + " ex: " + ex);
                    }
                };
                // Complete if they started
                if (arA != null) {
                    doComplete("A", bdiA, arA);
                }
                if (arB != null) {
                    doComplete("B", bdiB, arB);
                }
                //
                repeat = console.ReadYesNo("Do again on same BDIs?", false);
            } while (repeat);
        }

        delegate void MyAction();
        delegate void MyAction<T0>(T0 p0);
        delegate void MyAction<T0, T1>(T0 p0, T1 p1);
        delegate void MyAction<T0, T1, T2>(T0 p0, T1 p1, T2 p2);

        [MenuItem, SubMenu("SDP")]
        public void SdpCreateCustom()
        {
            ServiceRecord record = CreateAVariousRecord();
            BluetoothListener lsnr = Create_BluetoothListener(BluetoothService.HealthDeviceSink,
                record);
            lsnr.Start();
            console.Pause("Un-pause to stop the server");
            lsnr.Stop();
        }

#if false
        [MenuItem, SubMenu("SDP")]
        public void SdpCreateCustomSimpleElements_Btps()
        {
            ServiceRecord record = CreateAVariousRecordWithSimpleElements();
            //
            var c = InTheHand.Net.Bluetooth.StonestreetOne
                .BluetopiaSdpCreator.CreateTestable();
            c.CreateServiceRecord(record);
            console.Pause("Un-pause to stop the server");
            c.DeleteServiceRecord();
        }

        [MenuItem, SubMenu("SDP")]
        public void SdpCreateCustom_Btps()
        {
            ServiceRecord record = CreateAVariousRecord();
            //
            var c = InTheHand.Net.Bluetooth.StonestreetOne
                .BluetopiaSdpCreator.CreateTestable();
            c.CreateServiceRecord(record);
            console.Pause("Un-pause to stop the server");
            c.DeleteServiceRecord();
        }
#endif

        private static ServiceRecord CreateAVariousRecord()
        {
            MyFunc<ElementType, ServiceAttributeId> createId = delegate(ElementType etX)
            {
                return (ServiceAttributeId)0x4000 + checked((byte)etX);
            };
            ServiceRecordBuilder bldr = new ServiceRecordBuilder();
            bldr.AddServiceClass(BluetoothService.HealthDevice);
            var longquotes = false;
            if (longquotes) {
                bldr.ServiceName = new string('"', 40);
                // cmd> sdptool search --bdaddr 00:0a:3a:68:65:bb --xml ftp
                bldr.AddServiceClass(BluetoothService.ObexFileTransfer);
            } else {
                bldr.ServiceName = "alan";
            }
            IList<ServiceAttribute> attrList = new List<ServiceAttribute>();
            ElementType et_;
            CreateVariousSimpleElements(createId, attrList);
            et_ = ElementType.Uuid16;
            attrList.Add(new ServiceAttribute(createId(et_),
                new ServiceElement(et_, (UInt16)et_)));
            et_ = ElementType.Uuid32;
            attrList.Add(new ServiceAttribute(createId(et_),
                new ServiceElement(et_, (UInt32)et_)));
            et_ = ElementType.Uuid128;
            attrList.Add(new ServiceAttribute(createId(et_),
                new ServiceElement(et_, BluetoothService.CreateBluetoothUuid((int)et_))));
            bldr.AddCustomAttributes(attrList);
            bldr.AddCustomAttributes(ElementsAndVariableAndFixedInDeepTree1());
            ServiceRecord record = bldr.ServiceRecord;
            return record;
        }

        private static ServiceRecord CreateAVariousRecordWithSimpleElements()
        {
            MyFunc<ElementType, ServiceAttributeId> createId = delegate(ElementType etX)
            {
                return (ServiceAttributeId)0x4000 + checked((byte)etX);
            };
            ServiceRecordBuilder bldr = new ServiceRecordBuilder();
            bldr.AddServiceClass(BluetoothService.HealthDevice); // not optional :-(
            IList<ServiceAttribute> attrList = new List<ServiceAttribute>();
            CreateVariousSimpleElements(createId, attrList);
            bldr.AddCustomAttributes(attrList);
            ServiceRecord record = bldr.ServiceRecord;
            return record;
        }

        private static void CreateVariousSimpleElements(MyFunc<ElementType, ServiceAttributeId> createId,
            IList<ServiceAttribute> attrList)
        {
            ElementType et_;
#if SUPPORT_NIL
            et_ = ElementType.Nil;
            attrList.Add(new ServiceAttribute(createId(et_), new ServiceElement(et_, null)));
#endif
            et_ = ElementType.Boolean;
            attrList.Add(new ServiceAttribute(createId(et_), new ServiceElement(et_, true)));
            ElementType[] weee = {
                ElementType.UInt8,  ElementType.UInt16, ElementType.UInt32, ElementType.UInt64, //UInt128,
                ElementType.Int8,   ElementType.Int16,  ElementType.Int32,  ElementType.Int64,  //Int128,
            };
            foreach (ElementType et in weee) {
                attrList.Add(new ServiceAttribute(
                    createId(et),
                    ServiceElement.CreateNumericalServiceElement(et, (uint)et)));
            }
        }

        public const String RecordBytes_OneString_StringValue = "abcd\u00e9fgh\u012dj";
        public static IList<ServiceAttribute> ElementsAndVariableAndFixedInDeepTree1()
        {
            IList<ServiceAttribute> attrs = new List<ServiceAttribute>();
            //
            String str = RecordBytes_OneString_StringValue;
            ServiceElement itemStr1 = new ServiceElement(ElementType.TextString, str);
            ServiceElement itemStr2 = new ServiceElement(ElementType.TextString, str);
            //
            Uri uri = new Uri("http://example.com/foo.txt");
            ServiceElement itemUrl = new ServiceElement(ElementType.Url, uri);
            //
            ServiceElement itemF1 = new ServiceElement(ElementType.UInt16, (UInt16)0xfe12);
            ServiceElement itemF2 = new ServiceElement(ElementType.UInt16, (UInt16)0x1234);
            //
            IList<ServiceElement> leaves2 = new List<ServiceElement>();
            leaves2.Add(itemStr1);
            leaves2.Add(itemUrl);
            leaves2.Add(itemF1);
            ServiceElement e2 = new ServiceElement(ElementType.ElementSequence, leaves2);
            //
            ServiceElement e1 = new ServiceElement(ElementType.ElementSequence, e2);
            //
            IList<ServiceElement> leaves0 = new List<ServiceElement>();
            leaves0.Add(e1);
            leaves0.Add(itemStr2);
            leaves0.Add(itemF2);
            attrs.Add(
                new ServiceAttribute(0x0401, new ServiceElement(ElementType.ElementAlternative,
                        leaves0)));
            return attrs;
        }

        [MenuItem, SubMenu("SDP")]
        public void SdpCreateHidAndPnpRecords()
        {
            ServiceRecord record = CreateAHumanInputDeviceRecord();
            BluetoothListener lsnr = Create_BluetoothListener(BluetoothService.HealthDeviceSink,
                record);
            ServiceRecord record2 = CreateAHumanInputDeviceRecordB();
            BluetoothListener lsnr2 = Create_BluetoothListener(BluetoothService.HealthDeviceSink,
                record2);
            ServiceRecord record3 = CreateAPnpRecord();
            BluetoothListener lsnr3 = Create_BluetoothListener(BluetoothService.HealthDeviceSink,
                record3);
            lsnr.Start();
            lsnr2.Start();
            lsnr3.Start();
            console.Pause("Un-pause to stop the server");
            lsnr.Stop();
            lsnr2.Stop();
            lsnr3.Stop();
        }

        [MenuItem, SubMenu("SDP")]
        public void SdpCreatePnpRecord()
        {
            ServiceRecord record = CreateAPnpRecord();
            BluetoothListener lsnr = Create_BluetoothListener(BluetoothService.HealthDeviceSink,
                record);
            lsnr.Start();
            console.Pause("Un-pause to stop the server");
            lsnr.Stop();
        }

        private ServiceRecord CreateAPnpRecord()
        {
            ServiceRecordBuilder bldr = new ServiceRecordBuilder();
            // Listener needs this. :-(
            bldr.ProtocolType = BluetoothProtocolDescriptorType.GeneralObex;
            bldr.AddServiceClass(BluetoothService.PnPInformation);
            bldr.AddCustomAttribute(new ServiceAttribute(DeviceIdProfileAttributeId.SpecificationId,
                ServiceElement.CreateNumericalServiceElement(ElementType.UInt16, 1)));
            bldr.AddCustomAttribute(new ServiceAttribute(DeviceIdProfileAttributeId.VendorId,
                ServiceElement.CreateNumericalServiceElement(ElementType.UInt16, 2)));
            bldr.AddCustomAttribute(new ServiceAttribute(DeviceIdProfileAttributeId.ProductId,
                ServiceElement.CreateNumericalServiceElement(ElementType.UInt16, 3)));
            bldr.AddCustomAttribute(new ServiceAttribute(DeviceIdProfileAttributeId.Version,
                ServiceElement.CreateNumericalServiceElement(ElementType.UInt16, 4)));
            bldr.AddCustomAttribute(new ServiceAttribute(DeviceIdProfileAttributeId.PrimaryRecord,
                new ServiceElement(ElementType.Boolean, true)));
            bldr.AddCustomAttribute(new ServiceAttribute(DeviceIdProfileAttributeId.VendorIdSource,
                ServiceElement.CreateNumericalServiceElement(ElementType.UInt16, 6)));
            return bldr.ServiceRecord;
        }

        [MenuItem, SubMenu("SDP")]
        public void SdpCreateHumanInputDeviceRecord()
        {
            ServiceRecord record = CreateAHumanInputDeviceRecord();
            BluetoothListener lsnr = Create_BluetoothListener(BluetoothService.HealthDeviceSink,
                record);
            ServiceRecord record2 = CreateAHumanInputDeviceRecordB();
            BluetoothListener lsnr2 = Create_BluetoothListener(BluetoothService.HealthDeviceSink,
                record2);
            lsnr.Start();
            lsnr2.Start();
            console.Pause("Un-pause to stop the servers");
            lsnr.Stop();
            lsnr2.Stop();
        }

        private ServiceRecord CreateAHumanInputDeviceRecord()
        {
            ServiceRecordBuilder bldr = new ServiceRecordBuilder();
            // Listener needs this. :-(
            bldr.ProtocolType = BluetoothProtocolDescriptorType.GeneralObex;
            bldr.AddServiceClass(BluetoothService.HumanInterfaceDevice);
            bldr.AddCustomAttribute(new ServiceAttribute(HidProfileAttributeId.DeviceReleaseNumber,
                ServiceElement.CreateNumericalServiceElement(ElementType.UInt16, 0x1000)));
            bldr.AddCustomAttribute(new ServiceAttribute(HidProfileAttributeId.ParserVersion,
                ServiceElement.CreateNumericalServiceElement(ElementType.UInt16, 1)));
            bldr.AddCustomAttribute(new ServiceAttribute(HidProfileAttributeId.DeviceSubclass,
                ServiceElement.CreateNumericalServiceElement(ElementType.UInt8, 2)));
            bldr.AddCustomAttribute(new ServiceAttribute(HidProfileAttributeId.CountryCode,
                ServiceElement.CreateNumericalServiceElement(ElementType.UInt8, 3)));
            bldr.AddCustomAttribute(new ServiceAttribute(HidProfileAttributeId.VirtualCable,
                ServiceElement.CreateNumericalServiceElement(ElementType.UInt8, 4)));
            bldr.AddCustomAttribute(new ServiceAttribute(HidProfileAttributeId.ReconnectInitiate,
                ServiceElement.CreateNumericalServiceElement(ElementType.UInt8, 5)));
            //bldr.AddCustomAttribute(new ServiceAttribute(HidProfileAttributeId.DescriptorList,
            //    new ServiceElement(ElementType.ElementSequence,
            //        ServiceElement.CreateNumericalServiceElement(ElementType.UInt8, 6))));
            //bldr.AddCustomAttribute(new ServiceAttribute(HidProfileAttributeId.LangIdBaseList,
            //    new ServiceElement(ElementType.ElementSequence,
            //        ServiceElement.CreateNumericalServiceElement(ElementType.UInt8, 7))));
            bldr.AddCustomAttribute(new ServiceAttribute(HidProfileAttributeId.SdpDisable,
                ServiceElement.CreateNumericalServiceElement(ElementType.UInt8, 8)));
            bldr.AddCustomAttribute(new ServiceAttribute(HidProfileAttributeId.BatteryPower,
                ServiceElement.CreateNumericalServiceElement(ElementType.UInt8, 9)));
            bldr.AddCustomAttribute(new ServiceAttribute(HidProfileAttributeId.RemoteWake,
                ServiceElement.CreateNumericalServiceElement(ElementType.UInt8, 10)));
            bldr.AddCustomAttribute(new ServiceAttribute(HidProfileAttributeId.BootDevice,
                ServiceElement.CreateNumericalServiceElement(ElementType.UInt8, 14)));
            bldr.AddCustomAttribute(new ServiceAttribute(HidProfileAttributeId.SupervisionTimeout,
                ServiceElement.CreateNumericalServiceElement(ElementType.UInt8, 12)));
            bldr.AddCustomAttribute(new ServiceAttribute(HidProfileAttributeId.NormallyConnectable,
                ServiceElement.CreateNumericalServiceElement(ElementType.UInt8, 13)));
            bldr.AddCustomAttribute(new ServiceAttribute(HidProfileAttributeId.ProfileVersion,
                ServiceElement.CreateNumericalServiceElement(ElementType.UInt8, 11)));
            return bldr.ServiceRecord;
        }
        private ServiceRecord CreateAHumanInputDeviceRecordB()
        {
            ServiceRecordBuilder bldr = new ServiceRecordBuilder();
            // Listener needs this. :-(
            bldr.ProtocolType = BluetoothProtocolDescriptorType.GeneralObex;
            bldr.AddServiceClass(BluetoothService.HumanInterfaceDevice);
            bldr.AddCustomAttribute(new ServiceAttribute(HidProfileAttributeId.DeviceReleaseNumber,
                ServiceElement.CreateNumericalServiceElement(ElementType.UInt16, 0x1FFF)));
            bldr.AddCustomAttribute(new ServiceAttribute(HidProfileAttributeId.ParserVersion,
                ServiceElement.CreateNumericalServiceElement(ElementType.UInt16, 0xFF1F)));
            bldr.AddCustomAttribute(new ServiceAttribute(HidProfileAttributeId.DeviceSubclass,
                ServiceElement.CreateNumericalServiceElement(ElementType.UInt8, 0x2F)));
            bldr.AddCustomAttribute(new ServiceAttribute(HidProfileAttributeId.CountryCode,
                ServiceElement.CreateNumericalServiceElement(ElementType.UInt8, 0x3F)));
            bldr.AddCustomAttribute(new ServiceAttribute(HidProfileAttributeId.VirtualCable,
                ServiceElement.CreateNumericalServiceElement(ElementType.UInt8, 0x4F)));
            bldr.AddCustomAttribute(new ServiceAttribute(HidProfileAttributeId.ReconnectInitiate,
                ServiceElement.CreateNumericalServiceElement(ElementType.UInt8, 0x5F)));
            //bldr.AddCustomAttribute(new ServiceAttribute(HidProfileAttributeId.DescriptorList,
            //    new ServiceElement(ElementType.ElementSequence,
            //        ServiceElement.CreateNumericalServiceElement(ElementType.UInt8, 6))));
            //bldr.AddCustomAttribute(new ServiceAttribute(HidProfileAttributeId.LangIdBaseList,
            //    new ServiceElement(ElementType.ElementSequence,
            //        ServiceElement.CreateNumericalServiceElement(ElementType.UInt8, 7))));
            bldr.AddCustomAttribute(new ServiceAttribute(HidProfileAttributeId.SdpDisable,
                ServiceElement.CreateNumericalServiceElement(ElementType.UInt8, 0x8F)));
            bldr.AddCustomAttribute(new ServiceAttribute(HidProfileAttributeId.BatteryPower,
                ServiceElement.CreateNumericalServiceElement(ElementType.UInt8, 0x9F)));
            bldr.AddCustomAttribute(new ServiceAttribute(HidProfileAttributeId.RemoteWake,
                ServiceElement.CreateNumericalServiceElement(ElementType.UInt8, 0x1F)));
            bldr.AddCustomAttribute(new ServiceAttribute(HidProfileAttributeId.BootDevice,
                ServiceElement.CreateNumericalServiceElement(ElementType.UInt8, 14)));
            bldr.AddCustomAttribute(new ServiceAttribute(HidProfileAttributeId.SupervisionTimeout,
                ServiceElement.CreateNumericalServiceElement(ElementType.UInt8, 12)));
            bldr.AddCustomAttribute(new ServiceAttribute(HidProfileAttributeId.NormallyConnectable,
                ServiceElement.CreateNumericalServiceElement(ElementType.UInt8, 13)));
            bldr.AddCustomAttribute(new ServiceAttribute(HidProfileAttributeId.ProfileVersion,
                ServiceElement.CreateNumericalServiceElement(ElementType.UInt8, 11)));
            return bldr.ServiceRecord;
        }


        [MenuItem, SubMenu("SDP")]
        private void SdpCreateAHumanInputDeviceRecordsAllTwoOfThree()
        {
            var create = new Converter<object, ServiceRecordBuilder>(delegate
            {
                ServiceRecordBuilder bldrF = new ServiceRecordBuilder();
                // Listener needs this. :-(
                bldrF.ProtocolType = BluetoothProtocolDescriptorType.GeneralObex;
                bldrF.AddServiceClass(BluetoothService.HumanInterfaceDevice);
                return bldrF;
            });
            var attrA = new Action<ServiceRecordBuilder>(delegate(ServiceRecordBuilder bldrF)
            {
                bldrF.AddCustomAttribute(new ServiceAttribute(HidProfileAttributeId.DeviceReleaseNumber,
                    ServiceElement.CreateNumericalServiceElement(ElementType.UInt16, 0x1FFF)));
            });
            var attrC = new Action<ServiceRecordBuilder>(delegate(ServiceRecordBuilder bldrF)
            {
                bldrF.AddCustomAttribute(new ServiceAttribute(HidProfileAttributeId.DeviceSubclass,
                    ServiceElement.CreateNumericalServiceElement(ElementType.UInt8, 0x2F)));
            });
            var attrB = new Action<ServiceRecordBuilder>(delegate(ServiceRecordBuilder bldrF)
            {
                bldrF.AddCustomAttribute(new ServiceAttribute(HidProfileAttributeId.CountryCode,
                    ServiceElement.CreateNumericalServiceElement(ElementType.UInt8, 0x3F)));
            });
            //
            ServiceRecordBuilder bldr;
            bldr = create(null);
            attrA(bldr);
            attrB(bldr);
            BluetoothListener lsnr = Create_BluetoothListener(BluetoothService.HealthDeviceSink,
                bldr.ServiceRecord);
            bldr = create(null);
            attrA(bldr);
            attrC(bldr);
            BluetoothListener lsnr2 = Create_BluetoothListener(BluetoothService.HealthDeviceSink,
                bldr.ServiceRecord);
            bldr = create(null);
            attrB(bldr);
            attrC(bldr);
            BluetoothListener lsnr3 = Create_BluetoothListener(BluetoothService.HealthDeviceSink,
                bldr.ServiceRecord);
            //
            lsnr.Start();
            lsnr2.Start();
            lsnr3.Start();
            console.Pause("Un-pause to stop the server");
            lsnr.Stop();
            lsnr2.Stop();
            lsnr3.Stop();
        }

        [MenuItem, SubMenu("SDP")]
        public void SdpCreateTwoSppRecordsOneWithAvailAndBrowse()
        {
            var bldr = new ServiceRecordBuilder();
            bldr.AddServiceClass(BluetoothService.WapClient);
            bldr.AddCustomAttribute(new ServiceAttribute(
                UniversalAttributeId.ServiceAvailability,
                ServiceElement.CreateNumericalServiceElement(ElementType.UInt8, 255)));
            bldr.AddCustomAttribute(new ServiceAttribute(
                UniversalAttributeId.BrowseGroupList,
                new ServiceElement(ElementType.ElementSequence,
                    new ServiceElement(ElementType.Uuid128, BluetoothService.PublicBrowseGroup))));
            var sr = bldr.ServiceRecord;
            //DEBUGconsole.Write(ServiceRecordUtilities.Dump(sr));
            var lsnr = Create_BluetoothListener(
                new BluetoothEndPoint(BluetoothAddress.None, BluetoothService.SerialPort, 22),
                sr);
            var lsnr2 = Create_BluetoothListener(
                new Guid("{E665C159-4721-4e73-8E97-9A8BE42423D9}"));
            //
            lsnr.Start();
            lsnr2.Start();
            console.Pause("Un-pause to stop the server");
            lsnr.Stop();
            lsnr2.Stop();
        }

        [MenuItem, SubMenu("SDP")]
        public void SdpCreateAndDumpAnAvcrpRecord()
        {
            ServiceRecord record = CreateAnAvcrpCtRecord();
            //
            string dump = ServiceRecordUtilities.Dump(record);
            console.WriteLine(dump);
        }

        internal static ServiceRecord CreateAnAvcrpCtRecord()
        {
            //const UInt16 SvcClass16Avcrp = 0x110E;
            const UInt16 SvcClass16AvcrpController_ = 0x110F;
            Guid SvcClass128AvcrpController = BluetoothService.CreateBluetoothUuid(SvcClass16AvcrpController_);
            //
            const UInt16 SvcClass16ProtocolL2CAP = 0x0100;
            Debug_Assert_CorrectShortUuid(SvcClass16ProtocolL2CAP, BluetoothService.L2CapProtocol);
            const UInt16 SvcClass16ProtocolAvctp = 0x0017;
            Debug_Assert_CorrectShortUuid(SvcClass16ProtocolAvctp, BluetoothService.AvctpProtocol);
            //
            const UInt16 PsmAvcrp = 0x0017;
            const UInt16 PsmAvcrpBrowsing = 0x001B;
            //
            const UInt16 Version = 0x0103; // 1.3.......
            //
            var layer0 = new ServiceElement(ElementType.ElementSequence,
                new ServiceElement(ElementType.Uuid16, SvcClass16ProtocolL2CAP),
                new ServiceElement(ElementType.UInt16, PsmAvcrp));
            var layer1 = new ServiceElement(ElementType.ElementSequence,
                new ServiceElement(ElementType.Uuid16, SvcClass16ProtocolAvctp),
                new ServiceElement(ElementType.UInt16, Version));
            ServiceElement pdl = new ServiceElement(ElementType.ElementSequence,
                layer0, layer1);
            //
            var apdlLayer0 = new ServiceElement(ElementType.ElementSequence,
                new ServiceElement(ElementType.Uuid16, SvcClass16ProtocolL2CAP),
                new ServiceElement(ElementType.UInt16, PsmAvcrpBrowsing));
            var apdlLayer1 = new ServiceElement(ElementType.ElementSequence,
                new ServiceElement(ElementType.Uuid16, SvcClass16ProtocolAvctp),
                new ServiceElement(ElementType.UInt16, Version));
            ServiceElement additionalPdlSubList0 = new ServiceElement(ElementType.ElementSequence,
                apdlLayer0, apdlLayer1);
            ServiceElement additionalPdl = new ServiceElement(ElementType.ElementSequence,
                additionalPdlSubList0);
            //
            ServiceRecordBuilder bldr = new ServiceRecordBuilder();
            bldr.AddServiceClass(BluetoothService.AVRemoteControl);
            bldr.AddServiceClass(SvcClass128AvcrpController);
            //
            bldr.ProtocolType = BluetoothProtocolDescriptorType.None;
            bldr.AddCustomAttributes(
                new ServiceAttribute(UniversalAttributeId.ProtocolDescriptorList, pdl),
                new ServiceAttribute(UniversalAttributeId.AdditionalProtocolDescriptorLists,
                    additionalPdl));
            //
            bldr.AddBluetoothProfileDescriptor(BluetoothService.AVRemoteControl, 1, 4);
            //
            bldr.AddCustomAttribute(new ServiceAttribute(HandsFreeProfileAttributeId.SupportedFeatures,
                ServiceElement.CreateNumericalServiceElement(ElementType.UInt16,
                (int)(AvcrpSupportedFeatures.Category1 | AvcrpSupportedFeatures.Category2)
                )));
            //
            bldr.ProviderName = "alanjmcf!!!!!!";
            bldr.ServiceName = "avcrp tc!!!!!!";
            return bldr.ServiceRecord;
        }

        [Conditional("DEBUG")]
        private static void Debug_Assert_CorrectShortUuid(UInt16 svcClass16, Guid svcClass)
        {
            Debug.Assert(svcClass.Equals(BluetoothService.CreateBluetoothUuid(svcClass16)),
                "Wrong integer value 0x" + svcClass16.ToString("X4") + ", extracted from: " + svcClass);
        }

        [Conditional("DEBUG")]
        private static void Debug_Assert_CorrectShortUuid(UInt32 svcClass32, Guid svcClass)
        {
            Debug.Assert(svcClass.Equals(BluetoothService.CreateBluetoothUuid(svcClass32)),
                "Wrong integer value 0x" + svcClass32.ToString("X8") + ", extracted from: " + svcClass);
        }

        [Flags]
        enum AvcrpSupportedFeatures : ushort
        {
            /// <summary>
            /// Category 1
            /// </summary>
            Category1 = 0x01,
            /// <summary>
            /// Category 2
            /// </summary>
            Category2 = 0x02,
            /// <summary>
            /// Category 3
            /// </summary>
            Category3 = 0x04,
            /// <summary>
            /// Category 4
            /// </summary>
            Category4 = 0x08,
            /// <summary>
            /// Player Application Settings
            /// </summary>
            /// -
            /// <remarks>"Bit 0 should be set for this bit to be set."
            /// </remarks>
            PlayerApplicationSettings = 0x10,
            /// <summary>
            /// Group Navigation
            /// </summary>
            /// -
            /// <remarks>"Bit 0 should be set for this bit to be set."
            /// </remarks>
            GroupNavigation = 0x20,
            /// <summary>
            /// Supports Browsing
            /// </summary>
            SupportsBrowsing = 0x40,
            /// <summary>
            /// Supports multiple media player applications 
            /// </summary>
            SupportsMultipleMediaPlayerApplications = 0x20,
            // RFA
        }

        internal static ServiceRecord CreateAnAvcrpCtRecord_GuidForUuid16()
        {
            //Guid SvcClass128Avcrp = /*0x110E*/BluetoothService.AVRemoteControl;
            const UInt16 _SvcClass16AvcrpController = 0x110F;
            Guid SvcClass128AvcrpController = BluetoothService.CreateBluetoothUuid(_SvcClass16AvcrpController);
            //
            Guid SvcClass128ProtocolL2CAP = /*0x0100*/BluetoothService.L2CapProtocol;
            Guid SvcClass128ProtocolAvctp = /*0x0017*/BluetoothService.AvctpProtocol;
            //
            const UInt16 PsmAvcrp = 0x0017;
            const UInt16 PsmAvcrpBrowsing = 0x001B;
            //
            const UInt16 Version = 0x0103; // 1.3.......
            //
            var layer0 = new ServiceElement(ElementType.ElementSequence,
                new ServiceElement(ElementType.Uuid16, GetBluetoothUuid16(SvcClass128ProtocolL2CAP)),
                new ServiceElement(ElementType.UInt16, PsmAvcrp));
            var layer1 = new ServiceElement(ElementType.ElementSequence,
                new ServiceElement(ElementType.Uuid16, GetBluetoothUuid16(SvcClass128ProtocolAvctp)),
                new ServiceElement(ElementType.UInt16, Version));
            ServiceElement pdl = new ServiceElement(ElementType.ElementSequence,
                layer0, layer1);
            //
            var apdlLayer0 = new ServiceElement(ElementType.ElementSequence,
                new ServiceElement(ElementType.Uuid16, GetBluetoothUuid16(SvcClass128ProtocolL2CAP)),
                new ServiceElement(ElementType.UInt16, PsmAvcrpBrowsing));
            var apdlLayer1 = new ServiceElement(ElementType.ElementSequence,
                new ServiceElement(ElementType.Uuid16, GetBluetoothUuid16(SvcClass128ProtocolAvctp)),
                new ServiceElement(ElementType.UInt16, Version));
            ServiceElement additionalPdlSubList0 = new ServiceElement(ElementType.ElementSequence,
                apdlLayer0, apdlLayer1);
            ServiceElement additionalPdl = new ServiceElement(ElementType.ElementSequence,
                additionalPdlSubList0);
            //
            ServiceRecordBuilder bldr = new ServiceRecordBuilder();
            bldr.AddServiceClass(BluetoothService.AVRemoteControl);
            bldr.AddServiceClass(SvcClass128AvcrpController);
            //
            bldr.ProtocolType = BluetoothProtocolDescriptorType.None;
            bldr.AddCustomAttributes(
                new ServiceAttribute(UniversalAttributeId.ProtocolDescriptorList, pdl),
                new ServiceAttribute(UniversalAttributeId.AdditionalProtocolDescriptorLists, additionalPdl));
            //
            bldr.AddBluetoothProfileDescriptor(BluetoothService.AVRemoteControl, 1, 4);
            //
            bldr.AddCustomAttribute(new ServiceAttribute(HandsFreeProfileAttributeId.SupportedFeatures,
                ServiceElement.CreateNumericalServiceElement(ElementType.UInt16,
                (int)(AvcrpSupportedFeatures.Category1 | AvcrpSupportedFeatures.Category2)
                )));
            //
            bldr.ProviderName = "alanjmcf!!!!!!";
            bldr.ServiceName = "avcrp tc!!!!!!";
            return bldr.ServiceRecord;
        }

        static UInt16 GetBluetoothUuid16(Guid sigServiceClass)
        {
            Int64 uuid32 = GetBluetoothUuid32(sigServiceClass);
            UInt16 uuid16;
            try {
                UInt32 uuid32Real = (UInt32)uuid32;
                uuid16 = (UInt16)uuid32Real;
                return uuid16;
            } catch (OverflowException oex) {
                throw new ArgumentException("The Service Class Guid does not have a UUID16 short form.", oex);
            }
        }

        static UInt32 GetBluetoothUuid32(Guid sigServiceClass)
        {
            byte[] ba = sigServiceClass.ToByteArray();
            UInt32 uuid32 = BitConverter.ToUInt32(ba, 0);
            Guid recreated = BluetoothService.CreateBluetoothUuid(uuid32);
            if (!recreated.Equals(sigServiceClass))
                throw new ArgumentException("The Service Class Guid is not a Bluetooth standard class.");
            return uuid32;
        }

        [MenuItem, SubMenu("SDP")]
        public void SdpDumpGiven()
        {
            console.WriteLine("Enter the record bytes, e.g. 0x36, 0x00, 0x53, 0x09, 0x00, 0x00, 0x0a ...");
            console.WriteLine("Enter an empty line to finish.");
            var lineList = new List<string>();
            while (true) {
                //string line = "0x36, 0x00, 0x56, 0x36, 0x00, 0x53, 0x09, 0x00, 0x00, 0x0a, 0x00, 0x01, 0x00, 0x00, 0x09, 0x00, ";
                string line = console.ReadLine(string.Empty);
                if (string.IsNullOrEmpty(line)) {
                    break;
                }
                lineList.Add(line);
            }
            //
            const int GuessMaxLineLen = 16;
            var bytesList = new List<byte>(GuessMaxLineLen * lineList.Count);
            foreach (var curLine in lineList) {
                string[] arr = curLine.Split(',');
                bool sawBlank = false;
                foreach (var cur in arr) {
                    if (sawBlank) {
                        throw new FormatException("Found blank array entry in line.");
                    }
                    string v = cur.Trim();
                    byte b;
                    if (v.Length == 0) { // Empty, allow if after last comma...
                        sawBlank = true;
                        continue;
                    }
                    if (v.StartsWith("0x", StringComparison.Ordinal)) {
                        v = v.Substring(2);
                        b = byte.Parse(v, NumberStyles.AllowHexSpecifier);
                    } else {
                        b = byte.Parse(v);
                    }
                    bytesList.Add(b);
                }
            }
            //
            byte[] raw = bytesList.ToArray();
            var p = new ServiceRecordParser();
            ServiceRecord rcd;
            try {
                rcd = p.Parse(raw);
            } catch (UriFormatException) {
                console.WriteLine("Record parse failed with UriFormatException,"
                    + " trying again with LazyUrlCreation=true.");
                p.LazyUrlCreation = true;
                rcd = p.Parse(raw);
            }
            SdpRecordDump(new ServiceRecord[] { rcd });
        }

        [MenuItem, SubMenu("SDP")]
        public void FromJsr82ServerUri()
        {
            var line = console.ReadLine("JSR-82 uri");
            var bldr = ServiceRecordBuilder.FromJsr82ServerUri(line);
            console.WriteLine(ServiceRecordUtilities.Dump(bldr.ServiceRecord));
        }


        //--------
        delegate TResult MyFunc<T0, TResult>(T0 p0);
        delegate TResult MyFunc<T0, T1, TResult>(T0 p0, T1 p1);

        //----
        [MenuItem, SubMenu("Data")]
        public void SendLots()
        {
            if (!VerifyConnectionWrite())
                return;
            byte[] data = MakeLotsData();
            Lots_CheckTheTest(ref data);
            bool @async = console.ReadYesNo("Async", true);
            if (@async) {
                IAsyncResult ar = _peer.BeginWrite(data, 0, data.Length, MiscCallback, "BeginWrite");
                console.WriteLine("Started writing (async), len: {0}.", data.Length);
                _peer.EndWrite(ar);
            } else {
                _peer.Write(data, 0, data.Length);
            }
            console.WriteLine("Finished writing.");
        }

        [MenuItem, SubMenu("Data")]
        public void SendLots_InSizedChunks()
        {
            if (!VerifyConnectionWrite())
                return;
            byte[] data = MakeLotsData();
            Lots_CheckTheTest(ref data);
            IList<byte[]> dataList = SplitIntoChunks(data, 999);
            bool @async = console.ReadYesNo("Async", true);
            if (@async) {
                List<IAsyncResult> arList = new List<IAsyncResult>(dataList.Count);
                int total = 0;
                foreach (byte[] cur in dataList) {
                    IAsyncResult ar = _peer.BeginWrite(cur, 0, cur.Length, EmptyCallback, "BeginWrite");
                    total += cur.Length;
                    console.Write(".");
                    arList.Add(ar);
                }
                console.WriteLine("Did BeginWrite all chunks ({2}, async), len: {0} is {1}.", total, data.Length, arList.Count);
                foreach (IAsyncResult cur in arList) {
                    _peer.EndWrite(cur);
                }
                console.WriteLine("Did EndWrite all chunks.");
            } else {
                foreach (byte[] chunk in dataList) {
                    console.WriteLine("chunk={0}", chunk.Length);
                    _peer.Write(chunk, 0, chunk.Length);
                }
            }
            console.WriteLine("Finished writing.");
        }

        private void Lots_CheckTheTest(ref byte[] data)
        {
            bool testChecking1 = console.ReadYesNo("check the TEST, set one byte wrong", false);
            if (testChecking1) {
                data[1030000] ^= 255;
            }
            int hackOffset = 1040000;
            bool testChecking2 = console.ReadYesNo("check the TEST, add two bytes at " + hackOffset, false);
            if (testChecking2) {
                byte[] dataSlodged = new byte[data.Length + 2];
                Array.Copy(data, 0, dataSlodged, 0, hackOffset);
                Array.Copy(data, hackOffset, dataSlodged, 2 + hackOffset, data.Length - hackOffset);
                data = dataSlodged;
            }
        }

        private IList<byte[]> SplitIntoChunks(byte[] data, int chunkSize)
        {
            int offset = 0;
            List<byte[]> chunkList = new List<byte[]>(data.Length / chunkSize + 1);
            while (offset < data.Length) {
                int curSize = Math.Min(chunkSize, data.Length - offset);
                byte[] cur = new byte[curSize];
                Array.Copy(data, offset, cur, 0, cur.Length);
                offset += cur.Length;
                chunkList.Add(cur);
            }
            if (offset != data.Length)
                throw new InvalidOperationException("NOT offset==data.Length: " + offset + " vs " + data.Length);
            return chunkList;
        }

        private byte[] MakeLotsData()
        {
            byte[] data = new byte[1 * 1024 * 1024];
            bool useRandom = console.ReadYesNo("Random data", true);
            if (useRandom) {
                Random r = new Random(999);
                r.NextBytes(data);
            } else {
                for (int i = 0; i < data.Length; ++i) {
                    data[i] = unchecked((byte)i);
                    if (data[i] == 0) // Don't allow zeros, to se if that bug occurs.
                        data[i] = 255;
                }
            }
            return data;
        }

        [MenuItem, SubMenu("Data")]
        public void ReadLots()
        {
            if (!VerifyConnectionRead())
                return;
            byte[] expectedData = MakeLotsData();
            ReadLotsState state = new ReadLotsState(_peer, expectedData);
            state.data = new byte[expectedData.Length + 20];
            ReadLotsStartNextRead(state);
            console.Pause("Un-pause to stop");
            //lock (readLotsCurAr) {
            //    readLotsCurAr.
            //}
        }

        IAsyncResult readLotsCurAr;

        private void ReadLotsStartNextRead(ReadLotsState state)
        {
            if (state.numCompletedSynchronously > ReadLotsState.MaxCompletedSynchronously) {
                // (There's lots of pending data and thus) We've CompletedSynchronously
                // *many* times, so there's a danger of stack overflow 
                // (BeginRead->callback->BeginRead->callback->BeginRead->callback->...),
                // so start the next operation on a new thread.
                WaitCallback dlgt = delegate(object stateP)
                {
                    ReadLotsState state0 = (ReadLotsState)stateP;
                    state.numCompletedSynchronously = 0;
                    ReadLotsStartNextRead(state);
                };
                ThreadPool.QueueUserWorkItem(dlgt);
                return;
            }
            readLotsCurAr = state.peer.BeginRead(state.data, state.totalLen, state.data.Length - state.totalLen,
                ReadLotsReadCallBack, state);
            console.Write("-");
        }

        class ReadLotsState
        {
            public ReadLotsState(Stream peer, byte[] expectedData)
            {
                this.peer = peer;
                this.expectedData = expectedData;
            }

            public Stream peer;
            public byte[] data;
            public int totalLen;
            //
            public byte[] expectedData;
            //
            public int numCompletedSynchronously;
            public const int MaxCompletedSynchronously = 50;
        }

        void ReadLotsReadCallBack(IAsyncResult ar)
        {
            ReadLotsState state = (ReadLotsState)ar.AsyncState;
            int readLen;
            try {
                readLen = state.peer.EndRead(ar);
            } catch (ObjectDisposedException) {
                console.WriteLine("Connection was closed during ReadLots.");
                console.WriteLine("???, hit return to continue.");
                return;
            }
            console.Write(">{1} ({0}) ", readLen, state.totalLen + readLen);
            ArraysEqual(state.expectedData, state.data, state.totalLen, readLen);
            state.totalLen += readLen;
            if (ar.CompletedSynchronously)
                ++state.numCompletedSynchronously;
            else
                state.numCompletedSynchronously = 0;
            if (state.totalLen == state.expectedData.Length) {
                console.WriteLine("got all!");
                return;
            }
            //
            if (readLen == 0) {
                console.WriteLine("EoF, hit return to continue.");
                return;
            }
            ReadLotsStartNextRead(state);
        }

        private void ArraysEqual(byte[] expected, byte[] actual, int offset, int count)
        {
            for (int i = 0; i < count; ++i) {
                if (offset + i >= expected.Length) {
                    console.WriteLine("!! ({0}+{1}=>) {2} >= {3}", offset, i, (offset + i), expected.Length);
                }
                if (offset + i >= actual.Length) {
                    console.WriteLine("!! ({0}+{1}=>) {2} >= {3}", offset, i, (offset + i), actual.Length);
                }
                if (expected[offset + i] != actual[offset + i]) {
                    console.WriteLine("wrong at {0}+{1}={2}", offset, i, offset + i);
                    break;
                }
            }
        }

        //----
        [MenuItem, SubMenu("Local")]
        public void GetAllRadios_OnUiThread()
        {
            EventHandler dlgt = delegate
            {
#if ANDROID
                InTheHand.Net.Bluetooth.Droid.AndroidBthInquiry
                    .MyActivity = (Android.App.Activity)console.InvokeeControl;
#endif
                var rl = BluetoothRadio.GetAllRadios();
            };
            console.UiInvoke(dlgt);
        }

        [MenuItem, SubMenu("Local")]
        public void GetAllRadios()
        {
            BluetoothRadio_GetAllAndDump();
        }

        [MenuItem, SubMenu("Local")]
        public void GetAllRadiosWith_Features()
        {
            BluetoothRadio_GetAllAndDump(true);
        }

        [MenuItem, SubMenu("Local")]
        public void Get_AllRadiosDumpRepeatedly()
        {
            BluetoothRadio[] list = BluetoothRadio.GetAllRadios();
            do {
                DumpBluetoothRadios(list, false);
            } while (console.ReadYesNo("Dump again", false));
        }

        BluetoothRadio[] BluetoothRadio_GetAllAndDump()
        {
            return BluetoothRadio_GetAllAndDump(false);
        }

        BluetoothRadio[] BluetoothRadio_GetAllAndDump(bool dumpFeatureList)
        {
            BluetoothRadio[] list;
            if (console.ReadYesNo("Get Method rather then Property", true)) {
                list = BluetoothRadio.GetAllRadios();
            } else {
                list = BluetoothRadio.AllRadios;
            }
            DumpBluetoothRadios(list, dumpFeatureList);
            return list;
        }

        void DumpBluetoothRadios(BluetoothRadio[] list, bool dumpFeatureList)
        {
            if (list == null)
                console.WriteLine("AllRadios returned null!!!");
            else if (list.Length == 0)
                console.WriteLine("AllRadios returned empty list.");
            int i = 1;
            foreach (BluetoothRadio r in list) {
                console.WriteLine("{0})  {1}", i, DumpBluetoothRadio(r, dumpFeatureList));
                ++i;
            }
        }

        [MenuItem, SubMenu("Local")]
        public void GetPrimaryRadio()
        {
            GetPrimaryRadio_(false);
        }

        [MenuItem, SubMenu("Local")]
        public void Get_PrimaryRadioAndDumpRepeatedly()
        {
            GetPrimaryRadio_(true);
        }

        void GetPrimaryRadio_(bool offerRepeat)
        {
            BluetoothRadio r;
            if (console.ReadYesNo("Get Method rather then Property", true)) {
                r = BluetoothRadio.GetPrimaryRadio();
            } else {
                r = BluetoothRadio.PrimaryRadio;
            }
            do {
                if (r == null)
                    console.WriteLine("PrimaryRadio returned null.");
                else
                    console.WriteLine(DumpBluetoothRadio(r, false));
            } while (offerRepeat
                && console.ReadYesNo("Dump again", false));
        }

        private static string DumpVersions(RadioVersions v)
        {
            if (v == null)
                throw new ArgumentNullException("radio");
            using (StringWriter wtr = new StringWriter()) {
                wtr.WriteLine("LMP Version: " + v.LmpVersion
                    + ", Subversion: " + v.LmpSubversion);
                wtr.WriteLine("Manufacturer: {0}",
                    v.Manufacturer);
                wtr.WriteLine("LMP Features: {0}",
                    v.LmpSupportedFeatures);
                return wtr.ToString();
            }
        }

        private static string DumpBluetoothRadio(BluetoothRadio radio, bool dumpFeatureList)
        {
            if (radio == null)
                throw new ArgumentNullException("radio");
            using (StringWriter wtr = new StringWriter()) {
                RadioMode mode = radio.Mode;
                // Warning: LocalAddress is null if the radio is powered-off.
                wtr.WriteLine("Radio, address: {0:C}", radio.LocalAddress);
#if RADIO_MODESSS
                wtr.Write("Mode: " + mode.ToString());
                wtr.WriteLine("; Modes: { " + radio.Modes.ToString() + " }");
#else
                wtr.WriteLine("Mode: " + mode.ToString());
#endif
                wtr.WriteLine("Name: " + ToStringQuotedOrNull(radio.Name));
                wtr.WriteLine("HCI Version: " + radio.HciVersion
                    + ", Revision: " + radio.HciRevision);
                wtr.WriteLine("LMP Version: " + radio.LmpVersion
                    + ", Subversion: " + radio.LmpSubversion);
                if (dumpFeatureList) { wtr.WriteLine("LMP Features: " + radio.LmpFeatures); }
                wtr.WriteLine("ClassOfDevice: " + radio.ClassOfDevice.ToString()
                    + ", device: " + radio.ClassOfDevice.Device.ToString()
                    + " / service: " + radio.ClassOfDevice.Service.ToString());
                wtr.WriteLine("Software: {0},  Hardware: {1}, status: {2}",
                    radio.SoftwareManufacturer, radio.Manufacturer, radio.HardwareStatus);
                //try {
                //    wtr.WriteLine("Handle: 0x{0:X}", radio.Handle);
                //} catch (Exception ex) {
                //    wtr.WriteLine("Handle: failed with: '{0}'", ex.GetType().Name);
                //}
                wtr.WriteLine("Remote: '{0}'", radio.Remote);
                return wtr.ToString();
            }
        }

        private static string DumpBluetoothRadioBrief(BluetoothRadio radio)
        {
            if (radio == null)
                throw new ArgumentNullException("radio");
            using (StringWriter wtr = new StringWriter()) {
                RadioMode mode = radio.Mode;
                // Warning: LocalAddress is null if the radio is powered-off.
                //wtr.Write("Address: {0:C}, ", radio.LocalAddress);
                wtr.Write("Mode: " + mode.ToString());
#if RADIO_MODESSS
                wtr.Write("; Modes: { " + radio.Modes.ToString() + " }");
#endif
                //wtr.Write(", Name: " + radio.Name);
                return wtr.ToString();
            }
        }

        [MenuItem, SubMenu("Local")]
        public void RepeatedlyGetPrimaryRadio()
        {
            int? initialDelay = console.ReadOptionalInteger("Initial delay (ms)");
            int? interDelay = 250;
            int? userInterDelay = console.ReadOptionalInteger("Inter delay (ms) (default " + interDelay + ")");
            if (userInterDelay.HasValue) interDelay = userInterDelay;
            int count = 20;
            int? userCount = console.ReadOptionalInteger("Optional count (default " + count + ")");
            if (userCount.HasValue) count = userCount.Value;
            //
            if (initialDelay.HasValue) Thread.Sleep(initialDelay.Value);
            for (int i = 0; i < count; ++i) {
                console.WriteLine(Environment.TickCount.ToString() + ": ");
                try {
                    BluetoothRadio r = BluetoothRadio.PrimaryRadio;
                    if (r == null) {
                        console.WriteLine("PrimaryRadio returned null.");
                    } else {
                        console.WriteLine(DumpBluetoothRadioBrief(r));
                    }
                } catch (Exception ex) {
                    console.WriteLine("Error:" + Exception_FirstLine(ex));
                    Debug.WriteLine("RGPR: " + ex);
                }
                if (interDelay.HasValue) Thread.Sleep(interDelay.Value);
            }//for
        }

        [MenuItem, SubMenu("Local")]
        public void IsSupported()
        {
            bool? f = null;
            EventHandler dlgt = (o, e) =>
                f = BluetoothRadio.IsSupported;
            bool ui = console.ReadYesNo("On UI thread?", false);
            if (!ui)
                dlgt(null, null);
            else
                console.UiInvoke(dlgt);
            console.WriteLine("IsSupported: {0}", f.Value);
        }


        //----
#if TEST_EARLY
        [MenuItem, SubMenu("BtLsnr")]
        public void WidcommHackListen()
        {
            BluetoothAddress addr = BluetoothAddress.None;
            //BluetoothAddress addr = console.ReadBluetoothAddress("Server's local BluetoothAddress");
            Guid svcClass = BluetoothService.WapClient;
            console.WriteLine("Default UUID : {0}", svcClass);
            Guid? inputGuid = console.ReadOptionalBluetoothUuid("UUID");
            if (inputGuid.HasValue)
                svcClass = inputGuid.Value;
            int? port = console.ReadOptionalInteger("Port number");
            //
            BluetoothEndPoint rep;
            if (port == null)
                rep = new BluetoothEndPoint(addr, svcClass);
            else
                rep = new BluetoothEndPoint(addr, svcClass, port.Value);
            console.WriteLine("Connecting to: {0}:{1}:{2}", rep.Address, rep.Service, rep.Port);
            //
            InTheHand.Net.Bluetooth.Widcomm.WidcommBluetoothListener lsnr
                = new InTheHand.Net.Bluetooth.Widcomm.WidcommBluetoothListener();
            lsnr.Construct(rep);
            lsnr.Start();
            BluetoothClient conn = lsnr.AcceptBluetoothClient();
            peer = conn.GetStream();
            s_cli = new WeakReferenceT<BluetoothClient>(conn);
        }
#endif

        [MenuItem, SubMenu("GC")]
        public void RunFinalizersAfterGc()
        {
            RunFinalizersAfterGc_();
        }

        internal static void RunFinalizersAfterGc_()
        {
            GC.Collect();
            GC.WaitForPendingFinalizers();
        }

        [MenuItem, SubMenu("GC")]
        public void RunGc()
        {
            RunGc_();
        }

        internal static void RunGc_()
        {
            GC.Collect();
        }

#if !NETCF && !ANDROID
        [MenuItem, SubMenu("GC")]
        public void BeepOnFinalization()
        {
            JRichter.GCNotification.StartBeeper();
        }
#endif

        //----------
        [MenuItem, SubMenu("OBEX")]
        public void _ObexWebRequest()
        {
            string addr = console.ReadLine("Address (IrDA / TCP/IP; hit return for BT)");
            bool useUriCtor = true;
            BluetoothAddress addrBth;
            if (addr.Length == 0) {
                addrBth = console.ReadBluetoothAddress("Target Bluetooth device");
                addr = addrBth.ToString();
                useUriCtor = !console.ReadYesNo("Use BluetoothAddress+stringPath constructor", !useUriCtor);
            } else {
                // Often get a space after string on NETCF (remembered string)
                addr = addr.Trim();
                addrBth = null;
            }
            string pathO;
            string fileSource;
            int? contentLen;
            if (console.ReadYesNo("Send dummy content", true)) {
                pathO = "/obexpush1.txt";
                contentLen = console.ReadOptionalInteger("How much content (default ~60 bytes)");
                fileSource = null;
                if (contentLen == null)
                    contentLen = 60;
            } else {
                contentLen = null;
                fileSource = console.GetFilename();
                pathO = Path.GetFileName(fileSource);
                pathO = "/" + pathO;
            }
            //
            int? timeout = console.ReadOptionalInteger("timeout (ms)");
            //
            const string scheme = "obex";
            Debug.Assert(pathO.StartsWith("/"), "NOT path starts with /");
            var s = string.Format(System.Globalization.CultureInfo.InvariantCulture,
                "{0}://{1}{2}",
                scheme, addr, pathO);
            Uri uri = new Uri(s);
            ObexWebRequest req;
            if (useUriCtor) {
                req = Create_ObexWebRequest(uri);
            } else {
                req = Create_ObexWebRequest(scheme, addrBth, pathO);
            }
            if (timeout != null) { req.Timeout = timeout.Value; }
            //
            if (contentLen != null) {
                WriteDummyContent(contentLen.Value, req);
            } else {
                req.ReadFile(fileSource);
            }
            console.WriteLine("Calling GetResponse with " + req.ContentLength + " bytes of content...");
            ObexWebResponse rsp = (ObexWebResponse)req.GetResponse();
            console.WriteLine("Response Code: {0} (0x{0:X})", rsp.StatusCode);
        }

        private static void WriteDummyContent(int contentLen, ObexWebRequest req)
        {
            using (Stream content = req.GetRequestStream()) {
                // Using a StreamWriter to write text to the stream...
                using (TextWriter wtr = new StreamWriter(content)) {
                    int i = 0;
                    while (content.Length < contentLen) {
                        ++i;
                        wtr.WriteLine("Hello World GetRequestStream {0}",
                            // Write the time to the first line
                            i == 1 ? DateTime.Now.ToString() : i.ToString());
                        wtr.Flush(); // push through to stream
                    }
                    // Set the Length header value
                    req.ContentLength = content.Length;
                }
            }
        }

#if !NETCF
        bool _touchedOwr;

        [MenuItem, SubMenu("OBEX")]
        public void WebClientPut()
        {
            if (!_touchedOwr) {
                bool ret = console.ReadYesNo("Touch ObexWebRequest to install protocol handler.", true);
                if (ret) {
                    var x = new ObexWebRequest(new Uri("obex://127.0.0.1/foo.txt"));
                    _touchedOwr = true;
                }
            }
            string addr = console.ReadLine("Address (IrDA / TCP/IP; hit return for BT)");
            if (addr.Length == 0) {
                BluetoothAddress addrB = console.ReadBluetoothAddress("Target Bluetooth device");
                addr = addrB.ToString();
            }
            int? contentLen = console.ReadOptionalInteger("How much content (default ~60 bytes)");
            if (contentLen == null)
                contentLen = 60;
            //NOT on NETCF!
            //  UriBuilder bldr = new UriBuilder();
            //  bldr.Scheme = "obex";
            //  bldr.Path = "/obexpush1.txt";
            //  bldr.Host = addr.ToString();
            Uri uri = new Uri(string.Format(System.Globalization.CultureInfo.InvariantCulture,
                "{0}://{1}{2}",
                "obex", addr, "/obexpush1.txt"));
            //
            var cli = new WebClient();
            cli.UploadProgressChanged += delegate(object sender, UploadProgressChangedEventArgs e)
            {
                console.WriteLine("Progress: {0}%, {1} of {2}",
                    e.ProgressPercentage, e.BytesSent, e.TotalBytesToSend);
            };
            cli.UploadDataCompleted += delegate(object sender, UploadDataCompletedEventArgs e)
            {
                WriteAsyncCompletedState("UploadData", e);
            };
            byte[] data;
            using (var content = new MemoryStream()) {
                // Using a StreamWriter to write text to the stream...
                using (TextWriter wtr = new StreamWriter(content)) {
                    int i = 0;
                    while (content.Length < contentLen) {
                        ++i;
                        wtr.WriteLine("Hello World GetRequestStream {0}",
                            // Write the time to the first line
                            i == 1 ? DateTime.Now.ToString() : i.ToString());
                        wtr.Flush(); // push through to stream
                    }
                    // 
                    data = content.ToArray();
                }
            }
            // Need method set!
            cli.UploadDataAsync(uri, "PUT", data);
            console.Pause("Un-pause after completion");
            //console.WriteLine("Calling GetResponse with " + req.ContentLength + " bytes of content...");
            //ObexWebResponse rsp = (ObexWebResponse)req.GetResponse();
            //console.WriteLine("Response Code: {0} (0x{0:X})", rsp.StatusCode);
        }
#endif

        [MenuItem, SubMenu("OBEX")]
        public void ObexWebRequest_GET()
        {
            string addr = console.ReadLine("Address (IrDA / TCP/IP; hit return for BT)");
            if (addr.Length == 0) {
                BluetoothAddress addrB = console.ReadBluetoothAddress("Target Bluetooth device");
                addr = addrB.ToString();
            }
            string path = console.ReadLine("Path");
            Uri uri = new Uri(string.Format(System.Globalization.CultureInfo.InvariantCulture,
                "{0}://{1}/{2}",
                "obex-ftp", addr, path));
            console.WriteLine("Using URL: '{0}'", uri);
            ObexWebRequest req = new ObexWebRequest(uri);
            req.Method = "GET";
            ObexWebResponse rsp = (ObexWebResponse)req.GetResponse();
            console.WriteLine("Response Code: {0} (0x{0:X})", rsp.StatusCode);
            var strm = rsp.GetResponseStream();
            console.WriteLine("  ContentLength: {0}, Stream.Length: {1}",
                rsp.ContentLength, strm.Length);
            using (Stream rspData = strm) {
                StreamReader rdr = new StreamReader(rspData);
                console.WriteLine("data, first line: '{0}'", rdr.ReadLine());
            }
        }

        [MenuItem, SubMenu("OBEX")]
        public void Obex_Listener()
        {
            m_lsnrStop = false;
            Interlocked.Exchange(ref m_lsnrId, 0);
            ObexListener lstnr = null;
            ObexTransport? proto = null;
            while (lstnr == null) {
                int? i = console.ReadOptionalInteger("Which ObexListener transport: 1. Bluetooth, 2. IrDA, 3. TCP/IP");
                if (!i.HasValue || i.Value == 1) {
                    proto = ObexTransport.Bluetooth;
                    lstnr = Create_ObexListener_Bluetooth();
                } else {
                    while (!proto.HasValue) {
                        switch (i) {
                            case 2:
                                proto = ObexTransport.IrDA;
                                break;
                            case 3:
                                proto = ObexTransport.Tcp;
                                break;
                            default:
                                // (No Trace.Fail on NETCFv2)
                                Debug.Assert(false, "invalid input: " + i);
                                break;
                        }
                    }
                    lstnr = new ObexListener(proto.Value);
                }
            }
            console.WriteLine("Created {0} ObexListener.", proto);
            //
            var auth = console.ReadYesNoCancel("Authenticate value (or don't set)", null);
            if (auth.HasValue) { lstnr.Authenticate = auth.Value; }
            console.WriteLine("get_Authenticate value: '{0}'", lstnr.Authenticate);
            var encrypt = console.ReadYesNoCancel("Encrypt value (or don't set)", null);
            if (encrypt.HasValue) { lstnr.Encrypt = encrypt.Value; }
            console.WriteLine("get_Encrypt value: '{0}'", lstnr.Encrypt);
            //
            lstnr.Start();
            console.WriteLine("OBEX listening");
            console.WriteLine("get_Authenticate value: '{0}'", lstnr.Authenticate);
            console.WriteLine("get_Encrypt value: '{0}'", lstnr.Encrypt);
            int? count = console.ReadOptionalInteger("How many acceptors threads? (1 by default)");
            if (count == null) {
                count = 1;
            }
            console.WriteLine("Starting acceptor...");
            for (int i = 0; i < count; ++i) {
                ThreadPool.QueueUserWorkItem(ObexListener_Worker, lstnr);
            }
            try {
                console.Pause("Un-pause to continue; and close listener");
            } finally {
                m_lsnrStop = true;
                lstnr.Stop();
            }
        }

        private volatile bool m_lsnrStop;
        private int m_lsnrId;

        void ObexListener_Worker(object state)
        {
            int id = Interlocked.Increment(ref m_lsnrId);
            while (true) {
                ObexListener lstnr = (ObexListener)state;
                if (m_lsnrStop || !lstnr.IsListening) {
                    break;
                }
                ObexListenerContext ctx = null;
                try {
                    ctx = lstnr.GetContext();
                    if (ctx == null) {
                        console.WriteLine("{0}: OBEX null context!", id);
                        continue;
                    }
                    console.WriteLine("{0}: OBEX accepted lContext", id);
                    ObexListenerRequest req = ctx.Request;
                    console.WriteLine("{0}: OBEX lRequest url: {1}, ContentLength64: {2}",
                        id, req.RawUrl, req.ContentLength64);
                    var ms = (MemoryStream)req.InputStream;
                    console.WriteLine("{0}: InputStream.Len: {1}",
                        id, ms.Length);
                } catch (Exception ex) {
                    console.WriteLine("{0}: OBEX ctx/req fault: {1}", id, ex);
                }
                ctx = null;
            }//while
        }


        //--------
#if TEST_EARLY
        [MenuItem, SubMenu("Security etc")]
        public void SetPain()
        {
            BluetoothAddress addr = console.ReadBluetoothAddress("Address");
            string passphrase = console.ReadLine("Passphrase");
            using (BluetoothClient cli = new BluetoothClient()) {
               InTheHand.Net.Bluetooth.Widcomm.BOND_RETURN_CODE ret = cli.WidcommHack__SetPinX(addr, passphrase);
               console.WriteLine("Bond returned: {0} = 0x{1:X}", ret, (int)ret);
           }
        }
#endif

        private BluetoothPublicFactory GetStackFactory()
        {
            var r = Get_BluetoothRadio();
            if (r == null) {
                console.WriteLine("No radios.");
                throw new InvalidOperationException("No radios.");
            }
            return r.StackFactory;
        }

        [MenuItem, SubMenu("Security etc")]
        public void PairRequest()
        {
            BluetoothAddress addr = console.ReadBluetoothAddress("Address");
            string passphrase = console.ReadLine("Passphrase");
            if (string.IsNullOrEmpty(passphrase)) {
                bool makeNull = console.ReadYesNo("Do you want to use a null/Nothing passphrase", true);
                passphrase = makeNull ? null : string.Empty;
            }
            InTheHand.Net.Bluetooth.Factory.IBluetoothSecurity sec
                = GetStackFactory().BluetoothSecurity;
            bool ret = sec.PairRequest(addr, passphrase);
            console.WriteLine("PairRequest returned: {0}", ret);
        }

        [MenuItem, SubMenu("Security etc")]
        public void RemoveDevice()
        {
            BluetoothAddress addr = console.ReadBluetoothAddress("Address");
            InTheHand.Net.Bluetooth.Factory.IBluetoothSecurity sec
                = GetStackFactory().BluetoothSecurity;
            bool ret = sec.RemoveDevice(addr);
            console.WriteLine("RemoveDevice returned: {0}", ret);
        }

        [MenuItem, SubMenu("Security etc")]
        public void SetPin()
        {
            string passphrase = console.ReadLine("Passphrase");
            if (string.IsNullOrEmpty(passphrase)) {
                bool makeNull = console.ReadYesNo("Do you want to use a null/Nothing passphrase", true);
                passphrase = makeNull ? null : string.Empty;
            }
            BluetoothAddress addr = console.ReadBluetoothAddress("Address");
            InTheHand.Net.Bluetooth.Factory.IBluetoothSecurity sec
                = GetStackFactory().BluetoothSecurity;
            bool ret = sec.SetPin(addr, passphrase);
            console.WriteLine("SetPin returned: {0}", ret);
        }

        [MenuItem, SubMenu("Security etc")]
        public void RevokePin()
        {
            BluetoothAddress addr = console.ReadBluetoothAddress("Address");
            string passphrase = console.ReadLine("Passphrase");
            if (string.IsNullOrEmpty(passphrase)) {
                bool makeNull = console.ReadYesNo("Do you want to use a null/Nothing passphrase", true);
                passphrase = makeNull ? null : string.Empty;
            }
            InTheHand.Net.Bluetooth.Factory.IBluetoothSecurity sec
                = GetStackFactory().BluetoothSecurity;
            bool ret = sec.RevokePin(addr);
            console.WriteLine("RevokePin returned: {0}", ret);
        }

        //--------
        [MenuItem, SubMenu("MultiStack")]
        public void ListenerOnStack1ClientOnStack2()
        {
            BluetoothRadio[] radios = BluetoothRadio_GetAllAndDump();
            Debug.Assert(radios != null, "Should't return null!");
            if (radios.Length < 2) {
                console.WriteLine("Fewer that two radios were found ({0}).", radios.Length);
                return;
            }
            //
            ListenerOnStackAClientOnStackB(radios[0], radios[1]);
        }

        [MenuItem, SubMenu("MultiStack")]
        public void ListenerOnStack2ClientOnStack1()
        {
            BluetoothRadio[] radios = BluetoothRadio_GetAllAndDump();
            Debug.Assert(radios != null, "Should't return null!");
            if (radios.Length < 2) {
                console.WriteLine("Fewer that two radios were found ({0}).", radios.Length);
                return;
            }
            //
            ListenerOnStackAClientOnStackB(radios[1], radios[0]);
        }

        public void ListenerOnStackAClientOnStackB(BluetoothRadio radioLsnr, BluetoothRadio radioCli)
        {
            BluetoothListener lsnr = radioLsnr.StackFactory.CreateBluetoothListener(BluetoothService.Wap);
            BluetoothClient conn = null;
            BluetoothClient cli = null;
            try {
                lsnr.Start();
#if APM_LSNR
            IAsyncResult arLsnr = lsnr.BeginAcceptBluetoothClient(MiscCallback, "ListenerOnStack1ClientOnStack2");
#else
                ManualResetEvent accepted = new ManualResetEvent(false);
                WaitCallback dlgt = delegate(object state)
                {
                    BluetoothListener lsnr_ = (BluetoothListener)state;
                    try {
                        conn = lsnr_.AcceptBluetoothClient();
                        console.WriteLine("Server got connection from : '{0}' {1}", conn.RemoteMachineName, conn.RemoteEndPoint);
                        PrintLocalEndpointIfAvailable(conn);
                    } catch (Exception ex) {
                        console.WriteLine("Accept failed with: " + ex);
                    } finally {
                        accepted.Set();
                    }
                };
                conn = null;
                ThreadPool.QueueUserWorkItem(dlgt, lsnr);
#endif
                BluetoothEndPoint lep = lsnr.LocalEndPoint;
                console.WriteLine("Listener active on SCN: {0}", lep.Port);
                //
                cli = radioCli.StackFactory.CreateBluetoothClient();
                BluetoothEndPoint rep = new BluetoothEndPoint(radioLsnr.LocalAddress, BluetoothService.Empty, lep.Port);
                console.WriteLine("Gonna connect to: {0}", rep);
                console.Pause("Un-pause to connect!");
                cli.Connect(rep);
                console.WriteLine("Client Connected to : '{0}' {1}", cli.RemoteMachineName, cli.RemoteEndPoint);
                PrintLocalEndpointIfAvailable(cli);
                //
#if APM_LSNR
                console.WriteLine("Lsnr.Accept.IsCompleted: {0}", arLsnr.IsCompleted);
                conn = lsnr.EndAcceptBluetoothClient(arLsnr);
#else
                console.WriteLine("waiting for Lsnr.Accept completion event.");
                accepted.WaitOne();
                Debug.Assert(conn != null, "Should have veen set by thread!");
#endif
                console.WriteLine("All success");
                console.Pause("Un-pause to exit (and close both)");
            } finally {
                if (lsnr != null)
                    lsnr.Stop();
                if (conn != null)
                    conn.Dispose();
                if (cli != null)
                    cli.Dispose();
            }
        }

        [MenuItem, SubMenu("MultiStack")]
        public void ObexWebRequest_MultiAsync()
        {
            BluetoothRadio[] radios = BluetoothRadio_GetAllAndDump();
            Debug.Assert(radios != null, "Should't return null!");
            if (radios.Length < 1) {
                console.WriteLine("No radios found.");
                return;
            }
            //
            List<BluetoothAddress> addrList = new List<BluetoothAddress>();
            for (int i = 0; i < radios.Length; ++i) {
                BluetoothAddress addr = console.ReadBluetoothAddress(
                    "Target device for radio #" + (i + 1));
                addrList.Add(addr);
            }//for
            bool bigSend = console.ReadYesNo("Send big (1MB) or small?", false);
            byte[] bigBuf = null;
            if (bigSend) {
                bigBuf = new byte[1024 * 1024];
#if !NETCF
                Array.ForEach(bigBuf, delegate(byte cur) { cur = (byte)'a'; });
#endif
            }
            List<IAsyncResult> arList = new List<IAsyncResult>(addrList.Count);
            for (int i = 0; i < radios.Length; ++i) {
                BluetoothAddress addr = addrList[i];
                Uri uri = new Uri(string.Format(System.Globalization.CultureInfo.InvariantCulture,
                    "{0}://{1}{2}",
                    "obex", addr, "/obexpush1.txt"));
                BluetoothPublicFactory factory = radios[i].StackFactory;
                ObexWebRequest req = factory.CreateObexWebRequest(uri);
                using (Stream content = req.GetRequestStream()) {
                    // Using a StreamWriter to write text to the stream...
                    if (bigSend) {
                        content.Write(bigBuf, 0, bigBuf.Length);
                    } else {
                        using (TextWriter wtr = new StreamWriter(content)) {
                            wtr.WriteLine("Hello World GetRequestStream");
                            wtr.WriteLine("Hello World GetRequestStream 2");
                            wtr.Flush();
                            // Set the Length header value
                            req.ContentLength = content.Length;
                        }
                    }
                }
                IAsyncResult ar = req.BeginGetResponse(null, req);
                arList.Add(ar);
            }//for
            //
            console.WriteLine("Waiting for all requests to complete...");
            WaitAll(arList);
            console.WriteLine("All requests completed...");
            //
            for (int i = 0; i < radios.Length; ++i) {
                IAsyncResult cur = arList[i];
                ObexWebRequest req = (ObexWebRequest)cur.AsyncState;
                console.WriteLine("- - - #{1} - - -", null, (i + 1));
                try {
                    ObexWebResponse rsp = (ObexWebResponse)req.EndGetResponse(cur);
                    console.WriteLine("#{1}. Response Code: {0} (0x{0:X})", rsp.StatusCode, (i + 1));
                } catch (Exception ex) {
                    console.WriteLine("#{1}. Failed: {0}", ex, (i + 1));
                }
            }//for
        }

        //----
        [MenuItem, SubMenu("Data")]
        public void SetReadTimeout()
        {
            if (_peer == null) {
                console.WriteLine("no connection");
                return;
            }
            console.WriteLine("ReadTimeout: {0}", _peer.ReadTimeout);
            int? to = console.ReadOptionalInteger("New value");
            if (to.HasValue)
                _peer.ReadTimeout = to.Value;
        }

        [MenuItem, SubMenu("Data")]
        public void SetWriteTimeout()
        {
            if (_peer == null) {
                console.WriteLine("no connection");
                return;
            }
            console.WriteLine("WriteTimeout: {0}", _peer.WriteTimeout);
            int? v = console.ReadOptionalInteger("New value");
            if (v.HasValue)
                _peer.WriteTimeout = v.Value;
        }

        //----
        Stream _tcpConn;

        [MenuItem, SubMenu("SOCKETS")]
        public void TcpConnect()
        {
            string hostname = console.ReadLine("hostname");
            int port = console.ReadInteger("port");
            System.Net.Sockets.TcpClient cli = new System.Net.Sockets.TcpClient(hostname, port);
            _tcpConn = cli.GetStream();
        }

        [MenuItem, SubMenu("SOCKETS")]
        public void TcpClose()
        {
            if (_tcpConn != null) {
                _tcpConn.Close();
            }
            _tcpConn = null;
        }

        //----
        [MenuItem, SubMenu("DeviceInfo")]
        public void GetDeviceInfo()
        {
            BluetoothAddress addr = console.ReadBluetoothAddress("Device Address");
            BluetoothDeviceInfo device = Create_BluetoothDeviceInfo(addr);
            bool again;
            do {
                console.WriteLine(DumpDeviceInfo(device));
                RadioVersions v;
                try {
#if true
                    v = device.GetVersions();
#elif false
                    var w = device.GetImpl<InTheHand.Net.Bluetooth.Msft.WindowsBluetoothDeviceInfo>();
                    if (w != null) {
                        v = w.GetVersions();
                    }
#endif
                } catch (Exception ex) {
                    console.WriteLine("GetVersions error: " + Exception_FirstLine(ex));
                    var w32ex = ex as Win32Exception;
                    if (w32ex != null) {
                        console.WriteLine("  NativeErrorCode: " + w32ex.NativeErrorCode);
                    }
                    goto afterDisplayVersion;
                }
                if (v == null) {
                    console.WriteLine("GetVersions returned null!!!!!!!!!!!!!");
                } else {
                    console.WriteLine(DumpVersions(v));
                }
            afterDisplayVersion:
                //
                again = console.ReadYesNo("Display same one again", false);
                if (again) {
                    var doSdp = console.ReadYesNo("Do SDP to", false);
                    if (doSdp) {
                        device.BeginGetServiceRecords(BluetoothService.L2CapProtocol, null, null);
                    }
                }
            } while (again);
        }

        [MenuItem, SubMenu("DeviceInfo")]
        public void GetDeviceInfoAndConnect()
        {
            Action<BluetoothAddress> dlgtDevInfo = delegate(BluetoothAddress addrX)
            {
                BluetoothDeviceInfo device = Create_BluetoothDeviceInfo(addrX);
                console.WriteLine("name0: " + ToStringQuotedOrNull(device.DeviceName));
                console.WriteLine("name1: " + ToStringQuotedOrNull(device.DeviceName));
            };
            Action<BluetoothAddress> dlgtConn = delegate(BluetoothAddress addrX)
            {
                Thread.Sleep(1500);
                console.WriteLine("Connecting...");
                ConnectSimpleClosingFirstPart2(addrX);
            };
            //
            BluetoothAddress addrDev0 = console.ReadBluetoothAddress("Device Address for DeviceInfo");
            BluetoothAddress addrConn = console.ReadBluetoothAddress("Device Address for Connect");
            long addrTmpl = addrDev0.ToInt64();
            var arrArBdi = new IAsyncResult[4];
            //
            new BluetoothClient(); // Init the stack in case the user forgot to do so before.
            var ar = DelegateExtension.BeginInvoke(dlgtConn, addrConn, null, null);
            for (int i = 0; i < arrArBdi.Length; ++i) {
                arrArBdi[i] = DelegateExtension.BeginInvoke(dlgtDevInfo, new BluetoothAddress(addrTmpl++), null, null);
            }
            try {
                DelegateExtension.EndInvoke(dlgtConn, ar);
                console.WriteLine("connect success");
            } catch (System.Net.Sockets.SocketException) {
                console.WriteLine("connect fail");
            }
            foreach (var curAr in arrArBdi) {
                DelegateExtension.EndInvoke(dlgtDevInfo, curAr);
            }
        }

        [MenuItem, SubMenu("DeviceInfo")]
        public void SetServiceState()
        {
            BluetoothAddress addr = console.ReadBluetoothAddress("Device Address");
            Guid? svcClass = console.ReadOptionalBluetoothUuid("Service Class (default SPP)", null);
            if (svcClass == null) svcClass = BluetoothService.SerialPort;
            console.WriteLine("Service: {0}", svcClass);
            BluetoothDeviceInfo device = Create_BluetoothDeviceInfo(addr);
            console.WriteLine(DumpDeviceInfoBrief(device));
            bool state = console.ReadYesNo("Enable/Disable the service", true);
            console.WriteLine("Will set the service to: " + state);
            device.SetServiceState(svcClass.Value, state, true);
        }

        [MenuItem, SubMenu("DeviceInfo")]
        public void GetInstalledServices()
        {
            BluetoothAddress addr = console.ReadBluetoothAddress("Device Address");
            BluetoothDeviceInfo device = Create_BluetoothDeviceInfo(addr);
            console.WriteLine(DumpDeviceInfoBrief(device));
            var guidList = device.InstalledServices;
            console.WriteLine("{0} of", guidList.Length);
            foreach (var cur in guidList) {
                var name = BluetoothService.GetName(cur);
                //var shortI = BluetoothService.CreateBluetoothUuid(
                console.WriteLine("* {0} aka {1}", cur, name);
            }
        }

#if !ANDROID
        [MenuItem, SubMenu("WidcommPlaying")]
        public void WidcommIsPresentConnected()
        {
            BluetoothAddress addr = console.ReadBluetoothAddress("Device Address");
            InTheHand.Net.Bluetooth.Widcomm.RemoteDeviceState state
                = new InTheHand.Net.Bluetooth.Widcomm.WidcommPlaying().FindIfPresentOrConnected(addr);
            console.WriteLine("state: {0}", state);
        }

        [MenuItem, SubMenu("WidcommPlaying")]
        public void DoPowerDownUpReset()
        {
            var p = new InTheHand.Net.Bluetooth.Widcomm.WidcommPlaying();
            var prev = p.DoPowerDownUpReset;
            var set = console.ReadYesNoCancel(string.Format(
                "DoPowerDownUpReset current: {0}.  Set to", prev), null);
            if (set.HasValue) {
                p.DoPowerDownUpReset = set.Value;
            }
            console.WriteLine("DoPowerDownUpReset set: {0}, was: {1}.",
                set, prev);
        }
#endif

        //----
#if !ANDROID
        [MenuItem, SubMenu("Serial")]
        public void SerialPorts_List()
        {
#if !NETCF
            SerialPortsListWmi();
#else
            SerialPortsListWmRegistry();
#endif
            //----
            console.WriteLine("SerialPort.GetPortNames...");
            string[] nameList = System.IO.Ports.SerialPort.GetPortNames();
            console.WriteLine("SerialPort.GetPortNames: {0}",
                string.Join(", ", nameList));
        }

#if NETCF
        private void SerialPortsListWmRegistry()
        {
            //console.WriteLine("SerialPortsListWmRegistry");
            using (var portsK = Registry.LocalMachine.OpenSubKey(@"Software\Microsoft\Bluetooth\Serial\Ports", false)) {
                if (portsK == null) {
                    console.WriteLine("Bluetooth COM port configuration is missing.");
                    return;
                }
                foreach (var devKeyName in portsK.GetSubKeyNames()) {
                    BluetoothAddress addr;
                    try {
                        addr = BluetoothAddress.Parse(devKeyName);
                    } catch (FormatException) {
                        console.WriteLine("Error: key name is not a device address: '{0}'", devKeyName);
                        continue;
                    }
                    console.WriteLine("DeviceID:    {0} ", addr);
                    using (var devKey = portsK.OpenSubKey(devKeyName)) {
                        var portN0 = devKey.GetValue("Port");
                        var portN1 = portN0 as string;
                        var portN = TruncateAtZeros(portN1);
                        console.WriteLine("PortName: '{0}'", portN);
                    }
                }//for
            }
        }

        string TruncateAtZeros(string value)
        {
            if (value == null) return null;
            string result = value;
            int idx = value.IndexOf((char)0);
            if (idx != -1) {
                result = value.Substring(0, idx);
            }
#if DUMP_TRUNCATED_STRING_CONTENT
            if (value.Length != result.Length) {
                console.WriteLine("(Zero in string!! ({0}vs{1}))", value.Length, result.Length);
                // (No Array.ForEach etc in NETCF)
                StringBuilder bldr = new StringBuilder();
                foreach (var ch in value.ToCharArray()) {
                    if (char.IsControl(ch))
                        bldr.AppendFormat(CultureInfo.InvariantCulture, "\\x{0:x4}", (ushort)ch);
                    else
                        bldr.Append(ch);
                }
                console.WriteLine("([{0}])", bldr.ToString());
            }
#endif
            return result;
        }
#endif

#if !NETCF
        private void SerialPortsListWmi()
        {
            const string Win32_SerialPort = "Win32_SerialPort";
#if false // Either work
            console.WriteLine("Running query...");
            System.Management.SelectQuery q = new System.Management.SelectQuery(Win32_SerialPort);
            System.Management.ManagementObjectSearcher s = new System.Management.ManagementObjectSearcher(q);
#else
            console.WriteLine("Running WMI query...");
            System.Management.ManagementObjectSearcher s = new System.Management.ManagementObjectSearcher(
                "SELECT DeviceID,PNPDeviceID FROM " + Win32_SerialPort);
#endif
            console.WriteLine("Getting results...");
            System.Management.ManagementObjectCollection list = s.Get();
            console.WriteLine("Enumerating results...");
            foreach (System.Management.ManagementBaseObject cur in list) {
                object id = cur.GetPropertyValue("DeviceID");
                object pnpId = cur.GetPropertyValue("PNPDeviceID");
                console.WriteLine("DeviceID:    {0} ", id);
                console.WriteLine("PNPDeviceID: {0} ", pnpId);
                console.WriteLine("");
            }//for
        }
#endif

        SerialPort SerialPortCreate()
        {
            var nameNum = console.ReadOptionalInteger("Port -- if numerical 'COMx'");
            string name;
            if (nameNum != null) {
                name = "COM" + nameNum.ToString();
            } else {
                name = console.ReadLine("Port name");
            }
            var bitrate = console.ReadOptionalInteger("Bit rate");
            System.IO.Ports.SerialPort port;
            if (bitrate == null) {
                console.WriteLine("Connecting to port '{0}'.", name);
                port = new System.IO.Ports.SerialPort(name);
            } else {
                console.WriteLine("Connecting to port '{0}' at bitrate '{1}'.", name, bitrate.Value);
                port = new System.IO.Ports.SerialPort(name, bitrate.Value);
            }
            return port;
        }

        [MenuItem, SubMenu("Serial")]
        public void SerialPort_GetDefaults()
        {
            string name = console.ReadLine("(Serial) Device Name");
            console.WriteLine("(Serial) Device Name: {0}", name);
            var cc = new Foo.COMMCONFIG(null);
            uint size = checked((uint)cc.dwSize);
            bool success = Foo.NativeMethods.GetDefaultCommConfig(name, ref cc, ref size);
            var gle = Marshal.GetLastWin32Error();
            if (!success) {
                console.WriteLine("Failed: " + gle);
                return;
            }
            console.WriteLine("dwProviderSubType: {0}, baud: {1}, size: {2} (provider offset: {3}, size: {4})",
                cc.dwProviderSubType, cc.dcb.BaudRate,
                cc.dwSize,
                cc.dwProviderOffset, cc.dwProviderSize);
        }

        static class Foo
        {
            internal static class NativeMethods
            {
                [DllImport("kernel32.dll", SetLastError = true)]
                internal static extern bool GetDefaultCommConfig(string lpszName, [In, Out] ref COMMCONFIG lpCC,
                   ref uint lpdwSize);

            }

            [StructLayout(LayoutKind.Sequential)]
            internal struct DCB
            {
                public Int32 DCBLength;
                public Int32 BaudRate;
                public Int32 fBitField;
                public Int16 wReserved;
                public Int16 XonLim;
                public Int16 XoffLim;
                public Byte ByteSize;
                public Byte Parity;
                public Byte StopBits;
                public Char XonChar;
                public Char XoffChar;
                public Char ErrorChar;
                public Char EofChar;
                public Char EvtChar;
                public Int32 wReserved1;
            }

            [StructLayout(LayoutKind.Sequential)]
            internal struct COMMCONFIG
            {
                public Int32 dwSize;
                public Int16 wVersion;
                public Int16 wReserved;
                public DCB dcb;
                public Int32 dwProviderSubType;
                public Int32 dwProviderOffset;
                public Int32 dwProviderSize;
                [MarshalAs(UnmanagedType.ByValArray, SizeConst = 200/*e.g.*/)]
                public byte[] ProviderData;

                public COMMCONFIG(object fake)
                    : this()
                {
                    this.dwSize = Marshal.SizeOf(this);
                }
            }
        }


        [MenuItem, SubMenu("Serial")]
        public void SerialPortCo_nnect()
        {
            var port = SerialPortCreate();
            port.Open();
            _peer = port.BaseStream;
        }

        [MenuItem, SubMenu("Serial")]
        public void SerialPort_ConnectAlsoUsePortEvents()
        {
            var port = SerialPortCreate();
            port.DataReceived += new SerialDataReceivedEventHandler(port_DataReceived);
            port.ErrorReceived += new SerialErrorReceivedEventHandler(port_ErrorReceived);
            port.PinChanged += new SerialPinChangedEventHandler(port_PinChanged);
            port.Open();
            _peer = port.BaseStream;
        }

        void port_PinChanged(object sender, SerialPinChangedEventArgs e)
        {
            console.WriteLine("Port PinChanged: " + e.EventType);
        }

        void port_ErrorReceived(object sender, SerialErrorReceivedEventArgs e)
        {
            console.WriteLine("Port Error: " + e.EventType);
        }

        void port_DataReceived(object sender, SerialDataReceivedEventArgs e)
        {
            console.WriteLine("Port Rcv: " + e.EventType);
        }
#endif

        [MenuItem, SubMenu("Serial")]
        public void OpenFileStream()
        {
            string name = console.ReadLine("File/port name");
            _peer = new FileStream(name, FileMode.Open);
        }

        //----

#if !ANDROID
#if NETCF
        InTheHand.Net.Ports.BluetoothSerialPort _btSerialPort;
#endif
        InTheHand.Net.Bluetooth.Widcomm.WidcommSerialPort _wcSerialPort;

        [MenuItem, SubMenu("Serial")]
        public void BtWcSerialPortCliClose()
        {
#if NETCF
            _btSerialPort.Close();
            _btSerialPort = null;
#endif
            _wcSerialPort.Close();
            _wcSerialPort = null;
        }

        [MenuItem, SubMenu("Serial")]
        public void BtWcSerialPortCliNullNoDispose()
        {
#if NETCF
            _btSerialPort = null;
#endif
            _wcSerialPort = null;
        }

#if NETCF
        [MenuItem, SubMenu("Serial")]
        public void BtSerialPortCliConnect()
        {
            var addr = console.ReadBluetoothAddress("target");
            var addrWithSpp = new BluetoothEndPoint(addr, BluetoothService.SerialPort);
            var spp = InTheHand.Net.Ports
                .BluetoothSerialPort.CreateClient(addrWithSpp);
            console.WriteLine("Success: {0}", spp.PortName);
            _btSerialPort = spp;
        }
#endif

        [MenuItem, SubMenu("Serial")]
        public void WcSerialPortCliConnect()
        {
            var addr = console.ReadBluetoothAddress("Target Device");
            var count = console.ReadOptionalInteger("Repeat count");
            console.WriteLine(null);
            Converter<BluetoothAddress, InTheHand.Net.Bluetooth.Widcomm.WidcommSerialPort> open
                = addrI =>
                {
                    var spp = InTheHand.Net.Bluetooth.Widcomm
                                        .WidcommSerialPort.CreateClient(addrI);
                    console.WriteLine("Success: {0}", spp.PortName);
                    return spp;
                };
            //
            if (count == null) {
                _wcSerialPort = open(addr);
            } else {
                for (int i = 0; i < count; ++i) {
                    using (var spp = open(addr)) {
                    }
                }//for
            }
        }
#endif

        //--------
        [MenuItem, SubMenu("SOCKETS")]
        public void TestsSocketsAndSockaddr()
        {
            Converter<bool, System.Net.Sockets.Socket> createSocket = delegate(bool unspecificProto)
            {
                System.Net.Sockets.Socket s0;
                if (unspecificProto)
                    s0 = new System.Net.Sockets.Socket(
                        AddressFamily32.Bluetooth, System.Net.Sockets.SocketType.Stream,
                        System.Net.Sockets.ProtocolType.Unspecified);
                else
                    s0 = new System.Net.Sockets.Socket(
                        AddressFamily32.Bluetooth, System.Net.Sockets.SocketType.Stream,
                        BluetoothProtocolType.RFComm);
                return s0;
            };
            BluetoothEndPoint ep;
            System.Net.Sockets.Socket s;
            //
            int step = 0;
            console.WriteLine("#{0}, gonna createSocket(false)", ++step);
            s = createSocket(false);
            ep = new BluetoothEndPoint(
                BluetoothAddress.None,
                BluetoothService.ObexFileTransfer);
            console.WriteLine("#{0}, gonna Bind", ++step);
            // Bind     None/FTP/None
            try {
                s.Bind(ep);
            } catch (Exception ex) {
                console.WriteLine(ex);
            }
            ep = new BluetoothEndPoint(
                BluetoothAddress.Parse("12345679abcd"),
                BluetoothService.ObexObjectPush);
            console.WriteLine("#{0}, gonna Connect", ++step);
            // Connect  Foo/OPP/None
            try {
                s.Connect(ep);
            } catch (Exception ex) {
                console.WriteLine(ex);
            }
            //
            console.WriteLine("#{0}, gonna createSocket(false)", ++step);
            s = createSocket(false);
            ep = new BluetoothEndPoint(
                BluetoothAddress.None,
                BluetoothService.ObexFileTransfer,
                unchecked((Int32)0xF2345678));
            console.WriteLine("#{0}, gonna Bind", ++step);
            // Bind     None/FTP/Bar
            try {
                s.Bind(ep);
            } catch (Exception ex) {
                console.WriteLine("Excepted failure");
                console.WriteLine(ex);
            }
            //
            ep = new BluetoothEndPoint(
                BluetoothAddress.None,
                BluetoothService.ObexFileTransfer,
                0x45);
            console.WriteLine("#{0}, gonna Bind", ++step);
            // Bind     None/FTP/Bar
            try {
                s.Bind(ep);
            } catch (Exception ex) {
                console.WriteLine(ex);
            }
            //
            ep = new BluetoothEndPoint(
                BluetoothAddress.Parse("12345679abcd"),
                BluetoothService.Fax, 0x45);
            console.WriteLine("#{0}, gonna Connect", ++step);
            // Connect  Foo/OPP/Bar
            try {
                s.Connect(ep);
            } catch (Exception ex) {
                console.WriteLine(ex);
            }
            //
            console.WriteLine("#{0}, gonna createSocket(true)", ++step);
            try {
                s = createSocket(true);
            } catch (System.Net.Sockets.SocketException ex) {
                const int WSAEPROTOTYPE = 10041;
#if NETCF
                if (ex.ErrorCode != WSAEPROTOTYPE)
                    throw;
#else
                if (ex.SocketErrorCode != System.Net.Sockets.SocketError.ProtocolType)
                    throw;
#endif
                Debug.Assert(ex.NativeErrorCode == WSAEPROTOTYPE);
                console.WriteLine("(Somewhat) expected failure; how to get 'Unspecified' behaviour supported?");
                console.WriteLine(ex);
            }
        }

        [MenuItem, SubMenu("SOCKETS")]
        public void TryAllMsftSocketOptions()
        {
            var wr = _cli;
            BluetoothClient cli = null;
            if (wr == null || (cli = wr.Target) == null) {
                console.WriteLine("No BluetoothClient available, do a Connect/Accept.");
                return;
            }
            var sock = cli.Client;
            // Do one get option manually.
            {
                System.Net.Sockets.SocketOptionName option;
#if NETCF
                option = BluetoothSocketOptionName.GetMtu;
#else
                option = BluetoothSocketOptionName.XPMtu;
#endif
                var v = sock.GetSocketOption(BluetoothSocketOptionLevel.RFComm, option);
                var i = (int)v;
                console.WriteLine("Option MTU value: {0}=0x{0:X}", i);
            }
            // Do all known options.
            var nameFiList = typeof(BluetoothSocketOptionName).GetFields(
                BindingFlags.Static | BindingFlags.Public);
            foreach (var curField in nameFiList) {
                var curOpt = (System.Net.Sockets.SocketOptionName)curField.GetValue(null);
                var curName = curField.Name;
                string txtOpt = (int)curOpt >= 0 ? ((int)curOpt).ToString()
                    : "0x" + ((int)curOpt).ToString("X8");
                console.Write("Option: {0,24} {1,11} : ",
                    curName, txtOpt);
                try {
                    var v = sock.GetSocketOption(BluetoothSocketOptionLevel.RFComm, curOpt);
                    var i = (int)v;
                    console.WriteLine("value: {0}=0x{0:X}", i);
                } catch (System.Net.Sockets.SocketException soex) {
                    console.WriteLine("error: " + SocketException_Codes(soex));
                }
            }//for
        }

        //--------
        [MenuItem, SubMenu("DeviceInfo")]
        public void RssiRepeated()
        {
            console.WriteLine("Stack: {0}", Get_BluetoothRadio().SoftwareManufacturer);
            BluetoothAddress addr = console.ReadBluetoothAddress("Address of device to read RSSI for");
            bool doSdp = console.ReadYesNo("Do concurrent repeated SDP Query", true);
            //
            _quitRepeatRssiing.Reset();
            try {
                ThreadPool.QueueUserWorkItem(RepeatRssiing_ReadRssi, addr);
                if (doSdp) { // Doing SDP queries to force forming a connection.
                    ThreadPool.QueueUserWorkItem(RepeatRssiing_DoSdp, addr);
                }
                console.WriteLine(null);
                console.Pause("Un-pause to stop RSSI-ing");
            } finally {
                _quitRepeatRssiing.Set();
            }
        }

        ManualResetEvent _quitRepeatRssiing = new ManualResetEvent(false);

        void RepeatRssiing_ReadRssi(object state)
        {
            BluetoothAddress addr = (BluetoothAddress)state;
            int delayMs = 1000;
            BluetoothDeviceInfo info = Create_BluetoothDeviceInfo(addr);
            int? lastRssi = null;
            while (!_quitRepeatRssiing.WaitOne(delayMs, false)) {
                int rssi = info.Rssi;
                console.Write("r");
                if (rssi != lastRssi) {
                    lastRssi = rssi;
                    console.WriteLine(null);
                    console.WriteLine("{0:T}: RSSI now: {1}", DateTime.Now, rssi);
                }
            }//while
        }

        void RepeatRssiing_DoSdp(object state)
        {
            Thread.Sleep(5000); // show rssi not available when not connected
            //
            BluetoothAddress addr = (BluetoothAddress)state;
            int delayMs = 1000;
            BluetoothDeviceInfo info = Create_BluetoothDeviceInfo(addr);
            while (!_quitRepeatRssiing.WaitOne(delayMs, false)) {
                ServiceRecord[] records = info.GetServiceRecords(BluetoothService.TcpProtocol);
                console.Write("s");
            }//while
        }

        //--------
#if RADIO_MODESSS
        [MenuItem, SubMenu("Local")]
        public void SetModesss()
        {
            BluetoothRadio r = Get_BluetoothRadio();
            if (r == null) {
                console.WriteLine("No radio(?)");
                return;
            }
            console.WriteLine("Radio stack is: {0}", r.SoftwareManufacturer);
            var conno = console.ReadYesNoCancel("Connectable (on/off/leave)", null);
            var disco = console.ReadYesNoCancel("Discoverable (on/off/leave)", null);
            bool doit = console.ReadYesNo("Set radio mode to: c=" + conno + " d=" + disco, true);
            if (doit) {
                console.WriteLine("Setting Modes({0},{1})", conno, disco);
                r.SetMode(conno, disco);
            }
        }
#endif

        [MenuItem, SubMenu("Local")]
        public void SetMode()
        {
            BluetoothRadio r = Get_BluetoothRadio();
            if (r == null) {
                console.WriteLine("No radio(?)");
                return;
            }
            console.WriteLine("Radio stack is: {0}", r.SoftwareManufacturer);
            int choice = console.ReadInteger("0. PowerOff, 1. Connectable, 2. Discoverable");
            RadioMode mode = (RadioMode)choice;
            bool doit = console.ReadYesNo("Set radio mode to: " + mode, true);
            if (doit) {
                r.Mode = mode;
            }
        }

        [MenuItem, SubMenu("Local")]
        public void SetAllModes()
        {
            BluetoothRadio r_ = Get_BluetoothRadio();
            if (r_ == null) {
                console.WriteLine("No radio(?)");
                return;
            }
            console.WriteLine("Radio stack is: {0}", r_.SoftwareManufacturer);
            var doIt = console.ReadYesNo("Do Set All Modes", false);
            if (!doIt) return;
            //
            // o->c, o->d; c->o, c->d; d->o, d->c.
            var stateList = new RadioMode[] {
                RadioMode.PowerOff, RadioMode.Connectable,  RadioMode.Connectable,  RadioMode.Discoverable,
                RadioMode.PowerOff, RadioMode.Discoverable, RadioMode.Discoverable, RadioMode.Connectable,
                RadioMode.PowerOff, RadioMode.PowerOff,
            };
            int i;
            var originalMode = r_.Mode;
            console.WriteLine("Running test, using same radio instance each time.");
            i = 0;
            var r0 = r_;
            foreach (var cur in stateList) {
                console.Write("   Set {0,12}, ", cur);
                var ts = RunAndTime(delegate { r0.Mode = cur; });
                RadioMode? got = null;
                var tg = RunAndTime(delegate { got = r0.Mode; });
                if (got != cur)
                    console.Write("error at {0} expected {1} was {2}, ",
                        i, cur, got);
                console.WriteLine("set: {0,-16}, get: {1,-16}", ts, tg);
                ++i;
            }//for
            console.WriteLine("Done {0} tests.", i);
            console.WriteLine("Do test again, using new radio instance each time.");
            i = 0;
            foreach (var cur in stateList) {
                var rx = Get_BluetoothRadio();
                if (rx == null) {
                    console.WriteLine("error at {0} radio is null!", i);
                    goto next;
                }
                console.Write("   Set {0,12}, ", cur);
                var ts = RunAndTime(delegate { rx.Mode = cur; });
                RadioMode? got = null;
                var tg = RunAndTime(delegate { got = rx.Mode; });
                if (got != cur)
                    console.Write("error at {0} expected {1} was {2}, ",
                        i, cur, got);
                console.WriteLine("set: {0,-16}, get: {1,-16}", ts, tg);
            next:
                ++i;
            }//for
            console.WriteLine("Done {0} tests.", i);
            r_.Mode = originalMode;
        }

        [MenuItem, SubMenu("Local")]
        public void SetName()
        {
            BluetoothRadio r = Get_BluetoothRadio();
            if (r == null) {
                console.WriteLine("No radio(?)");
                return;
            }
            console.WriteLine("Radio stack is: {0}", r.SoftwareManufacturer);
            var name = console.ReadLine("New Name");
            bool doit = console.ReadYesNo("Set radio name to: " + name, true);
            if (doit) {
                r.Name = name;
            }
        }


        //--------
        [MenuItem, SubMenu("Data")]
        public void CloseLinger()
        {
            if (!VerifyConnectionWrite())
                return;
            BluetoothClient cli = _cli.Target;
            if (cli == null) {
                console.WriteLine("No BtCli to set LingerState on!.");
                return;
            }
            cli.LingerState = new System.Net.Sockets.LingerOption(true, 30);
            // Write until buffers full
            List<IAsyncResult> arList = new List<IAsyncResult>();
            byte[] buf = new byte[16 * 1024];
            bool exitAfterNext = false;
            while (true) {
                IAsyncResult ar = _peer.BeginWrite(buf, 0, buf.Length, MiscCallback, "BeginWrite");
                arList.Add(ar);
                console.Write(".");
                if (exitAfterNext)
                    break;
                if (!ar.IsCompleted) {
                    bool signalled = ar.AsyncWaitHandle.WaitOne(10000, false);
                    if (!signalled) {
                        exitAfterNext = true;
                    }
                }
            }//while
            console.WriteLine("Did BeginWrite until full ({0} times).", arList.Count);
            //
            console.WriteLine("Now going to Close.  Release receiver to not linger timeout.");
            console.Pause("Un-pause to Close");
            console.WriteLine("Closing at {0}", GetTime());
            DateTime startT = DateTime.UtcNow;
            try {
                _peer.Close();
                string end = GetTime();
                console.WriteLine("Close exited cleanly at {0} after {1}.", end, DateTime.UtcNow - startT);
            } catch (Exception ex) { // We throw Exception currently!
                string end = GetTime();
                console.WriteLine("Close failed at {0} after {1} with: {2}", end, DateTime.UtcNow - startT, ex);
            }
            //
            int i = 0;
            console.Write("Write statuses (. or x, where x=exception): ");
            foreach (IAsyncResult cur in arList) {
                if (!cur.IsCompleted) {
                    console.WriteLine("Write #{0} is not completed!", i + 1);
                }
                try {
                    _peer.EndWrite(cur);
                    console.Write(".");
                } catch (IOException) {
                    console.Write("x");
                }
                ++i;
            }//for
            console.WriteLine(null);
            console.WriteLine("Finished.");
        }

        //--------
        [MenuItem, SubMenu("Playing")]
        public void HackShutdownAll()
        {
            InTheHand.Net.Bluetooth.Factory.BluetoothFactory.HackShutdownAll();
            console.WriteLine("Done HackShutdownAll");
        }

        //--------
#if NETCF
        [MenuItem, SubMenu("Playing")]
        public void HidEnable_NotCompletedTesting()
        {
            IntPtr h = CreateFile("BHI0:", 0, 0, IntPtr.Zero, CreateFile__OPEN_EXISTING, 0, IntPtr.Zero);
            if (h == IntPtr.Zero || h == (IntPtr)(-1)) {
                int err = Marshal.GetLastWin32Error();
                console.WriteLine("CreateFile(BHI0:) returned: {0}, gle: {1} = 0x{1:X}", h, err);
                return;
            }
            console.WriteLine("CreateFile(BHI0:) SUCCESS");
            //console.WriteLine("Skipping for now!!!!!!");
            //return;
            //----
            int tmp;
            BluetoothAddress addr = console.ReadBluetoothAddress("Device address");
            byte[] addrBytes = addr.ToByteArray();
            bool ret = DeviceIoControl(h, BTHHID_IOCTL_HIDConnect, addrBytes, addrBytes.Length,
                IntPtr.Zero, 0, out tmp, IntPtr.Zero);
            int err2 = Marshal.GetLastWin32Error();
            console.WriteLine("DeviceIoControl(h, BTHHID_IOCTL_HIDConnect) ret: {0}", ret);
            if (!ret) {
                console.WriteLine("DeviceIoControl(h, BTHHID_IOCTL_HIDConnect) gle: {0} = 0x{0:X}", err2);
            }
        }

        // http://read.pudn.com//downloads123/sourcecode/embed/523853/BLUETOOTH/PROFILES/HID/BASE/hidioctl.h__.htm
        const int BTHHID_IOCTL_HIDConnect = 1;
        const int BTHHID_IOCTL_HIDVerify = 2;

        const int CreateFile__OPEN_EXISTING = 3;

        [System.Runtime.InteropServices.DllImport("coredll.dll", SetLastError = true)]
        static extern IntPtr CreateFile(string lpFileName, UInt32 dwDesiredAccess,
            UInt32 dwShareMode, IntPtr lpSecurityAttributes, UInt32 dwCreationDisposition,
            UInt32 dwFlagsAndAttributes, IntPtr hTemplateFile);

        [System.Runtime.InteropServices.DllImport("coredll.dll", SetLastError = true)]
        private static extern bool DeviceIoControl(IntPtr hDevice, int dwIoControlCode, byte[] lpInBuffer, int nInBufferSize, byte[] lpOutBuffer, int nOutBufferSize, out int lpBytesReturned, IntPtr lpOverlapped);
        [System.Runtime.InteropServices.DllImport("coredll.dll", SetLastError = true)]
        private static extern bool DeviceIoControl(IntPtr hDevice, int dwIoControlCode, byte[] lpInBuffer, int nInBufferSize, IntPtr lpOutBuffer, int nOutBufferSize, out int lpBytesReturned, IntPtr lpOverlapped);
        [System.Runtime.InteropServices.DllImport("coredll.dll", SetLastError = true)]
        private static extern bool DeviceIoControl(IntPtr hDevice, int dwIoControlCode, IntPtr lpInBuffer, int nInBufferSize, IntPtr lpOutBuffer, int nOutBufferSize, out int lpBytesReturned, IntPtr lpOverlapped);
#endif

#if NETCF
        [System.Runtime.InteropServices.DllImport("coredll.dll", SetLastError = true, CharSet = CharSet.Unicode)]
        private static extern int EnumDevices([Out]char[] devList, ref int bufLen);

        [MenuItem, SubMenu("Playing")]
        public void EnumDevices()
        {
            var buf = new char[4096];
            int bufLen = buf.Length; // Docs don't say measured in bytes or wchars!  Be conservative
            //const int ERROR_MORE_DATA = 234;
            var ret = EnumDevices(buf, ref bufLen);
            if (ret != 0) {
                console.WriteLine("!! EnumDevices failed: {0}", ret);
            }
            int dbgCharsUsed;
            var list = ParseDoubleNullTerminatedStrings(buf, out dbgCharsUsed);
            Debug.Assert(dbgCharsUsed * 2 == bufLen, "is measured in bytes");
            var x = list.Count;
            const string Sep = ", ";
            var all = string.Join(Sep, list.ToArray());
            console.WriteLine(all);
            //
            //
            TestParseDoubleNullTerminatedStrings();
        }

        private static List<string> ParseDoubleNullTerminatedStrings(char[] buf, out int dbgCharsUsed)
        {
            int idx = 0;
            var list = new List<string>();
            while (true) {
                if (buf[idx] == 0) {
                    break;
                }
                var idxEnd = Array.IndexOf(buf, (char)0, idx);
                var len = idxEnd - idx;
                var str = new string(buf, idx, len);
                list.Add(str);
                idx = idxEnd + 1;
            }
            dbgCharsUsed = idx + 1;
            return list;
        }

        static void TestParseDoubleNullTerminatedStrings()
        {
            var buf = new char[30];
            List<string> list;
            const char NullChar = (char)0;
            //
            list = DoTestParse(new char[]{
                'a','b','c',NullChar,
                'e','f',NullChar,
                'm','n','o','p',NullChar,
                NullChar });
            Assert_AreEqual(3, list.Count, "A Count");
            Assert_AreEqual(3, list[0].Length, "A0 Len");
            Assert_AreEqual("abc", list[0], "A0 Count");
            Assert_AreEqual(2, list[1].Length, "A1 Len");
            Assert_AreEqual("ef", list[1], "A1");
            Assert_AreEqual(4, list[2].Length, "A2 Len");
            Assert_AreEqual("mnop", list[2], "A2");
            //
            // Null at start -- (like first is empty)
            list = DoTestParse(new char[]{
                NullChar,
                NullChar });
            Assert_AreEqual(0, list.Count, "00 B list.Count");
            //
            // None -- NOT double null, is valid
            list = DoTestParse(new char[]{
                NullChar,'*','*'});
            Assert_AreEqual(0, list.Count, "C Count");
            //
            // First is empty -- same as all empty
            list = DoTestParse(new char[]{
                NullChar,
                'e','f',NullChar,
                NullChar });
            Assert_AreEqual(0, list.Count, "D Count");
            //
            // Second is empty -- same as termination
            list = DoTestParse(new char[]{
                'a','b','c',NullChar,
                NullChar,
                'm','n','o','p',NullChar,
                NullChar });
            Assert_AreEqual(1, list.Count, "E Count");
            Assert_AreEqual(3, list[0].Length, "E0 Len");
            Assert_AreEqual("abc", list[0], "E0 Count");
        }

        private static void FillWithRubbish(char[] buf)
        {
            for (int i = 0; i < buf.Length; ++i) buf[i] = 'z';
        }

        private static void Assert_AreEqual(int expected, int actual, string name)
        {
            if (expected != actual) throw new RankException(name);
        }

        private static void Assert_AreEqual(string expected, string actual, string name)
        {
            if (expected != actual) throw new RankException(name);
        }

        private static List<string> DoTestParse(char[] content)
        {
            char[] buf;
            //
            buf = new char[content.Length * 2];
            FillWithRubbish(buf);
            content.CopyTo(buf, 0);
            int dbgUsed;
            var list = ParseDoubleNullTerminatedStrings(buf, out dbgUsed);
            //TODO assert on dbgUsed
            return list;
#if false
            //
            buf = new char[content.Length];
            FillWithRubbish(buf);
            content.CopyTo(buf, 0);
            list = ParseDoubleNullTerminatedStrings(buf, buf.Length);
#endif
        }
#endif

        //--------
#if !NETCF
        [MenuItem]
        public void Win32EventsNew()
        {
            var r = Get_BluetoothRadio();
            // Better be MSFT+Win32 radio!!!
            using (var x = new BluetoothWin32Events(r)) {
                x.InRange += HandleWin32InRange;
                x.OutOfRange += HandleWin32OutOfRange;
                console.Pause("Continue to stop getting events");
            }
        }

        [MenuItem]
        public void Win32EventsShared()
        {
            var r = Get_BluetoothRadio();
            // Better be MSFT+Win32 radio!!!
            var x = BluetoothWin32Events.GetInstance();
            try {
                x.InRange += HandleWin32InRange;
                x.OutOfRange += HandleWin32OutOfRange;
                console.Pause("Continue to stop getting events");
            } finally {
                x.InRange -= HandleWin32InRange;
                x.OutOfRange -= HandleWin32OutOfRange;
            }
        }

        void HandleWin32InRange(object sender, BluetoothWin32RadioInRangeEventArgs e)
        {
            console.WriteLine("{0}: InRange {1} '{2}', now '{3}' was '{4}'.",
                GetTimeWallclockHR(), e.Device.DeviceAddress, e.Device.DeviceName,
                e.CurrentState, e.PreviousState);
        }
        void HandleWin32OutOfRange(object sender, BluetoothWin32RadioOutOfRangeEventArgs e)
        {
            console.WriteLine("{0}: OutOfRange {1} '{2}'.",
                GetTimeWallclockHR(), e.Device.DeviceAddress, e.Device.DeviceName);
        }
#endif

#if !NETCF && false
        [MenuItem, SubMenu("Playing")]
        public void AllIoctls()
        {
            console.WriteLine("Output is on Debug.Write...");
            InTheHand.Net.Bluetooth.Msft.MsftPlaying.AllIoctls();
        }

        [MenuItem, SubMenu("Playing")]
        public void AuthDeviceExFakeOob()
        {
            var device = console.ReadBluetoothAddress("target");
            byte[] oobData;
            int ret;
            //
            oobData = new byte[16];
            new Random().NextBytes(oobData);
            ret = InTheHand.Net.Bluetooth.Msft.MsftPlaying.AuthDeviceExFakeOob(
                 device, oobData);
            console.WriteLine("ret: {0} = 0x{0:X}", ret);
        }

        [MenuItem, SubMenu("Playing")]
        public void AuthDeviceExFakeOob_ThreeWays()
        {
            var device = console.ReadBluetoothAddress("target");
            byte[] oobData;
            int ret;
            //
            oobData = new byte[16];
            new Random().NextBytes(oobData);
            ret = InTheHand.Net.Bluetooth.Msft.MsftPlaying.AuthDeviceExFakeOob(
                 device, oobData);
            console.WriteLine("ret: {0} = 0x{0:X}", ret);
            //
            oobData = new byte[32];
            ret = InTheHand.Net.Bluetooth.Msft.MsftPlaying.AuthDeviceExFakeOob(
                 device, oobData);
            console.WriteLine("ret: {0} = 0x{0:X}", ret);
            //
            oobData = null;
            ret = InTheHand.Net.Bluetooth.Msft.MsftPlaying.AuthDeviceExFakeOob(
                 device, oobData);
            console.WriteLine("ret: {0} = 0x{0:X}", ret);
        }
#endif

#if false
        [MenuItem, SubMenu("Playing")]
        public void BlueZSdpDumpSdpBlueZDbus()
        {
            var b = new ServiceRecordBuilder();
            b.AddServiceClass(0x1105);
            b.AddServiceClass(BluetoothService.SerialPort);
            b.AddServiceClass(0x12345);
            //
            b.AddCustomAttribute(0x500, ElementType.Boolean, false);
            b.AddCustomAttribute(0x501, ElementType.Boolean, true);
            b.AddCustomAttribute(0x511, ElementType.Nil, null);
            //
            // UUID128 (AddServiceClass shortens automatically)
            b.AddCustomAttribute(0x1000, ElementType.Uuid128, BluetoothService.SerialPort);
            var g128 = new Guid("{54D39E6A-2AF2-47dd-BB14-59C476CF2848}");
            b.AddCustomAttribute(0x1001, ElementType.Uuid128, g128);
            //
            b.AddCustomAttribute(0x6000 + (ushort)ElementType.UInt8, ElementType.UInt8, (int)ElementType.UInt8);
            b.AddCustomAttribute(0x6000 + (ushort)ElementType.UInt16, ElementType.UInt16, 0xfe00 + (int)ElementType.UInt16);
            b.AddCustomAttribute(0x6000 + (ushort)ElementType.UInt32, ElementType.UInt32, 0xfe00 + (int)ElementType.UInt32);
            b.AddCustomAttribute(0x6000 + (ushort)ElementType.UInt64, ElementType.UInt64, 0xfe00 + (int)ElementType.UInt64);
            var arr128 = new byte[16];
            arr128[0] = 0xfe;
            arr128[15] = (byte)ElementType.UInt64;
            //b.AddCustomAttribute(0x6000 + (ushort)ElementType.UInt128, ElementType.UInt128, arr128);
            //b.AddCustomAttribute(new ServiceAttribute(0x6000 + (ushort)ElementType.UInt128, 
            //    new ServiceElement(ElementType.UInt128, arr128)));
            //
            b.AddCustomAttribute(0x7000 + (ushort)ElementType.Int8, ElementType.Int8, (int)ElementType.Int8);
            b.AddCustomAttribute(0x7000 + (ushort)ElementType.Int16, ElementType.Int16, 0x7e00 + (int)ElementType.Int16);
            b.AddCustomAttribute(0x7000 + (ushort)ElementType.Int32, ElementType.Int32, 0x7e00 + (int)ElementType.Int32);
            b.AddCustomAttribute(0x7000 + (ushort)ElementType.Int64, ElementType.Int64, 0x7e00 + (int)ElementType.Int64);
            //
            b.AddCustomAttribute(new ServiceAttribute(0x7000,
                new ServiceElement(ElementType.ElementAlternative,
                    ServiceElement.CreateNumericalServiceElement(ElementType.UInt8, 1),
                    ServiceElement.CreateNumericalServiceElement(ElementType.UInt8, 2))));
            var foo = true;
            if (foo) {
                b.ServiceName = "foo";
            }
            //----
            var s = new BluezSdpXmlWriter().Write(b.ServiceRecord);
            console.WriteLine(s);
            //----
            var rOut = new BluezSdpXmlReader().Read(s);
            console.WriteLine(ServiceRecordUtilities.Dump(rOut));
            //================
            //
            new BluezSdpReaderTests().One();
            new BluezSdpReaderTests().Two_UnterminatedEntity();
        }
#endif

        //--------
        public static string ToStringQuotedOrNull<T>(T obj)
        {
            if (obj == null)
                return "(null)";
            else
                return obj.ToString();
        }

        static string Exception_FirstLine(Exception ex)
        {
            string line;
            using (StringReader rdr = new StringReader(ex.ToString())) {
                line = rdr.ReadLine();
            }
            var soex = ex as System.Net.Sockets.SocketException;
            if (soex != null) {
                line += SocketException_Codes(soex);
            }
            return line;
        }

        static string SocketException_Codes(System.Net.Sockets.SocketException soex)
        {
            string line = null;// string.Empty;
            line += " (" + soex.ErrorCode; // int
#if !NETCF
            line += " " + soex.SocketErrorCode; // Enum name 
#endif
            line += ")";
            return line;
        }

        static bool _WaitAll(WaitHandle[] events, int timeout)
        {
#if false && !NETCF
            return WaitHandle.WaitAll(events, timeout);
#else
            var final = DateTime.UtcNow.AddMilliseconds(timeout);
            foreach (var curE in events) {
                TimeSpan curTo = final.Subtract(DateTime.UtcNow);
                if (curTo.CompareTo(TimeSpan.Zero) <= 0) {
                    Debug.Fail("Should we expect to get here?  Normally exit at !signalled below...");
                    return false;
                }
                bool signalled = curE.WaitOne((int)curTo.TotalMilliseconds, false);
                if (!signalled) {
                    return false;
                }
            }//for
            return true;
#endif
        }

        static TimeSpan RunAndTime(ThreadStart method)
        {
            var start = DateTime.UtcNow;
            method();
            var time = DateTime.UtcNow - start;
            return time;
        }

    }//class

}