/// <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; }