private void init()
{
m_updateListener = new UpdateListener(this);
m_updateSubject
.Synchronize()
.Throttle(TimeSpan.FromMilliseconds(10))
.SubscribeOnDispatcher()
.Subscribe(m_updateListener);
m_sessionVolumeListener = new AudioSessionVolumeListener(this);
m_sessionMuteListener = new AudioSessionMuteListener(this);
m_coreAudioController = new CoreAudioController();
m_coreAudioController.DefaultPlaybackDevice.GetCapability <IAudioSessionController>().SessionCreated.Subscribe(new AudioSessionAddedListener(this));
m_coreAudioController.DefaultPlaybackDevice.GetCapability <IAudioSessionController>().SessionDisconnected.Subscribe(new AudioSessionRemovedListener(this));
m_coreAudioController.AudioDeviceChanged.Subscribe(new DeviceChangeListener(this));
var masterVolumeListener = new MasterVolumeListener(this);
m_coreAudioController.DefaultPlaybackDevice.VolumeChanged.Throttle(TimeSpan.FromMilliseconds(10)).Subscribe(masterVolumeListener);
m_coreAudioController.DefaultPlaybackDevice.MuteChanged.Throttle(TimeSpan.FromMilliseconds(10)).Subscribe(masterVolumeListener);
new Thread(() =>
{
updateState(null);
Server = new Server(this);
}).Start();
}
/// <summary>
/// Add a listener that will be updated as fast a possible by the loop. Also will enable background tasks to run at the same time
/// as this listener. Those can be added using addBackgroundUpdateListener and giving the same name given here.
/// You must add the main thread update listener before adding the updates that will run in the background.
/// </summary>
/// <param name="listener">The listener to add.</param>
public void addUpdateListenerWithBackgrounding(String name, UpdateListener listener)
{
UpdateListenerWithBackgrounding bgListenerWorker = new UpdateListenerWithBackgrounding(listener);
multiThreadedWorkerListeners.Add(name, bgListenerWorker);
addUpdateListener(bgListenerWorker);
}
/// <summary>
/// Remove a listener from the full speed loop.
/// </summary>
/// <param name="listener">The listener to remove</param>
public void removeUpdateListenerWithBackgrounding(String name, UpdateListener listener)
{
UpdateListenerWithBackgrounding bgListenerWorker = multiThreadedWorkerListeners[name];
removeUpdateListener(bgListenerWorker);
bgListenerWorker.Dispose();
multiThreadedWorkerListeners.Remove(name);
}
public static void CompileDeployAddListener(
string epl,
string stmtName,
UpdateListener listener,
EPRuntime runtime,
Configuration configuration)
{
var compiled = Compile(epl, configuration, new RegressionPath());
DeployAddListener(compiled, stmtName, listener, runtime);
}
public void AddUpdate(Action <int> callback)
{
foreach (Delegate del in UpdateListener.GetInvocationList())
{
Action <int> action = (Action <int>)del;
if (callback.Equals(action)) //If this callback exists already, ignore this addlistener
{
return;
}
}
UpdateListener += callback;
}
/// <summary>
/// Remove an update listener from the fixed updater part of the timer.
/// </summary>
/// <param name="listener">The listener to remove.</param>
public void removeUpdateListener(UpdateListener listener)
{
int index = updateListeners.IndexOf(listener);
if (index != -1)
{
updateListeners.RemoveAt(index);
//Adjust the iteration index backwards if the element being removed is before or on the index.
//This way nothing gets skipped.
if (index <= fixedUpdateIndex)
{
--fixedUpdateIndex;
}
}
}
public void SetPeriodTest()
{
const int TEST_TIMES = 4;
const long PERIOD_NEW = 5000;
const double PERIOD_DELTA = 1800;
const string UPDATE_CHANGE_FILE_NAME = "update_change_field_profiles.zip";
string sourceFile = Path.GetFullPath(Path.Combine(DATA_PATH, ZIP_FILE_NAME));
string updateFile = Path.GetFullPath(Path.Combine(DATA_PATH, UPDATE_CHANGE_FILE_NAME));
string targetFile = Path.GetFullPath(Path.Combine(DATA_PATH, TEST_FILE_NAME));
Assert.True(File.Exists(sourceFile));
Assert.True(File.Exists(updateFile));
Uri uri = new Uri(targetFile);
File.Copy(sourceFile, targetFile, true);
InstrumentProfileConnection connection = new InstrumentProfileConnection(uri.AbsoluteUri + UPDATE_PERIOD_STR);
UpdateListener updateListener = new UpdateListener();
connection.AddUpdateListener(updateListener);
connection.Start();
DateTime time = DateTime.Now;
while (!updateListener.IsUpdated)
{
}
for (int i = 0; i < TEST_TIMES * 2; i++)
{
if (i == TEST_TIMES)
{
connection.UpdatePeriod = PERIOD_NEW;
}
updateListener.DropState();
File.Copy(updateFile, targetFile, true);
File.SetLastWriteTime(targetFile, DateTime.Now);
while (!updateListener.IsUpdated)
{
}
Assert.AreEqual(connection.UpdatePeriod, DateTime.Now.Subtract(time).TotalMilliseconds, PERIOD_DELTA);
time = DateTime.Now;
//swap source/update files
string temp = updateFile;
updateFile = sourceFile;
sourceFile = temp;
}
connection.Close();
}
public static void ReplaceListener(UpdateListener listener, SudokuGrid value, ref SudokuGrid grid)
{
if (grid == value)
{
return;
}
if (grid != null)
{
grid.RemoveListener(listener);
}
grid = value;
if (grid != null)
{
grid.AddListener(listener);
}
}
public void UpdateRemoveTest()
{
const int UPDATE_ADD_COUNT = 2;
const string UPDATE_REMOVE_FILE_NAME = "update_remove_profiles.zip";
const string PRODUCT_SYMBOL_1 = "/CL";
const string PRODUCT_SYMBOL_2 = "/TF";
string sourceFile = Path.GetFullPath(Path.Combine(DATA_PATH, ZIP_FILE_NAME));
string updateFile = Path.GetFullPath(Path.Combine(DATA_PATH, UPDATE_REMOVE_FILE_NAME));
string targetFile = Path.GetFullPath(Path.Combine(DATA_PATH, TEST_FILE_NAME));
Assert.True(File.Exists(sourceFile));
Assert.True(File.Exists(updateFile));
Uri uri = new Uri(targetFile);
File.Copy(sourceFile, targetFile, true);
InstrumentProfileConnection connection = new InstrumentProfileConnection(uri.AbsoluteUri + UPDATE_PERIOD_STR);
UpdateListener updateListener = new UpdateListener();
connection.AddUpdateListener(updateListener);
connection.Start();
while (!updateListener.IsUpdated)
{
}
Assert.AreEqual(IPF_COUNT, updateListener.LastUpdate.Count);
updateListener.DropState();
File.Copy(updateFile, targetFile, true);
File.SetLastWriteTime(targetFile, DateTime.Now);
while (!updateListener.IsUpdated)
{
}
Assert.AreEqual(UPDATE_ADD_COUNT, updateListener.LastUpdate.Count);
foreach (InstrumentProfile ip in updateListener.LastUpdate)
{
if (ip.GetTypeName().Equals(InstrumentProfileType.REMOVED.Name) &&
(ip.GetSymbol().Equals(PRODUCT_SYMBOL_1) || ip.GetSymbol().Equals(PRODUCT_SYMBOL_2)))
{
continue;
}
Assert.Fail("Unexpected instrument profiles here!");
}
connection.Close();
}
/// <summary>
/// Add a new fixed update listener.
/// </summary>
static public void AddOnUpdate(Component mb, OnUpdateCallback callback)
{
ProximityManager pro = GetInstance(mb);
foreach (UpdateListener p in pro.mOnUpdate)
{
if (p.mb == mb && p.callback == callback)
{
return;
}
}
UpdateListener ent = new UpdateListener();
ent.mb = mb;
ent.callback = callback;
pro.mOnUpdate.Add(ent);
}
private Task Client_MessageCreated(MessageCreateEventArgs e)
{
UpdateListener.CheckMessage(e);
if (e.Author.IsBot)
{
return(Done); // explicitly ignore bot messages
}
var isKarmaMessage = ExperienceManager.IsExpMessage(e.Message);
var gaveKarma = false;
if (isKarmaMessage)
{
gaveKarma = ExperienceManager.UserToUserGiveExpAndNotify(e.Channel, e.Author, e.MentionedUsers);
}
return(Done);
}
public static void DeployAddListener(
EPCompiled compiledStmt,
string stmtName,
UpdateListener listener,
EPRuntime runtime)
{
try {
var deployed = runtime.DeploymentService.Deploy(
compiledStmt,
new DeploymentOptions().WithStatementNameRuntime(ctx => stmtName));
if (deployed.Statements.Length != 1) {
throw new UnsupportedOperationException("This method is designed for a single statement");
}
deployed.Statements[0].AddListener(listener);
}
catch (EPDeployException e) {
throw new EPException(e);
}
}
void FixedUpdate()
{
for (int i = mList.Count; i > 0;)
{
Entry ent = mList[--i];
if (ent.rb == null)
{
mList.RemoveAt(i);
}
}
for (int i = mOnUpdate.Count; i > 0;)
{
UpdateListener listener = mOnUpdate[--i];
if (listener.mb == null || !listener.callback(mList))
{
mOnUpdate.RemoveAt(i);
}
}
}
public void AddListenerTest()
{
const string UPDATE_CHANGE_FILE_NAME = "update_change_field_profiles.zip";
string sourceFile = Path.GetFullPath(Path.Combine(DATA_PATH, ZIP_FILE_NAME));
string updateFile = Path.GetFullPath(Path.Combine(DATA_PATH, UPDATE_CHANGE_FILE_NAME));
string targetFile = Path.GetFullPath(Path.Combine(DATA_PATH, TEST_FILE_NAME));
Assert.True(File.Exists(sourceFile));
Assert.True(File.Exists(updateFile));
Uri uri = new Uri(targetFile);
File.Copy(sourceFile, targetFile, true);
InstrumentProfileConnection connection = new InstrumentProfileConnection(uri.AbsoluteUri + UPDATE_PERIOD_STR);
UpdateListener updateListener = new UpdateListener();
connection.AddUpdateListener(updateListener);
connection.Start();
while (!updateListener.IsUpdated)
{
}
Assert.AreEqual(IPF_COUNT, updateListener.LastUpdate.Count);
updateListener.DropState();
File.Copy(updateFile, targetFile, true);
File.SetLastWriteTime(targetFile, DateTime.Now);
while (!updateListener.IsUpdated)
{
}
UpdateListener newListener = new UpdateListener();
connection.AddUpdateListener(newListener);
while (!newListener.IsUpdated)
{
}
Assert.AreEqual(IPF_COUNT, newListener.LastUpdate.Count);
connection.Close();
}
public void RemoveListener(UpdateListener listener)
{
listeners.Remove(listener);
}
public void AddListener(UpdateListener listener)
{
listeners.Add(listener);
}
public int OnUpdate(UpdateListener listener)
{
return(Utilities.Add(updateListeners, listener));
}
/// <summary>
/// Add an update listener to get updates from the fixed updater part of the timer.
/// </summary>
/// <param name="listener">The listener to add</param>
public void addUpdateListener(UpdateListener listener)
{
updateListeners.Add(listener);
}
public void UpdateChangeTest()
{
const int UPDATE_CHANGE_1_COUNT = 1;
const int UPDATE_CHANGE_2_COUNT = 3;
const string UPDATE_CHANGE_1_FILE_NAME = "update_change_field_profiles.zip";
const string UPDATE_CHANGE_2_FILE_NAME = "update_change_ins_profiles.zip";
const string CUSTOM_FIELD_ONE_NAME = "CUSTOM_ONE";
const string CUSTOM_FIELD_TWO_NAME = "CUSTOM_TWO";
const string CUSTOM_FIELD_ONE_VALUE = "filled_custom_one";
const string CUSTOM_FIELD_TWO_VALUE = "filled_custom_two";
const string UPDATED_FIELD_NAME = "DESCRIPTION";
const string UPDATED_FIELD_VALUE = "Updated Description";
const string PRODUCT_SYMBOL = "/6E";
string sourceFile = Path.GetFullPath(Path.Combine(DATA_PATH, ZIP_FILE_NAME));
string updateFile = Path.GetFullPath(Path.Combine(DATA_PATH, UPDATE_CHANGE_1_FILE_NAME));
string targetFile = Path.GetFullPath(Path.Combine(DATA_PATH, TEST_FILE_NAME));
Assert.True(File.Exists(sourceFile));
Assert.True(File.Exists(updateFile));
Uri uri = new Uri(targetFile);
File.Copy(sourceFile, targetFile, true);
InstrumentProfileConnection connection = new InstrumentProfileConnection(uri.AbsoluteUri + UPDATE_PERIOD_STR);
UpdateListener updateListener = new UpdateListener();
connection.AddUpdateListener(updateListener);
connection.Start();
while (!updateListener.IsUpdated)
{
}
Assert.AreEqual(IPF_COUNT, updateListener.LastUpdate.Count);
//update#1 - updated one of field
updateListener.DropState();
File.Copy(updateFile, targetFile, true);
File.SetLastWriteTime(targetFile, DateTime.Now);
while (!updateListener.IsUpdated)
{
}
Assert.AreEqual(UPDATE_CHANGE_1_COUNT, updateListener.LastUpdate.Count);
foreach (InstrumentProfile ip in updateListener.LastUpdate)
{
if (ip.GetTypeName().Equals(InstrumentProfileType.PRODUCT.Name) && ip.GetSymbol().Equals(PRODUCT_SYMBOL))
{
Assert.AreEqual(ip.GetField(UPDATED_FIELD_NAME), UPDATED_FIELD_VALUE);
continue;
}
}
//update #2 - new fields inserted
updateFile = Path.GetFullPath(Path.Combine(DATA_PATH, UPDATE_CHANGE_2_FILE_NAME));
updateListener.DropState();
File.Copy(updateFile, targetFile, true);
File.SetLastWriteTime(targetFile, DateTime.Now);
while (!updateListener.IsUpdated)
{
}
Assert.AreEqual(UPDATE_CHANGE_2_COUNT, updateListener.LastUpdate.Count);
foreach (InstrumentProfile ip in updateListener.LastUpdate)
{
if (ip.GetTypeName().Equals(InstrumentProfileType.PRODUCT.Name) && ip.GetSymbol().Equals(PRODUCT_SYMBOL))
{
Assert.AreEqual(ip.GetField(CUSTOM_FIELD_ONE_NAME), CUSTOM_FIELD_ONE_VALUE);
Assert.AreEqual(ip.GetField(CUSTOM_FIELD_TWO_NAME), CUSTOM_FIELD_TWO_VALUE);
continue;
}
}
connection.Close();
}
public void SetUpdateListener(UpdateListener u)
{
this.updateListener = u;
}
public void AddListener(UpdateListener listener)
{
statement.AddListener(listener);
}
/// <summary>
/// Processes a single pending update from the queue, or returns immediately
/// if there are no pending updates.
/// </summary>
/// <returns>The snapshot of the state after the last processed update,
/// and a flag that indicates whether there are more unprocessed updates in the queue.
/// </returns>
/// <remarks>
/// This method should be used in a loop on each frame's update step,
/// until either there are no more pending updates, or there is not enough
/// time left to process the remaining updates in this frame.
/// The caller can stop at any point, and resume processing the transactions
/// on the next opportunity (for example, on the next frame's update step).
/// </remarks>
public (StateSnapshot, bool) ProcessSingleUpdate(UpdateListener listener)
{
throw new NotImplementedException();
}
public UpdateListenerWithBackgrounding(UpdateListener mainThreadUpdate)
{
this.mainThreadUpdate = mainThreadUpdate;
}
public void SetUpdateListener(UpdateListener u)
{
this.updateListener = u;
}
