public IAsyncOperation<String> CreateOnServerAsync(SyncManager syncManager, String objectType,
IDictionary<String, Object> fields)
{
var manager = JsonConvert.SerializeObject(syncManager);
var fieldList = new Dictionary<String, Object>(fields);
return Task.Run(async() => await _syncUpTarget.CreateOnServerAsync(JsonConvert.DeserializeObject<SDK.SmartSync.Manager.SyncManager>(manager), objectType, fieldList)).AsAsyncOperation();
}
public string ContinueFetch(SyncManager syncManager)
{
var manager = JsonConvert.SerializeObject(syncManager);
var target = Task.Run(async () => await _soqlSyncDownTarget.ContinueFetch(JsonConvert.DeserializeObject<SDK.SmartSync.Manager.SyncManager>(manager))).AsAsyncOperation();
var array = target.GetResults();
return array.ToString();
}
public EmdatProcessor(SyncManager syncManager)
: base(syncManager)
{
// redirect python stdin/stdout
engine.Runtime.IO.SetOutput(Console.OpenStandardOutput(), Console.OutputEncoding);
engine.Runtime.IO.SetErrorOutput(Console.OpenStandardError(), Console.OutputEncoding);
// set module search paths
string scriptDir = Path.GetDirectoryName("C:\\Documents and Settings\\Admin\\My Documents\\Visual Studio 2008\\Projects\\ATUAV_RT\\RealTimeProcessing\\emdat.py");
string emdatDir = Path.GetDirectoryName("C:\\Documents and Settings\\Admin\\My Documents\\Visual Studio 2008\\Projects\\ATUAV_RT\\RealTimeProcessing\\EMDAT\\src\\");
string pythonDir = Path.GetDirectoryName("C:\\Python26\\Lib\\");
ICollection<string> paths = engine.GetSearchPaths();
if (!String.IsNullOrEmpty(scriptDir))
{
paths.Add(scriptDir);
paths.Add(emdatDir);
paths.Add(pythonDir);
}
else
{
paths.Add(Environment.CurrentDirectory);
}
engine.SetSearchPaths(paths);
// import modules
emdat = engine.ImportModule("emdat");
// add conditions
Condition showText = new ShowText(this);
conditions.Add(showText.Id, showText);
Condition showIntervention = new ShowIntervention(this);
conditions.Add(showIntervention.Id, showIntervention);
}
/// <summary>
/// Creates the option button.
/// </summary>
/// <param name="manager">The manager.</param>
public static void CreateButtons(SyncManager manager)
{
RemoveButtons();
syncManager = manager;
var missing = Type.Missing;
var menubar = ApplicationData.Application.ActiveExplorer().CommandBars.ActiveMenuBar;
var newMenuBar = (CommandBarPopup)menubar.Controls.Add(MsoControlType.msoControlPopup, missing, missing, missing, false);
if (newMenuBar != null)
{
newMenuBar.Caption = "GoogleSync";
newMenuBar.Tag = "GoogleSync";
syncButton = (CommandBarButton)newMenuBar.Controls.Add(MsoControlType.msoControlButton, missing, missing, 1, true);
syncButton.Style = MsoButtonStyle.msoButtonCaption;
syncButton.Caption = "Sync now!";
syncButton.Click += syncButton_Click;
optionsButton = (CommandBarButton)newMenuBar.Controls.Add(MsoControlType.msoControlButton, missing, missing, missing, true);
optionsButton.Style = MsoButtonStyle.msoButtonCaption;
optionsButton.Caption = "Options";
optionsButton.Click += optionsButton_Click;
newMenuBar.Visible = true;
}
}
static void EyetrackerFound(object sender, EyetrackerInfoEventArgs e)
{
EyetrackerConnector connector = new EyetrackerConnector(e.EyetrackerInfo);
connector.Connect();
// sync CPU and Eyetracker clocks
SyncManager syncManager = new SyncManager(clock, e.EyetrackerInfo, EventThreadingOptions.BackgroundThread);
// detect fixations
GazeDataFixationHandler fixations = new GazeDataFixationHandler(syncManager);
connector.Eyetracker.GazeDataReceived += fixations.GazeDataReceived;
/*/ print each event to console
GazeDataConsolePrintHandler printer = new GazeDataConsolePrintHandler(syncManager);
//connector.Eyetracker.GazeDataReceived += printer.GazeDataReceived;
fixations.FixationDetector.FixationEnd += printer.FixationEnd;*/
// windowed print to console
GazeDataWindowingPrintHandler printer = new GazeDataWindowingPrintHandler(syncManager);
//connector.Eyetracker.GazeDataReceived += printer.GazeDataReceived;
fixations.FixationDetector.FixationEnd += printer.FixationEnd;
printer.StartWindow();
while (true)
{
Thread.Sleep(3000);
printer.RenewWindow(true);
}
}
public static async Task TestSetup(TestContext context)
{
var settings = new EncryptionSettings(new HmacSHA256KeyGenerator());
Encryptor.init(settings);
var options = new LoginOptions(TestCredentials.LoginUrl, TestCredentials.ClientId, TestCallbackUrl, "mobile",
TestScopes);
var response = new AuthResponse
{
RefreshToken = TestCredentials.RefreshToken,
AccessToken = TestAuthToken,
InstanceUrl = TestCredentials.InstanceUrl,
IdentityUrl = TestCredentials.IdentityUrl,
Scopes = TestScopes,
};
Account account = await AccountManager.CreateNewAccount(options, response);
account.UserId = TestCredentials.UserId;
account.UserName = TestCredentials.Username;
await OAuth2.RefreshAuthToken(account);
_smartStore = SmartStore.GetGlobalSmartStore();
_smartStore.ResetDatabase();
_syncManager = SyncManager.GetInstance();
_restClient = new RestClient(account.InstanceUrl, account.AccessToken,
async () =>
{
account = AccountManager.GetAccount();
AuthResponse authResponse =
await OAuth2.RefreshAuthTokenRequest(account.GetLoginOptions(), account.RefreshToken);
account.AccessToken = authResponse.AccessToken;
return account.AccessToken;
}
);
CreateAccountsSoup();
_idToNames = await CreateTestAccountsOnServer(CountTestAccounts);
}
public string StartFetch(SyncManager syncManager, long maxTimeStamp)
{
var manager = JsonConvert.SerializeObject(syncManager);
var target = Task.Run(async () => await _mruSyncDownTarget.StartFetch(JsonConvert.DeserializeObject<SDK.SmartSync.Manager.SyncManager>(manager),
maxTimeStamp)).AsAsyncOperation();
var array = target.GetResults();
return array.ToString();
}
public ContactSyncViewModel()
{
Account account = AccountManager.GetAccount();
if (account == null) return;
_store = SmartStore.GetSmartStore(account);
_syncManager = SyncManager.GetInstance(account);
Contacts = new SortedObservableCollection<ContactObject>();
FilteredContacts = new SortedObservableCollection<ContactObject>();
IndexReference = new ObservableCollection<string>();
}
public IAsyncOperation<bool> DeleteOnServer(SyncManager syncManager, String objectType, String objectId)
{
var manager = JsonConvert.SerializeObject(syncManager);
return
Task.Run(
async () =>
await
_syncUpTarget.DeleteOnServer(
JsonConvert.DeserializeObject<SDK.SmartSync.Manager.SyncManager>(manager), objectType,
objectId)).AsAsyncOperation();
}
public override async Task<JArray> StartFetch(SyncManager syncManager, long maxTimeStamp)
{
string queryToRun = maxTimeStamp > 0 ? AddFilterForReSync(Query, maxTimeStamp) : Query;
await syncManager.SendRestRequest(RestRequest.GetRequestForResources("v33.0"));
// cheap call to refresh session
RestRequest request = BuildQueryRequest(syncManager.RestClient.AccessToken, queryToRun);
RestResponse response = await syncManager.SendRestRequest(request);
JArray records = ParseSoapResponse(response);
return records;
}
public override async Task<JArray> StartFetch(SyncManager syncManager, long maxTimeStamp)
{
var request = RestRequest.GetRequestForSearch(syncManager.ApiVersion, Query);
var response = await syncManager.SendRestRequest(request);
var records = response.AsJArray;
// Recording total size
TotalSize = records.Count;
return records;
}
public override async Task <JArray> StartFetch(SyncManager syncManager, long maxTimeStamp)
{
string queryToRun = maxTimeStamp > 0 ? AddFilterForReSync(Query, maxTimeStamp) : Query;
await syncManager.SendRestRequest(RestRequest.GetRequestForResources("v33.0"));
// cheap call to refresh session
RestRequest request = BuildQueryRequest(syncManager.RestClient.AccessToken, queryToRun);
RestResponse response = await syncManager.SendRestRequest(request);
JArray records = ParseSoapResponse(response);
return(records);
}
protected override void InitializeInner()
{
_grpsServer = new Server
{
Services =
{
SyncManager.BindService(new SyncManagerImpl(_synchronizationContext, _chainDataServicesManager, _hashCalculationsRepository, _log)),
TransactionalChainManager.BindService(new TransactionalChainManagerImpl(_chainDataServicesManager, _identityKeyProvidersRegistry, _hashCalculationsRepository, _log))
},
Ports = { { _host, _interactionConfiguration.Port, ServerCredentials.Insecure } }
};
}
public void EmitsSyncingWhenStartingFullSync()
{
SyncProgress?progressAfterFullSync = null;
Queue.Dequeue().Returns(Pull);
SyncManager.ForceFullSync();
SyncManager.ProgressObservable.Subscribe(
progress => progressAfterFullSync = progress);
progressAfterFullSync.Should().NotBeNull();
progressAfterFullSync.Should().Be(SyncProgress.Syncing);
}
public void EmitsSyncingWhenStartingPush()
{
SyncProgress?progressAfterPushing = null;
Queue.Dequeue().Returns(Push);
SyncManager.PushSync();
SyncManager.ProgressObservable.Subscribe(
progress => progressAfterPushing = progress);
progressAfterPushing.Should().NotBeNull();
progressAfterPushing.Should().Be(SyncProgress.Syncing);
}
public async Task TracksIfSyncFails(PushNotificationSyncSourceState sourceState)
{
var exception = new Exception();
SyncManager.ForceFullSync().Returns(Observable.Throw <SyncState>(exception));
var interactor = CreateSyncInteractor(sourceState);
await interactor.Execute().SingleAsync();
AnalyticsService.PushNotificationSyncStarted.Received().Track(sourceState.ToString());
AnalyticsService.PushNotificationSyncFinished.Received().Track(sourceState.ToString());
AnalyticsService.PushNotificationSyncFailed.Received().Track(sourceState.ToString(), exception.GetType().FullName, exception.Message, exception.StackTrace);
}
public void EditSettings(SyncManager _syncMgr)
{
syncMgr = _syncMgr;
LoadSettings();
this.ShowDialog();
if (bIsOK)
{
SaveSettings();
}
}
public async Task<String> CreateOnServerAsync(SyncManager syncManager, String objectType, Dictionary<String, Object> fields)
{
JToken id;
var request = RestRequest.GetRequestForCreate(syncManager.ApiVersion, objectType, fields);
var response = await syncManager.SendRestRequest(request);
var responseObject = response.AsJObject;
responseObject.TryGetValue(Constants.Lid, out id);
if (id != null)
{
return response.Success ? id.ToString() : null;
}
return null;
}
public async Task InitiatesPushSync()
{
var preferences = new MockPreferences();
PreferencesSubject.OnNext(preferences);
var observable = Observable.Return(preferences);
InteractorFactory.UpdatePreferences(Arg.Any <EditPreferencesDTO>()).Execute().Returns(observable);
ViewModel.ToggleTwentyFourHourSettings.Execute();
TestScheduler.Start();
SyncManager.Received().PushSync();
}
private void SyncWithServerAsync(ApplicationUser user)
{
CurrentUser = _context.Users.SingleOrDefault(u => u.Id.Equals(user.Id));
if (CurrentUser.AutSync && DoIHaveInternet() &&
((int)GetValueFromProperties(StoreKeys.AppMode) == 0))
{
NetworkService ns = new NetworkService()
{
AuthCookie = GetValueFromProperties(StoreKeys.AuthCookie) as string
};
var syncManager = new SyncManager(_context, CurrentUser.Id, ns);
syncManager.SyncAsync();
}
}
public async Task InitiatesPushSync()
{
var oldValue = false;
var preferences = new MockPreferences {
CollapseTimeEntries = oldValue
};
PreferencesSubject.OnNext(preferences);
ViewModel.ToggleTimeEntriesGrouping.Execute();
TestScheduler.Start();
await SyncManager.Received().PushSync();
}
public IAsyncOperation <bool> UpdateOnServer(SyncManager syncManager, String objectType, String objectId,
IDictionary <String, Object> fields)
{
var manager = JsonConvert.SerializeObject(syncManager);
var fieldList = new Dictionary <String, Object>(fields);
return
(Task.Run(
async() =>
await
_syncUpTarget.UpdateOnServer(
JsonConvert.DeserializeObject <SDK.SmartSync.Manager.SyncManager>(manager), objectType,
objectId, fieldList)).AsAsyncOperation());
}
int count = 0; //testing
#endregion Fields
#region Constructors
/// <summary>
/// Initializes default fixation detector to Tobii Studio default **TODO**
/// Analyzer = EFDAnalyzer.fdaFixationSize
/// Filter = EFDFilter.fdfAveraging
/// </summary>
/// <param name="syncManager"></param>
public GazeDataFixationHandler(SyncManager syncManager)
: base(syncManager)
{
fixationDetector = new FixDetectorClass();
fixationDetector.init();
// TODO determine settings of Tobii Studio fixation detector
fixationDetector.Analyzer = EFDAnalyzer.fdaFixationSize;
fixationDetector.Filter = EFDFilter.fdfAveraging;
// fixationDetector.FilterBufferSize =
// fixationDetector.FilterWeight =
// fixationDetector.MinFixDuration =
// fixationDetector.UpdateInterval =
}
/// <summary>
/// Returns the dataset loaded from the given document data.
/// </summary>
/// <param name="documentData">Document data to make the dataset from</param>
/// <param name="taskType">Task type</param>
/// <param name="taskObjectType">Task object type</param>
protected virtual DataSet GetDataSet(string documentData, TaskTypeEnum taskType, string taskObjectType)
{
var man = SyncManager.GetInstance();
man.OperationType = OperationTypeEnum.Synchronization;
string className = DocumentHierarchyHelper.GetNodeClassName(documentData, ExportFormatEnum.XML);
DataSet ds = man.GetSynchronizationTaskDataSet(taskType, className, taskObjectType);
XmlParserContext xmlContext = new XmlParserContext(null, null, null, XmlSpace.None);
XmlReader reader = new XmlTextReader(documentData, XmlNodeType.Element, xmlContext);
return(DataHelper.ReadDataSetFromXml(ds, reader, null, null));
}
const string MODIFIED_TOKEN = "[modified]"; // name of a child object added to watch for object reset
private void Awake()
{
_syncManager = FindObjectOfType <SyncManager>();
if (_syncManager == null)
{
enabled = false;
return;
}
_syncManager.onInstanceAdded += SyncManager_InstanceAdded;
_syncManager.onSyncUpdateEnd += SyncManager_SyncUpdateEnd;
_syncManager.onProjectClosed += SyncManager_ProjectClosed;
}
public void ReturnsAnObservableWhichEmitsWhenTheForceFullSyncObservableEmits()
{
bool emitted = false;
var forceFullSyncSubject = new Subject <SyncState>();
SyncManager.ForceFullSync().Returns(forceFullSyncSubject.AsObservable());
var observable = DataSource.StartSyncing();
observable.Subscribe(_ => emitted = true);
forceFullSyncSubject.OnNext(SyncState.Pull);
emitted.Should().BeTrue();
}
public async Task RunsTheOperationsInCorrectOrder()
{
var interactor = InteractorFactory.CreateDefaultWorkspace();
await interactor.Execute();
Received.InOrder(() =>
{
DataSource.Workspaces.Create(Arg.Any <IThreadSafeWorkspace>());
DataSource.User.Update(Arg.Any <IThreadSafeUser>());
SyncManager.PushSync();
SyncManager.ForceFullSync();
});
}
public NoteSyncViewModel()
{
Account account = AccountManager.GetAccount();
if (account == null)
{
return;
}
_store = SmartStore.GetSmartStore();
_syncManager = SyncManager.GetInstance(account);
Notes = new SortedObservableCollection <NoteObject>();
FilteredNotes = new SortedObservableCollection <NoteObject>();
IndexReference = new ObservableCollection <string>();
}
public async ThreadingTask UnsubscribesFromTheSignalAfterLogout()
{
var subject = new Subject <TimeSpan>();
BackgroundService.AppResumedFromBackground.Returns(subject.AsObservable());
await DataSource.StartSyncing();
SyncManager.ClearReceivedCalls();
await DataSource.Logout();
subject.OnNext(MinimumTimeInBackgroundForFullSync + TimeSpan.FromSeconds(1));
await SyncManager.DidNotReceive().ForceFullSync();
}
public void CompletesWhenSleepStateOccursAfterPushSync()
{
bool finished = false;
SyncManager.PushSync();
var observable = SyncManager.Freeze().Subscribe(_ => finished = true);
OrchestratorStates.OnNext(Push);
OrchestratorStates.OnNext(Sleep);
SyncManager.IsRunningSync.Should().BeFalse();
finished.Should().BeTrue();
}
public void KeepsWaitingWhileNoSleepStateOccursAfterPushSync()
{
bool finished = false;
Queue.Dequeue().Returns(Push);
SyncManager.PushSync();
var observable = SyncManager.Freeze().Subscribe(_ => finished = true);
OrchestratorStates.OnNext(Push);
SyncManager.IsRunningSync.Should().BeTrue();
finished.Should().BeFalse();
}
/// <summary>
/// Get content documents from sfdc
/// </summary>
internal async Task <IList <Model.Models.ContentDocument> > GetFromSoql(SyncManager syncManager)
{
var results = new List <Model.Models.ContentDocument>();
var target = new SoqlSyncDownTarget(SoqlQuery);
var page = await target.StartFetch(syncManager, -1);
while (page != null && page.Count > 0)
{
results.AddRange(page.Select(x => x.ToObject <Model.Models.ContentDocument>()).ToList());
page = await target.ContinueFetch(syncManager);
}
return(results);
}
/// <summary>
/// Connects to found eyetrackers, synchronizes CPU and eyetracker clocks, and attaches event handlers.
/// </summary>
/// <param name="sender"></param>
/// <param name="e">Contains found EyetrackerInfo</param>
static void EyetrackerFound(object sender, EyetrackerInfoEventArgs e)
{
EyetrackerConnector connector = new EyetrackerConnector(e.EyetrackerInfo);
connector.Connect();
// sync CPU and Eyetracker clocks
SyncManager syncManager = new SyncManager(clock, e.EyetrackerInfo, EventThreadingOptions.BackgroundThread);
// detect fixations
FixationDetector fixations = new FixationDetector(syncManager);
connector.Eyetracker.GazeDataReceived += fixations.GazeDataReceived;
/*/ 1. print each event to console
* ConsolePrinter printer = new ConsolePrinter(syncManager);
* //connector.Eyetracker.GazeDataReceived += printer.GazeDataReceived;
* fixations.FixDetector.FixationEnd += printer.FixationEnd;//*/
/*/ 2. windowed print to console
* WindowingConsolePrinter printer = new WindowingConsolePrinter(syncManager);
* //connector.Eyetracker.GazeDataReceived += printer.GazeDataReceived;
* fixations.FixDetector.FixationEnd += printer.FixationEnd;
*
* printer.StartWindow();
* while (true)
* {
* Thread.Sleep(windowDuration);
* printer.ProcessWindow(cumulativeWindows);
* }//*/
// 3. process windows with EMDAT
EmdatProcessor processor = new EmdatProcessor(syncManager);
if (aoiFilePath != null)
{
processor.AoiFilePath = aoiFilePath;
}
connector.Eyetracker.GazeDataReceived += processor.GazeDataReceived;
fixations.FixDetector.FixationEnd += processor.FixationEnd;
processor.StartWindow();
while (true)
{
Thread.Sleep(windowDuration);
processor.ProcessWindow(cumulativeWindows);
}//*/
}
private SyncState LoadState(long ssid)
{
var state = SyncManager.LoadState(ssid);
if (state != null)
{
// Fix user colors
foreach (var user in state.Users)
{
UserColors.CountColor(user);
}
}
return(state);
}
private async void UploadData()
{
SyncManager SyncManager = new SyncManager();
if (SyncManager.CheckSyncConditions(SyncPolicy.Forced))
{
if ((Reachability.InternetConnectionStatus() == NetworkStatus.ReachableViaWiFiNetwork) ||
(Reachability.InternetConnectionStatus() != NetworkStatus.ReachableViaWiFiNetwork && !Settings.PreferUnmeteredConnection))
{
var src = new CancellationTokenSource();
var token = src.Token;
await SyncManager.Synchronize(token);
}
}
}
protected void Reset()
{
var analyticsService = Substitute.For <IAnalyticsService>();
var lastTimeUsageStorage = Substitute.For <ILastTimeUsageStorage>();
var timeService = Substitute.For <ITimeService>();
var automaticSyncingService = Substitute.For <IAutomaticSyncingService>();
Queue = new SyncStateQueue();
Transitions = new TransitionHandlerProvider(analyticsService);
Scheduler = new TestScheduler();
StateMachine = new StateMachine(Transitions, Scheduler);
EntryPoints = new StateMachineEntryPoints();
Orchestrator = new StateMachineOrchestrator(StateMachine, EntryPoints);
SyncManager = new SyncManager(Queue, Orchestrator, analyticsService, lastTimeUsageStorage, timeService, automaticSyncingService);
}
public async Task StartsTheSyncAlgorithm()
{
View.Select(
Arg.Any <string>(),
Arg.Any <IEnumerable <SelectOption <IThreadSafeWorkspace> > >(),
Arg.Any <int>())
.Returns(Observable.Return(new MockWorkspace {
Id = workspaceId
}));
ViewModel.PickDefaultWorkspace.Execute();
TestScheduler.Start();
SyncManager.Received().PushSync();
}
public async Task <String> CreateOnServerAsync(SyncManager syncManager, String objectType, Dictionary <String, Object> fields)
{
JToken id;
var request = RestRequest.GetRequestForCreate(syncManager.ApiVersion, objectType, fields);
var response = await syncManager.SendRestRequest(request);
var responseObject = response.AsJObject;
responseObject.TryGetValue(Constants.Lid, out id);
if (id != null)
{
return(response.Success ? id.ToString() : null);
}
return(null);
}
public override async Task <JArray> ContinueFetch(SyncManager syncManager)
{
if (String.IsNullOrWhiteSpace(NextRecordsUrl))
{
return(null);
}
var request = new RestRequest(HttpMethod.Get, NextRecordsUrl);
var response = await syncManager.SendRestRequest(request);
JObject responseJson = response.AsJObject;
var records = responseJson.ExtractValue <JArray>(Constants.Records);
return(records);
}
internal async Task <IList <Model.Models.MobileAppConfig> > GetFromSoql(SyncManager syncManager)
{
List <Model.Models.MobileAppConfig> results = new List <Model.Models.MobileAppConfig>();
var target = new SoqlSyncDownTarget(SoqlQuery);
// Sync to JSON
var _results = await target.StartFetch(syncManager, -1);
while (_results != null && _results.Count > 0)
{
results.AddRange(_results.Select(x => x.ToObject <Model.Models.MobileAppConfig>()).ToList());
_results = await target.ContinueFetch(syncManager);
}
return(results);
}
void OnChatAdded(object sender, ChatViewAddedEventArgs e)
{
Trace.Call(sender, e);
GLib.Idle.Add(delegate {
var chatView = (ChatView)CreateChatView(e.ChatModel,
e.ChatType,
e.ProtocolManagerType);
chatView.ID = e.ChatID;
chatView.Name = e.ChatID;
chatView.Position = e.ChatPosition;
f_Chats.Add(chatView);
if (f_Config != null)
{
chatView.ApplyConfig(f_Config);
}
// POSSIBLE REMOTING CALL
int idx = GetSortedChatPosition(chatView);
#if LOG4NET
f_Logger.Debug("OnChatAdded(): adding " +
"<" + chatView.ID + "> at: " + idx);
#endif
if (idx == -1)
{
f_Notebook.AppendPage(chatView, chatView.LabelWidget);
}
else
{
f_Notebook.InsertPage(chatView, chatView.LabelWidget, idx);
}
// notify the sync manager that the ChatView is ready to be synced
SyncManager.ReleaseSync(chatView);
#if GTK_SHARP_2_10
f_Notebook.SetTabReorderable(chatView, true);
#endif
chatView.ShowAll();
if (ChatAdded != null)
{
ChatAdded(this, new ChatViewManagerChatAddedEventArgs(chatView));
}
return(false);
});
}
public void ClearTheDatabaseOnlyOnceTheSyncManagerFreezeEmitsAValueEvenThoughItDoesNotComplete()
{
var freezingSubject = new Subject <SyncState>();
SyncManager.Freeze().Returns(freezingSubject.AsObservable());
var observable = interactor.Execute().Publish();
observable.Connect();
Database.DidNotReceive().Clear();
freezingSubject.OnNext(SyncState.Sleep);
Database.Received().Clear();
}
public void UnsubscribesFromTheBackgroundServiceObservableWhenExceptionIsCaught()
{
var subject = new Subject <TimeSpan>();
var errorsSubject = new Subject <Exception>();
BackgroundService.AppResumedFromBackground.Returns(subject.AsObservable());
SyncManager.Errors.Returns(errorsSubject);
AutomaticSyncingService.SetupAutomaticSync(UserAccessManager);
LoggedIn.OnNext(DataSource);
SyncManager.ClearReceivedCalls();
errorsSubject.OnNext(new Exception());
subject.OnNext(MinimumTimeInBackgroundForFullSync);
SyncManager.DidNotReceive().ForceFullSync();
}
public override async Task<JArray> StartFetch(SyncManager syncManager, long maxTimeStamp)
{
string queryToRun = maxTimeStamp > 0 ? AddFilterForReSync(Query, maxTimeStamp) : Query;
RestRequest request = RestRequest.GetRequestForQuery(syncManager.ApiVersion, queryToRun);
var response = await syncManager.SendRestRequest(request);
JObject responseJson = response.AsJObject;
var records = responseJson.ExtractValue<JArray>(Constants.Records);
// Record total size
TotalSize = responseJson.ExtractValue<int>(Constants.TotalSize);
// Capture next records url
NextRecordsUrl = responseJson.ExtractValue<string>(Constants.NextRecordsUrl);
return records;
}
private static int windowDuration = 3000; // ms
#endregion Fields
#region Methods
/// <summary>
/// Connects to found eyetrackers, synchronizes CPU and eyetracker clocks, and attaches event handlers.
/// </summary>
/// <param name="sender"></param>
/// <param name="e">Contains found EyetrackerInfo</param>
static void EyetrackerFound(object sender, EyetrackerInfoEventArgs e)
{
EyetrackerConnector connector = new EyetrackerConnector(e.EyetrackerInfo);
connector.Connect();
// sync CPU and Eyetracker clocks
SyncManager syncManager = new SyncManager(clock, e.EyetrackerInfo, EventThreadingOptions.BackgroundThread);
// detect fixations
FixationDetector fixations = new FixationDetector(syncManager);
connector.Eyetracker.GazeDataReceived += fixations.GazeDataReceived;
/*/ 1. print each event to console
ConsolePrinter printer = new ConsolePrinter(syncManager);
//connector.Eyetracker.GazeDataReceived += printer.GazeDataReceived;
fixations.FixDetector.FixationEnd += printer.FixationEnd;//*/
/*/ 2. windowed print to console
WindowingConsolePrinter printer = new WindowingConsolePrinter(syncManager);
//connector.Eyetracker.GazeDataReceived += printer.GazeDataReceived;
fixations.FixDetector.FixationEnd += printer.FixationEnd;
printer.StartWindow();
while (true)
{
Thread.Sleep(windowDuration);
printer.ProcessWindow(cumulativeWindows);
}//*/
// 3. process windows with EMDAT
EmdatProcessor processor = new EmdatProcessor(syncManager);
if (aoiFilePath != null)
{
processor.AoiFilePath = aoiFilePath;
}
connector.Eyetracker.GazeDataReceived += processor.GazeDataReceived;
fixations.FixDetector.FixationEnd += processor.FixationEnd;
processor.StartWindow();
while (true)
{
Thread.Sleep(windowDuration);
processor.ProcessWindow(cumulativeWindows);
}//*/
}
/// <summary>
/// Initializes fixation detector to Tobii Studio default
/// </summary>
/// <param name="syncManager"></param>
public FixationDetector(SyncManager syncManager)
: base(syncManager)
{
fixationDetector = new FixDetector();
fixationDetector.init();
// mimic Tobii Fixation Filter
// Detailed information available in Tobii Studio User Manual 1.X
// http://www.tobii.com/Global/Analysis/Downloads/User_Manuals_and_Guides/Tobii_Studio1.X_UserManual.pdf
// as well as the appendix of Olsson, P. 2007. Real-time and offline filters for eye tracking. Msc thesis, KTH Royal Institue of Technology, April 2007.
fixationDetector.Analyzer = EFDAnalyzer.fdaFixationSize;
fixationDetector.Filter = EFDFilter.fdfAveraging;
fixationDetector.setAnalyzerProperty("fixation_radius", 35);
fixationDetector.setAnalyzerProperty("noise_filter", 1);
fixationDetector.FilterBufferSize = 5;
fixationDetector.MinFixDuration = 0;
}
static void Main(string[] args)
{
SyncManager _syncManager = new SyncManager(1000);
_syncManager.AddSync(new QueueCollection());
_syncManager.SyncBegin += new SyncManager.SyncBeginHandler(_syncManager_SyncBegin);
_syncManager.SyncComplete += new EventHandler(_syncManager_SyncComplete);
_syncManager.SyncFailed += new SyncManager.SyncFailedHandler(_syncManager_SyncFailed);
_syncManager.SyncRetry += new SyncManager.SyncRetryHandler(_syncManager_SyncRetry);
_syncManager.SyncFinish += new SyncManager.SyncFinishHandler(_syncManager_SyncFinish);
_syncManager.BeginSync();
Console.ReadLine();
_syncManager.EndSync();
}
static void EyetrackerFound(object sender, EyetrackerInfoEventArgs e)
{
EyetrackerConnector connector = new EyetrackerConnector(e.EyetrackerInfo);
connector.Connect();
// sync CPU and Eyetracker clocks
SyncManager syncManager = new SyncManager(clock, e.EyetrackerInfo, EventThreadingOptions.BackgroundThread);
// detect fixations
GazeDataFixationHandler fixations = new GazeDataFixationHandler(syncManager);
connector.AddGazeDataHandler(fixations.GazeDataReceived);
// print to console
GazeDataConsolePrintHandler printer = new GazeDataConsolePrintHandler(syncManager);
//connector.AddGazeDataHandler(printer.GazeDataReceived);
fixations.FixationDetector.FixationEnd += printer.FixationEnd;
}
private async void btnSync_Click(object sender, EventArgs e)
{
SyncManager syncManager = new SyncManager(_logger);
WaitingBar.Visible = true;
WaitingBar.StartWaiting();
btnSync.Enabled = false;
await syncManager.Sync();
btnSync.Enabled = true;
WaitingBar.StopWaiting();
WaitingBar.Visible = false;
MessageBoxDisplayService.ShowSuccess("Sincronizacion Finalizada con Exito");
}
public async override Task<JArray> StartFetch(SyncManager syncManager, long maxTimeStamp)
{
var request = RestRequest.GetRequestForMetadata(syncManager.ApiVersion, ObjectType);
var response = await syncManager.SendRestRequest(request);
var recentItems = SyncManager.Pluck<string>(response.AsJObject.ExtractValue<JArray>(Constants.RecentItems),
Constants.Id);
// Building SOQL query to get requested at
String soql = SOQLBuilder.GetInstanceWithFields(FieldList.ToArray()).From(ObjectType).Where("Id IN ('" + String.Join("', '", recentItems) + "')").Build();
// Get recent items attributes from server
request = RestRequest.GetRequestForQuery(syncManager.ApiVersion, soql);
response = await syncManager.SendRestRequest(request);
var responseJson = response.AsJObject;
var records = responseJson.ExtractValue<JArray>(Constants.Records);
// Recording total size
TotalSize = records.Count;
return records;
}
private void ConnectToTracker(EyetrackerInfo info)
{
try
{
_connectedTracker = EyetrackerFactory.CreateEyetracker(info);
_connectedTracker.ConnectionError += HandleConnectionError;
_connectionName = info.ProductId;
_syncManager = new SyncManager(_clock, info);
_connectedTracker.GazeDataReceived += _connectedTracker_GazeDataReceived;
_connectedTracker.FramerateChanged += _connectedTracker_FramerateChanged;
}
catch (EyetrackerException ee)
{
if(ee.ErrorCode == 0x20000402)
{
MessageBox.Show("Failed to upgrade protocol. " +
"This probably means that the firmware needs" +
" to be upgraded to a version that supports the new sdk.","Upgrade Failed",MessageBoxButtons.OK,
MessageBoxIcon.Error);
}
else
{
MessageBox.Show("Eyetracker responded with error " + ee, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
DisconnectTracker();
}
catch(Exception)
{
MessageBox.Show("Could not connect to eyetracker.","Connection Failed",MessageBoxButtons.OK,MessageBoxIcon.Error);
DisconnectTracker();
}
UpdateUIElements();
}
public EmdatProcessor(SyncManager syncManager)
: base(syncManager)
{
// redirect python stdin/stdout
engine.Runtime.IO.SetOutput(Console.OpenStandardOutput(), Console.OutputEncoding);
engine.Runtime.IO.SetErrorOutput(Console.OpenStandardError(), Console.OutputEncoding);
// set module search paths
string scriptDir = Path.GetDirectoryName("C:\\Documents and Settings\\Admin\\My Documents\\Visual Studio 2008\\Projects\\ATUAV_RT\\RealTimeProcessing\\emdat.py");
string emdatDir = Path.GetDirectoryName("C:\\Documents and Settings\\Admin\\My Documents\\Visual Studio 2008\\Projects\\ATUAV_RT\\RealTimeProcessing\\EMDAT\\src\\");
string pythonDir = Path.GetDirectoryName("C:\\Python26\\Lib\\");
ICollection<string> paths = engine.GetSearchPaths();
if (!String.IsNullOrEmpty(scriptDir))
{
paths.Add(scriptDir);
paths.Add(emdatDir);
paths.Add(pythonDir);
}
else
{
paths.Add(Environment.CurrentDirectory);
}
engine.SetSearchPaths(paths);
// import modules
emdat = engine.ImportModule("emdat");
// add conditions
foreach (Type type in AllConditionTypes)
{
ConstructorInfo info = type.GetConstructor(new[] { typeof(EmdatProcessor) });
Condition condition = (Condition) info.Invoke(new object[] { this } );
conditions.Add(condition.Id, condition);
}
}
public async Task<bool> DeleteOnServer(SyncManager syncManager, String objectType, String objectId)
{
var request = RestRequest.GetRequestForDelete(syncManager.ApiVersion, objectType, objectId);
var response = await syncManager.SendRestRequest(request);
return response.Success;
}
public abstract Task<JArray> ContinueFetch(SyncManager syncManager);
public abstract Task<JArray> StartFetch(SyncManager syncManager, long maxTimeStamp);
public async Task<String> FetchLastModifiedDate(SyncManager syncManager, String objectType, String objectId)
{
String query = SOQLBuilder.GetInstanceWithFields(Constants.LastModifiedDate)
.From(objectType)
.Where(Constants.Id + " = '" + objectId + "'")
.Build();
var lastModResponse = await syncManager.SendRestRequest(RestRequest.GetRequestForQuery(syncManager.ApiVersion, query));
if (lastModResponse.Success)
{
return
lastModResponse.AsJObject.ExtractValue<JArray>(Constants.Records)[0].Value<JObject>()
.ExtractValue<string>(Constants.LastModifiedDate);
}
return null;
}
public GazeDataSynchronizedHandler(SyncManager syncManager)
: base(syncManager)
{
}
public override async Task<JArray> ContinueFetch(SyncManager syncManager)
{
if (String.IsNullOrWhiteSpace(NextRecordsUrl))
{
return null;
}
var request = new RestRequest(HttpMethod.Get, NextRecordsUrl);
var response = await syncManager.SendRestRequest(request);
JObject responseJson = response.AsJObject;
var records = responseJson.ExtractValue<JArray>(Constants.Records);
return records;
}
public HashSet<String> GetIdsOfRecordsToSyncUp(SyncManager syncManager, String soupName)
{
return syncManager.GetDirtyRecordIds(soupName, SmartStore.Store.SmartStore.SoupEntryId);
}
protected virtual void Awake()
{
_anim = GetComponent<Animator>();
_hash = GameObject.FindGameObjectWithTag(Tags.gameController).GetComponent<HashIDs>();
_syncManager = GameObject.FindGameObjectWithTag(Tags.networkController).GetComponent<SyncManager>();
_modelInfo = GetComponent<ModelInfo>();
// Create a marker object for player's ranged target.
_rangedTarget = InstantiateAsChild(ResourceDirectory.Instance.Creatures["redMarker"], transform) as GameObject;
// Create IK controller for right arm.
GameObject rArmIkController = GameObject.Instantiate(Resources.Load("Prefabs/Animation/LimbIkController")) as GameObject;
rArmIkController.transform.parent = gameObject.transform;
_rArmIkLimb = rArmIkController.GetComponent<IkLimb>();
_rArmIkLimb.upperArm = _modelInfo.rArm.transform;
_rArmIkLimb.forearm = _modelInfo.rForearm.transform;
_rArmIkLimb.hand = _modelInfo.rHand.transform;
_rArmIkLimb.elbowTarget = _modelInfo.rArmPistolIkElbowTarget;
_rArmIkLimb.target = _modelInfo.rArmPistolIkHandTarget.transform;
_rArmIkLimb.IsEnabled = false;
_rArmIkLimb.debug = true;
_rArmIkLimb.transition = 0.65f;
_rArmIkLimb.handRotationPolicy = IkLimb.HandRotations.UseTargetRotation;
// Create IK controller for left arm.
GameObject lArmIkController = GameObject.Instantiate(Resources.Load("Prefabs/Animation/LimbIkController")) as GameObject;
lArmIkController.transform.parent = gameObject.transform;
_lArmIkLimb = lArmIkController.GetComponent<IkLimb>();
_lArmIkLimb.upperArm = _modelInfo.lArm.transform;
_lArmIkLimb.forearm = _modelInfo.lForearm.transform;
_lArmIkLimb.hand = _modelInfo.lHand.transform;
_lArmIkLimb.elbowTarget = _modelInfo.lArmPistolIkElbowTarget;
_lArmIkLimb.target = _modelInfo.lArmPistolIkHandTarget;
_lArmIkLimb.IsEnabled = false;
_lArmIkLimb.debug = true;
_lArmIkLimb.transition = 0.9f;
// Add DamageLocation scripts to skeleton.
DamageLocation headDamageLocation = _modelInfo.head.AddComponent<DamageLocation>();
headDamageLocation.damageLocationType = DamageLocationType.Head;
headDamageLocation.player = this.gameObject;
DamageLocation torsoDamageLocation = _modelInfo.torso.AddComponent<DamageLocation>();
torsoDamageLocation.damageLocationType = DamageLocationType.Torso;
torsoDamageLocation.player = this.gameObject;
DamageLocation legsDamageLocation = _modelInfo.legs.AddComponent<DamageLocation>();
legsDamageLocation.damageLocationType = DamageLocationType.Legs;
legsDamageLocation.player = this.gameObject;
// Create initial NoWeapon object.
EquipWeaponByName("NoWeapon");
// Create camera orbiter object.
MouseOrbit = (GameObject.Instantiate(ResourceDirectory.Instance.Camera["Orbiter"]) as GameObject).GetComponent<MouseOrbit>();
MouseOrbit.transform.parent = transform;
MouseOrbit.target = transform;
}
