/// <summary>
/// Constructs a new <see cref="TrackBass"/> from provided audio data.
/// </summary>
/// <param name="data">The sample data stream.</param>
/// <param name="quick">If true, the track will not be fully loaded, and should only be used for preview purposes. Defaults to false.</param>
public TrackBass(Stream data, bool quick = false)
{
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
// todo: support this internally to match the underlying Track implementation (which can support this).
const float tempo_minimum_supported = 0.05f;
AggregateTempo.ValueChanged += t =>
{
if (t.NewValue < tempo_minimum_supported)
{
throw new ArgumentException($"{nameof(TrackBass)} does not support {nameof(Tempo)} specifications below {tempo_minimum_supported}. Use {nameof(Frequency)} instead.");
}
};
EnqueueAction(() =>
{
Preview = quick;
activeStream = prepareStream(data, quick);
// will be -1 in case of an error
double seconds = Bass.ChannelBytes2Seconds(activeStream, byteLength = Bass.ChannelGetLength(activeStream));
bool success = seconds >= 0;
if (success)
{
Length = seconds * 1000;
// Bass does not allow seeking to the end of the track, so the last available position is 1 sample before.
lastSeekablePosition = Bass.ChannelBytes2Seconds(activeStream, byteLength - BYTES_PER_SAMPLE) * 1000;
Bass.ChannelGetAttribute(activeStream, ChannelAttribute.Frequency, out float frequency);
initialFrequency = frequency;
bitrate = (int)Bass.ChannelGetAttribute(activeStream, ChannelAttribute.Bitrate);
stopCallback = new SyncCallback((a, b, c, d) => RaiseFailed());
endCallback = new SyncCallback((a, b, c, d) =>
{
if (!Looping)
{
RaiseCompleted();
}
});
Bass.ChannelSetSync(activeStream, SyncFlags.Stop, 0, stopCallback.Callback, stopCallback.Handle);
Bass.ChannelSetSync(activeStream, SyncFlags.End, 0, endCallback.Callback, endCallback.Handle);
isLoaded = true;
bassAmplitudeProcessor?.SetChannel(activeStream);
}
});
InvalidateState();
}
protected override void Dispose(bool disposing)
{
if (activeStream != 0)
{
isRunning = false;
Bass.ChannelStop(activeStream);
Bass.StreamFree(activeStream);
}
activeStream = 0;
dataStream?.Dispose();
dataStream = null;
fileCallbacks?.Dispose();
fileCallbacks = null;
stopCallback?.Dispose();
stopCallback = null;
endCallback?.Dispose();
endCallback = null;
base.Dispose(disposing);
}
/// <summary>
/// 添加到队列中
/// </summary>
/// <param name="d">委托</param>
/// <param name="state">参数</param>
public void Enqueue(SendOrPostCallback d, object state)
{
var callBack = new SyncCallback(d, state);
this.quque.Enqueue(callBack);
this.resetEvent.Set();
}
public string SyncNow(TaskSyncProfile syncProfile, SyncMetric syncMetric, SyncCallback syncCallback)
{
try
{
if (syncProfile.GoogleSettings.GoogleAccount == null ||
syncProfile.GoogleSettings.GoogleCalendar == null ||
!syncProfile.ValidateOutlookSettings())
{
MessageService.ShowMessageAsync(
"Please configure Google and Outlook calendar in settings to continue.");
return("Invalid Settings");
}
ResetSyncData();
var isSyncComplete = TaskUpdateService.SyncTask(syncProfile, syncMetric, syncCallback);
return(isSyncComplete ? null : "Error Occurred");
}
catch (AggregateException exception)
{
var flattenException = exception.Flatten();
MessageService.ShowMessageAsync(flattenException.Message);
Logger.Error(exception);
return(flattenException.Message);
}
catch (Exception exception)
{
MessageService.ShowMessageAsync(exception.Message);
Logger.Error(exception);
return(exception.Message);
}
}
public void start(object param)
{
SyncCallback <T> callback = (SyncCallback <T>)param;
this.algorithm.start((iteration) =>
{
if (iteration % this.syncPeriod == 0)
{
callback(this);
}
});
}
void PacketDataSyncResponse(byte[] arguments)
{
SDataSync DataSync = CSerialization.Deserialize <SDataSync>(arguments);
foreach (SSyncCallback SyncCallback in SyncCallbacks)
{
if (SyncCallback.list == DataSync.list)
{
SyncCallback.callback(DataSync.type, DataSync.index, DataSync.data);
break;
}
}
}
public void testNoWatchesTriggeredForFailedMultiRequest()
{
HasTriggeredWatcher watcher = new HasTriggeredWatcher();
zk.getChildren("/", watcher);
try
{
zk.multi(Arrays.asList(Op.create("/t", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT), Op.delete("/nonexisting", -1)));
Assert.fail("expected previous multi op to fail!");
}
catch (KeeperException.NoNodeException)
{
// expected
}
SyncCallback cb = new SyncCallback();
zk.sync("/").ContinueWith(t => cb.processResult(1, null, null));
// by waiting for the callback we're assured that the event queue is flushed
cb.done.Wait(CONNECTION_TIMEOUT);
Assert.assertEquals(false, watcher.triggered.IsSet);
}
/// <summary>
/// Delete appointments in destination
/// </summary>
/// <param name="syncProfile"></param>
/// <param name="syncMetric"></param>
/// <param name="destinationCalendarSpecificData"></param>
/// <param name="syncCallback"></param>
/// <returns>
/// </returns>
private bool DeleteDestinationAppointments(CalendarSyncProfile syncProfile, SyncMetric syncMetric,
IDictionary <string, object> destinationCalendarSpecificData, SyncCallback syncCallback)
{
//Updating entry isDeleteOperation status
CalendarSyncStatus = StatusHelper.GetMessage(SyncStateEnum.Line);
CalendarSyncStatus = StatusHelper.GetMessage(SyncStateEnum.ReadingEntriesToDelete,
DestinationCalendarService.CalendarServiceName);
//Getting appointments to isDeleteOperation
CalendarSyncEngine.GetDestEntriesToDelete(syncProfile,
SourceAppointments, DestinationAppointments);
var appointmentsToDelete = CalendarSyncEngine.DestAppointmentsToDelete;
if (syncProfile.SyncMode == SyncModeEnum.OneWay && CalendarSyncEngine.DestOrphanEntries.Any())
{
if (syncProfile.SyncSettings.ConfirmOnDelete && syncCallback != null)
{
var orphanEntries = Environment.NewLine +
string.Join(Environment.NewLine, CalendarSyncEngine.DestOrphanEntries);
//Log Orphan Entries
Logger.Warn("Orphan entries to delete: " + orphanEntries);
var message =
$"Are you sure you want to delete {appointmentsToDelete.Count} orphan entries from {DestinationCalendarService.CalendarServiceName}?{orphanEntries}";
var e = new SyncEventArgs(message, UserActionEnum.ConfirmDelete);
var task = syncCallback(e);
if (task.Result)
{
appointmentsToDelete.AddRange(CalendarSyncEngine.DestOrphanEntries);
}
}
else
{
if (!syncProfile.SyncSettings.DisableDelete)
{
appointmentsToDelete.AddRange(CalendarSyncEngine.DestOrphanEntries);
}
else
{
CalendarSyncStatus = StatusHelper.GetMessage(SyncStateEnum.SkipDelete);
}
}
}
//Updating Get entry isDeleteOperation status
CalendarSyncStatus = StatusHelper.GetMessage(SyncStateEnum.EntriesToDelete, appointmentsToDelete.Count);
if (appointmentsToDelete.Count == 0)
{
CalendarSyncStatus = StatusHelper.GetMessage(SyncStateEnum.Line);
return(true);
}
//Updating isDeleteOperation status
CalendarSyncStatus = StatusHelper.GetMessage(SyncStateEnum.DeletingEntries,
DestinationCalendarService.CalendarServiceName);
//Deleting entries
var deletedAppointments =
DestinationCalendarService.DeleteCalendarEvents(appointmentsToDelete, destinationCalendarSpecificData)
.Result;
var isSuccess = deletedAppointments.IsSuccess;
//Update status if entries were successfully deleted
CalendarSyncStatus =
StatusHelper.GetMessage(isSuccess
? SyncStateEnum.DeletingEntriesComplete
: SyncStateEnum.DeletingEntriesFailed);
CalendarSyncStatus = StatusHelper.GetMessage(SyncStateEnum.Line);
if (isSuccess)
{
syncMetric.DestMetric.DeleteCount = appointmentsToDelete.Count;
syncMetric.DestMetric.DeleteFailedCount = appointmentsToDelete.Count - deletedAppointments.Count;
for (var index = 0; index < appointmentsToDelete.Count; index++)
{
DestinationAppointments.Remove(appointmentsToDelete[index]);
}
}
return(isSuccess);
}
public void AddVSyncCallback(SyncCallback vsync_callback)
{
m_vsync_callbacks += vsync_callback;
}
/// <summary>
/// Constructs a new <see cref="TrackBass"/> from provided audio data.
/// </summary>
/// <param name="data">The sample data stream.</param>
/// <param name="quick">If true, the track will not be fully loaded, and should only be used for preview purposes. Defaults to false.</param>
public TrackBass(Stream data, bool quick = false)
{
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
// todo: support this internally to match the underlying Track implementation (which can support this).
const float tempo_minimum_supported = 0.05f;
AggregateTempo.ValueChanged += t =>
{
if (t.NewValue < tempo_minimum_supported)
{
throw new ArgumentException($"{nameof(TrackBass)} does not support {nameof(Tempo)} specifications below {tempo_minimum_supported}. Use {nameof(Frequency)} instead.");
}
};
EnqueueAction(() =>
{
Preview = quick;
//encapsulate incoming stream with async buffer if it isn't already.
dataStream = data as AsyncBufferStream ?? new AsyncBufferStream(data, quick ? 8 : -1);
fileCallbacks = new FileCallbacks(new DataStreamFileProcedures(dataStream));
BassFlags flags = Preview ? 0 : BassFlags.Decode | BassFlags.Prescan;
activeStream = Bass.CreateStream(StreamSystem.NoBuffer, flags, fileCallbacks.Callbacks, fileCallbacks.Handle);
if (!Preview)
{
// We assign the BassFlags.Decode streams to the device "bass_nodevice" to prevent them from getting
// cleaned up during a Bass.Free call. This is necessary for seamless switching between audio devices.
// Further, we provide the flag BassFlags.FxFreeSource such that freeing the activeStream also frees
// all parent decoding streams.
const int bass_nodevice = 0x20000;
Bass.ChannelSetDevice(activeStream, bass_nodevice);
tempoAdjustStream = BassFx.TempoCreate(activeStream, BassFlags.Decode | BassFlags.FxFreeSource);
Bass.ChannelSetDevice(tempoAdjustStream, bass_nodevice);
activeStream = BassFx.ReverseCreate(tempoAdjustStream, 5f, BassFlags.Default | BassFlags.FxFreeSource);
Bass.ChannelSetAttribute(activeStream, ChannelAttribute.TempoUseQuickAlgorithm, 1);
Bass.ChannelSetAttribute(activeStream, ChannelAttribute.TempoOverlapMilliseconds, 4);
Bass.ChannelSetAttribute(activeStream, ChannelAttribute.TempoSequenceMilliseconds, 30);
}
// will be -1 in case of an error
double seconds = Bass.ChannelBytes2Seconds(activeStream, byteLength = Bass.ChannelGetLength(activeStream));
bool success = seconds >= 0;
if (success)
{
Length = seconds * 1000;
// Bass does not allow seeking to the end of the track, so the last available position is 1 sample before.
lastSeekablePosition = Bass.ChannelBytes2Seconds(activeStream, byteLength - BYTES_PER_SAMPLE) * 1000;
Bass.ChannelGetAttribute(activeStream, ChannelAttribute.Frequency, out float frequency);
initialFrequency = frequency;
bitrate = (int)Bass.ChannelGetAttribute(activeStream, ChannelAttribute.Bitrate);
stopCallback = new SyncCallback((a, b, c, d) => RaiseFailed());
endCallback = new SyncCallback((a, b, c, d) =>
{
if (!Looping)
{
RaiseCompleted();
}
});
Bass.ChannelSetSync(activeStream, SyncFlags.Stop, 0, stopCallback.Callback, stopCallback.Handle);
Bass.ChannelSetSync(activeStream, SyncFlags.End, 0, endCallback.Callback, endCallback.Handle);
isLoaded = true;
}
});
InvalidateState();
}
/// <summary>
/// Constructs a new <see cref="TrackBass"/> from provided audio data.
/// </summary>
/// <param name="data">The sample data stream.</param>
/// <param name="quick">If true, the track will not be fully loaded, and should only be used for preview purposes. Defaults to false.</param>
public TrackBass(Stream data, bool quick = false)
{
EnqueueAction(() =>
{
Preview = quick;
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
//encapsulate incoming stream with async buffer if it isn't already.
dataStream = data as AsyncBufferStream ?? new AsyncBufferStream(data, quick ? 8 : -1);
fileCallbacks = new FileCallbacks(new DataStreamFileProcedures(dataStream));
BassFlags flags = Preview ? 0 : BassFlags.Decode | BassFlags.Prescan;
activeStream = Bass.CreateStream(StreamSystem.NoBuffer, flags, fileCallbacks.Callbacks, fileCallbacks.Handle);
if (!Preview)
{
// We assign the BassFlags.Decode streams to the device "bass_nodevice" to prevent them from getting
// cleaned up during a Bass.Free call. This is necessary for seamless switching between audio devices.
// Further, we provide the flag BassFlags.FxFreeSource such that freeing the activeStream also frees
// all parent decoding streams.
const int bass_nodevice = 0x20000;
Bass.ChannelSetDevice(activeStream, bass_nodevice);
tempoAdjustStream = BassFx.TempoCreate(activeStream, BassFlags.Decode | BassFlags.FxFreeSource);
Bass.ChannelSetDevice(activeStream, bass_nodevice);
activeStream = BassFx.ReverseCreate(tempoAdjustStream, 5f, BassFlags.Default | BassFlags.FxFreeSource);
Bass.ChannelSetAttribute(activeStream, ChannelAttribute.TempoUseQuickAlgorithm, 1);
Bass.ChannelSetAttribute(activeStream, ChannelAttribute.TempoOverlapMilliseconds, 4);
Bass.ChannelSetAttribute(activeStream, ChannelAttribute.TempoSequenceMilliseconds, 30);
}
// will be -1 in case of an error
double seconds = Bass.ChannelBytes2Seconds(activeStream, Bass.ChannelGetLength(activeStream));
bool success = seconds >= 0;
if (success)
{
Length = seconds * 1000;
Bass.ChannelGetAttribute(activeStream, ChannelAttribute.Frequency, out float frequency);
initialFrequency = frequency;
bitrate = (int)Bass.ChannelGetAttribute(activeStream, ChannelAttribute.Bitrate);
stopCallback = new SyncCallback((a, b, c, d) => RaiseFailed());
endCallback = new SyncCallback((a, b, c, d) =>
{
if (!Looping)
{
RaiseCompleted();
}
});
Bass.ChannelSetSync(activeStream, SyncFlags.Stop, 0, stopCallback.Callback, stopCallback.Handle);
Bass.ChannelSetSync(activeStream, SyncFlags.End, 0, endCallback.Callback, endCallback.Handle);
isLoaded = true;
}
});
InvalidateState();
}
/// <summary>
/// Delete appointments from source
/// </summary>
/// <param name="syncProfile"></param>
/// <param name="sourceCalendarSpecificData"></param>
/// <param name="syncCallback"></param>
/// <returns>
/// </returns>
private bool DeleteSourceTasks(TaskSyncProfile syncProfile, SyncMetric syncMetric,
IDictionary <string, object> sourceCalendarSpecificData, SyncCallback syncCallback)
{
//if (syncProfile.SyncSettings.DisableDelete)
//{
// return true;
//}
//Updating entry isDeleteOperation status
TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.Line);
TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.ReadingEntriesToDelete,
SourceTaskService.TaskServiceName);
//Getting appointments to isDeleteOperation
TaskSyncEngine.GetSourceEntriesToDelete(syncProfile, SourceTasks, DestinationTasks);
var appointmentsToDelete = TaskSyncEngine.SourceTasksToDelete;
//Updating Get entry isDeleteOperation status
TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.EntriesToDelete, appointmentsToDelete.Count);
if (appointmentsToDelete.Count == 0)
{
TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.Line);
return(true);
}
//Updating isDeleteOperation status
TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.DeletingEntries,
SourceTaskService.TaskServiceName);
//Deleting entries
var deletedTasks =
SourceTaskService.DeleteReminderTasks(appointmentsToDelete, sourceCalendarSpecificData).Result;
var isSuccess = deletedTasks.IsSuccess;
//Update status if entries were successfully deleted
TaskSyncStatus =
StatusHelper.GetMessage(isSuccess
? SyncStateEnum.DeletingEntriesComplete
: SyncStateEnum.DeletingEntriesFailed);
TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.Line);
if (isSuccess)
{
syncMetric.SourceMetric.DeleteCount = appointmentsToDelete.Count;
syncMetric.SourceMetric.DeleteFailedCount = appointmentsToDelete.Count - deletedTasks.Count;
for (var index = 0; index < appointmentsToDelete.Count; index++)
{
SourceTasks.Remove(appointmentsToDelete[index]);
}
}
return(isSuccess);
}
public void SyncTasks(SyncCallback callback)
{
TaskListTaskCollection tmp = new TaskListTaskCollection(this);
if (!GetFlag(TaskListFlags.Smart))
{
tmp.Resync(() =>
{
mTasks = tmp;
OnPropertyChanged("Tasks");
OnPropertyChanged("Count");
callback();
});
}
else if (!IsFrozen && GetFlag(TaskListFlags.Smart))
{
// Resync all the time for smart lists...
//TODO: maybe use cache like normal lists, but for only a short time?
tmp.SmartResync(() =>
{
mTasks = tmp;
OnPropertyChanged("Tasks");
OnPropertyChanged("Count");
callback();
});
}
}
public string SyncNow(CalendarSyncProfile syncProfile, SyncMetric syncMetric, SyncCallback syncCallback)
{
try
{
if (syncProfile.GoogleAccount == null || syncProfile.GoogleAccount.GoogleCalendar == null ||
!syncProfile.ValidateOutlookSettings())
{
_messageService.ShowMessageAsync(
"Please configure Google and Outlook calendar in settings to continue.");
return "Invalid Settings";
}
ResetSyncData();
var isSyncComplete = _calendarUpdateService.SyncCalendar(syncProfile, syncMetric, syncCallback);
return isSyncComplete ? null : "Error Occurred";
}
catch (AggregateException exception)
{
var flattenException = exception.Flatten();
_messageService.ShowMessageAsync(flattenException.Message);
_applicationLogger.Error(exception);
return flattenException.Message;
}
catch (Exception exception)
{
_messageService.ShowMessageAsync(exception.Message);
_applicationLogger.Error(exception);
return exception.Message;
}
}
public void SyncEverything(SyncCallback callback)
{
/// This commented section is needed to sync EVERYTHING, but settings,
/// locations and contacts are not yet fully supported, so add them
/// to the uncommmented chain below as they are implemented.
/*
SyncUserSettings(() =>
{
SyncLocations(() =>
{
SyncContacts(() =>
{
SyncContactGroups(() =>
{
SyncTaskLists(() =>
{
CacheTasks(() =>
{
StartTimeline((timeline) =>
{
callback();
});
});
});
});
});
});
});*/
SyncLocations(() =>
{
CacheLists(() =>
{
CacheTasks(() =>
{
StartTimeline((timeline) =>
{
callback();
});
});
});
});
}
/// <summary>
/// Delete appointments in destination
/// </summary>
/// <param name="syncProfile"></param>
/// <param name="syncMetric"></param>
/// <param name="destinationCalendarSpecificData"></param>
/// <param name="syncCallback"></param>
/// <returns>
/// </returns>
private bool DeleteDestinationTasks(TaskSyncProfile syncProfile, SyncMetric syncMetric,
IDictionary<string, object> destinationCalendarSpecificData, SyncCallback syncCallback)
{
//if (syncProfile.SyncSettings.DisableDelete)
//{
// return true;
//}
//Updating entry isDeleteOperation status
TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.Line);
TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.ReadingEntriesToDelete,
DestinationTaskService.TaskServiceName);
//Getting appointments to isDeleteOperation
TaskSyncEngine.GetDestEntriesToDelete(syncProfile,
SourceTasks, DestinationTasks);
var appointmentsToDelete = TaskSyncEngine.DestTasksToDelete;
if (syncProfile.SyncMode == SyncModeEnum.OneWay)
{
//if (syncProfile.SyncSettings.ConfirmOnDelete && syncCallback != null)
//{
// var orphanEntries = Environment.NewLine +
// string.Join(Environment.NewLine, TaskSyncEngine.DestOrphanEntries);
// //Log Orphan Entries
// Logger.Warn("Orphan entries to delete: " + orphanEntries);
// var message = string.Format("Are you sure you want to delete {0} orphan entries from {1}?{2}",
// appointmentsToDelete.Count, DestinationTaskService.TaskServiceName,
// orphanEntries);
// var e = new SyncEventArgs(message, UserActionEnum.ConfirmDelete);
// var task = syncCallback(e);
// if (task.Result)
// {
// appointmentsToDelete.AddRange(TaskSyncEngine.DestOrphanEntries);
// }
//}
//else if (!syncProfile.SyncSettings.DisableDelete)
//{
// appointmentsToDelete.AddRange(TaskSyncEngine.DestOrphanEntries);
//}
}
//Updating Get entry isDeleteOperation status
TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.EntriesToDelete, appointmentsToDelete.Count);
if (appointmentsToDelete.Count == 0)
{
TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.Line);
return true;
}
//Updating isDeleteOperation status
TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.DeletingEntries,
DestinationTaskService.TaskServiceName);
//Deleting entries
var deletedTasks = DestinationTaskService.DeleteReminderTasks(appointmentsToDelete, destinationCalendarSpecificData)
.Result;
var isSuccess = deletedTasks.IsSuccess;
//Update status if entries were successfully deleted
TaskSyncStatus =
StatusHelper.GetMessage(isSuccess
? SyncStateEnum.DeletingEntriesComplete
: SyncStateEnum.DeletingEntriesFailed);
TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.Line);
if (isSuccess)
{
syncMetric.DestMetric.DeleteCount = appointmentsToDelete.Count;
syncMetric.DestMetric.DeleteFailedCount = appointmentsToDelete.Count - deletedTasks.Count;
for (var index = 0; index < appointmentsToDelete.Count; index++)
{
DestinationTasks.Remove(appointmentsToDelete[index]);
}
}
return isSuccess;
}
public void SyncTasks(SyncCallback callback)
{
TaskListTaskCollection tmp = new TaskListTaskCollection(this);
if (IsSmart == true)
{
tmp.SmartResync(() =>
{
mTasks = tmp;
OnPropertyChanged("Tasks");
OnPropertyChanged("Count");
callback();
});
}
else
{
tmp.Resync(() =>
{
mTasks = tmp;
OnPropertyChanged("Tasks");
OnPropertyChanged("Count");
callback();
});
}
}
public void SyncContactGroups(SyncCallback callback)
{
ContactGroupCollection tmp = new ContactGroupCollection(this);
tmp.Resync(() =>
{
System.Threading.Interlocked.Exchange(ref mContactGroups, tmp);
callback();
});
}
/// <summary>
/// Delete appointments in destination
/// </summary>
/// <param name="syncProfile"></param>
/// <param name="syncMetric"></param>
/// <param name="destinationCalendarSpecificData"></param>
/// <param name="syncCallback"></param>
/// <returns>
/// </returns>
private bool DeleteDestinationTasks(TaskSyncProfile syncProfile, SyncMetric syncMetric,
IDictionary <string, object> destinationCalendarSpecificData, SyncCallback syncCallback)
{
//if (syncProfile.SyncSettings.DisableDelete)
//{
// return true;
//}
//Updating entry isDeleteOperation status
TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.Line);
TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.ReadingEntriesToDelete,
DestinationTaskService.TaskServiceName);
//Getting appointments to isDeleteOperation
TaskSyncEngine.GetDestEntriesToDelete(syncProfile,
SourceTasks, DestinationTasks);
var appointmentsToDelete = TaskSyncEngine.DestTasksToDelete;
if (syncProfile.SyncMode == SyncModeEnum.OneWay)
{
//if (syncProfile.SyncSettings.ConfirmOnDelete && syncCallback != null)
//{
// var orphanEntries = Environment.NewLine +
// string.Join(Environment.NewLine, TaskSyncEngine.DestOrphanEntries);
// //Log Orphan Entries
// Logger.Warn("Orphan entries to delete: " + orphanEntries);
// var message = string.Format("Are you sure you want to delete {0} orphan entries from {1}?{2}",
// appointmentsToDelete.Count, DestinationTaskService.TaskServiceName,
// orphanEntries);
// var e = new SyncEventArgs(message, UserActionEnum.ConfirmDelete);
// var task = syncCallback(e);
// if (task.Result)
// {
// appointmentsToDelete.AddRange(TaskSyncEngine.DestOrphanEntries);
// }
//}
//else if (!syncProfile.SyncSettings.DisableDelete)
//{
// appointmentsToDelete.AddRange(TaskSyncEngine.DestOrphanEntries);
//}
}
//Updating Get entry isDeleteOperation status
TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.EntriesToDelete, appointmentsToDelete.Count);
if (appointmentsToDelete.Count == 0)
{
TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.Line);
return(true);
}
//Updating isDeleteOperation status
TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.DeletingEntries,
DestinationTaskService.TaskServiceName);
//Deleting entries
var deletedTasks = DestinationTaskService.DeleteReminderTasks(appointmentsToDelete, destinationCalendarSpecificData)
.Result;
var isSuccess = deletedTasks.IsSuccess;
//Update status if entries were successfully deleted
TaskSyncStatus =
StatusHelper.GetMessage(isSuccess
? SyncStateEnum.DeletingEntriesComplete
: SyncStateEnum.DeletingEntriesFailed);
TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.Line);
if (isSuccess)
{
syncMetric.DestMetric.DeleteCount = appointmentsToDelete.Count;
syncMetric.DestMetric.DeleteFailedCount = appointmentsToDelete.Count - deletedTasks.Count;
for (var index = 0; index < appointmentsToDelete.Count; index++)
{
DestinationTasks.Remove(appointmentsToDelete[index]);
}
}
return(isSuccess);
}
/// <summary>
/// Delete appointments in destination
/// </summary>
/// <param name="syncProfile"></param>
/// <param name="syncMetric"></param>
/// <param name="destinationCalendarSpecificData"></param>
/// <param name="syncCallback"></param>
/// <returns>
/// </returns>
private bool DeleteDestinationAppointments(CalendarSyncProfile syncProfile, SyncMetric syncMetric,
IDictionary<string, object> destinationCalendarSpecificData, SyncCallback syncCallback)
{
//Updating entry isDeleteOperation status
CalendarSyncStatus = StatusHelper.GetMessage(SyncStateEnum.Line);
CalendarSyncStatus = StatusHelper.GetMessage(SyncStateEnum.ReadingEntriesToDelete,
DestinationCalendarService.CalendarServiceName);
//Getting appointments to isDeleteOperation
CalendarSyncEngine.GetDestEntriesToDelete(syncProfile,
SourceAppointments, DestinationAppointments);
var appointmentsToDelete = CalendarSyncEngine.DestAppointmentsToDelete;
if (syncProfile.SyncMode == SyncModeEnum.OneWay && CalendarSyncEngine.DestOrphanEntries.Any())
{
if (syncProfile.SyncSettings.ConfirmOnDelete && syncCallback != null)
{
var orphanEntries = Environment.NewLine +
string.Join(Environment.NewLine, CalendarSyncEngine.DestOrphanEntries);
//Log Orphan Entries
Logger.Warn("Orphan entries to delete: " + orphanEntries);
var message =
$"Are you sure you want to delete {appointmentsToDelete.Count} orphan entries from {DestinationCalendarService.CalendarServiceName}?{orphanEntries}";
var e = new SyncEventArgs(message, UserActionEnum.ConfirmDelete);
var task = syncCallback(e);
if (task.Result)
{
appointmentsToDelete.AddRange(CalendarSyncEngine.DestOrphanEntries);
}
}
else
{
if (!syncProfile.SyncSettings.DisableDelete)
{
appointmentsToDelete.AddRange(CalendarSyncEngine.DestOrphanEntries);
}
else
{
CalendarSyncStatus = StatusHelper.GetMessage(SyncStateEnum.SkipDelete);
}
}
}
//Updating Get entry isDeleteOperation status
CalendarSyncStatus = StatusHelper.GetMessage(SyncStateEnum.EntriesToDelete, appointmentsToDelete.Count);
if (appointmentsToDelete.Count == 0)
{
CalendarSyncStatus = StatusHelper.GetMessage(SyncStateEnum.Line);
return true;
}
//Updating isDeleteOperation status
CalendarSyncStatus = StatusHelper.GetMessage(SyncStateEnum.DeletingEntries,
DestinationCalendarService.CalendarServiceName);
//Deleting entries
var deletedAppointments = DestinationCalendarService.DeleteCalendarEvents(appointmentsToDelete, destinationCalendarSpecificData)
.Result;
var isSuccess = deletedAppointments.IsSuccess;
//Update status if entries were successfully deleted
CalendarSyncStatus =
StatusHelper.GetMessage(isSuccess
? SyncStateEnum.DeletingEntriesComplete
: SyncStateEnum.DeletingEntriesFailed);
CalendarSyncStatus = StatusHelper.GetMessage(SyncStateEnum.Line);
if (isSuccess)
{
syncMetric.DestMetric.DeleteCount = appointmentsToDelete.Count;
syncMetric.DestMetric.DeleteFailedCount = appointmentsToDelete.Count - deletedAppointments.Count;
for (var index = 0; index < appointmentsToDelete.Count; index++)
{
DestinationAppointments.Remove(appointmentsToDelete[index]);
}
}
return isSuccess;
}
public bool SyncTask(TaskSyncProfile syncProfile, SyncMetric syncMetric, SyncCallback syncCallback)
{
InitiatePreSyncSetup(syncProfile);
var isSuccess = false;
if (syncProfile != null)
{
TaskSyncEngine.Clear();
//Add log for sync mode
TaskSyncStatus = string.Format("Calendar Sync : {0} {2} {1}", SourceTaskService.TaskServiceName,
DestinationTaskService.TaskServiceName,
syncProfile.SyncMode == SyncModeEnum.TwoWay ? "<===>" : "===>");
TaskSyncStatus = StatusHelper.GetMessage(SyncStateEnum.Line);
DateTime startDate, endDate;
GetDateRange(syncProfile, out startDate, out endDate);
//Add log for date range
TaskSyncStatus = $"Date Range : {startDate.ToString("d")} - {endDate.ToString("d")}";
//Load calendar specific data
var sourceCalendarSpecificData =
GetCalendarSpecificData(syncProfile.Source, syncProfile);
var destinationCalendarSpecificData =
GetCalendarSpecificData(syncProfile.Destination, syncProfile);
//Get source and destination Tasks
isSuccess = LoadTasks(sourceCalendarSpecificData,
destinationCalendarSpecificData);
if (isSuccess)
{
syncMetric.SourceMetric.OriginalCount = SourceTasks.Count;
syncMetric.DestMetric.OriginalCount = DestinationTasks.Count;
//LoadSourceId(DestinationTasks, SourceTasks.TaskListId);
//LoadSourceId(SourceTasks, DestinationTasks.TaskListId);
}
if (isSuccess)
{
//Delete destination Tasks
isSuccess = DeleteDestinationTasks(syncProfile, syncMetric, destinationCalendarSpecificData, syncCallback);
}
if (isSuccess)
{
//Add Tasks to destination
isSuccess = AddDestinationTasks(syncProfile, syncMetric, destinationCalendarSpecificData);
}
if (isSuccess && syncProfile.SyncMode == SyncModeEnum.TwoWay)
{
//Delete destination appointments
isSuccess = DeleteSourceTasks(syncProfile, syncMetric, sourceCalendarSpecificData, syncCallback);
if (isSuccess)
{
//If sync mode is two way... add events to source
isSuccess = AddSourceTasks(syncProfile, syncMetric, sourceCalendarSpecificData);
}
}
if (isSuccess)
{
isSuccess = UpdateEntries(syncProfile, syncMetric, sourceCalendarSpecificData, destinationCalendarSpecificData);
}
}
syncMetric.IsSuccess = isSuccess;
SourceTasks = null;
DestinationTasks = null;
SourceTaskService = null;
DestinationTaskService = null;
return(isSuccess);
}
public bool SyncCalendar(CalendarSyncProfile syncProfile, SyncMetric syncMetric, SyncCallback syncCallback)
{
InitiatePreSyncSetup(syncProfile);
var isSuccess = false;
if (syncProfile != null)
{
CalendarSyncEngine.Clear();
//Add log for sync mode
CalendarSyncStatus = string.Format("Calendar Sync : {0} {2} {1}", SourceCalendarService.CalendarServiceName,
DestinationCalendarService.CalendarServiceName,
syncProfile.SyncMode == SyncModeEnum.TwoWay ? "<===>" : "===>");
CalendarSyncStatus = StatusHelper.GetMessage(SyncStateEnum.Line);
DateTime startDate, endDate;
GetDateRange(syncProfile, out startDate, out endDate);
//Add log for date range
CalendarSyncStatus = $"Date Range : {startDate.ToString("d")} - {endDate.ToString("d")}";
//Load calendar specific data
var sourceCalendarSpecificData =
GetCalendarSpecificData(syncProfile.Source, syncProfile);
var destinationCalendarSpecificData =
GetCalendarSpecificData(syncProfile.Destination, syncProfile);
//Get source and destination appointments
isSuccess = LoadAppointments(startDate, endDate, syncProfile.SyncSettings.SkipPrivateEntries,
sourceCalendarSpecificData,
destinationCalendarSpecificData);
if (isSuccess)
{
syncMetric.SourceMetric.OriginalCount = SourceAppointments.Count;
syncMetric.DestMetric.OriginalCount = DestinationAppointments.Count;
LoadSourceId(DestinationAppointments, SourceAppointments.CalendarId);
LoadSourceId(SourceAppointments, DestinationAppointments.CalendarId);
}
if (isSuccess)
{
//Delete destination appointments
isSuccess = DeleteDestinationAppointments(syncProfile, syncMetric, destinationCalendarSpecificData, syncCallback);
}
if (isSuccess)
{
//Add appointments to destination
isSuccess = AddDestinationAppointments(syncProfile, syncMetric, destinationCalendarSpecificData);
}
if (isSuccess && syncProfile.SyncMode == SyncModeEnum.TwoWay)
{
//Delete destination appointments
isSuccess = DeleteSourceAppointments(syncProfile, syncMetric, sourceCalendarSpecificData, syncCallback);
if (isSuccess)
{
//If sync mode is two way... add events to source
isSuccess = AddSourceAppointments(syncProfile, syncMetric, sourceCalendarSpecificData);
}
}
if (isSuccess)
{
isSuccess = UpdateEntries(syncProfile, syncMetric, sourceCalendarSpecificData, destinationCalendarSpecificData);
}
}
syncMetric.IsSuccess = isSuccess;
SourceAppointments = null;
DestinationAppointments = null;
SourceCalendarService = null;
DestinationCalendarService = null;
return isSuccess;
}
public void SyncEverything(SyncCallback callback)
{
SyncUserSettings(() =>
{
CacheLocations(() =>
{
CacheLists(() =>
{
CacheTasks(() =>
{
StartTimeline((timeline) =>
{
callback();
});
});
});
});
});
}
/// <summary>
/// Constructs a new <see cref="TrackBass"/> from provided audio data.
/// </summary>
/// <param name="data">The sample data stream.</param>
/// <param name="quick">If true, the track will not be fully loaded, and should only be used for preview purposes. Defaults to false.</param>
public TrackBass(Stream data, bool quick = false)
{
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
relativeFrequencyHandler = new BassRelativeFrequencyHandler
{
FrequencyChangedToZero = () => stopInternal(),
FrequencyChangedFromZero = () =>
{
// Do not resume the track if a play wasn't requested at all or has been paused via Stop().
if (!isPlayed)
{
return;
}
startInternal();
}
};
// todo: support this internally to match the underlying Track implementation (which can support this).
const float tempo_minimum_supported = 0.05f;
AggregateTempo.ValueChanged += t =>
{
if (t.NewValue < tempo_minimum_supported)
{
throw new ArgumentException($"{nameof(TrackBass)} does not support {nameof(Tempo)} specifications below {tempo_minimum_supported}. Use {nameof(Frequency)} instead.");
}
};
EnqueueAction(() =>
{
Preview = quick;
activeStream = prepareStream(data, quick);
long byteLength = Bass.ChannelGetLength(activeStream);
// will be -1 in case of an error
double seconds = Bass.ChannelBytes2Seconds(activeStream, byteLength);
bool success = seconds >= 0;
if (success)
{
Length = seconds * 1000;
// Bass does not allow seeking to the end of the track, so the last available position is 1 sample before.
lastSeekablePosition = Bass.ChannelBytes2Seconds(activeStream, byteLength - BYTES_PER_SAMPLE) * 1000;
bitrate = (int)Bass.ChannelGetAttribute(activeStream, ChannelAttribute.Bitrate);
stopCallback = new SyncCallback((a, b, c, d) => RaiseFailed());
endCallback = new SyncCallback((a, b, c, d) =>
{
if (Looping)
{
return;
}
hasCompleted = true;
RaiseCompleted();
});
endMixtimeCallback = new SyncCallback((a, b, c, d) =>
{
// this is separate from the above callback as this is required to be invoked on mixtime.
// see "BASS_SYNC_MIXTIME" part of http://www.un4seen.com/doc/#bass/BASS_ChannelSetSync.html for reason why.
if (Looping)
{
seekInternal(RestartPoint);
}
});
Bass.ChannelSetSync(activeStream, SyncFlags.Stop, 0, stopCallback.Callback, stopCallback.Handle);
Bass.ChannelSetSync(activeStream, SyncFlags.End, 0, endCallback.Callback, endCallback.Handle);
Bass.ChannelSetSync(activeStream, SyncFlags.End | SyncFlags.Mixtime, 0, endMixtimeCallback.Callback, endMixtimeCallback.Handle);
isLoaded = true;
relativeFrequencyHandler.SetChannel(activeStream);
bassAmplitudeProcessor?.SetChannel(activeStream);
}
});
InvalidateState();
}
/// <summary>
/// Delete appointments from source
/// </summary>
/// <param name="syncProfile"></param>
/// <param name="sourceCalendarSpecificData"></param>
/// <param name="syncCallback"></param>
/// <returns>
/// </returns>
private bool DeleteSourceAppointments(CalendarSyncProfile syncProfile, SyncMetric syncMetric,
IDictionary<string, object> sourceCalendarSpecificData, SyncCallback syncCallback)
{
//Updating entry isDeleteOperation status
CalendarSyncStatus = StatusHelper.GetMessage(SyncStateEnum.Line);
CalendarSyncStatus = StatusHelper.GetMessage(SyncStateEnum.ReadingEntriesToDelete,
SourceCalendarService.CalendarServiceName);
//Getting appointments to isDeleteOperation
CalendarSyncEngine.GetSourceEntriesToDelete(syncProfile, SourceAppointments, DestinationAppointments);
var appointmentsToDelete = CalendarSyncEngine.SourceAppointmentsToDelete;
//Updating Get entry isDeleteOperation status
CalendarSyncStatus = StatusHelper.GetMessage(SyncStateEnum.EntriesToDelete, appointmentsToDelete.Count);
if (appointmentsToDelete.Count == 0)
{
CalendarSyncStatus = StatusHelper.GetMessage(SyncStateEnum.Line);
return true;
}
//Updating isDeleteOperation status
CalendarSyncStatus = StatusHelper.GetMessage(SyncStateEnum.DeletingEntries,
SourceCalendarService.CalendarServiceName);
//Deleting entries
var deletedAppointments =
SourceCalendarService.DeleteCalendarEvents(appointmentsToDelete, sourceCalendarSpecificData).Result;
var isSuccess = deletedAppointments.IsSuccess;
//Update status if entries were successfully deleted
CalendarSyncStatus =
StatusHelper.GetMessage(isSuccess
? SyncStateEnum.DeletingEntriesComplete
: SyncStateEnum.DeletingEntriesFailed);
CalendarSyncStatus = StatusHelper.GetMessage(SyncStateEnum.Line);
if (isSuccess)
{
syncMetric.SourceMetric.DeleteCount = appointmentsToDelete.Count;
syncMetric.SourceMetric.DeleteFailedCount = appointmentsToDelete.Count - deletedAppointments.Count;
for (var index = 0; index < appointmentsToDelete.Count; index++)
{
SourceAppointments.Remove(appointmentsToDelete[index]);
}
}
return isSuccess;
}
public void SyncLocations(SyncCallback callback)
{
LocationCollection tmp = new LocationCollection(this);
tmp.Resync(() =>
{
System.Threading.Interlocked.Exchange(ref mLocations, tmp);
callback();
});
}
public void SyncTaskLists(SyncCallback callback)
{
TaskListCollection tmp = new TaskListCollection(this);
tmp.Resync(() =>
{
System.Threading.Interlocked.Exchange(ref mTaskLists, tmp);
callback();
});
}
public void SyncUserSettings(SyncCallback callback)
{
GetResponse("rtm.settings.getList", (response) =>
{
UserSettings tmp = new UserSettings(response.Settings);
System.Threading.Interlocked.Exchange(ref mUserSettings, tmp);
callback();
});
}
public bool SyncContact(ContactSyncProfile syncProfile, SyncMetric syncMetric, SyncCallback syncCallback)
{
throw new NotImplementedException();
}
public void AddHSyncCallback(SyncCallback hsync_callback)
{
m_hsync_callbacks += hsync_callback;
}
