diff --git a/Banshee.sln b/Banshee.sln
index 4e3d4ca..3d445e2 100644
--- a/Banshee.sln
+++ b/Banshee.sln
@@ -63,6 +63,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Banshee.NowPlaying", "src\E
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Banshee.Lastfm", "src\Extensions\Banshee.Lastfm\Banshee.Lastfm.csproj", "{02FD8195-9796-4AF5-A9D2-D310721963F4}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Banshee.LibraryWatcher", "src\Extensions\Banshee.LibraryWatcher\Banshee.LibraryWatcher.csproj", "{49CA3F27-0BB6-428d-8B3A-20232493652E}"
+EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Banshee.Wikipedia", "src\Extensions\Banshee.Wikipedia\Banshee.Wikipedia.csproj", "{BF5D1722-269B-452E-B577-AEBA0CB894BA}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Banshee.PlayQueue", "src\Extensions\Banshee.PlayQueue\Banshee.PlayQueue.csproj", "{74B2E4CC-2701-4C8B-A11D-6E4443F4B21B}"
@@ -227,6 +229,8 @@ Global
 		{EABA3019-7539-4430-9935-D36CEA96F250}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{F38B53BA-8F85-4DC6-9B94-029C1CF96F24}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{F38B53BA-8F85-4DC6-9B94-029C1CF96F24}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{49CA3F27-0BB6-428d-8B3A-20232493652E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{49CA3F27-0BB6-428d-8B3A-20232493652E}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{FCC1AE87-E10B-4B47-8ADE-D5F447E48518}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{FCC1AE87-E10B-4B47-8ADE-D5F447E48518}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{BB1D1D81-7A74-4183-B7B1-3E78B32D42F1}.Debug|Any CPU.Build.0 = Debug|Any CPU
@@ -289,6 +293,8 @@ Global
 		{0130499B-8A93-4CD9-8F3C-593B231609C7}.Windows|Any CPU.ActiveCfg = Windows|Any CPU
 		{F38B53BA-8F85-4DC6-9B94-029C1CF96F24}.Windows|Any CPU.Build.0 = Windows|Any CPU
 		{F38B53BA-8F85-4DC6-9B94-029C1CF96F24}.Windows|Any CPU.ActiveCfg = Windows|Any CPU
+		{49CA3F27-0BB6-428d-8B3A-20232493652E}.Windows|Any CPU.Build.0 = Windows|Any CPU
+		{49CA3F27-0BB6-428d-8B3A-20232493652E}.Windows|Any CPU.ActiveCfg = Windows|Any CPU
 		{FCC1AE87-E10B-4B47-8ADE-D5F447E48518}.Windows|Any CPU.Build.0 = Windows|Any CPU
 		{FCC1AE87-E10B-4B47-8ADE-D5F447E48518}.Windows|Any CPU.ActiveCfg = Windows|Any CPU
 		{46AD1892-C5D3-4696-BA40-FBF7F4CE2B39}.Windows|Any CPU.Build.0 = Windows|Any CPU
@@ -369,6 +375,7 @@ Global
 		{16FB0D3A-53FA-4B8E-B02B-4AF66E87829A} = {4DD1DE63-F20B-4FC3-8FDA-F0BDF4183722}
 		{0130499B-8A93-4CD9-8F3C-593B231609C7} = {4DD1DE63-F20B-4FC3-8FDA-F0BDF4183722}
 		{F38B53BA-8F85-4DC6-9B94-029C1CF96F24} = {4DD1DE63-F20B-4FC3-8FDA-F0BDF4183722}
+		{49CA3F27-0BB6-428d-8B3A-20232493652E} = {4DD1DE63-F20B-4FC3-8FDA-F0BDF4183722}
 		{FCC1AE87-E10B-4B47-8ADE-D5F447E48518} = {4DD1DE63-F20B-4FC3-8FDA-F0BDF4183722}
 		{46AD1892-C5D3-4696-BA40-FBF7F4CE2B39} = {4DD1DE63-F20B-4FC3-8FDA-F0BDF4183722}
 		{6FF6F049-9DAB-48A7-BC4B-F7F3ED0EBA63} = {4DD1DE63-F20B-4FC3-8FDA-F0BDF4183722}
diff --git a/build/build.environment.mk b/build/build.environment.mk
index 6bce1c1..25a4abb 100644
--- a/build/build.environment.mk
+++ b/build/build.environment.mk
@@ -124,6 +124,7 @@ REF_EXTENSION_COVERART = $(LINK_BANSHEE_THICKCLIENT_DEPS)
 REF_EXTENSION_DAAP = $(LINK_BANSHEE_THICKCLIENT_DEPS) $(LINK_ICSHARP_ZIP_LIB) $(LINK_MONO_ZEROCONF)
 REF_EXTENSION_FILESYSTEMQUEUE = $(LINK_BANSHEE_THICKCLIENT_DEPS)
 REF_EXTENSION_INTERNETRADIO = $(LINK_BANSHEE_THICKCLIENT_DEPS)
+REF_EXTENSION_LIBRARYWATCHER = $(LINK_BANSHEE_SERVICES_DEPS)
 REF_EXTENSION_MINIMODE = $(LINK_BANSHEE_THICKCLIENT_DEPS)
 REF_EXTENSION_MULTIMEDIAKEYS = $(LINK_BANSHEE_SERVICES_DEPS)
 REF_EXTENSION_NOTIFICATIONAREA = $(LINK_BANSHEE_THICKCLIENT_DEPS)
diff --git a/configure.ac b/configure.ac
index 7f63678..118d431 100644
--- a/configure.ac
+++ b/configure.ac
@@ -274,6 +274,7 @@ src/Extensions/Banshee.Daap/Makefile
 src/Extensions/Banshee.FileSystemQueue/Makefile
 src/Extensions/Banshee.InternetRadio/Makefile
 src/Extensions/Banshee.Lastfm/Makefile
+src/Extensions/Banshee.LibraryWatcher/Makefile
 src/Extensions/Banshee.MediaWeb/Makefile
 src/Extensions/Banshee.MiniMode/Makefile
 src/Extensions/Banshee.MultimediaKeys/Makefile
diff --git a/src/Core/Banshee.Services/Banshee.Sources/PrimarySource.cs b/src/Core/Banshee.Services/Banshee.Sources/PrimarySource.cs
index f19049f..286724f 100644
--- a/src/Core/Banshee.Services/Banshee.Sources/PrimarySource.cs
+++ b/src/Core/Banshee.Services/Banshee.Sources/PrimarySource.cs
@@ -335,7 +335,7 @@ namespace Banshee.Sources
             OnTracksChanged ();
         }
 
-        internal void NotifyTracksDeleted ()
+        public void NotifyTracksDeleted ()
         {
             OnTracksDeleted ();
         }
diff --git a/src/Extensions/Banshee.LibraryWatcher/Banshee.LibraryWatcher.addin.xml b/src/Extensions/Banshee.LibraryWatcher/Banshee.LibraryWatcher.addin.xml
new file mode 100644
index 0000000..421c7d8
--- /dev/null
+++ b/src/Extensions/Banshee.LibraryWatcher/Banshee.LibraryWatcher.addin.xml
@@ -0,0 +1,22 @@
+<Addin
+    id="Banshee.LibraryWatcher"
+    version="1.0"
+    compatVersion="1.0"
+    copyright="© 2008-2009 Christian Martellini, Alexander Hixon, Alexander Kojevnikov. Licensed under the MIT X11 license."
+    name="Library Watcher"
+    category="Hardware"
+    description="Automatically update music and video libraries"
+    author="Christian Martellini, Alexander Hixon, Alexander Kojevnikov"
+    url="http://banshee-project.org/"
+    defaultEnabled="true">
+
+  <Dependencies>
+    <Addin id="Banshee.Services" version="1.0"/>
+    <Addin id="Banshee.ThickClient" version="1.0"/>
+  </Dependencies>
+
+  <Extension path="/Banshee/ServiceManager/Service">
+    <Service class="Banshee.LibraryWatcher.LibraryWatcherService"/>
+  </Extension>
+
+</Addin>
diff --git a/src/Extensions/Banshee.LibraryWatcher/Banshee.LibraryWatcher.csproj b/src/Extensions/Banshee.LibraryWatcher/Banshee.LibraryWatcher.csproj
new file mode 100644
index 0000000..ae55b3a
--- /dev/null
+++ b/src/Extensions/Banshee.LibraryWatcher/Banshee.LibraryWatcher.csproj
@@ -0,0 +1,85 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="3.5">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>8.0.50727</ProductVersion>
+    <ProjectGuid>{49CA3F27-0BB6-428d-8B3A-20232493652E}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <UseParentDirectoryAsNamespace>true</UseParentDirectoryAsNamespace>
+    <AssemblyName>Banshee.LibraryWatcher</AssemblyName>
+    <SchemaVersion>2.0</SchemaVersion>
+    <TargetFrameworkVersion>v2.0</TargetFrameworkVersion>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>..\..\..\bin</OutputPath>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <CheckForOverflowUnderflow>true</CheckForOverflowUnderflow>
+    <CustomCommands>
+      <CustomCommands>
+        <Command type="Build" command="make" workingdir="${SolutionDir}" />
+        <Command type="Execute" command="make run" workingdir="${SolutionDir}" />
+      </CustomCommands>
+    </CustomCommands>
+    <AssemblyKeyFile>.</AssemblyKeyFile>
+  </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\Core\Banshee.Core\Banshee.Core.csproj">
+      <Project>{2ADB831A-A050-47D0-B6B9-9C19D60233BB}</Project>
+      <Name>Banshee.Core</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\Core\Banshee.Services\Banshee.Services.csproj">
+      <Project>{B28354F0-BA87-44E8-989F-B864A3C7C09F}</Project>
+      <Name>Banshee.Services</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\Libraries\Hyena\Hyena.csproj">
+      <Project>{95374549-9553-4C1E-9D89-667755F90E12}</Project>
+      <Name>Hyena</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\Core\Banshee.ThickClient\Banshee.ThickClient.csproj">
+      <Project>{AC839523-7BDF-4AB6-8115-E17921B96EC6}</Project>
+      <Name>Banshee.ThickClient</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="Mono.Addins, Version=0.4.0.0, Culture=neutral, PublicKeyToken=0738eb9f132ed756" />
+    <Reference Include="gtk-sharp, Version=2.12.0.0, Culture=neutral, PublicKeyToken=35e10195dab3c99f" />
+  </ItemGroup>
+  <ItemGroup>
+    <EmbeddedResource Include="Banshee.LibraryWatcher.addin.xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Banshee.LibraryWatcher\LibraryWatcherService.cs" />
+    <Compile Include="Banshee.LibraryWatcher\SourceWatcher.cs" />
+    <Compile Include="Banshee.LibraryWatcher\IO\FileSystemWatcher.cs" />
+    <Compile Include="Banshee.LibraryWatcher\IO\InotifyWatcher.cs" />
+    <Compile Include="Banshee.LibraryWatcher\IO\IFileWatcher.cs" />
+    <Compile Include="Banshee.LibraryWatcher\IO\FileAction.cs" />
+    <Compile Include="Banshee.LibraryWatcher\IO\SearchPattern.cs" />
+    <Compile Include="Banshee.LibraryWatcher\FileSystemWatcherProxy.cs" />
+  </ItemGroup>
+  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
+  <ProjectExtensions>
+    <MonoDevelop>
+      <Properties>
+        <MonoDevelop.Autotools.MakefileInfo IntegrationEnabled="true" RelativeMakefileName="./Makefile.am">
+          <BuildFilesVar Sync="true" Name="SOURCES" />
+          <DeployFilesVar />
+          <ResourcesVar Sync="true" Name="RESOURCES" />
+          <OthersVar />
+          <GacRefVar />
+          <AsmRefVar />
+          <ProjectRefVar />
+        </MonoDevelop.Autotools.MakefileInfo>
+      </Properties>
+    </MonoDevelop>
+  </ProjectExtensions>
+  <ItemGroup>
+    <Folder Include="Banshee.LibraryWatcher\IO\" />
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/src/Extensions/Banshee.LibraryWatcher/Banshee.LibraryWatcher/FileSystemWatcherProxy.cs b/src/Extensions/Banshee.LibraryWatcher/Banshee.LibraryWatcher/FileSystemWatcherProxy.cs
new file mode 100644
index 0000000..2193702
--- /dev/null
+++ b/src/Extensions/Banshee.LibraryWatcher/Banshee.LibraryWatcher/FileSystemWatcherProxy.cs
@@ -0,0 +1,146 @@
+//
+// FileSystemWatcherProxy.cs
+//
+// Authors:
+//   Alexander Kojevnikov <alexander@kojevnikov.com>
+//
+// Copyright (C) 2009 Alexander Kojevnikov
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+using System;
+
+namespace Banshee.LibraryWatcher
+{
+    public class FileSystemWatcherProxy : IDisposable
+    {
+        private readonly Banshee.LibraryWatcher.IO.FileSystemWatcher watcher_fixed;
+        private readonly System.IO.FileSystemWatcher watcher;
+
+        public FileSystemWatcherProxy(string path)
+        {
+            // FIXME: There must be a better way to check if we are running under Linux.
+            if (Environment.OSVersion.Platform == PlatformID.Unix &&
+                Environment.OSVersion.Version.ToString ().StartsWith ("2.6.")) {
+                watcher_fixed = new Banshee.LibraryWatcher.IO.FileSystemWatcher (path);
+            } else {
+                watcher = new System.IO.FileSystemWatcher (path);
+            }
+        }
+
+        public void Dispose ()
+        {
+            if (watcher_fixed != null) {
+                watcher_fixed.Dispose ();
+            } else {
+                watcher.Dispose ();
+            }
+        }
+
+        public bool IncludeSubdirectories {
+            set {
+                if (watcher_fixed != null) {
+                    watcher_fixed.IncludeSubdirectories = value;
+                } else {
+                    watcher.IncludeSubdirectories = value;
+                }
+            }
+        }
+
+        public event System.IO.FileSystemEventHandler Changed {
+            add {
+                if (watcher_fixed != null) {
+                    watcher_fixed.Changed += value;
+                } else {
+                    watcher.Changed += value;
+                }
+            }
+            remove {
+                if (watcher_fixed != null) {
+                    watcher_fixed.Changed -= value;
+                } else {
+                    watcher.Changed -= value;
+                }
+            }
+        }
+
+        public event System.IO.FileSystemEventHandler Created {
+            add {
+                if (watcher_fixed != null) {
+                    watcher_fixed.Created += value;
+                } else {
+                    watcher.Created += value;
+                }
+            }
+            remove {
+                if (watcher_fixed != null) {
+                    watcher_fixed.Created -= value;
+                } else {
+                    watcher.Created -= value;
+                }
+            }
+        }
+
+        public event System.IO.FileSystemEventHandler Deleted {
+            add {
+                if (watcher_fixed != null) {
+                    watcher_fixed.Deleted += value;
+                } else {
+                    watcher.Deleted += value;
+                }
+            }
+            remove {
+                if (watcher_fixed != null) {
+                    watcher_fixed.Deleted -= value;
+                } else {
+                    watcher.Deleted -= value;
+                }
+            }
+        }
+
+        public event System.IO.RenamedEventHandler Renamed {
+            add {
+                if (watcher_fixed != null) {
+                    watcher_fixed.Renamed += value;
+                } else {
+                    watcher.Renamed += value;
+                }
+            }
+            remove {
+                if (watcher_fixed != null) {
+                    watcher_fixed.Renamed -= value;
+                } else {
+                    watcher.Renamed -= value;
+                }
+            }
+        }
+
+        public bool EnableRaisingEvents {
+            set {
+                if (watcher_fixed != null) {
+                    watcher_fixed.EnableRaisingEvents = value;
+                } else {
+                    watcher.EnableRaisingEvents = value;
+                }
+            }
+        }
+    }
+}
diff --git a/src/Extensions/Banshee.LibraryWatcher/Banshee.LibraryWatcher/IO/FileAction.cs b/src/Extensions/Banshee.LibraryWatcher/Banshee.LibraryWatcher/IO/FileAction.cs
new file mode 100644
index 0000000..8d64a87
--- /dev/null
+++ b/src/Extensions/Banshee.LibraryWatcher/Banshee.LibraryWatcher/IO/FileAction.cs
@@ -0,0 +1,39 @@
+// 
+// System.IO.FileAction.cs
+//
+// Authors:
+//	Gonzalo Paniagua Javier (gonzalo@ximian.com)
+//
+// (c) 2004 Novell, Inc. (http://www.novell.com)
+//
+
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+namespace Banshee.LibraryWatcher.IO {
+	enum FileAction {
+		Added = 1,
+		Removed = 2,
+		Modified = 3,
+		RenamedOldName = 4,
+		RenamedNewName = 5
+	}
+}
diff --git a/src/Extensions/Banshee.LibraryWatcher/Banshee.LibraryWatcher/IO/FileSystemWatcher.cs b/src/Extensions/Banshee.LibraryWatcher/Banshee.LibraryWatcher/IO/FileSystemWatcher.cs
new file mode 100644
index 0000000..f4eba39
--- /dev/null
+++ b/src/Extensions/Banshee.LibraryWatcher/Banshee.LibraryWatcher/IO/FileSystemWatcher.cs
@@ -0,0 +1,541 @@
+// 
+// System.IO.FileSystemWatcher.cs
+//
+// Authors:
+// 	Tim Coleman (tim@timcoleman.com)
+//	Gonzalo Paniagua Javier (gonzalo@ximian.com)
+//
+// Copyright (C) Tim Coleman, 2002 
+// (c) 2003 Ximian, Inc. (http://www.ximian.com)
+// Copyright (C) 2004, 2006 Novell, Inc (http://www.novell.com)
+//
+
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+using System;
+using System.IO;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Security.Permissions;
+using System.Threading;
+
+namespace Banshee.LibraryWatcher.IO {
+	[DefaultEvent("Changed")]
+#if NET_2_0
+	[IODescription ("")]
+#endif
+	public class FileSystemWatcher : Component, ISupportInitialize {
+
+		#region Fields
+
+		bool enableRaisingEvents;
+		string filter;
+		bool includeSubdirectories;
+		int internalBufferSize;
+		NotifyFilters notifyFilter;
+		string path;
+		string fullpath;
+		ISynchronizeInvoke synchronizingObject;
+		WaitForChangedResult lastData;
+		bool waiting;
+		SearchPattern2 pattern;
+		bool disposed;
+		string mangledFilter;
+		static IFileWatcher watcher;
+		static object lockobj = new object ();
+
+		#endregion // Fields
+
+		#region Constructors
+
+		public FileSystemWatcher ()
+		{
+			this.notifyFilter = NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.DirectoryName;
+			this.enableRaisingEvents = false;
+			this.filter = "*.*";
+			this.includeSubdirectories = false;
+			this.internalBufferSize = 8192;
+			this.path = "";
+			InitWatcher ();
+		}
+
+		public FileSystemWatcher (string path)
+			: this (path, "*.*")
+		{
+		}
+
+		public FileSystemWatcher (string path, string filter)
+		{
+			if (path == null)
+				throw new ArgumentNullException ("path");
+
+			if (filter == null)
+				throw new ArgumentNullException ("filter");
+
+			if (path == String.Empty)
+				throw new ArgumentException ("Empty path", "path");
+
+			if (!Directory.Exists (path))
+				throw new ArgumentException ("Directory does not exists", "path");
+
+			this.enableRaisingEvents = false;
+			this.filter = filter;
+			this.includeSubdirectories = false;
+			this.internalBufferSize = 8192;
+			this.notifyFilter = NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.DirectoryName;
+			this.path = path;
+			this.synchronizingObject = null;
+			InitWatcher ();
+		}
+
+		[EnvironmentPermission (SecurityAction.Assert, Read="MONO_MANAGED_WATCHER")]
+		void InitWatcher ()
+		{
+			lock (lockobj) {
+				if (watcher != null)
+					return;
+
+				/*string managed = Environment.GetEnvironmentVariable ("MONO_MANAGED_WATCHER");
+				int mode = 0;
+				if (managed == null)
+					mode = InternalSupportsFSW ();
+				
+				bool ok = false;
+				switch (mode) {
+				case 1: // windows
+					ok = DefaultWatcher.GetInstance (out watcher);
+					//ok = WindowsWatcher.GetInstance (out watcher);
+					break;
+				case 2: // libfam
+					ok = FAMWatcher.GetInstance (out watcher, false);
+					break;
+				case 3: // kevent
+					ok = KeventWatcher.GetInstance (out watcher);
+					break;
+				case 4: // libgamin
+					ok = FAMWatcher.GetInstance (out watcher, true);
+					break;
+				case 5: // inotify
+					ok = InotifyWatcher.GetInstance (out watcher, true);
+					break;
+				}
+
+				if (mode == 0 || !ok) {
+					if (String.Compare (managed, "disabled", true) == 0)
+						NullFileWatcher.GetInstance (out watcher);
+					else
+						DefaultWatcher.GetInstance (out watcher);
+				}*/
+                InotifyWatcher.GetInstance (out watcher, true);
+
+				ShowWatcherInfo ();
+			}
+		}
+
+		[Conditional ("DEBUG"), Conditional ("TRACE")]
+		void ShowWatcherInfo ()
+		{
+			Console.WriteLine ("Watcher implementation: {0}", watcher != null ? watcher.GetType ().ToString () : "<none>");
+		}
+		
+		#endregion // Constructors
+
+		#region Properties
+
+		/* If this is enabled, we Pulse this instance */
+		internal bool Waiting {
+			get { return waiting; }
+			set { waiting = value; }
+		}
+
+		internal string MangledFilter {
+			get {
+				if (filter != "*.*")
+					return filter;
+
+				if (mangledFilter != null)
+					return mangledFilter;
+
+				string filterLocal = "*.*";
+				//if (!(watcher.GetType () == typeof (WindowsWatcher)))
+					filterLocal = "*";
+
+				return filterLocal;
+			}
+		}
+
+		internal SearchPattern2 Pattern {
+			get {
+				if (pattern == null) {
+					pattern = new SearchPattern2 (MangledFilter);
+				}
+				return pattern;
+			}
+		}
+
+		internal string FullPath {
+			get {
+				if (fullpath == null) {
+					if (path == null || path == "")
+						fullpath = Environment.CurrentDirectory;
+					else
+						fullpath = System.IO.Path.GetFullPath (path);
+				}
+
+				return fullpath;
+			}
+		}
+
+		[DefaultValue(false)]
+		[IODescription("Flag to indicate if this instance is active")]
+		public bool EnableRaisingEvents {
+			get { return enableRaisingEvents; }
+			set {
+				if (value == enableRaisingEvents)
+					return; // Do nothing
+
+				enableRaisingEvents = value;
+				if (value) {
+					Start ();
+				} else {
+					Stop ();
+				}
+			}
+		}
+
+		[DefaultValue("*.*")]
+		[IODescription("File name filter pattern")]
+		//[RecommendedAsConfigurable(true)]
+		//[TypeConverter ("System.Diagnostics.Design.StringValueConverter, " + Consts.AssemblySystem_Design)]
+		public string Filter {
+			get { return filter; }
+			set {
+				if (value == null || value == "")
+					value = "*.*";
+
+				if (filter != value) {
+					filter = value;
+					pattern = null;
+					mangledFilter = null;
+				}
+			}
+		}
+
+		[DefaultValue(false)]
+		[IODescription("Flag to indicate we want to watch subdirectories")]
+		public bool IncludeSubdirectories {
+			get { return includeSubdirectories; }
+			set {
+				if (includeSubdirectories == value)
+					return;
+
+				includeSubdirectories = value;
+				if (value && enableRaisingEvents) {
+					Stop ();
+					Start ();
+				}
+			}
+		}
+
+		[Browsable(false)]
+		[DefaultValue(8192)]
+		public int InternalBufferSize {
+			get { return internalBufferSize; }
+			set {
+				if (internalBufferSize == value)
+					return;
+
+				if (value < 4196)
+					value = 4196;
+
+				internalBufferSize = value;
+				if (enableRaisingEvents) {
+					Stop ();
+					Start ();
+				}
+			}
+		}
+
+		[DefaultValue(NotifyFilters.FileName | NotifyFilters.DirectoryName | NotifyFilters.LastWrite)]
+		[IODescription("Flag to indicate which change event we want to monitor")]
+		public NotifyFilters NotifyFilter {
+			get { return notifyFilter; }
+			set {
+				if (notifyFilter == value)
+					return;
+					
+				notifyFilter = value;
+				if (enableRaisingEvents) {
+					Stop ();
+					Start ();
+				}
+			}
+		}
+
+		[DefaultValue("")]
+		[IODescription("The directory to monitor")]
+		//[RecommendedAsConfigurable(true)]
+		//[TypeConverter ("System.Diagnostics.Design.StringValueConverter, " + Consts.AssemblySystem_Design)]
+		//[Editor ("System.Diagnostics.Design.FSWPathEditor, " + Consts.AssemblySystem_Design, "System.Drawing.Design.UITypeEditor, " + Consts.AssemblySystem_Drawing)]
+		public string Path {
+			get { return path; }
+			set {
+				if (path == value)
+					return;
+
+				bool exists = false;
+				Exception exc = null;
+
+				try {
+					exists = Directory.Exists (value);
+				} catch (Exception e) {
+					exc = e;
+				}
+
+				if (exc != null)
+					throw new ArgumentException ("Invalid directory name", "value", exc);
+
+				if (!exists)
+					throw new ArgumentException ("Directory does not exists", "value");
+
+				path = value;
+				fullpath = null;
+				if (enableRaisingEvents) {
+					Stop ();
+					Start ();
+				}
+			}
+		}
+
+		[Browsable(false)]
+		public override ISite Site {
+			get { return base.Site; }
+			set { base.Site = value; }
+		}
+
+		[DefaultValue(null)]
+		[IODescription("The object used to marshal the event handler calls resulting from a directory change")]
+#if NET_2_0
+		[Browsable (false)]
+#endif
+		public ISynchronizeInvoke SynchronizingObject {
+			get { return synchronizingObject; }
+			set { synchronizingObject = value; }
+		}
+
+		#endregion // Properties
+
+		#region Methods
+	
+		public void BeginInit ()
+		{
+			// Not necessary in Mono
+		}
+
+		protected override void Dispose (bool disposing)
+		{
+			if (!disposed) {
+				disposed = true;
+				Stop ();
+			}
+
+			base.Dispose (disposing);
+		}
+
+		~FileSystemWatcher ()
+		{
+			disposed = true;
+			Stop ();
+		}
+		
+		public void EndInit ()
+		{
+			// Not necessary in Mono
+		}
+
+		enum EventType {
+			FileSystemEvent,
+			ErrorEvent,
+			RenameEvent
+		}
+		private void RaiseEvent (Delegate ev, EventArgs arg, EventType evtype)
+		{
+			if (ev == null)
+				return;
+
+			if (synchronizingObject == null) {
+				switch (evtype) {
+				case EventType.RenameEvent:
+					((RenamedEventHandler)ev).BeginInvoke (this, (RenamedEventArgs) arg, null, null);
+					break;
+				case EventType.ErrorEvent:
+					((ErrorEventHandler)ev).BeginInvoke (this, (ErrorEventArgs) arg, null, null);
+					break;
+				case EventType.FileSystemEvent:
+					((FileSystemEventHandler)ev).BeginInvoke (this, (FileSystemEventArgs) arg, null, null);
+					break;
+				}
+				return;
+			}
+			
+			synchronizingObject.BeginInvoke (ev, new object [] {this, arg});
+		}
+
+		protected void OnChanged (FileSystemEventArgs e)
+		{
+			RaiseEvent (Changed, e, EventType.FileSystemEvent);
+		}
+
+		protected void OnCreated (FileSystemEventArgs e)
+		{
+			RaiseEvent (Created, e, EventType.FileSystemEvent);
+		}
+
+		protected void OnDeleted (FileSystemEventArgs e)
+		{
+			RaiseEvent (Deleted, e, EventType.FileSystemEvent);
+		}
+
+		protected void OnError (ErrorEventArgs e)
+		{
+			RaiseEvent (Error, e, EventType.ErrorEvent);
+		}
+
+		protected void OnRenamed (RenamedEventArgs e)
+		{
+			RaiseEvent (Renamed, e, EventType.RenameEvent);
+		}
+
+		public WaitForChangedResult WaitForChanged (WatcherChangeTypes changeType)
+		{
+			return WaitForChanged (changeType, Timeout.Infinite);
+		}
+
+		public WaitForChangedResult WaitForChanged (WatcherChangeTypes changeType, int timeout)
+		{
+			WaitForChangedResult result = new WaitForChangedResult ();
+			bool prevEnabled = EnableRaisingEvents;
+			if (!prevEnabled)
+				EnableRaisingEvents = true;
+
+			bool gotData;
+			lock (this) {
+				waiting = true;
+				gotData = Monitor.Wait (this, timeout);
+				if (gotData)
+					result = this.lastData;
+			}
+
+			EnableRaisingEvents = prevEnabled;
+			if (!gotData)
+				result.TimedOut = true;
+
+			return result;
+		}
+
+		internal void DispatchEvents (FileAction act, string filename, ref RenamedEventArgs renamed)
+		{
+			if (waiting) {
+				lastData = new WaitForChangedResult ();
+			}
+
+			switch (act) {
+			case FileAction.Added:
+				lastData.Name = filename;
+				lastData.ChangeType = WatcherChangeTypes.Created;
+				OnCreated (new FileSystemEventArgs (WatcherChangeTypes.Created, path, filename));
+				break;
+			case FileAction.Removed:
+				lastData.Name = filename;
+				lastData.ChangeType = WatcherChangeTypes.Deleted;
+				OnDeleted (new FileSystemEventArgs (WatcherChangeTypes.Deleted, path, filename));
+				break;
+			case FileAction.Modified:
+				lastData.Name = filename;
+				lastData.ChangeType = WatcherChangeTypes.Changed;
+				OnChanged (new FileSystemEventArgs (WatcherChangeTypes.Changed, path, filename));
+				break;
+			case FileAction.RenamedOldName:
+				if (renamed != null) {
+					OnRenamed (renamed);
+				}
+				lastData.OldName = filename;
+				lastData.ChangeType = WatcherChangeTypes.Renamed;
+				renamed = new RenamedEventArgs (WatcherChangeTypes.Renamed, path, filename, "");
+				break;
+			case FileAction.RenamedNewName:
+				lastData.Name = filename;
+				lastData.ChangeType = WatcherChangeTypes.Renamed;
+				if (renamed == null) {
+					renamed = new RenamedEventArgs (WatcherChangeTypes.Renamed, path, "", filename);
+				}
+				OnRenamed (renamed);
+				renamed = null;
+				break;
+			default:
+				break;
+			}
+		}
+
+		void Start ()
+		{
+			watcher.StartDispatching (this);
+		}
+
+		void Stop ()
+		{
+			watcher.StopDispatching (this);
+		}
+		#endregion // Methods
+
+		#region Events and Delegates
+
+		[IODescription("Occurs when a file/directory change matches the filter")]
+		public event FileSystemEventHandler Changed;
+
+		[IODescription("Occurs when a file/directory creation matches the filter")]
+		public event FileSystemEventHandler Created;
+
+		[IODescription("Occurs when a file/directory deletion matches the filter")]
+		public event FileSystemEventHandler Deleted;
+
+		[Browsable(false)]
+		public event ErrorEventHandler Error;
+
+		[IODescription("Occurs when a file/directory rename matches the filter")]
+		public event RenamedEventHandler Renamed;
+
+		#endregion // Events and Delegates
+
+		/* 0 -> not supported	*/
+		/* 1 -> windows		*/
+		/* 2 -> FAM		*/
+		/* 3 -> Kevent		*/
+		/* 4 -> gamin		*/
+		/* 5 -> inotify		*/
+		//[MethodImplAttribute(MethodImplOptions.InternalCall)]
+		//static extern int InternalSupportsFSW ();
+	}
+}
+
diff --git a/src/Extensions/Banshee.LibraryWatcher/Banshee.LibraryWatcher/IO/IFileWatcher.cs b/src/Extensions/Banshee.LibraryWatcher/Banshee.LibraryWatcher/IO/IFileWatcher.cs
new file mode 100644
index 0000000..b761016
--- /dev/null
+++ b/src/Extensions/Banshee.LibraryWatcher/Banshee.LibraryWatcher/IO/IFileWatcher.cs
@@ -0,0 +1,37 @@
+// 
+// System.IO.IFileWatcher.cs
+//
+// Authors:
+//	Gonzalo Paniagua Javier (gonzalo@ximian.com)
+//
+// (c) 2004 Novell, Inc. (http://www.novell.com)
+//
+
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+namespace Banshee.LibraryWatcher.IO {
+	interface IFileWatcher {
+		void StartDispatching (FileSystemWatcher fsw);
+		void StopDispatching (FileSystemWatcher fsw);
+	}
+}
+
diff --git a/src/Extensions/Banshee.LibraryWatcher/Banshee.LibraryWatcher/IO/InotifyWatcher.cs b/src/Extensions/Banshee.LibraryWatcher/Banshee.LibraryWatcher/IO/InotifyWatcher.cs
new file mode 100644
index 0000000..d1af099
--- /dev/null
+++ b/src/Extensions/Banshee.LibraryWatcher/Banshee.LibraryWatcher/IO/InotifyWatcher.cs
@@ -0,0 +1,624 @@
+// 
+// System.IO.Inotify.cs: interface with inotify
+//
+// Authors:
+//	Gonzalo Paniagua (gonzalo@novell.com)
+//	Anders Rune Jensen (anders@iola.dk)
+//
+// (c) 2006 Novell, Inc. (http://www.novell.com)
+
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+using System;
+using System.IO;
+using System.Collections;
+using System.ComponentModel;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading;
+
+namespace Banshee.LibraryWatcher.IO {
+
+	[Flags]
+	enum InotifyMask : uint {
+		Access = 1 << 0,
+		Modify = 1 << 1,
+		Attrib = 1 << 2,
+		CloseWrite = 1 << 3,
+		CloseNoWrite = 1 << 4,
+		Open = 1 << 5,
+		MovedFrom = 1 << 6,
+		MovedTo = 1 << 7,
+		Create = 1 << 8,
+		Delete = 1 << 9,
+		DeleteSelf = 1 << 10,
+		MoveSelf = 1 << 11,
+		BaseEvents = 0x00000fff,
+		// Can be sent at any time
+		Umount = 0x0002000,
+		Overflow = 0x0004000,
+		Ignored = 0x0008000,
+
+		// Special flags.
+		OnlyDir = 0x01000000,
+		DontFollow = 0x02000000,
+		AddMask = 0x20000000,
+		Directory = 0x40000000,
+		OneShot = 0x80000000
+	}
+
+	struct InotifyEvent { // Our internal representation for the data returned by the kernel
+		public static readonly InotifyEvent Default = new InotifyEvent ();
+		public int WatchDescriptor;
+		public InotifyMask Mask;
+		public string Name;
+
+		public override string ToString ()
+		{
+			return String.Format ("[Descriptor: {0} Mask: {1} Name: {2}]", WatchDescriptor, Mask, Name);
+		}
+	}
+
+	class ParentInotifyData
+	{
+		public bool IncludeSubdirs;
+		public bool Enabled;
+	        public ArrayList children; // InotifyData
+	        public InotifyData data;
+	}
+
+	class InotifyData {
+		public FileSystemWatcher FSW;
+		public string Directory;
+		public int Watch;
+	}
+
+	class InotifyWatcher : IFileWatcher
+	{
+		static bool failed;
+		static InotifyWatcher instance;
+		static Hashtable watches; // FSW to ParentInotifyData
+		static Hashtable requests; // FSW to InotifyData
+		static IntPtr FD;
+		static Thread thread;
+		static bool stop;
+		
+		private InotifyWatcher ()
+		{
+		}
+		
+		// Locked by caller
+		public static bool GetInstance (out IFileWatcher watcher, bool gamin)
+		{
+			if (failed == true) {
+				watcher = null;
+				return false;
+			}
+
+			if (instance != null) {
+				watcher = instance;
+				return true;
+			}
+
+			FD = GetInotifyInstance ();
+			if ((long) FD == -1) {
+				failed = true;
+				watcher = null;
+				return false;
+			}
+
+			watches = Hashtable.Synchronized (new Hashtable ());
+			requests = Hashtable.Synchronized (new Hashtable ());
+			instance = new InotifyWatcher ();
+			watcher = instance;
+			return true;
+		}
+		
+		public void StartDispatching (FileSystemWatcher fsw)
+		{
+			ParentInotifyData parent;
+			lock (this) {
+				if ((long) FD == -1)
+					FD = GetInotifyInstance ();
+
+				if (thread == null) {
+					thread = new Thread (new ThreadStart (Monitor));
+					thread.IsBackground = true;
+					thread.Start ();
+				}
+
+				parent = (ParentInotifyData) watches [fsw];
+			}
+
+			if (parent == null) {
+				InotifyData data = new InotifyData ();
+				data.FSW = fsw;
+				data.Directory = fsw.FullPath;
+
+				parent = new ParentInotifyData();
+				parent.IncludeSubdirs = fsw.IncludeSubdirectories;
+				parent.Enabled = true;
+				parent.children = new ArrayList();
+				parent.data = data;
+
+				watches [fsw] = parent;
+
+				try {
+					StartMonitoringDirectory (data, false);
+					lock (this) {
+						AppendRequestData (data);
+						stop = false;
+					}
+				} catch {} // ignore the directory if StartMonitoringDirectory fails.
+			}
+		}
+		
+		static void AppendRequestData (InotifyData data)
+		{
+			int wd = data.Watch;
+
+			object obj = requests [wd];
+			ArrayList list = null;
+			if (obj == null) {
+				requests [data.Watch] = data;
+			} else if (obj is InotifyData) {
+				list = new ArrayList ();
+				list.Add (obj);
+				list.Add (data);
+				requests [data.Watch] = list;
+			} else {
+				list = (ArrayList) obj;
+				list.Add (data);
+			}
+		}
+
+		static bool RemoveRequestData (InotifyData data)
+		{
+			int wd = data.Watch;
+			object obj = requests [wd];
+			if (obj == null)
+				return true;
+
+			if (obj is InotifyData) {
+				if (obj == data) {
+					requests.Remove (wd);
+					return true;
+				}
+				return false;
+			}
+
+			ArrayList list = (ArrayList) obj;
+			list.Remove (data);
+			if (list.Count == 0) {
+				requests.Remove (wd);
+				return true;
+			}
+			return false;
+		}
+
+		// Attempt to match MS and linux behavior.
+		static InotifyMask GetMaskFromFilters (NotifyFilters filters)
+		{
+			InotifyMask mask = InotifyMask.Create | InotifyMask.Delete | InotifyMask.DeleteSelf | InotifyMask.AddMask;
+			if ((filters & NotifyFilters.Attributes) != 0)
+				mask |= InotifyMask.Attrib;
+
+			if ((filters & NotifyFilters.Security) != 0)
+				mask |= InotifyMask.Attrib;
+
+			if ((filters & NotifyFilters.Size) != 0) {
+				mask |= InotifyMask.Attrib;
+				mask |= InotifyMask.Modify;
+			}
+
+			if ((filters & NotifyFilters.LastAccess) != 0) {
+				mask |= InotifyMask.Attrib;
+				mask |= InotifyMask.Access;
+				mask |= InotifyMask.Modify;
+			}
+
+			if ((filters & NotifyFilters.LastWrite) != 0) {
+				mask |= InotifyMask.Attrib;
+				mask |= InotifyMask.Modify;
+			}
+
+			if ((filters & NotifyFilters.FileName) != 0) {
+				mask |= InotifyMask.MovedFrom;
+				mask |= InotifyMask.MovedTo;
+			}
+
+			if ((filters & NotifyFilters.DirectoryName) != 0) {
+				mask |= InotifyMask.MovedFrom;
+				mask |= InotifyMask.MovedTo;
+			}
+
+			return mask;
+		}
+
+		static void StartMonitoringDirectory (InotifyData data, bool justcreated)
+		{
+			InotifyMask mask = GetMaskFromFilters (data.FSW.NotifyFilter);
+			int wd = AddDirectoryWatch (FD, data.Directory, mask);
+			if (wd == -1) {
+				int error = Marshal.GetLastWin32Error ();
+				if (error == 4) { // Too many open watches
+					string nr_watches = "(unknown)";
+					try {
+						using (StreamReader reader = new StreamReader ("/proc/sys/fs/inotify/max_user_watches")) {
+							nr_watches = reader.ReadLine ();
+						}
+					} catch {}
+
+					string msg = String.Format ("The per-user inotify watches limit of {0} has been reached. " +
+								"If you're experiencing problems with your application, increase that limit " +
+								"in /proc/sys/fs/inotify/max_user_watches.", nr_watches);
+					
+					throw new Win32Exception (error, msg);
+				}
+				throw new Win32Exception (error);
+			}
+
+			FileSystemWatcher fsw = data.FSW;
+			data.Watch = wd;
+
+			ParentInotifyData parent = (ParentInotifyData) watches[fsw];
+
+			if (parent.IncludeSubdirs) {
+				foreach (string directory in Directory.GetDirectories (data.Directory)) {
+					InotifyData fd = new InotifyData ();
+					fd.FSW = fsw;
+					fd.Directory = directory;
+
+					if (justcreated) {
+						lock (fsw) {
+							RenamedEventArgs renamed = null;
+							if (fsw.Pattern.IsMatch (directory)) {
+								fsw.DispatchEvents (FileAction.Added, directory, ref renamed);
+								if (fsw.Waiting) {
+									fsw.Waiting = false;
+									System.Threading.Monitor.PulseAll (fsw);
+								}
+							}
+						}
+					}
+
+					try {
+						StartMonitoringDirectory (fd, justcreated);
+						AppendRequestData (fd);
+					        parent.children.Add(fd);
+					} catch {} // ignore errors and don't add directory.
+				}
+			}
+
+			if (justcreated) {
+				foreach (string filename in Directory.GetFiles (data.Directory)) {
+					lock (fsw) {
+						RenamedEventArgs renamed = null;
+						if (fsw.Pattern.IsMatch (filename)) {
+							fsw.DispatchEvents (FileAction.Added, filename, ref renamed);
+							/* If a file has been created, then it has been written to */
+							fsw.DispatchEvents (FileAction.Modified, filename, ref renamed);
+
+							if (fsw.Waiting) {
+								fsw.Waiting = false;
+								System.Threading.Monitor.PulseAll(fsw);
+							}
+						}
+					}
+				}
+			}
+		}
+
+		public void StopDispatching (FileSystemWatcher fsw)
+		{
+			ParentInotifyData parent;
+			lock (this) {
+				parent = (ParentInotifyData) watches [fsw];
+				if (parent == null)
+					return;
+
+				if (RemoveRequestData (parent.data)) {
+					StopMonitoringDirectory (parent.data);
+				}
+				watches.Remove (fsw);
+				if (watches.Count == 0) {
+					stop = true;
+					IntPtr fd = FD;
+					FD = (IntPtr) (-1);
+					Close (fd);
+				}
+
+				if (!parent.IncludeSubdirs)
+					return;
+
+				foreach (InotifyData idata in parent.children)
+				{
+				    if (RemoveRequestData (idata)) {
+					StopMonitoringDirectory (idata);
+				    }
+				}
+			}
+		}
+
+		static void StopMonitoringDirectory (InotifyData data)
+		{
+			RemoveWatch (FD, data.Watch);
+		}
+
+		void Monitor ()
+		{
+			byte [] buffer = new byte [4096];
+			int nread;
+			while (!stop) {
+				nread = ReadFromFD (FD, buffer, (IntPtr) buffer.Length);
+				if (nread == -1)
+					continue;
+
+				lock (this) {
+					ProcessEvents (buffer, nread);
+
+				}
+			}
+
+			lock (this) {
+				thread = null;
+				stop = false;
+			}
+		}
+		/*
+		struct inotify_event {
+			__s32           wd;
+			__u32           mask;
+			__u32           cookie;
+			__u32           len;		// Includes any trailing null in 'name'
+			char            name[0];
+		};
+		*/
+
+		static int ReadEvent (byte [] source, int off, int size, out InotifyEvent evt)
+		{
+			evt = new InotifyEvent ();
+			if (size <= 0 || off > size - 16) {
+				return -1;
+			}
+
+			int len;
+			if (BitConverter.IsLittleEndian) {
+				evt.WatchDescriptor = source [off] + (source [off + 1] << 8) +
+							(source [off + 2] << 16) + (source [off + 3] << 24);
+				evt.Mask = (InotifyMask) (source [off + 4] + (source [off + 5] << 8) +
+							(source [off + 6] << 16) + (source [off + 7] << 24));
+				// Ignore Cookie -> +4
+				len = source [off + 12] + (source [off + 13] << 8) +
+					(source [off + 14] << 16) + (source [off + 15] << 24);
+			} else {
+				evt.WatchDescriptor = source [off + 3] + (source [off + 2] << 8) +
+							(source [off + 1] << 16) + (source [off] << 24);
+				evt.Mask = (InotifyMask) (source [off + 7] + (source [off + 6] << 8) +
+							(source [off + 5] << 16) + (source [off + 4] << 24));
+				// Ignore Cookie -> +4
+				len = source [off + 15] + (source [off + 14] << 8) +
+					(source [off + 13] << 16) + (source [off + 12] << 24);
+			}
+
+			if (len > 0) {
+				if (off > size - 16 - len)
+					return -1;
+				string name = Encoding.UTF8.GetString (source, off + 16, len);
+				evt.Name = name.Trim ('\0');
+			} else {
+				evt.Name = null;
+			}
+
+			return 16 + len;
+		}
+
+		static IEnumerable GetEnumerator (object source)
+		{
+			if (source == null)
+				yield break;
+
+			if (source is InotifyData)
+				yield return source;
+
+			if (source is ArrayList) {
+				ArrayList list = (ArrayList) source;
+				for (int i = 0; i < list.Count; i++)
+					yield return list [i];
+			}
+		}
+
+		/* Interesting events:
+			* Modify
+			* Attrib
+			* MovedFrom
+			* MovedTo
+			* Create
+			* Delete
+			* DeleteSelf
+		*/
+		static InotifyMask Interesting = InotifyMask.Modify | InotifyMask.Attrib | InotifyMask.MovedFrom |
+							InotifyMask.MovedTo | InotifyMask.Create | InotifyMask.Delete |
+							InotifyMask.DeleteSelf;
+
+		void ProcessEvents (byte [] buffer, int length)
+		{
+			ArrayList newdirs = null;
+			InotifyEvent evt;
+			int nread = 0;
+			RenamedEventArgs renamed = null;
+			while (length > nread) {
+				int bytes_read = ReadEvent (buffer, nread, length, out evt);
+				if (bytes_read <= 0)
+					break;
+
+				nread += bytes_read;
+
+				InotifyMask mask = evt.Mask;
+				bool is_directory = (mask & InotifyMask.Directory) != 0;
+				mask = (mask & Interesting); // Clear out all the bits that we don't need
+				if (mask == 0)
+					continue;
+
+				foreach (InotifyData data in GetEnumerator (requests [evt.WatchDescriptor])) {
+				        ParentInotifyData parent = (ParentInotifyData) watches[data.FSW];
+
+					if (data == null || parent.Enabled == false)
+						continue;
+
+					string directory = data.Directory;
+					string filename = evt.Name;
+					if (filename == null)
+						filename = directory;
+
+					FileSystemWatcher fsw = data.FSW;
+					FileAction action = 0;
+					if ((mask & (InotifyMask.Modify | InotifyMask.Attrib)) != 0) {
+						action = FileAction.Modified;
+					} else if ((mask & InotifyMask.Create) != 0) {
+						action = FileAction.Added;
+					} else if ((mask & InotifyMask.Delete) != 0) {
+						action = FileAction.Removed;
+					} else if ((mask & InotifyMask.DeleteSelf) != 0) {
+						if (data.Watch != parent.data.Watch) {
+							// To avoid duplicate events handle DeleteSelf only for the top level directory.
+							continue;
+						}
+						action = FileAction.Removed;
+					} else if ((mask & InotifyMask.MoveSelf) != 0) {
+						//action = FileAction.Removed;
+						continue; // Ignore this one
+					} else if ((mask & InotifyMask.MovedFrom) != 0) {
+						InotifyEvent to;
+						int i = ReadEvent (buffer, nread, length, out to);
+						if (i == -1 || (to.Mask & InotifyMask.MovedTo) == 0 || evt.WatchDescriptor != to.WatchDescriptor) {
+							action = FileAction.Removed;
+						} else {
+							nread += i;
+							action = FileAction.RenamedNewName;
+							renamed = new RenamedEventArgs (WatcherChangeTypes.Renamed, data.Directory, to.Name, evt.Name);
+							if (evt.Name != data.Directory && !fsw.Pattern.IsMatch (evt.Name))
+								filename = to.Name;
+						}
+					} else if ((mask & InotifyMask.MovedTo) != 0) {
+						action = FileAction.Added;
+					}
+					if (fsw.IncludeSubdirectories) {
+						string full = fsw.FullPath;
+						string datadir = data.Directory;
+						if (datadir != full) {
+							int len = full.Length;
+							int slash = 1;
+							if (len > 1 && full [len - 1] == Path.DirectorySeparatorChar)
+								slash = 0;
+							string reldir = datadir.Substring (full.Length + slash);
+							datadir = Path.Combine (datadir, filename);
+							filename = Path.Combine (reldir, filename);
+						} else {
+							datadir = Path.Combine (full, filename);
+						}
+
+						if (action == FileAction.Added && is_directory) {
+							if (newdirs == null)
+								newdirs = new ArrayList (2);
+
+							InotifyData fd = new InotifyData ();
+							fd.FSW = fsw;
+							fd.Directory = datadir;
+							newdirs.Add (fd);
+						}
+
+						if (action == FileAction.RenamedNewName && is_directory) {
+							foreach (InotifyData child in parent.children) {
+								if (child.Directory.StartsWith (renamed.OldFullPath)) {
+									child.Directory = renamed.FullPath +
+										child.Directory.Substring (renamed.OldFullPath.Length);
+								}
+							}
+						}
+					}
+
+					if (action == FileAction.Removed && filename == data.Directory) {
+						int idx = parent.children.IndexOf (data);
+						if (idx != -1) {
+							parent.children.RemoveAt (idx);
+							if (!fsw.Pattern.IsMatch (Path.GetFileName (filename))) {
+								continue;
+							}
+						}
+					}
+
+					if (filename != data.Directory && !fsw.Pattern.IsMatch (Path.GetFileName (filename))) {
+						continue;
+					}
+
+					lock (fsw) {
+						fsw.DispatchEvents (action, filename, ref renamed);
+						if (action == FileAction.RenamedNewName)
+							renamed = null;
+						if (fsw.Waiting) {
+							fsw.Waiting = false;
+							System.Threading.Monitor.PulseAll (fsw);
+						}
+					}
+				}
+			}
+
+			if (newdirs != null) {
+			        foreach (InotifyData newdir in newdirs) {
+					try {
+						StartMonitoringDirectory (newdir, true);
+						AppendRequestData (newdir);
+					        ((ParentInotifyData) watches[newdir.FSW]).children.Add(newdir);
+					} catch {} // ignore the given directory
+				}
+				newdirs.Clear ();
+			}
+		}
+
+		static int AddDirectoryWatch (IntPtr fd, string directory, InotifyMask mask)
+		{
+			mask |= InotifyMask.Directory;
+			return AddWatch (fd, directory, mask);
+		}
+
+		[DllImport ("libc", EntryPoint="close")]
+		internal extern static int Close (IntPtr fd);
+
+		[DllImport ("libc", EntryPoint = "read")]
+		extern static int ReadFromFD (IntPtr fd, byte [] buffer, IntPtr length);
+
+		//[MethodImplAttribute(MethodImplOptions.InternalCall)]
+        [DllImport ("libc", EntryPoint = "inotify_init")]
+		extern static IntPtr GetInotifyInstance ();
+
+		//[MethodImplAttribute(MethodImplOptions.InternalCall)]
+        [DllImport ("libc", EntryPoint = "inotify_add_watch")]
+		extern static int AddWatch (IntPtr fd, string name, InotifyMask mask);
+
+		//[MethodImplAttribute(MethodImplOptions.InternalCall)]
+        [DllImport ("libc", EntryPoint = "inotify_rm_watch")]
+		extern static IntPtr RemoveWatch (IntPtr fd, int wd);
+	}
+}
+
diff --git a/src/Extensions/Banshee.LibraryWatcher/Banshee.LibraryWatcher/IO/SearchPattern.cs b/src/Extensions/Banshee.LibraryWatcher/Banshee.LibraryWatcher/IO/SearchPattern.cs
new file mode 100644
index 0000000..cb3adf4
--- /dev/null
+++ b/src/Extensions/Banshee.LibraryWatcher/Banshee.LibraryWatcher/IO/SearchPattern.cs
@@ -0,0 +1,225 @@
+//
+// System.IO.SearchPattern2.cs: Filename glob support.
+//
+// Author:
+//   Dan Lewis (dihlewis@yahoo.co.uk)
+//
+// (C) 2002
+//
+
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+// Copied from corlib/System.IO/SearchPatter.cs
+using System;
+using System.IO;
+
+namespace Banshee.LibraryWatcher.IO {
+
+	// FIXME: there's a complication with this algorithm under windows.
+	// the pattern '*.*' matches all files (i think . matches the extension),
+	// whereas under UNIX it should only match files containing the '.' character.
+
+	class SearchPattern2 {
+		public SearchPattern2 (string pattern) : this (pattern, false) { }
+
+		public SearchPattern2 (string pattern, bool ignore)
+		{
+			this.ignore = ignore;
+			this.pattern = pattern;
+			Compile (pattern);
+		}
+
+		// OSX has a retarded case-insensitive yet case-aware filesystem
+		// so we need a overload in here for the Kqueue watcher
+		public bool IsMatch (string text, bool ignorecase)
+		{
+			if (!hasWildcard) {
+				bool match = String.Compare (pattern, text, ignorecase) == 0;
+				if (match)
+					return true;
+				
+				// This is a special case for FSW. It needs to match e.g. subdir/file.txt
+				// when the pattern is "file.txt"
+				int idx = text.LastIndexOf ('/');
+				if (idx == -1)
+					return false;
+				idx++;
+				if (idx == text.Length)
+					return false;
+				
+				return (String.Compare (pattern, text.Substring (idx), ignorecase) == 0);
+			}
+			
+			return Match (ops, text, 0);
+		}
+
+		public bool IsMatch (string text)
+		{
+			return IsMatch (text, ignore);
+		}
+
+		public bool HasWildcard {
+			get { return hasWildcard; }
+		}
+		// private
+
+		Op ops;		// the compiled pattern
+		bool ignore;	// ignore case
+		bool hasWildcard;
+		string pattern;
+
+		private void Compile (string pattern)
+		{
+			if (pattern == null || pattern.IndexOfAny (InvalidChars) >= 0)
+				throw new ArgumentException ("Invalid search pattern: '" + pattern + "'");
+
+			if (pattern == "*") {	// common case
+				ops = new Op (OpCode.True);
+				hasWildcard = true;
+				return;
+			}
+
+			ops = null;
+
+			int ptr = 0;
+			Op last_op = null;
+			while (ptr < pattern.Length) {
+				Op op;
+			
+				switch (pattern [ptr]) {
+				case '?':
+					op = new Op (OpCode.AnyChar);
+					++ ptr;
+					hasWildcard = true;
+					break;
+
+				case '*':
+					op = new Op (OpCode.AnyString);
+					++ ptr;
+					hasWildcard = true;
+					break;
+					
+				default:
+					op = new Op (OpCode.ExactString);
+					int end = pattern.IndexOfAny (WildcardChars, ptr);
+					if (end < 0)
+						end = pattern.Length;
+
+					op.Argument = pattern.Substring (ptr, end - ptr);
+					if (ignore)
+						op.Argument = op.Argument.ToLower ();
+
+					ptr = end;
+					break;
+				}
+
+				if (last_op == null)
+					ops = op;
+				else
+					last_op.Next = op;
+
+				last_op = op;
+			}
+
+			if (last_op == null)
+				ops = new Op (OpCode.End);
+			else
+				last_op.Next = new Op (OpCode.End);
+		}
+
+		private bool Match (Op op, string text, int ptr)
+		{
+			while (op != null) {
+				switch (op.Code) {
+				case OpCode.True:
+					return true;
+
+				case OpCode.End:
+					if (ptr == text.Length)
+						return true;
+
+					return false;
+				
+				case OpCode.ExactString:
+					int length = op.Argument.Length;
+					if (ptr + length > text.Length)
+						return false;
+
+					string str = text.Substring (ptr, length);
+					if (ignore)
+						str = str.ToLower ();
+
+					if (str != op.Argument)
+						return false;
+
+					ptr += length;
+					break;
+
+				case OpCode.AnyChar:
+					if (++ ptr > text.Length)
+						return false;
+					break;
+
+				case OpCode.AnyString:
+					while (ptr <= text.Length) {
+						if (Match (op.Next, text, ptr))
+							return true;
+
+						++ ptr;
+					}
+
+					return false;
+				}
+
+				op = op.Next;
+			}
+
+			return true;
+		}
+
+		// private static
+
+		internal static readonly char [] WildcardChars = { '*', '?' };
+		internal static readonly char [] InvalidChars = { Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar };
+
+		private class Op {
+			public Op (OpCode code)
+			{
+				this.Code = code;
+				this.Argument = null;
+				this.Next = null;
+			}
+		
+			public OpCode Code;
+			public string Argument;
+			public Op Next;
+		}
+
+		private enum OpCode {
+			ExactString,		// literal
+			AnyChar,		// ?
+			AnyString,		// *
+			End,			// end of pattern
+			True			// always succeeds
+		};
+	}
+}
diff --git a/src/Extensions/Banshee.LibraryWatcher/Banshee.LibraryWatcher/LibraryWatcherService.cs b/src/Extensions/Banshee.LibraryWatcher/Banshee.LibraryWatcher/LibraryWatcherService.cs
new file mode 100644
index 0000000..fee1aed
--- /dev/null
+++ b/src/Extensions/Banshee.LibraryWatcher/Banshee.LibraryWatcher/LibraryWatcherService.cs
@@ -0,0 +1,120 @@
+//
+// LibraryWatcherService.cs
+//
+// Authors:
+//   Alexander Hixon <hixon.alexander@mediati.org>
+//   Christian Martellini <christian.martellini@gmail.com>
+//
+// Copyright (C) 2008 Alexander Hixon
+// Copyright (C) 2009 Christian Martellini
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+using System;
+using System.Collections.Generic;
+
+using Banshee.Base ;
+using Banshee.Sources;
+using Banshee.ServiceStack;
+using Banshee.Library;
+
+namespace Banshee.LibraryWatcher
+{
+    public class LibraryWatcherService : IExtensionService, IDisposable, IDelayedInitializeService
+    {
+        private readonly Dictionary<LibrarySource, SourceWatcher> watchers =
+            new Dictionary<LibrarySource, SourceWatcher> ();
+
+        string IService.ServiceName {
+            get { return "LibraryWatcherService"; }
+        }
+
+        void IExtensionService.Initialize ()
+        {
+        }
+
+        public void DelayedInitialize ()
+        {
+            ServiceManager.SourceManager.SourceAdded += OnSourceAdded;
+            ServiceManager.SourceManager.SourceRemoved += OnSourceRemoved;
+
+            foreach (var library in ServiceManager.SourceManager.FindSources<LibrarySource> ()) {
+                AddLibrary (library);
+            }
+        }
+
+        public void Dispose ()
+        {
+            lock (watchers) {
+                foreach (var watcher in watchers.Values) {
+                    watcher.Dispose ();
+                }
+                watchers.Clear ();
+            }
+        }
+
+        private void OnSourceAdded (SourceAddedArgs args)
+        {
+            var library = args.Source as LibrarySource;
+            if (library != null) {
+                AddLibrary (library);
+            }
+        }
+
+        private void OnSourceRemoved (SourceEventArgs args)
+        {
+            var library = args.Source as LibrarySource;
+            if (library != null) {
+                RemoveLibrary (library);
+            }
+        }
+
+        private void AddLibrary (LibrarySource library)
+        {
+            if (!Banshee.IO.Directory.Exists(library.BaseDirectoryWithSeparator)) {
+                Hyena.Log.DebugFormat ("Will not watch library {0} because its folder doesn't exist: {1}",
+                    library.Name, library.BaseDirectoryWithSeparator);
+                return;
+            }
+            lock (watchers) {
+                if (!watchers.ContainsKey (library)) {
+                    try {
+                        watchers[library] = new SourceWatcher (library);
+                        Hyena.Log.DebugFormat ("Started LibraryWatcher for {0} ({1})",
+                            library.Name, library.BaseDirectoryWithSeparator);
+                    } catch (Exception e) {
+                        Hyena.Log.Exception (e);
+                    }
+                }
+            }
+        }
+
+        private void RemoveLibrary (LibrarySource library)
+        {
+            lock (watchers) {
+                if (watchers.ContainsKey (library)) {
+                    watchers[library].Dispose ();
+                    watchers.Remove (library);
+                }
+            }
+        }
+    }
+}
diff --git a/src/Extensions/Banshee.LibraryWatcher/Banshee.LibraryWatcher/SourceWatcher.cs b/src/Extensions/Banshee.LibraryWatcher/Banshee.LibraryWatcher/SourceWatcher.cs
new file mode 100644
index 0000000..b2d1b35
--- /dev/null
+++ b/src/Extensions/Banshee.LibraryWatcher/Banshee.LibraryWatcher/SourceWatcher.cs
@@ -0,0 +1,293 @@
+//
+// SourceWatcher.cs
+//
+// Authors:
+//   Christian Martellini <christian.martellini@gmail.com>
+//   Alexander Kojevnikov <alexander@kojevnikov.com>
+//
+// Copyright (C) 2009 Christian Martellini
+// Copyright (C) 2009 Alexander Kojevnikov
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+using System;
+using System.IO;
+using System.Linq;
+using System.Data;
+using System.Threading;
+using System.Collections.Generic;
+
+using Hyena;
+using Hyena.Data.Sqlite;
+
+using Banshee.Base;
+using Banshee.Collection;
+using Banshee.Collection.Database;
+using Banshee.Library;
+using Banshee.ServiceStack;
+using Banshee.Sources;
+using Banshee.Streaming;
+
+namespace Banshee.LibraryWatcher
+{
+    public class SourceWatcher : IDisposable
+    {
+        private readonly LibraryImportManager import_manager;
+        private readonly LibrarySource library;
+        private readonly FileSystemWatcherProxy watcher;
+        private readonly ManualResetEvent handle;
+        private readonly Thread watch_thread;
+
+        private readonly Queue<QueueItem> queue = new Queue<QueueItem> ();
+        private readonly TimeSpan delay = TimeSpan.FromMilliseconds (1000);
+
+        private bool active;
+        private bool disposed;
+
+        private class QueueItem
+        {
+            public DateTime When;
+            public WatcherChangeTypes ChangeType;
+            public string OldFullPath;
+            public string FullPath;
+            public string MetadataHash;
+        }
+
+        public SourceWatcher (LibrarySource library)
+        {
+            this.library = library;
+            handle = new ManualResetEvent(false);
+            string path = library.BaseDirectoryWithSeparator;
+            string home = Environment.GetFolderPath (Environment.SpecialFolder.Personal) + Path.DirectorySeparatorChar;
+            if (path == home) {
+                throw new Exception ("Will not create LibraryWatcher for the entire home directory");
+            }
+
+            import_manager = ServiceManager.Get<LibraryImportManager> ();
+
+            watcher = new FileSystemWatcherProxy (path);
+            watcher.IncludeSubdirectories = true;
+            watcher.Changed += OnChanged;
+            watcher.Created += OnChanged;
+            watcher.Deleted += OnChanged;
+            watcher.Renamed += OnChanged;
+
+            active = true;
+            watch_thread = new Thread (new ThreadStart (Watch));
+            watch_thread.Name = String.Format ("LibraryWatcher for {0}", library.Name);
+            watch_thread.IsBackground = true;
+            watch_thread.Start ();
+        }
+
+#region Public Methods
+
+        public void Dispose ()
+        {
+            if (!disposed) {
+                watcher.EnableRaisingEvents = false;
+                active = false;
+                watcher.Changed -= OnChanged;
+                watcher.Created -= OnChanged;
+                watcher.Deleted -= OnChanged;
+                watcher.Renamed -= OnChanged;
+
+                watcher.Dispose ();
+                disposed = true;
+            }
+        }
+
+#endregion
+
+#region Private Methods
+
+        private void OnChanged (object source, FileSystemEventArgs args)
+        {
+            var item = new QueueItem {
+                When = DateTime.Now,
+                ChangeType = args.ChangeType,
+                FullPath = args.FullPath,
+                OldFullPath = args is RenamedEventArgs ? ((RenamedEventArgs)args).OldFullPath : args.FullPath
+            };
+
+            lock (queue) {
+                queue.Enqueue (item);
+            }
+            handle.Set ();
+
+            if (args.ChangeType != WatcherChangeTypes.Changed) {
+                Hyena.Log.DebugFormat ("Watcher: {0} {1}{2}",
+                    item.ChangeType, args is RenamedEventArgs ? item.OldFullPath + " => " : "", item.FullPath);
+            }
+        }
+
+        private void Watch ()
+        {
+            watcher.EnableRaisingEvents = true;
+
+            while (active) {
+                WatcherChangeTypes change_types = 0;
+                while (queue.Count > 0) {
+                    QueueItem item;
+                    lock (queue) {
+                        item = queue.Dequeue ();
+                    }
+
+                    int sleep =  (int) (item.When + delay - DateTime.Now).TotalMilliseconds;
+                    if (sleep > 0) {
+                        Hyena.Log.DebugFormat ("Watcher: sleeping {0}ms", sleep);
+                        Thread.Sleep (sleep);
+                    }
+
+                    if (item.ChangeType == WatcherChangeTypes.Changed) {
+                        UpdateTrack (item.FullPath);
+                    } else if (item.ChangeType == WatcherChangeTypes.Created) {
+                        AddTrack (item.FullPath);
+                    } else if (item.ChangeType == WatcherChangeTypes.Deleted) {
+                        RemoveTrack (item.FullPath);
+                    } else if (item.ChangeType == WatcherChangeTypes.Renamed) {
+                        RenameTrack (item.OldFullPath, item.FullPath);
+                    }
+
+                    change_types |= item.ChangeType;
+                }
+
+                if ((change_types & WatcherChangeTypes.Deleted) > 0) {
+                    library.NotifyTracksDeleted ();
+                }
+                if ((change_types & (WatcherChangeTypes.Renamed |
+                    WatcherChangeTypes.Created | WatcherChangeTypes.Changed)) > 0) {
+                    library.NotifyTracksChanged ();
+                }
+
+                handle.WaitOne ();
+                handle.Reset ();
+            }
+        }
+
+        private void UpdateTrack (string track)
+        {
+            using (var reader = ServiceManager.DbConnection.Query (
+                DatabaseTrackInfo.Provider.CreateFetchCommand (
+                "CoreTracks.Uri = ? LIMIT 1"), new SafeUri (track).AbsoluteUri)) {
+                if (reader.Read ()) {
+                    var track_info = DatabaseTrackInfo.Provider.Load (reader);
+                    if (Banshee.IO.File.GetModifiedTime (track_info.Uri) > track_info.FileModifiedStamp) {
+                        var file = StreamTagger.ProcessUri (track_info.Uri);
+                        StreamTagger.TrackInfoMerge (track_info, file, false);
+                        track_info.LastSyncedStamp = DateTime.Now;
+                        track_info.Save (false);
+                    }
+                }
+            }
+        }
+
+        private void AddTrack (string track)
+        {
+            import_manager.ImportTrack (track);
+
+            // Trigger file rename.
+            string uri = new SafeUri(track).AbsoluteUri;
+            HyenaSqliteCommand command = new HyenaSqliteCommand (@"
+                UPDATE CoreTracks
+                SET DateUpdatedStamp = LastSyncedStamp + 1
+                WHERE Uri = ?", uri);
+            ServiceManager.DbConnection.Execute (command);
+        }
+
+        private void RemoveTrack (string track)
+        {
+            string uri = new SafeUri(track).AbsoluteUri;
+            const string hash_sql = @"SELECT TrackID, MetadataHash FROM CoreTracks WHERE Uri = ? LIMIT 1";
+            int track_id = 0;
+            string hash = null;
+            using (var reader = new HyenaDataReader (ServiceManager.DbConnection.Query (hash_sql, uri))) {
+                if (reader.Read ()) {
+                    track_id = reader.Get<int> (0);
+                    hash = reader.Get<string> (1);
+                }
+            }
+
+            if (hash != null) {
+                QueueItem item;
+                lock (queue) {
+                    item = queue.FirstOrDefault (
+                        i => i.ChangeType == WatcherChangeTypes.Created && GetMetadataHash(i) == hash);
+                }
+                if (item != null) {
+                    item.ChangeType = WatcherChangeTypes.Renamed;
+                    item.OldFullPath = track;
+                    return;
+                }
+            }
+
+            const string delete_sql = @"
+                INSERT INTO CoreRemovedTracks (DateRemovedStamp, TrackID, Uri)
+                SELECT ?, TrackID, Uri FROM CoreTracks WHERE TrackID IN ({0})
+                ;
+                DELETE FROM CoreTracks WHERE TrackID IN ({0})";
+
+            // If track_id is 0, it's a directory.
+            HyenaSqliteCommand delete_command;
+            if (track_id > 0) {
+                delete_command = new HyenaSqliteCommand (String.Format (delete_sql,
+                    "?"), DateTime.Now, track_id, track_id);
+            } else {
+                string pattern = StringUtil.EscapeLike (uri) + "/_%";
+                delete_command = new HyenaSqliteCommand (String.Format (delete_sql,
+                    @"SELECT TrackID FROM CoreTracks WHERE Uri LIKE ? ESCAPE '\'"), DateTime.Now, pattern, pattern);
+            }
+
+            ServiceManager.DbConnection.Execute (delete_command);
+        }
+
+        private void RenameTrack(string oldFullPath, string fullPath)
+        {
+            if (oldFullPath == fullPath) {
+                // FIXME: bug in Mono, see bnc#322330
+                return;
+            }
+            string old_uri = new SafeUri (oldFullPath).AbsoluteUri;
+            string new_uri = new SafeUri (fullPath).AbsoluteUri;
+            string pattern = StringUtil.EscapeLike (old_uri) + "%";
+            HyenaSqliteCommand rename_command = new HyenaSqliteCommand (@"
+                UPDATE CoreTracks
+                SET Uri = REPLACE(Uri, ?, ?), DateUpdatedStamp = ?
+                WHERE Uri LIKE ? ESCAPE '\'",
+                old_uri, new_uri, DateTime.Now, pattern);
+            ServiceManager.DbConnection.Execute (rename_command);
+        }
+
+        private string GetMetadataHash (QueueItem item)
+        {
+            if (item.ChangeType == WatcherChangeTypes.Created && item.MetadataHash == null) {
+                var uri = new SafeUri (item.FullPath);
+                if (DatabaseImportManager.IsWhiteListedFile (item.FullPath) && Banshee.IO.File.Exists (uri)) {
+                    var track = new TrackInfo ();
+                    StreamTagger.TrackInfoMerge (track, StreamTagger.ProcessUri (uri));
+                    item.MetadataHash = track.MetadataHash;
+                }
+            }
+            return item.MetadataHash;
+        }
+
+#endregion
+    }
+}
diff --git a/src/Extensions/Banshee.LibraryWatcher/Makefile.am b/src/Extensions/Banshee.LibraryWatcher/Makefile.am
new file mode 100644
index 0000000..64fbd62
--- /dev/null
+++ b/src/Extensions/Banshee.LibraryWatcher/Makefile.am
@@ -0,0 +1,19 @@
+ASSEMBLY = Banshee.LibraryWatcher
+TARGET = library
+LINK = $(REF_EXTENSION_LIBRARYWATCHER)
+INSTALL_DIR = $(EXTENSIONS_INSTALL_DIR)
+
+SOURCES =  \
+	Banshee.LibraryWatcher/FileSystemWatcherProxy.cs \
+	Banshee.LibraryWatcher/IO/FileAction.cs \
+	Banshee.LibraryWatcher/IO/FileSystemWatcher.cs \
+	Banshee.LibraryWatcher/IO/IFileWatcher.cs \
+	Banshee.LibraryWatcher/IO/InotifyWatcher.cs \
+	Banshee.LibraryWatcher/IO/SearchPattern.cs \
+	Banshee.LibraryWatcher/LibraryWatcherService.cs \
+	Banshee.LibraryWatcher/SourceWatcher.cs
+
+RESOURCES = Banshee.LibraryWatcher.addin.xml
+
+include $(top_srcdir)/build/build.mk
+
diff --git a/src/Extensions/Makefile.am b/src/Extensions/Makefile.am
index caef9f9..cdf1298 100644
--- a/src/Extensions/Makefile.am
+++ b/src/Extensions/Makefile.am
@@ -8,6 +8,7 @@ SUBDIRS = \
 	Banshee.FileSystemQueue \
 	Banshee.InternetRadio \
 	Banshee.Lastfm \
+	Banshee.LibraryWatcher \
 	Banshee.MiniMode \
 	Banshee.MultimediaKeys \
 	Banshee.NotificationArea \
@@ -21,4 +22,5 @@ SUBDIRS = \
 	Banshee.RemoteAudio \
 	Banshee.Wikipedia
 
+
 MAINTAINERCLEANFILES = Makefile.in
diff --git a/src/Libraries/Hyena/Hyena.Query/StringQueryValue.cs b/src/Libraries/Hyena/Hyena.Query/StringQueryValue.cs
index 5e60d4a..1c54c2e 100644
--- a/src/Libraries/Hyena/Hyena.Query/StringQueryValue.cs
+++ b/src/Libraries/Hyena/Hyena.Query/StringQueryValue.cs
@@ -90,9 +90,7 @@ namespace Hyena.Query
 
             if (op == Contains   || op == DoesNotContain ||
                 op == StartsWith || op == EndsWith) {
-                return orig.Replace ("\\", "\\\\")
-                           .Replace ("%", "\\%")
-                           .Replace ("_", "\\_");
+                return StringUtil.EscapeLike (orig);
             }
             
             return orig;
diff --git a/src/Libraries/Hyena/Hyena/StringUtil.cs b/src/Libraries/Hyena/Hyena/StringUtil.cs
index 4d271a9..ed9a7d8 100644
--- a/src/Libraries/Hyena/Hyena/StringUtil.cs
+++ b/src/Libraries/Hyena/Hyena/StringUtil.cs
@@ -328,5 +328,14 @@ namespace Hyena
                 position = index + 1;
             }
         }
+
+        private static readonly char[] escaped_like_chars = new char[] {'\\', '%', '_'};
+        public static string EscapeLike (string s)
+        {
+            if (s.IndexOfAny (escaped_like_chars) != -1) {
+                return s.Replace (@"\", @"\\").Replace ("%", @"\%").Replace ("_", @"\_");
+            }
+            return s;
+        }
     }
 }
