protected override void Run(Action readyCallback)
ret = NativeMethodsLibudev.Instance.udev_monitor_filter_add_match_subsystem_devtype(monitor, "hidraw", null);

var device = udev_monitor_receive_device(monitor);
                try {
                    var action = udev_device_get_action(device);
                    var syspath = udev_device_get_syspath(device);
                    switch (action) {
                    case "add":
                        if (syspath != null) {
                            paths.Add(syspath);
                        }
                        break;
                    case "remove":
                        paths.Remove(syspath);
                        break;
                    }

class LinuxHidManager 
    {
        IntPtr udev;
        IntPtr monitor;
        IList<string> paths = new SynchronizedCollection<string>(); // System.ServiceModel

        public void Init()
        {
            // TODO: should probably do some better error checking here
            udev = udev_new();

            Console.WriteLine("Path udev = udev_new();");

            monitor = udev_monitor_new_from_netlink(udev, "udev");
            udev_monitor_filter_add_match_subsystem_devtype(monitor, "hidraw", null);
            udev_monitor_enable_receiving(monitor);
            var enumerate = udev_enumerate_new(udev);
            try
            {
                udev_enumerate_add_match_subsystem(enumerate, "hidraw");
                udev_enumerate_scan_devices(enumerate);
                for (var entry = udev_enumerate_get_list_entry(enumerate);
                     entry != IntPtr.Zero;
                     entry = udev_list_entry_get_next(entry))
                {
                    var syspath = udev_list_entry_get_name(entry);
                    if (syspath != null)
                    {
                        paths.Add(syspath);
                    }
                }

                Console.WriteLine("Path udev_enumerate_add_match_subsystem");
            }
            finally
            {
                udev_enumerate_unref(enumerate);
            }
            // FIXME: Need to implement IDisposeable and free udev and monitor
        }

        public string Runing()
        {
            Console.WriteLine("Entered in Runing()");

            string action;
            var fds = new pollfd[1];
            fds[0].fd = udev_monitor_get_fd(monitor);
            fds[0].events = pollev.IN;
            Console.WriteLine("Pass fds[0].events = pollev.IN;");
            while (true)
            {
                int ret = retry(() => poll(fds, (IntPtr)fds.Length, -1)); // What happened here??? Program will freeze!!!
                Console.WriteLine("Pass в retry(() => poll;");
                if (ret == -1)
                {
                    Console.WriteLine("Something went wrong");
                    // FIXME: how do we notify the main program that something bad happened here?
                    break;
                }
                var device = udev_monitor_receive_device(monitor);
                try
                {
                    Console.WriteLine("Catch an action");
                    action = udev_device_get_action(device);
                    var syspath = udev_device_get_syspath(device);
                    Console.WriteLine(syspath);
                    switch (action)
                    {
                        case "add":
                            if (syspath != null)
                            {
                                paths.Add(syspath);
                            }
                            break;
                        case "remove":
                            paths.Remove(syspath);
                            break;
                    }
                    Console.WriteLine("What message in action");
                    

                    return action;
                }
                finally
                {
                    udev_device_unref(device);
                }
            }

            return "Test";
        }

        protected object[] Refresh()
        {
            return paths.Cast<object>().ToArray();
        }

        public bool IsSupported
        {
            get
            {
                // basically, we are just testing if libudev is present
                try
                {
                    var udev = NativeMethods.udev_new();
                    if (udev == IntPtr.Zero)
                    {
                        return false;
                    }
                    NativeMethods.udev_unref(udev);
                    return true;
                }
                catch (DllNotFoundException)
                {
                    return false;
                }
            }
        }
    }
    
    
  // ++++++++++++++++++++++++ MAIN (TEST) ++++++++++++++++++++++++ 
  class Program
    {
        static LinuxHidManager ld = new LinuxHidManager();
        private static string Message { get; set; }

        static void Main(string[] args)
        {
            
            Console.WriteLine("++++++++++++++++++++++++++++");
            Init();
            Console.ReadLine();
        }

        private static void Init()
        {
            ld.Init();
            Message = ld.Runing();

static void Main(string[] args)
    {
        var list = DeviceList.Local;

        Console.WriteLine("USB monitor");

        list.Changed += (sender, e) => Console.WriteLine("Device list changed.");

        var hidDeviceList = list.GetHidDevices().ToArray();

        Console.WriteLine("Complete device list {0} devices:", hidDeviceList.Length);

        foreach (var device in hidDeviceList)
        {
            Console.WriteLine(device);
        }

        Console.ReadLine();
    }