public PICSChanges(CallbackManager manager)
: base(manager)
{
if (Settings.IsFullRun)
{
PreviousChangeNumber = 1; // Request everything
manager.Register(new Callback<SteamApps.PICSChangesCallback>(OnPICSChangesFullRun));
return;
}
manager.Register(new Callback<SteamApps.PICSChangesCallback>(OnPICSChanges));
using (MySqlDataReader Reader = DbWorker.ExecuteReader("SELECT `ChangeID` FROM `Changelists` ORDER BY `ChangeID` DESC LIMIT 1"))
{
if (Reader.Read())
{
PreviousChangeNumber = Reader.GetUInt32("ChangeID");
Log.WriteInfo("PICSChanges", "Previous changelist was {0}", PreviousChangeNumber);
}
}
if (PreviousChangeNumber == 0)
{
Log.WriteWarn("PICSChanges", "Looks like there are no changelists in the database.");
Log.WriteWarn("PICSChanges", "If you want to fill up your database first, restart with \"FullRun\" setting set to 1.");
}
}
public PICSChanges(CallbackManager manager)
: base(manager)
{
if (Settings.IsFullRun)
{
PreviousChangeNumber = 1; // Request everything
manager.Register(new Callback <SteamApps.PICSChangesCallback>(OnPICSChangesFullRun));
return;
}
manager.Register(new Callback <SteamApps.PICSChangesCallback>(OnPICSChanges));
using (var db = Database.GetConnection())
{
BillingTypeKey = db.ExecuteScalar <uint>("SELECT `ID` FROM `KeyNamesSubs` WHERE `Name` = 'root_billingtype'");
PreviousChangeNumber = db.ExecuteScalar <uint>("SELECT `ChangeID` FROM `Changelists` ORDER BY `ChangeID` DESC LIMIT 1");
Log.WriteInfo("PICSChanges", "Previous changelist was {0}", PreviousChangeNumber);
}
if (PreviousChangeNumber == 0)
{
Log.WriteWarn("PICSChanges", "Looks like there are no changelists in the database.");
Log.WriteWarn("PICSChanges", "If you want to fill up your database first, restart with \"FullRun\" setting set to 1.");
}
}
public GameCoordinator(SteamClient steamClient, CallbackManager manager)
{
SessionMap = new Dictionary <uint, SessionInfo>();
// Map gc messages to our callback functions
MessageMap = new Dictionary <uint, Action <uint, IPacketGCMsg> >
{
{ (uint)EGCBaseClientMsg.k_EMsgGCClientConnectionStatus, OnConnectionStatus },
{ (uint)EGCBaseClientMsg.k_EMsgGCClientWelcome, OnWelcome },
{ (uint)EGCItemMsg.k_EMsgGCUpdateItemSchema, OnItemSchemaUpdate },
{ (uint)EGCItemMsg.k_EMsgGCClientVersionUpdated, OnVersionUpdate },
{ (uint)EGCBaseMsg.k_EMsgGCSystemMessage, OnSystemMessage },
// TF2 specific messages
{ k_EMsgGCClientGoodbye, OnConnectionStatus },
{ (uint)EGCItemMsg.k_EMsgGCGoldenWrenchBroadcast, OnWrenchBroadcast },
{ k_EMsgGCTFSpecificItemBroadcast, OnItemBroadcast },
};
SteamGameCoordinator = steamClient.GetHandler <SteamGameCoordinator>();
SessionTimer = new Timer();
SessionTimer.Interval = TimeSpan.FromSeconds(30).TotalMilliseconds;
SessionTimer.Elapsed += OnSessionTick;
SessionTimer.Start();
manager.Register(new Callback <SteamGameCoordinator.MessageCallback>(OnGameCoordinatorMessage));
manager.Register(new Callback <SteamUser.LoggedOffCallback>(OnLoggedOff));
manager.Register(new Callback <SteamClient.DisconnectedCallback>(OnDisconnected));
}
public GameCoordinator(SteamClient steamClient, CallbackManager manager)
{
SessionMap = new Dictionary<uint, SessionInfo>();
// Map gc messages to our callback functions
MessageMap = new Dictionary<uint, Action<uint, IPacketGCMsg>>
{
{ (uint)EGCBaseClientMsg.k_EMsgGCClientConnectionStatus, OnConnectionStatus },
{ (uint)EGCBaseClientMsg.k_EMsgGCClientWelcome, OnWelcome },
{ (uint)EGCItemMsg.k_EMsgGCUpdateItemSchema, OnItemSchemaUpdate },
{ (uint)EGCItemMsg.k_EMsgGCClientVersionUpdated, OnVersionUpdate },
{ (uint)EGCBaseMsg.k_EMsgGCSystemMessage, OnSystemMessage },
// TF2 specific messages
{ k_EMsgGCClientGoodbye, OnConnectionStatus },
{ (uint)EGCItemMsg.k_EMsgGCGoldenWrenchBroadcast, OnWrenchBroadcast },
{ k_EMsgGCTFSpecificItemBroadcast, OnItemBroadcast },
};
SteamGameCoordinator = steamClient.GetHandler<SteamGameCoordinator>();
SessionTimer = new Timer();
SessionTimer.Interval = TimeSpan.FromSeconds(30).TotalMilliseconds;
SessionTimer.Elapsed += OnSessionTick;
SessionTimer.Start();
manager.Register(new Callback<SteamGameCoordinator.MessageCallback>(OnGameCoordinatorMessage));
manager.Register(new Callback<SteamUser.LoggedOffCallback>(OnLoggedOff));
manager.Register(new Callback<SteamClient.DisconnectedCallback>(OnDisconnected));
}
public static Task <List <byte> > DecryptSealedBoxAsync(List <byte> cipherText, ulong pkHandle, ulong skHandle)
{
var tcs = new TaskCompletionSource <List <byte> >();
var cipherPtr = cipherText.ToIntPtr();
DecryptSealedBoxCb callback = null;
callback = (self, result, dataPtr, dataLen) => {
// Marshal.FreeHGlobal(cipherPtr); // TODO: Temp soln
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(callback);
return;
}
var data = dataPtr.ToList <byte>(dataLen);
tcs.SetResult(data);
CallbackManager.Unregister(callback);
};
CallbackManager.Register(callback);
NativeBindings.DecryptSealedBox(Session.AppPtr, cipherPtr, (IntPtr)cipherText.Count, pkHandle, skHandle, Session.UserData, callback);
// Marshal.FreeHGlobal(cipherPtr);
return(tcs.Task);
}
public static Task <List <List <byte> > > MDataKeysForEachAsync(ulong entKeysH)
{
var tcs = new TaskCompletionSource <List <List <byte> > >();
var keys = new List <List <byte> >();
MDataKeysForEachCb forEachCb = null;
forEachCb = (pVoid, bytePtr, len) => {
var key = bytePtr.ToList <byte>(len);
keys.Add(key);
};
CallbackManager.Register(forEachCb);
MDataKeysForEachResCb forEachResCb = null;
forEachResCb = (ptr, result) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(forEachCb);
CallbackManager.Unregister(forEachResCb);
return;
}
tcs.SetResult(keys);
CallbackManager.Unregister(forEachCb);
CallbackManager.Unregister(forEachResCb);
};
CallbackManager.Register(forEachResCb);
NativeBindings.MDataKeysForEach(Session.AppPtr, entKeysH, forEachCb, Session.UserData, forEachResCb);
return(tcs.Task);
}
public static Task <List <Tuple <List <byte>, List <byte>, ulong> > > MDataEntriesForEachAsync(ulong entH)
{
var tcs = new TaskCompletionSource <List <Tuple <List <byte>, List <byte>, ulong> > >();
var entries = new List <Tuple <List <byte>, List <byte>, ulong> >();
MDataEntriesForEachCb forEachCb = null;
forEachCb = (pVoid, entryKeyPtr, entryKeyLen, entryValPtr, entryValLen, entryVersion) => {
var entryKey = entryKeyPtr.ToList <byte>(entryKeyLen);
var entryVal = entryValPtr.ToList <byte>(entryValLen);
entries.Add(Tuple.Create(entryKey, entryVal, entryVersion));
};
CallbackManager.Register(forEachCb);
MDataEntriesForEachResCb forEachResCb = null;
forEachResCb = (ptr, result) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(forEachCb);
CallbackManager.Unregister(forEachResCb);
return;
}
tcs.SetResult(entries);
CallbackManager.Unregister(forEachCb);
CallbackManager.Unregister(forEachResCb);
};
CallbackManager.Register(forEachResCb);
NativeBindings.MDataEntriesForEach(Session.AppPtr, entH, forEachCb, Session.UserData, forEachResCb);
return(tcs.Task);
}
public static Task <Tuple <List <byte>, ulong> > MDataGetValueAsync(ulong infoHandle, List <byte> key)
{
var tcs = new TaskCompletionSource <Tuple <List <byte>, ulong> >();
var keyPtr = key.ToIntPtr();
MDataGetValueCb callback = null;
callback = (self, result, dataPtr, dataLen, entryVersion) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(callback);
return;
}
var data = dataPtr.ToList <byte>(dataLen);
tcs.SetResult(Tuple.Create(data, entryVersion));
CallbackManager.Unregister(callback);
};
CallbackManager.Register(callback);
NativeBindings.MDataGetValue(Session.AppPtr, infoHandle, keyPtr, (IntPtr)key.Count, Session.UserData, callback);
Marshal.FreeHGlobal(keyPtr);
return(tcs.Task);
}
public Connection(CallbackManager manager)
: base(manager)
{
SentryFile = Path.Combine(Application.Path, "files", ".support", "sentry.bin");
ReconnectionTimer = new Timer();
ReconnectionTimer.AutoReset = false;
ReconnectionTimer.Elapsed += Reconnect;
ReconnectionTimer.Interval = TimeSpan.FromSeconds(RETRY_DELAY).TotalMilliseconds;
manager.Register(new Callback<SteamClient.ConnectedCallback>(OnConnected));
manager.Register(new Callback<SteamClient.DisconnectedCallback>(OnDisconnected));
manager.Register(new Callback<SteamUser.LoggedOnCallback>(OnLoggedOn));
manager.Register(new Callback<SteamUser.LoggedOffCallback>(OnLoggedOff));
manager.Register(new Callback<SteamUser.UpdateMachineAuthCallback>(OnMachineAuth));
}
public Connection(CallbackManager manager)
: base(manager)
{
SentryFile = Path.Combine(Application.Path, "sentry.bin");
ReconnectionTimer = new Timer();
ReconnectionTimer.AutoReset = false;
ReconnectionTimer.Elapsed += Reconnect;
ReconnectionTimer.Interval = TimeSpan.FromSeconds(RETRY_DELAY).TotalMilliseconds;
manager.Register(new Callback <SteamClient.ConnectedCallback>(OnConnected));
manager.Register(new Callback <SteamClient.DisconnectedCallback>(OnDisconnected));
manager.Register(new Callback <SteamUser.LoggedOnCallback>(OnLoggedOn));
manager.Register(new Callback <SteamUser.LoggedOffCallback>(OnLoggedOff));
manager.Register(new Callback <SteamUser.UpdateMachineAuthCallback>(OnMachineAuth));
}
public static Task <bool> AppRegisteredAsync(string appId, AuthGranted authGranted)
{
return(Task.Run(
() => {
var tcs = new TaskCompletionSource <bool>();
var authGrantedFfi = new AuthGrantedFfi {
AccessContainer = authGranted.AccessContainer,
AppKeys = authGranted.AppKeys,
BootStrapConfigPtr = authGranted.BootStrapConfig.ToIntPtr(),
BootStrapConfigLen = (IntPtr)authGranted.BootStrapConfig.Count
};
var authGrantedFfiPtr = CommonUtils.Helpers.StructToPtr(authGrantedFfi);
AppRegisteredCallback callback = null;
callback = (ptr, result, appPtr) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(callback);
return;
}
AppPtr = appPtr;
tcs.SetResult(true);
CallbackManager.Unregister(callback);
};
CallbackManager.Register(callback);
NativeBindings.AppRegistered(appId, authGrantedFfiPtr, IntPtr.Zero, UserData, NetObs, callback);
Marshal.FreeHGlobal(authGrantedFfi.BootStrapConfigPtr);
Marshal.FreeHGlobal(authGrantedFfiPtr);
return tcs.Task;
}));
}
public static Task <ulong> MDataInfoDeserialiseAsync(List <byte> serialisedData)
{
var tcs = new TaskCompletionSource <ulong>();
MDataInfoDeserialiseCb callback = null;
callback = (pVoid, result, mdataInfoH) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(callback);
return;
}
tcs.SetResult(mdataInfoH);
CallbackManager.Unregister(callback);
};
CallbackManager.Register(callback);
var serialisedDataPtr = serialisedData.ToIntPtr();
NativeBindings.MDataInfoDeserialise(Session.AppPtr, serialisedDataPtr, (IntPtr)serialisedData.Count, Session.UserData, callback);
Marshal.FreeHGlobal(serialisedDataPtr);
return(tcs.Task);
}
public static Task <string> EncodeAuthReqAsync(AuthReq authReq)
{
return(Task.Run(
() => {
var tcs = new TaskCompletionSource <string>();
var authReqFfi = new AuthReqFfi {
AppContainer = authReq.AppContainer,
AppExchangeInfo = authReq.AppExchangeInfo,
ContainersLen = (IntPtr)authReq.Containers.Count,
ContainersArrayPtr = authReq.Containers.ToIntPtr()
};
var authReqFfiPtr = CommonUtils.Helpers.StructToPtr(authReqFfi);
EncodeAuthReqCb callback = null;
callback = (ptr, result, id, req) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(callback);
return;
}
tcs.SetResult(req);
CallbackManager.Unregister(callback);
};
CallbackManager.Register(callback);
NativeBindings.EncodeAuthReq(authReqFfiPtr, UserData, callback);
Marshal.FreeHGlobal(authReqFfi.ContainersArrayPtr);
Marshal.FreeHGlobal(authReqFfiPtr);
return tcs.Task;
}));
}
public static Task <ulong> MDataInfoNewPublicAsync(List <byte> xorName, ulong typeTag)
{
var tcs = new TaskCompletionSource <ulong>();
MDataInfoNewPublicCb callback = null;
callback = (pVoid, result, pubMDataInfoH) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(callback);
return;
}
tcs.SetResult(pubMDataInfoH);
CallbackManager.Unregister(callback);
};
CallbackManager.Register(callback);
var xorNamePtr = xorName.ToIntPtr();
NativeBindings.MDataInfoNewPublic(Session.AppPtr, xorNamePtr, typeTag, Session.UserData, callback);
Marshal.FreeHGlobal(xorNamePtr);
return(tcs.Task);
}
public static Task <List <byte> > MDataInfoDecryptAsync(ulong mDataInfoH, List <byte> cipherText)
{
var tcs = new TaskCompletionSource <List <byte> >();
var cipherPtr = cipherText.ToIntPtr();
var cipherLen = (IntPtr)cipherText.Count;
MDataInfoDecryptCb callback = null;
callback = (pVoid, result, plainText, len) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(callback);
return;
}
var byteList = plainText.ToList <byte>(len);
tcs.SetResult(byteList);
CallbackManager.Unregister(callback);
};
CallbackManager.Register(callback);
NativeBindings.MDataInfoDecrypt(Session.AppPtr, mDataInfoH, cipherPtr, cipherLen, Session.UserData, callback);
Marshal.FreeHGlobal(cipherPtr);
return(tcs.Task);
}
public virtual INavigationOperation TryShowAsync(IViewModel viewModel, IDataContext context,
IViewModelPresenter parentPresenter)
{
if (!MultiViewModel.ViewModelType.IsInstanceOfType(viewModel))
{
return(null);
}
bool data;
if (context.TryGetData(NavigationConstants.SuppressTabNavigation, out data) && data)
{
return(null);
}
if (!CanShowViewModel(viewModel, context, parentPresenter))
{
return(null);
}
if (MultiViewModel.ItemsSource.Any(vm => vm == viewModel))
{
MultiViewModel.SelectedItem = viewModel;
}
else
{
MultiViewModel.AddViewModel(viewModel, true);
}
var operation = new NavigationOperation();
CallbackManager.Register(OperationType.TabNavigation, viewModel, operation.ToOperationCallback(), context);
return(operation);
}
public GameCoordinator(uint appID, SteamClient steamClient, CallbackManager callbackManager)
{
// Map gc messages to our callback functions
GCMessageMap = new Dictionary<uint, Action<IPacketGCMsg>>
{
{ (uint)EGCBaseClientMsg.k_EMsgGCClientWelcome, OnClientWelcome },
{ (uint)EGCItemMsg.k_EMsgGCUpdateItemSchema, OnItemSchemaUpdate },
{ (uint)EGCBaseMsg.k_EMsgGCSystemMessage, OnSystemMessage },
{ (uint)EGCBaseClientMsg.k_EMsgGCClientConnectionStatus, OnClientConnectionStatus },
{ (uint)4008 /* TF2's k_EMsgGCClientGoodbye */, OnClientConnectionStatus }
};
this.AppID = appID;
this.SteamClient = steamClient;
this.SteamGameCoordinator = SteamClient.GetHandler<SteamGameCoordinator>();
this.Name = string.Format("GC {0}", appID);
// Make sure Steam knows we're playing the game
Timer = new System.Timers.Timer();
Timer.Elapsed += OnTimerPlayGame;
Timer.Interval = TimeSpan.FromMinutes(5).TotalMilliseconds;
Timer.Start();
Timer = new System.Timers.Timer();
Timer.Elapsed += OnTimer;
callbackManager.Register(new Callback<SteamGameCoordinator.MessageCallback>(OnGameCoordinatorMessage));
}
public PICSTokens(CallbackManager manager)
: base(manager)
{
manager.Register(new Callback <SteamApps.PICSTokensCallback>(OnPICSTokens));
Reload();
}
public PICSTokens(CallbackManager manager)
: base(manager)
{
manager.Register(new Callback<SteamApps.PICSTokensCallback>(OnPICSTokens));
Reload();
}
public GCIdler(uint appID)
{
AppID = appID;
Client = new SteamClient();
User = Client.GetHandler <SteamGameServer>();
CallbackManager = new CallbackManager(Client);
CallbackManager.Register(new Callback <SteamClient.ConnectedCallback>(OnConnected));
CallbackManager.Register(new Callback <SteamClient.DisconnectedCallback>(OnDisconnected));
CallbackManager.Register(new Callback <SteamUser.LoggedOnCallback>(OnLoggedOn));
CallbackManager.Register(new Callback <SteamUser.LoggedOffCallback>(OnLoggedOff));
GameCoordinator = new GameCoordinator(AppID, Client, CallbackManager);
}
public GCIdler(uint appID)
{
AppID = appID;
Client = new SteamClient();
User = Client.GetHandler<SteamGameServer>();
CallbackManager = new CallbackManager(Client);
CallbackManager.Register(new Callback<SteamClient.ConnectedCallback>(OnConnected));
CallbackManager.Register(new Callback<SteamClient.DisconnectedCallback>(OnDisconnected));
CallbackManager.Register(new Callback<SteamUser.LoggedOnCallback>(OnLoggedOn));
CallbackManager.Register(new Callback<SteamUser.LoggedOffCallback>(OnLoggedOff));
GameCoordinator = new GameCoordinator(AppID, Client, CallbackManager);
}
public void RegisterCommandHandlers(CommandHandler handler)
{
if (Settings.Current.ChatRooms.Count > 0)
{
CallbackManager.Register(new Callback <SteamFriends.ChatMsgCallback>(handler.OnSteamChatMessage));
}
CallbackManager.Register(new Callback <SteamFriends.FriendMsgCallback>(handler.OnSteamFriendMessage));
}
public DepotProcessor(SteamClient client, CallbackManager manager)
{
DepotLocks = new ConcurrentDictionary <uint, byte>();
CDNClient = new CDNClient(client);
FileDownloader.SetCDNClient(CDNClient);
CDNServers = new List <string>
{
"cdn.level3.cs.steampowered.com",
"cdn.akamai.cs.steampowered.com",
"cdn.highwinds.cs.steampowered.com"
};
manager.Register(new Callback <SteamApps.CDNAuthTokenCallback>(OnCDNAuthTokenCallback));
manager.Register(new Callback <SteamApps.DepotKeyCallback>(OnDepotKeyCallback));
}
public DepotProcessor(SteamClient client, CallbackManager manager)
{
DepotLocks = new ConcurrentDictionary<uint, byte>();
CDNClient = new CDNClient(client);
FileDownloader.SetCDNClient(CDNClient);
CDNServers = new List<string>
{
"cdn.level3.cs.steampowered.com",
"cdn.akamai.cs.steampowered.com",
"cdn.highwinds.cs.steampowered.com"
};
manager.Register(new Callback<SteamApps.CDNAuthTokenCallback>(OnCDNAuthTokenCallback));
manager.Register(new Callback<SteamApps.DepotKeyCallback>(OnDepotKeyCallback));
}
public GCIdler(uint appID, string username, string password)
{
Username = username;
Password = password;
AppID = appID;
Client = new SteamClient();
User = Client.GetHandler<SteamUser>();
Friends = Client.GetHandler<SteamFriends>();
CallbackManager = new CallbackManager(Client);
CallbackManager.Register(new Callback<SteamClient.ConnectedCallback>(OnConnected));
CallbackManager.Register(new Callback<SteamClient.DisconnectedCallback>(OnDisconnected));
CallbackManager.Register(new Callback<SteamUser.AccountInfoCallback>(OnAccountInfo));
CallbackManager.Register(new Callback<SteamUser.LoggedOnCallback>(OnLoggedOn));
GameCoordinator = new GameCoordinator(AppID, Client, CallbackManager);
}
public DepotProcessor(SteamClient client, CallbackManager manager)
{
DepotLocks = new ConcurrentDictionary<uint, byte>();
CDNClient = new CDNClient(client);
CDNServers = new List<string>
{
"content1.steampowered.com", // Limelight
"content2.steampowered.com", // Level3
"content3.steampowered.com", // Highwinds
//"content4.steampowered.com", // EdgeCast, seems to be missing content
"content5.steampowered.com", // CloudFront
//"content6.steampowered.com", // Comcast, non optimal
"content7.steampowered.com", // Akamai
"content8.steampowered.com" // Akamai
};
manager.Register(new Callback<SteamApps.CDNAuthTokenCallback>(OnCDNAuthTokenCallback));
manager.Register(new Callback<SteamApps.DepotKeyCallback>(OnDepotKeyCallback));
}
protected virtual IAsyncOperation TryShowInternalAsync(IViewModel viewModel, IDataContext context, IViewModelPresenter parentPresenter)
{
if (MultiViewModel.ItemsSource.Any(vm => vm == viewModel))
{
MultiViewModel.SelectedItem = viewModel;
}
else
{
MultiViewModel.AddViewModel(viewModel, true);
}
var operation = new AsyncOperation <object>();
CallbackManager.Register(OperationType.TabNavigation, viewModel, operation.ToOperationCallback(), context);
return(operation);
}
public Task NavigateAsync(IOperationCallback callback, IDataContext context)
{
Should.NotBeNull(context, nameof(context));
IViewModel viewModel = context.GetData(NavigationConstants.ViewModel);
if (viewModel == null)
{
throw new InvalidOperationException($"The '{GetType()}' provider doesn't support the DataContext without navigation target.");
}
context = context.ToNonReadOnly();
if (ReferenceEquals(viewModel, CurrentViewModel))
{
if (callback != null)
{
CallbackManager.Register(OperationType.PageNavigation, viewModel, callback, context);
}
return(Empty.Task);
}
//The view model is already shown as page and we need to bring it to front
if (viewModel.Settings.State.Contains(IsNavigatedConstant))
{
context.AddOrUpdate(NavigationProviderConstants.BringToFront, true);
}
string viewName = viewModel.GetViewName(context);
var vmType = viewModel.GetType();
var mappingItem = ViewMappingProvider.FindMappingForViewModel(vmType, viewName, true);
var id = Guid.NewGuid().ToString("n");
var parameter = GenerateNavigationParameter(vmType, id);
var tcs = new TaskCompletionSource <object>();
CurrentNavigationTask.TryExecuteSynchronously(_ =>
ThreadManager.InvokeOnUiThreadAsync(() =>
{
_navigatedTcs = tcs;
_navigationTargetVm = viewModel;
_currentCallback = callback;
_lastContext = context;
_currentOperationId = id;
if (_navigationService.Navigate(mappingItem, parameter, context))
{
ClearCacheIfNeed(context, viewModel);
}
}));
return(tcs.Task);
}
public static Task <bool> InitLoggingAsync()
{
return(Task.Run(
() => {
var tcs = new TaskCompletionSource <bool>();
InitLoggingCb cb2 = null;
cb2 = (ptr, result) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(cb2);
return;
}
tcs.SetResult(true);
CallbackManager.Unregister(cb2);
};
CallbackManager.Register(cb2);
AppOutputLogPathCallback cb1 = null;
cb1 = async(ptr, result, path) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(cb1);
CallbackManager.Unregister(cb2);
return;
}
var appPath = Path.GetDirectoryName(path);
var fileList = new List <Tuple <string, string> > {
Tuple.Create("log.toml", Path.Combine(appPath, "log.toml"))
};
var fileOps = DependencyService.Get <IFileOps>();
await fileOps.TransferAssetsAsync(fileList);
Debug.WriteLine("Assets Transferred");
NativeBindings.AppInitLogging(null, UserData, cb2);
CallbackManager.Unregister(cb1);
};
CallbackManager.Register(cb1);
NativeBindings.AppOutputLogPath("test_file", UserData, cb1);
return tcs.Task;
}));
}
public static Task <ulong> MDataEntriesLenAsync(ulong entriesHandle)
{
var tcs = new TaskCompletionSource <ulong>();
MDataEntriesLenCb callback = null;
callback = (self, len) => {
// TODO: no result?
tcs.SetResult(len);
CallbackManager.Unregister(callback);
};
CallbackManager.Register(callback);
NativeBindings.MDataEntriesLen(Session.AppPtr, entriesHandle, Session.UserData, callback);
return(tcs.Task);
}
public static void Main()
{
Log.WriteInfo("Program", "Starting...");
Console.CancelKeyPress += delegate
{
Log.WriteInfo("Program", "Exiting...");
try
{
Client.Disconnect();
}
catch
{
Log.WriteError("Steam", "Failed to disconnect from Steam");
}
IsRunning = false;
};
TwitterToken = new Token(
ConfigurationManager.AppSettings["token_AccessToken"],
ConfigurationManager.AppSettings["token_AccessTokenSecret"],
ConfigurationManager.AppSettings["token_ConsumerKey"],
ConfigurationManager.AppSettings["token_ConsumerSecret"]
);
ITokenRateLimits tokenLimits = TwitterToken.GetRateLimit();
Log.WriteInfo("Twitter", "Remaining Twitter requests: {0} of {1}", tokenLimits.ApplicationRateLimitStatusLimit.Remaining, tokenLimits.ApplicationRateLimitStatusLimit.Limit);
Timer.Elapsed += OnTimer;
Timer.Interval = TimeSpan.FromMinutes(10).TotalMilliseconds;
var CallbackManager = new CallbackManager(Client);
CallbackManager.Register(new Callback<SteamClient.ConnectedCallback>(OnConnected));
CallbackManager.Register(new Callback<SteamClient.DisconnectedCallback>(OnDisconnected));
CallbackManager.Register(new Callback<SteamUser.LoggedOnCallback>(OnLoggedOn));
CallbackManager.Register(new Callback<SteamUser.LoggedOffCallback>(OnLoggedOff));
CallbackManager.Register(new Callback<SteamUser.AccountInfoCallback>(OnAccountInfo));
CallbackManager.Register(new Callback<SteamFriends.ClanStateCallback>(OnClanState));
Client.Connect();
while (IsRunning)
{
CallbackManager.RunWaitCallbacks(TimeSpan.FromSeconds(5));
}
}
private void UpdateNavigationContext(IOperationCallback callback, IViewModel navigationViewModel, NavigationEventArgsBase args, ref INavigationContext context)
{
var vmType = context.GetData(ViewModelTypeConstant);
if (vmType == null)
{
return;
}
var viewModel = GetViewModelForView(args, navigationViewModel, context, vmType);
if (!ReferenceEquals(context.ViewModelTo, viewModel))
{
context = new NavigationContext(NavigationType.Page, context.NavigationMode, context.ViewModelFrom, viewModel, context.NavigationProvider);
}
if (viewModel != null && callback != null)
{
CallbackManager.Register(OperationType.PageNavigation, viewModel, callback, context);
}
}
/// <summary>
/// Tries to show the specified <see cref="IViewModel" />.
/// </summary>
/// <param name="viewModel">The specified <see cref="IViewModel" /> to show.</param>
/// <param name="context">The specified context.</param>
/// <param name="parentPresenter">The parent presenter, if any.</param>
public virtual IAsyncOperation <bool?> TryShowAsync(IViewModel viewModel, IDataContext context,
IViewModelPresenter parentPresenter)
{
Should.NotBeNull(viewModel, "viewModel");
bool data;
if (context.TryGetData(NavigationConstants.SuppressTabNavigation, out data) && data)
{
return(null);
}
if (!CanShowViewModel(viewModel, context, parentPresenter))
{
return(null);
}
MultiViewModel.AddViewModel(viewModel);
var operation = new AsyncOperation <bool?>();
CallbackManager.Register(OperationType.TabNavigation, viewModel, operation.ToOperationCallback(), context);
return(operation);
}
public static Task MDataMutateEntriesAsync(ulong mDataInfoH, ulong entryActionsH)
{
var tcs = new TaskCompletionSource <object>();
MDataMutateEntriesCb callback = null;
callback = (pVoid, result) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(callback);
return;
}
tcs.SetResult(null);
CallbackManager.Unregister(callback);
};
CallbackManager.Register(callback);
NativeBindings.MDataMutateEntries(Session.AppPtr, mDataInfoH, entryActionsH, Session.UserData, callback);
return(tcs.Task);
}
public static Task <ulong> MDataListKeysAsync(ulong mDataInfoH)
{
var tcs = new TaskCompletionSource <ulong>();
MDataListKeysCb callback = null;
callback = (pVoid, result, mDataEntKeysH) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(callback);
return;
}
tcs.SetResult(mDataEntKeysH);
CallbackManager.Unregister(callback);
};
CallbackManager.Register(callback);
NativeBindings.MDataListKeys(Session.AppPtr, mDataInfoH, Session.UserData, callback);
return(tcs.Task);
}
public static Task <List <byte> > IDataReadFromSelfEncryptorAsync(ulong seHandle, ulong fromPos, ulong len)
{
var tcs = new TaskCompletionSource <List <byte> >();
IDataReadFromSelfEncryptorCb callback = null;
callback = (self, result, dataPtr, dataLen) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(callback);
return;
}
var data = dataPtr.ToList <byte>(dataLen);
tcs.SetResult(data);
CallbackManager.Unregister(callback);
};
CallbackManager.Register(callback);
NativeBindings.IDataReadFromSelfEncryptor(Session.AppPtr, seHandle, fromPos, len, Session.UserData, callback);
return(tcs.Task);
}
public static Task <ulong> MDataListEntriesAsync(ulong infoHandle)
{
var tcs = new TaskCompletionSource <ulong>();
MDataListEntriesCb callback = null;
callback = (self, result, mDataEntriesHandle) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(callback);
return;
}
tcs.SetResult(mDataEntriesHandle);
CallbackManager.Unregister(callback);
};
CallbackManager.Register(callback);
NativeBindings.MDataListEntries(Session.AppPtr, infoHandle, Session.UserData, callback);
return(tcs.Task);
}
public static Task <List <byte> > MDataInfoSerialiseAsync(ulong mdataInfoH)
{
var tcs = new TaskCompletionSource <List <byte> >();
MDataInfoSerialiseCb callback = null;
callback = (pVoid, result, bytesPtr, len) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(callback);
return;
}
tcs.SetResult(bytesPtr.ToList <byte>(len));
CallbackManager.Unregister(callback);
};
CallbackManager.Register(callback);
NativeBindings.MDataInfoSerialise(Session.AppPtr, mdataInfoH, Session.UserData, callback);
return(tcs.Task);
}
public static Task <ulong> CipherOptNewPlaintextAsync()
{
var tcs = new TaskCompletionSource <ulong>();
CipherOptNewPlaintextCb callback = null;
callback = (self, result, cipherOptHandle) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(callback);
return;
}
tcs.SetResult(cipherOptHandle);
CallbackManager.Unregister(callback);
};
CallbackManager.Register(callback);
NativeBindings.CipherOptNewPlaintext(Session.AppPtr, Session.UserData, callback);
return(tcs.Task);
}
public static Task CipherOptFreeAsync(ulong cipherOptHandle)
{
var tcs = new TaskCompletionSource <object>();
CipherOptFreeCb callback = null;
callback = (self, result) => {
if (result.ErrorCode != 0)
{
CallbackManager.Unregister(callback);
tcs.SetException(result.ToException());
return;
}
tcs.SetResult(null);
CallbackManager.Unregister(callback);
};
CallbackManager.Register(callback);
NativeBindings.CipherOptFree(Session.AppPtr, cipherOptHandle, Session.UserData, callback);
return(tcs.Task);
}
public GameCoordinator(uint appID, SteamClient steamClient, CallbackManager callbackManager)
{
// Map gc messages to our callback functions
GCMessageMap = new Dictionary<uint, Action<IPacketGCMsg>>
{
{ (uint)4008 /* TF2's k_EMsgGCClientGoodbye */, OnConnectionStatus },
{ (uint)EGCBaseClientMsg.k_EMsgGCServerConnectionStatus, OnConnectionStatus },
{ (uint)EGCBaseClientMsg.k_EMsgGCServerWelcome, OnWelcome },
{ (uint)EGCItemMsg.k_EMsgGCUpdateItemSchema, OnItemSchemaUpdate },
{ (uint)EGCItemMsg.k_EMsgGCServerVersionUpdated, OnVersionUpdate },
{ (uint)EGCBaseMsg.k_EMsgGCSystemMessage, OnSystemMessage }
};
this.AppID = appID;
this.SteamClient = steamClient;
this.SteamGameCoordinator = SteamClient.GetHandler<SteamGameCoordinator>();
this.Name = string.Format("GC {0}", appID);
Timer = new System.Timers.Timer();
Timer.Elapsed += OnTimer;
callbackManager.Register(new Callback<SteamGameCoordinator.MessageCallback>(OnGameCoordinatorMessage));
}
public AccountInfo(CallbackManager manager)
: base(manager)
{
manager.Register(new Callback<SteamUser.AccountInfoCallback>(OnAccountInfo));
}
public ChatMemberInfo(CallbackManager manager)
: base(manager)
{
manager.Register(new Callback<SteamFriends.ChatMemberInfoCallback>(OnChatMemberInfo));
}
public LicenseList(CallbackManager manager)
: base(manager)
{
manager.Register(new Callback<SteamApps.LicenseListCallback>(OnLicenseListCallback));
}
public ClanState(CallbackManager manager)
: base(manager)
{
manager.Register(new Callback<SteamFriends.ClanStateCallback>(OnClanState));
}
public static void init()
{
if (Settings.startRevision > 0) { PreviousChange = (uint)Settings.startRevision; }
manager = new CallbackManager(steamClient);
Apps = steamClient.GetHandler<SteamApps>();
ChangedApps = new List<App>();
manager.Register(new Callback<SteamApps.LicenseListCallback>(OnLicenseListCallback));
manager.Register(new JobCallback<SteamApps.PICSProductInfoCallback>(OnPICSProductInfo));
manager.Register(new JobCallback<SteamApps.PICSChangesCallback>(OnPICSChanges));
manager.Register(new JobCallback<SteamApps.AppInfoCallback>(OnAppInfoCallback));
}
public void Init()
{
ProcessorPool = new SmartThreadPool(new STPStartInfo { ThreadPriority = ThreadPriority.AboveNormal });
SecondaryPool = new SmartThreadPool(new STPStartInfo { ThreadPriority = ThreadPriority.BelowNormal });
ProcessorPool.Name = "Processor Pool";
SecondaryPool.Name = "Secondary Pool";
Timer = new System.Timers.Timer();
Timer.Elapsed += new System.Timers.ElapsedEventHandler(OnTimer);
Timer.Interval = TimeSpan.FromSeconds(1).TotalMilliseconds;
Client = new SteamClient();
User = Client.GetHandler<SteamUser>();
Apps = Client.GetHandler<SteamApps>();
Friends = Client.GetHandler<SteamFriends>();
UserStats = Client.GetHandler<SteamUserStats>();
Unified = Client.GetHandler<SteamUnifiedMessages>();
CallbackManager = new CallbackManager(Client);
CallbackManager.Register(new Callback<SteamClient.ConnectedCallback>(OnConnected));
CallbackManager.Register(new Callback<SteamClient.DisconnectedCallback>(OnDisconnected));
CallbackManager.Register(new Callback<SteamUser.AccountInfoCallback>(OnAccountInfo));
CallbackManager.Register(new Callback<SteamUser.LoggedOnCallback>(OnLoggedOn));
CallbackManager.Register(new Callback<SteamUser.LoggedOffCallback>(OnLoggedOff));
CallbackManager.Register(new Callback<SteamApps.LicenseListCallback>(OnLicenseListCallback));
CallbackManager.Register(new JobCallback<SteamUser.UpdateMachineAuthCallback>(OnMachineAuth));
CallbackManager.Register(new JobCallback<SteamApps.PICSChangesCallback>(OnPICSChanges));
CallbackManager.Register(new JobCallback<SteamApps.PICSProductInfoCallback>(OnPICSProductInfo));
// irc specific
if (Settings.Current.FullRun == 0)
{
CallbackManager.Register(new JobCallback<SteamUnifiedMessages.ServiceMethodResponse>(SteamProxy.Instance.OnServiceMethod));
CallbackManager.Register(new JobCallback<SteamUserStats.NumberOfPlayersCallback>(SteamProxy.Instance.OnNumberOfPlayers));
CallbackManager.Register(new Callback<SteamFriends.ClanStateCallback>(SteamProxy.Instance.OnClanState));
CallbackManager.Register(new Callback<SteamFriends.ChatMsgCallback>(SteamProxy.Instance.OnChatMessage));
CallbackManager.Register(new Callback<SteamFriends.ChatMemberInfoCallback>(SteamProxy.Instance.OnChatMemberInfo));
CallbackManager.Register(new Callback<SteamUser.MarketingMessageCallback>(MarketingHandler.OnMarketingMessage));
// game coordinator
if (Settings.Current.Steam.IdleAppID > 0)
{
GameCoordinator = new GameCoordinator(Settings.Current.Steam.IdleAppID, Client, CallbackManager);
}
}
DepotProcessor.Init();
GetLastChangeNumber();
IsRunning = true;
Client.Connect();
while (IsRunning)
{
CallbackManager.RunWaitCallbacks(TimeSpan.FromSeconds(1));
}
}
public PICSProductInfo(CallbackManager manager)
: base(manager)
{
manager.Register(new Callback<SteamApps.PICSProductInfoCallback>(OnPICSProductInfo));
}
public WebAuth(CallbackManager manager)
: base(manager)
{
manager.Register(new Callback<SteamUser.LoggedOnCallback>(OnLoggedOn));
manager.Register(new Callback<SteamUser.WebAPIUserNonceCallback>(OnWebAPIUserNonce));
}
public UnifiedServices(CallbackManager manager)
: base(manager)
{
manager.Register(new Callback<SteamUnifiedMessages.ServiceMethodResponse>(OnServiceMethod));
}
public void Init()
{
ProcessorPool = new SmartThreadPool(new STPStartInfo { WorkItemPriority = WorkItemPriority.Highest, MaxWorkerThreads = 50 });
SecondaryPool = new SmartThreadPool();
ProcessorPool.Name = "Processor Pool";
SecondaryPool.Name = "Secondary Pool";
ProcessedApps = new ConcurrentDictionary<uint, IWorkItemResult>();
ProcessedSubs = new ConcurrentDictionary<uint, IWorkItemResult>();
Timer = new System.Timers.Timer();
Timer.Elapsed += OnTimer;
Timer.Interval = TimeSpan.FromSeconds(1).TotalMilliseconds;
Client = new SteamClient();
User = Client.GetHandler<SteamUser>();
Apps = Client.GetHandler<SteamApps>();
Friends = Client.GetHandler<SteamFriends>();
UserStats = Client.GetHandler<SteamUserStats>();
Unified = Client.GetHandler<SteamUnifiedMessages>();
CallbackManager = new CallbackManager(Client);
CallbackManager.Register(new Callback<SteamClient.ConnectedCallback>(OnConnected));
CallbackManager.Register(new Callback<SteamClient.DisconnectedCallback>(OnDisconnected));
CallbackManager.Register(new Callback<SteamUser.AccountInfoCallback>(OnAccountInfo));
CallbackManager.Register(new Callback<SteamUser.LoggedOnCallback>(OnLoggedOn));
CallbackManager.Register(new Callback<SteamUser.LoggedOffCallback>(OnLoggedOff));
CallbackManager.Register(new Callback<SteamApps.LicenseListCallback>(OnLicenseListCallback));
CallbackManager.Register(new JobCallback<SteamUser.UpdateMachineAuthCallback>(OnMachineAuth));
CallbackManager.Register(new JobCallback<SteamApps.PICSProductInfoCallback>(OnPICSProductInfo));
CallbackManager.Register(new JobCallback<SteamApps.PICSTokensCallback>(OnPICSTokens));
// irc specific
if (Settings.Current.FullRun == 0)
{
CallbackManager.Register(new JobCallback<SteamApps.PICSChangesCallback>(OnPICSChanges));
CallbackManager.Register(new JobCallback<SteamUserStats.NumberOfPlayersCallback>(SteamProxy.Instance.OnNumberOfPlayers));
CallbackManager.Register(new Callback<SteamFriends.ClanStateCallback>(SteamProxy.Instance.OnClanState));
CallbackManager.Register(new Callback<SteamFriends.ChatMsgCallback>(SteamProxy.Instance.OnChatMessage));
CallbackManager.Register(new Callback<SteamFriends.ChatMemberInfoCallback>(SteamProxy.Instance.OnChatMemberInfo));
CallbackManager.Register(new Callback<SteamUser.MarketingMessageCallback>(MarketingHandler.OnMarketingMessage));
// game coordinator
if (Settings.Current.Steam.IdleAppID > 0)
{
GameCoordinator = new GameCoordinator(Settings.Current.Steam.IdleAppID, Client, CallbackManager);
}
}
else
{
CallbackManager.Register(new JobCallback<SteamApps.PICSChangesCallback>(OnPICSChangesFullRun));
}
// Use EU servers
Servers = new ReadOnlyCollection<IPEndPoint>( new List<IPEndPoint>
{
new IPEndPoint( IPAddress.Parse( "146.66.152.12" ), 27017 ),
new IPEndPoint( IPAddress.Parse( "146.66.152.12" ), 27018 ),
new IPEndPoint( IPAddress.Parse( "146.66.152.12" ), 27019 ),
new IPEndPoint( IPAddress.Parse( "146.66.152.13" ), 27017 ),
new IPEndPoint( IPAddress.Parse( "146.66.152.13" ), 27018 ),
new IPEndPoint( IPAddress.Parse( "146.66.152.13" ), 27019 ),
new IPEndPoint( IPAddress.Parse( "146.66.152.14" ), 27017 ),
new IPEndPoint( IPAddress.Parse( "146.66.152.14" ), 27018 ),
new IPEndPoint( IPAddress.Parse( "146.66.152.14" ), 27019 ),
new IPEndPoint( IPAddress.Parse( "146.66.152.15" ), 27017 ),
new IPEndPoint( IPAddress.Parse( "146.66.152.15" ), 27018 ),
new IPEndPoint( IPAddress.Parse( "146.66.152.15" ), 27019 )
} );
DepotProcessor.Init();
GetLastChangeNumber();
IsRunning = true;
Client.Connect(Servers[ new Random().Next( Servers.Count ) ]);
while (IsRunning)
{
CallbackManager.RunWaitCallbacks(TimeSpan.FromSeconds(1));
}
}
public MarketingMessage(CallbackManager manager)
: base(manager)
{
manager.Register(new Callback<SteamUser.MarketingMessageCallback>(OnMarketingMessage));
}