public RemotingSession(uint id, uint functionId, Remoting remoting, IBytesPool bytesPool)
{
this.Id = id;
this.FunctionId = functionId;
_remoting = remoting;
_bytesPool = bytesPool;
}
private void MainWindow_OnActivated(object sender, EventArgs e)
{
if (FirstTimeActivated)
{
FirstTimeActivated = false;
var allAssemblies = new List <LeagueSharpAssembly>();
foreach (var profile in Config.Instance.Profiles)
{
allAssemblies.AddRange(profile.InstalledAssemblies);
}
allAssemblies = allAssemblies.Distinct().ToList();
GitUpdater.ClearUnusedRepos(allAssemblies);
PrepareAssemblies(allAssemblies, Config.Instance.FirstRun || Config.Instance.UpdateOnLoad, true, true);
Remoting.Init();
}
var text = Clipboard.GetText();
if (text.StartsWith(LSUriScheme.FullName))
{
Clipboard.SetText("");
LSUriScheme.HandleUrl(text, this);
}
}
void Remoting.ICore.AssignBinder(Remoting.ISoulBinder binder)
{
if (_Center != null)
{
_Join(binder);
}
}
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
// create flutter view host
var flutterView = Flutter.Bindings.Flutter.CreateView(this, this.Lifecycle, "home");
var layout = new FrameLayout.LayoutParams(600, 800)
{
LeftMargin = 200, TopMargin = 400
};
// setup Autofac
var cb = new ContainerBuilder();
cb.RegisterType <TestService>().As <ITestService>();
var container = cb.Build();
// create the service factory
var serviceFactory = new AutofacServiceFactory(container, new TypeResolver());
// create the remoting instance
var remotingInstance = Remoting.Create <FlutterView, PlatformChannelsHandler>(serviceFactory);
// and tell Flutter that 'we are listening'
remotingInstance.Start(flutterView);
AddContentView(flutterView, layout);
}
public Adventure(Adventurer adventurer, Remoting.ISoulBinder binder, IZone zone)
{
_Adventurer = adventurer;
_Zone = zone;
this._Binder = binder;
_Squad = new Squad(adventurer.Formation ,_Adventurer.Teammates, _Adventurer.Controller);
}
public User(Remoting.ISoulBinder binder , IStorage storage)
{
_Machine = new Utility.StageMachine();
this._Binder = binder;
_Account = new Data.Account();
_Storage = storage;
}
public User(Remoting.ISoulBinder binder, IStorage _Storage , Zone zone)
{
this._Binder = binder;
_Zone = zone;
_Binder.BreakEvent += _Break;
this._Storage = _Storage;
_Machine = new Regulus.Utility.StageMachine();
}
public Adventure(ActorInfomation actor_infomation , Remoting.ISoulBinder binder, IMap zone)
{
_ActorInfomation = actor_infomation;
_Map = zone;
this._Binder = binder;
_Entity = new Entity(_ActorInfomation.Id);
}
public User(Remoting.ISoulBinder provider, Regulus.Project.SamebestKeys.UserRoster user_roster, IWorld world , IStorage storage)
{
_Storage = storage;
_UserRoster = user_roster;
_Machine = new Regulus.Game.StageMachine<User>(this);
Provider = provider;
provider.BreakEvent += Quit;
_World = world;
}
public InterQStandalone()
{
T.DefaultContext.OutputRedirect += DefaultContext_OutputRedirect;
InitializeComponent();
//CheckForIllegalCrossThreadCalls = false;
numericUpDown1.Value = T.DefaultContext.CurrentLevel;
T.INFO("--- INTER-QUEUES STANDALONE INICIADO --");
Remoting.DumpAllInfoAboutRegisteredRemotingTypes();
}
public static int Helper(string socketPath)
{
DoSomething self = new DoSomething();
Remoting.Publish(socketPath, self);
Thread.Sleep(Timeout.Infinite);
return(0);
}
public User(Remoting.ISoulBinder provider, IWorld world , IStorage storage)
{
_Storage = storage;
_Machine = new Regulus.Utility.StageMachine();
Provider = provider;
provider.BreakEvent += Quit;
_World = world;
}
private Scene _Create(Data.Scene realm, Remoting.Time time)
{
var instance = new Generator(realm).Create();
if (realm.Singleton)
{
_Register(instance , realm.Name);
}
return instance;
}
private void _BroadcastBattler(Remoting.Value<IBattleAdmissionTickets> value, Guid[] battlers)
{
value.OnValue += (battle_admission_tickets) =>
{
foreach (var battler in battlers)
{
_BattleEvent(battler , battle_admission_tickets);
}
};
}
public Scene(Team team, Zone zone, Remoting.Time time , bool need_recovery)
{
_Team = team;
_Id = Guid.NewGuid();
this._Zone = zone;
this._Time = time;
_Updater = new Utility.Updater();
_NeedRecover = need_recovery;
}
public ActorCast(Serializable.Skill skill, ActorPropertyAbility actor, Remoting.Value<CastResult> return_value)
{
_Actor = actor;
this._Skill = skill;
this._ReturnValue = return_value;
_Done = false;
_Machine = new Utility.StageMachine();
_Step = CastStep.NotYet;
}
private void InitSystem()
{
PathRandomizer.CopyFiles();
Remoting.Init();
this.InjectThread = new Thread(
() =>
{
var trigger = new EdgeTrigger();
trigger.Rising += (sender, args) =>
{
Application.Current.Dispatcher.InvokeAsync(
() =>
{
this.icon_connected.Visibility = Visibility.Visible;
this.icon_disconnected.Visibility = Visibility.Collapsed;
});
};
trigger.Falling += (sender, args) =>
{
Application.Current.Dispatcher.InvokeAsync(
async() =>
{
this.icon_connected.Visibility = Visibility.Collapsed;
this.icon_disconnected.Visibility = Visibility.Visible;
await this.UpdateAccount();
});
};
while (true)
{
try
{
Thread.Sleep(3000);
if (Config.Instance.Install)
{
Injection.Pulse();
trigger.Value = Injection.IsInjected;
Console.WriteLine(Injection.SharedMemory.Data.IsLoaded);
}
}
catch
{
// ignored - A task was canceled.
}
}
});
this.InjectThread.SetApartmentState(ApartmentState.STA);
this.InjectThread.Start();
}
/// <summary>
/// Save settings.
/// </summary>
/// <param name="storage">Settings storage.</param>
public override void Save(SettingsStorage storage)
{
base.Save(storage);
storage.SetValue("Uuid", Uuid);
storage.SetValue("Address", Address.To <string>());
storage.SetValue("Login", Login);
storage.SetValue("Password", Password);
storage.SetValue("Remoting", Remoting.To <string>());
storage.SetValue("UseNativeReconnect", UseNativeReconnect);
storage.SetValue("EnableOECLogging", EnableOECLogging);
}
private void OnLogin(string username)
{
Utility.Log(LogStatus.Ok, "Login", string.Format("Succesfully signed in as {0}", username), Logs.MainLog);
this.Browser.Visibility = Visibility.Visible;
this.TosBrowser.Visibility = Visibility.Visible;
try
{
Utility.MapClassToXmlFile(typeof(Config), Config.Instance, Directories.ConfigFilePath);
}
catch
{
MessageBox.Show(Utility.GetMultiLanguageText("ConfigWriteError"));
}
if (!PathRandomizer.CopyFiles())
{
}
Remoting.Init();
this.InjectThread = new Thread(
() =>
{
while (true)
{
if (Config.Instance.Install)
{
Injection.Pulse();
}
Application.Current.Dispatcher.Invoke(
() =>
{
if (Injection.IsInjected)
{
this.icon_connected.Visibility = Visibility.Visible;
this.icon_disconnected.Visibility = Visibility.Collapsed;
}
else
{
this.icon_connected.Visibility = Visibility.Collapsed;
this.icon_disconnected.Visibility = Visibility.Visible;
}
});
Thread.Sleep(3000);
}
});
this.InjectThread.SetApartmentState(ApartmentState.STA);
this.InjectThread.Start();
}
private void RequestID()
{
try
{
clientTcp = new ClientTcp();
req = Activator.GetObject(typeof(Remoting), "tcp://localhost:1000/TakeID") as Remoting;
clientTcp.ID = req.GetID();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public CrossStage(Remoting.ISoulBinder provider
, Regulus.Project.SamebestKeys.IWorld world
, string target_map
, Regulus.CustomType.Vector2 target_position
, string current_map
, Regulus.CustomType.Vector2 current_position)
{
this._World = world;
this._TargetMap = target_map;
this._TargetPosition = target_position;
this._CurrentMap = current_map;
this._CurrentPosition = current_position;
_Provider = provider;
}
public static int Run()
{
DoSomething doSomething;
TimeSpan time;
Console.WriteLine("Measuring remote");
using (Remoting helper = new Remoting()) {
helper.Start("RemotingHelper.exe", helper.SocketPath);
doSomething = helper.Get <DoSomething>();
time = Do(doSomething);
}
Console.WriteLine("Elapsed (remote): {0}", time);
Console.WriteLine("Measuring local");
doSomething = new DoSomething();
time = Do(doSomething);
Console.WriteLine("Elapsed (local): {0}", time);
return(0);
}
public void ApplyMachineInformation(string ipAddress, Remoting.Server.Data.Transfer.Machine machine)
{
if (ipAddress.Equals("localhost"))
ipAddress = Instances.Single(i => i.MachineName.Equals(Environment.MachineName)).IpAddress;
Instance instance = Instances.SingleOrDefault(i => i.IpAddress.Equals(ipAddress));
if (instance != null)
instanceMachines[instance] = machine;
TreeNode[] nodes = treeView1.Nodes[0].Nodes.Find(ipAddress, false);
if (nodes.Length > 0)
{
if ((machine.TotalSha256Hashrate > 0) && (machine.TotalScryptHashrate > 0))
{
nodes[0].Text = String.Format("{0} ({1}, {2})",
GetMachineName(ipAddress),
machine.TotalSha256Hashrate.ToHashrateString(),
machine.TotalScryptHashrate.ToHashrateString());
}
else if (machine.TotalSha256Hashrate > 0)
{
nodes[0].Text = String.Format("{0} ({1})",
GetMachineName(ipAddress),
machine.TotalSha256Hashrate.ToHashrateString());
}
else if (machine.TotalScryptHashrate > 0)
{
nodes[0].Text = String.Format("{0} ({1})",
GetMachineName(ipAddress),
machine.TotalScryptHashrate.ToHashrateString());
}
else
{
nodes[0].Text = GetMachineName(ipAddress);
}
}
RefreshNetworkTotals();
}
private void InitSystem()
{
PathRandomizer.CopyFiles();
Remoting.Init();
this.InjectThread = new Thread(
() =>
{
while (true)
{
if (Config.Instance.Install)
{
Injection.Pulse();
}
Application.Current.Dispatcher.Invoke(
() =>
{
if (Injection.IsInjected)
{
this.icon_connected.Visibility = Visibility.Visible;
this.icon_disconnected.Visibility = Visibility.Collapsed;
}
else
{
this.icon_connected.Visibility = Visibility.Collapsed;
this.icon_disconnected.Visibility = Visibility.Visible;
}
});
Thread.Sleep(3000);
}
});
this.InjectThread.SetApartmentState(ApartmentState.STA);
this.InjectThread.Start();
}
public void ApplyMachineInformation(string ipAddress, Remoting.Data.Transfer.Machine machine)
{
if (ipAddress.Equals("localhost"))
ipAddress = ThisPCInstance.IpAddress;
Instance instance = Instances.SingleOrDefault(i => i.IpAddress.Equals(ipAddress));
if (instance != null)
{
instanceUpdateDates[instance] = DateTime.Now;
instanceMachines[instance] = machine;
}
TreeNode[] nodes = treeView1.Nodes[0].Nodes.Find(ipAddress, false);
if (nodes.Length > 0)
{
if (machine.TotalHashrates.Keys.Count > 0)
{
string text = String.Empty;
foreach (string algorithm in machine.TotalHashrates.Keys)
{
if (!String.IsNullOrEmpty(text))
text = text + ", ";
text = String.Format("{0}{1}: {2}", text, algorithm, machine.TotalHashrates[algorithm].ToHashrateString());
}
nodes[0].Text = String.Format("{0} ({1})", GetMachineName(ipAddress), text);
}
else
{
nodes[0].Text = GetMachineName(ipAddress);
}
}
RemoveOrphans();
RefreshNetworkTotals();
}
private void _Bind(Player player, Remoting.ISoulBinder binder)
{
binder.Bind<IPlayer>(player);
var observe = player.FindAbility<IObserveAbility>();
if (observe != null)
{
_ObservedInto = (observed) =>
{
binder.Bind<IObservedAbility>(observed);
_Observeds.Add(observed);
};
_ObservedLeft = (observed) =>
{
_Observeds.Remove(observed);
binder.Unbind<IObservedAbility>(observed);
};
observe.IntoEvent += _ObservedInto;
observe.LeftEvent += _ObservedLeft;
}
binder.Bind<Regulus.Remoting.ITime>(LocalTime.Instance);
binder.Bind<IRealmJumper>(this);
}
public IRemoting Create(IConnection connection, IRemotingMessengerFactory messengerFactory, IRemotingFunctionFactory functionFactory, IBytesPool bytesPool)
{
var result = new Remoting(connection, messengerFactory, functionFactory, bytesPool);
return(result);
}
private void SetConfigurationRequested(object sender, Remoting.ConfigurationEventArgs ea)
{
PerformRequestedCommand(ea.IpAddress, ea.Signature, () =>
{
string oldConfigPath = PathConfiguration.SharedConfigPath;
if (ea.Application != null)
{
ObjectCopier.CopyObject(ea.Application.ToModelObject(), ApplicationConfiguration);
ApplicationConfiguration.SaveApplicationConfiguration();
}
if (ea.Engine != null)
{
ObjectCopier.CopyObject(ea.Engine.ToModelObject(), EngineConfiguration);
EngineConfiguration.SaveAllConfigurations();
}
if (ea.Path != null)
{
ObjectCopier.CopyObject(ea.Path, PathConfiguration);
PathConfiguration.SavePathConfiguration();
}
if (ea.Perks != null)
{
ObjectCopier.CopyObject(ea.Perks, PerksConfiguration);
PerksConfiguration.SavePerksConfiguration();
}
//save settings as the "shared" config path may have changed
//these are settings not considered machine/device-specific
//e.g. no device settings, no miner settings
string newConfigPath = PathConfiguration.SharedConfigPath;
MigrateSettingsToNewFolder(oldConfigPath, newConfigPath);
Context.BeginInvoke((Action)(() =>
{
//code to update UI
LocalViewModel.ApplyCoinConfigurationModels(EngineConfiguration.CoinConfigurations);
LocalViewModel.ApplyDeviceConfigurationModels(EngineConfiguration.DeviceConfigurations,
EngineConfiguration.CoinConfigurations);
if (ConfigurationModified != null) ConfigurationModified(this, new EventArgs());
}), null);
});
}
private void GetConfigurationRequested(object sender, Remoting.ConfigurationEventArgs ea)
{
PerformRequestedCommand(ea.IpAddress, ea.Signature, () =>
{
ObjectCopier.CopyObject(ApplicationConfiguration.ToTransferObject(), ea.Application);
ObjectCopier.CopyObject(EngineConfiguration.ToTransferObject(), ea.Engine);
ObjectCopier.CopyObject(PathConfiguration, ea.Path);
ObjectCopier.CopyObject(PerksConfiguration, ea.Perks);
});
}
public void PopulateLocalMachineHashrates(Remoting.Data.Transfer.Machine machine, bool includeNetworkDevices)
{
machine.TotalScryptHashrate = GetLocalInstanceHashrate(AlgorithmNames.Scrypt, includeNetworkDevices);
machine.TotalSha256Hashrate = GetLocalInstanceHashrate(AlgorithmNames.SHA256, includeNetworkDevices);
IList<CoinAlgorithm> algorithms = MinerFactory.Instance.Algorithms;
foreach (CoinAlgorithm algorithm in algorithms)
{
double hashrate = GetLocalInstanceHashrate(algorithm.Name, includeNetworkDevices);
if (hashrate > 0.00)
machine.TotalHashrates[algorithm.Name] = hashrate;
}
}
private void HandlePacketReceived(object sender, Remoting.Server.Broadcast.PacketReceivedArgs ea)
{
Type type = typeof(Remoting.Server.Data.Transfer.Machine);
if (ea.Packet.Descriptor.Equals(type.FullName))
{
JavaScriptSerializer serializer = new JavaScriptSerializer();
Remoting.Server.Data.Transfer.Machine dto = serializer.Deserialize<Remoting.Server.Data.Transfer.Machine>(ea.Packet.Payload);
BeginInvoke((Action)(() =>
{
//code to update UI
instancesControl.ApplyMachineInformation(ea.IpAddress, dto);
}));
}
}
private void HandlePacketReceived(object sender, Remoting.Broadcast.PacketReceivedArgs ea)
{
Type type = typeof(Remoting.Data.Transfer.Machine);
if (ea.Packet.Descriptor.Equals(type.FullName))
{
JavaScriptSerializer serializer = new JavaScriptSerializer();
Remoting.Data.Transfer.Machine dto = serializer.Deserialize<Remoting.Data.Transfer.Machine>(ea.Packet.Payload);
if ((instancesControl.ThisPCInstance != null) &&
(instancesControl.ThisPCInstance.IpAddress.Equals(ea.IpAddress)))
//don't process packets broadcast by This PC
//for instance we don't broadcast out hashrate for Network Devices and
//so don't want to process the packet
return;
BeginInvoke((Action)(() =>
{
//code to update UI
instancesControl.ApplyMachineInformation(ea.IpAddress, dto);
}));
}
}
private void SetConfigurationRemotely(
Instance instance,
Remoting.Data.Transfer.Configuration.Application application,
Remoting.Data.Transfer.Configuration.Engine engine,
Remoting.Data.Transfer.Configuration.Path path,
Remoting.Data.Transfer.Configuration.Perks perks)
{
PerformRemoteCommand(instance, (service) =>
{
service.SetApplicationConfiguration(
GetSendingSignature(instance),
application,
engine,
path,
perks);
});
}
private void _Unbind(Player player, Remoting.ISoulBinder binder)
{
binder.Unbind<IRealmJumper>(this);
binder.Unbind<Regulus.Remoting.ITime>(LocalTime.Instance);
var observe = player.FindAbility<IObserveAbility>();
if (observe != null)
{
observe.IntoEvent -= _ObservedInto;
observe.LeftEvent -= _ObservedLeft;
}
foreach (var o in _Observeds)
{
binder.Unbind<IObservedAbility>(o);
}
binder.Unbind<IPlayer>(player);
}
void Utility.ICore.ObtainController(Remoting.ISoulBinder binder)
{
_Hall.PushUser(new User(binder, _Stroage));
}
private void button1_Click(object sender, EventArgs e)
{
T.MARK(" ------------ INTER-QUEUES STANDALONE MARK {0} ------------ ", mark_cnt++);
Remoting.DumpAllInfoAboutRegisteredRemotingTypes();
}
void Game.ICore.ObtainController(Remoting.ISoulBinder binder)
{
_Complex.ObtainController(binder);
}
public static Remoting GetInstance()
{
if (_theUniqueInstance == null)
return _theUniqueInstance = new Remoting();
return _theUniqueInstance;
}
public RemotingMessageReceiver(Remoting remoting)
{
_remoting = remoting;
}
public VerifyStage(Remoting.ISoulBinder binder, Verify verify)
{
this._Verify = verify;
this._Binder = binder;
}
private void PopulateLocalMachineHashrates(Remoting.Data.Transfer.Machine machine, bool includeNetworkDevices)
{
machine.TotalScryptHashrate = GetLocalInstanceHashrate(CoinAlgorithm.Scrypt, includeNetworkDevices);
machine.TotalSha256Hashrate = GetLocalInstanceHashrate(CoinAlgorithm.SHA256, includeNetworkDevices);
IList<CoinAlgorithm> algorithms = ((CoinAlgorithm[])Enum.GetValues(typeof(CoinAlgorithm))).ToList();
foreach (CoinAlgorithm algorithm in algorithms)
{
double hashrate = GetLocalInstanceHashrate(algorithm, includeNetworkDevices);
if (hashrate > 0.00)
machine.TotalHashrates[algorithm.ToString()] = hashrate;
}
}
public VerifyStage(Remoting.ISoulBinder binder , IStorage storage)
{
this._Binder = binder;
_Storage = storage;
}
public SkillHitToIdleBehaviorHandler(Entity entity, Remoting.Value<CastResult> result)
{
this._Entity = entity;
this._Result = result;
}
public Battle(IBattleAdmissionTickets battle_admission_tickets, ActorInfomation actor_infomation, Remoting.ISoulBinder binder, IStorage stroage)
{
_BattleAdmissionTickets = battle_admission_tickets;
_ActorInfomation = actor_infomation;
_Binder = binder;
_Storage = stroage;
}
