public DirectoryWatcher(string path, TimeSpan latency)
{
Log.WriteLine(TraceLevel.Verbose, "App", "creating a directory watcher for '{0}'", path);
Path = path;
m_callback = this.DoCallback;
NSArray paths = NSArray.Create(path);
m_stream = FSEventStreamCreate( // note that the stream will always be valid
IntPtr.Zero, // allocator
m_callback, // callback
IntPtr.Zero, // context
paths, // pathsToWatch
kFSEventStreamEventIdSinceNow, // sinceWhen
latency.TotalSeconds, // latency (in seconds)
FSEventStreamCreateFlags.kFSEventStreamCreateFlagNone); // flags
FSEventStreamScheduleWithRunLoop(
m_stream, // streamRef
CFRunLoopGetMain(), // runLoop
kCFRunLoopDefaultMode); // runLoopMode
bool started = FSEventStreamStart(m_stream);
if (!started)
{
GC.SuppressFinalize(this);
throw new InvalidOperationException("Failed to start FSEvent stream for " + path);
}
ActiveObjects.Add(this);
Log.WriteLine(TraceLevel.Verbose, "App", "created the directory watcher");
}
public MacWatcher(string path)
{
Path = path;
m_callback = DoCallback;
NSString [] s = new NSString [1];
s [0] = new NSString(path);
NSArray path_p = NSArray.FromNSObjects(s);
m_stream = FSEventStreamCreate( // note that the stream will always be valid
IntPtr.Zero, // allocator
m_callback, // callback
IntPtr.Zero, // context
path_p.Handle, // pathsToWatch
kFSEventStreamEventIdSinceNow, // sinceWhen
2, // latency (in seconds)
FSEventStreamCreateFlags.kFSEventStreamCreateFlagNone); // flags
FSEventStreamScheduleWithRunLoop(
m_stream, // streamRef
CFRunLoopGetMain(), // runLoop
kCFRunLoopDefaultMode); // runLoopMode
bool started = FSEventStreamStart(m_stream);
if (!started)
{
GC.SuppressFinalize(this);
throw new InvalidOperationException("Failed to start FSEvent stream for " + path);
}
}
public SparkleMacWatcher (string path)
{
Path = path;
m_callback = DoCallback;
NSString [] s = new NSString [1];
s [0] = new NSString (path);
NSArray path_p = NSArray.FromNSObjects (s);
m_stream = FSEventStreamCreate ( // note that the stream will always be valid
IntPtr.Zero, // allocator
m_callback, // callback
IntPtr.Zero, // context
path_p.Handle, // pathsToWatch
kFSEventStreamEventIdSinceNow, // sinceWhen
2, // latency (in seconds)
FSEventStreamCreateFlags.kFSEventStreamCreateFlagNone); // flags
FSEventStreamScheduleWithRunLoop (
m_stream, // streamRef
CFRunLoopGetMain(), // runLoop
kCFRunLoopDefaultMode); // runLoopMode
bool started = FSEventStreamStart (m_stream);
if (!started) {
GC.SuppressFinalize (this);
throw new InvalidOperationException ("Failed to start FSEvent stream for " + path);
}
}
private static extern SafeEventStreamHandle FSEventStreamCreate(
IntPtr allocator,
FSEventStreamCallback cb,
IntPtr context,
SafeCreateHandle pathsToWatch,
FSEventStreamEventId sinceWhen,
CFTimeInterval latency,
FSEventStreamCreateFlags flags);
private extern static IntPtr FSEventStreamCreate(
IntPtr allocator,
FSEventStreamCallback callback,
IntPtr context,
IntPtr pathsToWatch,
ulong sinceWhen,
double latency,
FSEventStreamCreateFlags flags);
private static extern FSEventStreamRef FSEventStreamCreate(
IntPtr allocator,
FSEventStreamCallback cb,
IntPtr context,
CFArrayRef pathsToWatch,
FSEventStreamEventId sinceWhen,
CFTimeInterval latency,
FSEventStreamCreateFlags flags);
/// <summary>
/// Creates a new EventStream to listen to events from the core OS (such as File System events).
/// </summary>
/// <param name="cb">A callback instance that will be called for every event batch.</param>
/// <param name="pathsToWatch">A CFArray of the path(s) to watch for events.</param>
/// <param name="sinceWhen">
/// The start point to receive events from. This can be to retrieve historical events or only new events.
/// To get historical events, pass in the corresponding ID of the event you want to start from.
/// To get only new events, pass in kFSEventStreamEventIdSinceNow.
/// </param>
/// <param name="latency">Coalescing period to wait before sending events.</param>
/// <param name="flags">Flags to say what kind of events should be sent through this stream.</param>
/// <returns>On success, returns a valid SafeCreateHandle to an FSEventStream object; otherwise, returns an invalid SafeCreateHandle</returns>
internal static SafeEventStreamHandle FSEventStreamCreate(
FSEventStreamCallback cb,
SafeCreateHandle pathsToWatch,
FSEventStreamEventId sinceWhen,
CFTimeInterval latency,
FSEventStreamCreateFlags flags)
{
return(FSEventStreamCreate(IntPtr.Zero, cb, IntPtr.Zero, pathsToWatch, sinceWhen, latency, flags));
}
/// <summary>
/// Creates a new EventStream to listen to events from the core OS (such as File System events).
/// </summary>
/// <param name="cb">A callback instance that will be called for every event batch.</param>
/// <param name="pathsToWatch">A CFArray of the path(s) to watch for events.</param>
/// <param name="sinceWhen">
/// The start point to receive events from. This can be to retrieve historical events or only new events.
/// To get historical events, pass in the corresponding ID of the event you want to start from.
/// To get only new events, pass in kFSEventStreamEventIdSinceNow.
/// </param>
/// <param name="latency">Coalescing period to wait before sending events.</param>
/// <param name="flags">Flags to say what kind of events should be sent through this stream.</param>
/// <returns>On success, returns a pointer to an FSEventStream object; otherwise, returns IntPtr.Zero</returns>
public static FSEventStreamRef FSEventStreamCreate(
FSEventStreamCallback cb,
CFArrayRef pathsToWatch,
FSEventStreamEventId sinceWhen,
CFTimeInterval latency,
FSEventStreamCreateFlags flags)
{
return(FSEventStreamCreate(IntPtr.Zero, cb, IntPtr.Zero, pathsToWatch, sinceWhen, latency, flags));
}
public FileSystemWatcher ()
{
_callback = Callback;
var currentDirectory = System.IO.Directory.GetCurrentDirectory();
IntPtr path = CFStringCreateWithCString (IntPtr.Zero, currentDirectory, 0);
IntPtr paths = CFArrayCreate (IntPtr.Zero, new IntPtr [1] { path }, 1, IntPtr.Zero);
_stream = FSEventStreamCreate (IntPtr.Zero, _callback, IntPtr.Zero, paths, FSEventStreamEventIdSinceNow, 0, FSEventStreamCreateFlags.WatchRoot | FSEventStreamCreateFlags.FileEvents);
CFRelease (paths);
CFRelease (path);
_runLoop = new Thread (RunLoop);
_runLoop.Name = "FSEventStream";
_runLoop.Start ();
}
public QloudSyncFileSystemWatcher(LocalRepository repo)
{
this.repo = repo;
ignoreBag = new ArrayList();
//Passar no construtor o param repo.....
physicalController = new PhysicalRepositoryController (repo);
string watchedFolder = this.repo.Path;
this.callback = this.Callback;
IntPtr path = CFStringCreateWithCString (IntPtr.Zero, watchedFolder, 0);
IntPtr paths = CFArrayCreate (IntPtr.Zero, new IntPtr [1] { path }, 1, IntPtr.Zero);
stream = FSEventStreamCreate (IntPtr.Zero, this.callback, IntPtr.Zero, paths, FSEventStreamEventIdSinceNow, 0, FSEventStreamCreateFlags.WatchRoot | FSEventStreamCreateFlags.FileEvents);
CFRelease (paths);
CFRelease (path);
}
void FSEventStreamInit(CFAllocator allocator, ulong deviceToWatch, NSArray pathsToWatchRelativeToDevice,
ulong sinceWhen, TimeSpan latency, FSEventStreamCreateFlags flags)
{
if (pathsToWatchRelativeToDevice == null)
{
throw new ArgumentNullException(nameof(pathsToWatchRelativeToDevice));
}
eventsCallback = new FSEventStreamCallback(EventsCallback);
handle = FSEventStreamCreateRelativeToDevice(
allocator.GetHandle(),
eventsCallback, IntPtr.Zero, deviceToWatch, pathsToWatchRelativeToDevice.GetHandle(),
sinceWhen, latency.TotalSeconds, flags | (FSEventStreamCreateFlags)0x1);
if (handle == IntPtr.Zero)
{
throw new InvalidOperationException("Unable to create FSEventStream");
}
}
public FSEventStream(CFAllocator allocator, NSArray pathsToWatch,
ulong sinceWhenId, TimeSpan latency, FSEventStreamCreateFlags flags)
{
if (pathsToWatch == null)
{
throw new ArgumentNullException("pathsToWatch");
}
eventsCallback = new FSEventStreamCallback(EventsCallback);
handle = FSEventStreamCreate(
allocator == null ? IntPtr.Zero : allocator.Handle,
eventsCallback, IntPtr.Zero, pathsToWatch.Handle,
sinceWhenId, latency.TotalSeconds, flags | (FSEventStreamCreateFlags)0x1 /* UseCFTypes */);
if (handle == IntPtr.Zero)
{
throw new Exception("Unable to create FSEventStream");
}
}
static extern IntPtr FSEventStreamCreate(IntPtr allocator, FSEventStreamCallback callback, IntPtr context, IntPtr pathsToWatch, ulong sinceWhen, double latency, FSEventStreamCreateFlags flags);
public FSEventStream(CFAllocator allocator, NSArray pathsToWatch,
ulong sinceWhenId, TimeSpan latency, FSEventStreamCreateFlags flags)
{
if (pathsToWatch == null) {
throw new ArgumentNullException ("pathsToWatch");
}
eventsCallback = new FSEventStreamCallback (EventsCallback);
handle = FSEventStreamCreate (
allocator == null ? IntPtr.Zero : allocator.Handle,
eventsCallback, IntPtr.Zero, pathsToWatch.Handle,
sinceWhenId, latency.TotalSeconds, flags | (FSEventStreamCreateFlags)0x1 /* UseCFTypes */);
if (handle == IntPtr.Zero) {
throw new Exception ("Unable to create FSEventStream");
}
}
private static extern SafeEventStreamHandle FSEventStreamCreate(
IntPtr allocator,
FSEventStreamCallback cb,
IntPtr context,
SafeCreateHandle pathsToWatch,
FSEventStreamEventId sinceWhen,
CFTimeInterval latency,
FSEventStreamCreateFlags flags);
/// <summary>
/// Creates a new EventStream to listen to events from the core OS (such as File System events).
/// </summary>
/// <param name="cb">A callback instance that will be called for every event batch.</param>
/// <param name="pathsToWatch">A CFArray of the path(s) to watch for events.</param>
/// <param name="sinceWhen">
/// The start point to receive events from. This can be to retrieve historical events or only new events.
/// To get historical events, pass in the corresponding ID of the event you want to start from.
/// To get only new events, pass in kFSEventStreamEventIdSinceNow.
/// </param>
/// <param name="latency">Coalescing period to wait before sending events.</param>
/// <param name="flags">Flags to say what kind of events should be sent through this stream.</param>
/// <returns>On success, returns a valid SafeCreateHandle to an FSEventStream object; otherwise, returns an invalid SafeCreateHandle</returns>
internal static SafeEventStreamHandle FSEventStreamCreate(
FSEventStreamCallback cb,
SafeCreateHandle pathsToWatch,
FSEventStreamEventId sinceWhen,
CFTimeInterval latency,
FSEventStreamCreateFlags flags)
{
return FSEventStreamCreate(IntPtr.Zero, cb, IntPtr.Zero, pathsToWatch, sinceWhen, latency, flags);
}
static extern IntPtr FSEventStreamCreateRelativeToDevice(IntPtr allocator, FSEventStreamCallback callback,
IntPtr context, ulong deviceToWatch, IntPtr pathsToWatchRelativeToDevice,
ulong sinceWhen, double latency, FSEventStreamCreateFlags flags);
