void HandlePublishedFileDetails(IPacketMsg packetMsg)
        {
            var details = new ClientMsgProtobuf <CMsgClientUCMGetPublishedFileDetailsResponse>(packetMsg);

            var innerCallback = new PublishedFileDetailsCallback(details.Body);
            var callback      = new SteamClient.JobCallback <PublishedFileDetailsCallback>(packetMsg.TargetJobID, innerCallback);

            Client.PostCallback(callback);
        }
        void HandleEnumPublishedFilesByAction(IPacketMsg packetMsg)
        {
            var response = new ClientMsgProtobuf <CMsgClientUCMEnumeratePublishedFilesByUserActionResponse>(packetMsg);

            var innerCallback = new UserActionPublishedFilesCallback(response.Body);
            var callback      = new SteamClient.JobCallback <UserActionPublishedFilesCallback>(response.TargetJobID, innerCallback);

            Client.PostCallback(callback);
        }
        void HandleEnumUserSubscribedFiles(IPacketMsg packetMsg)
        {
            var response = new ClientMsgProtobuf <CMsgClientUCMEnumerateUserSubscribedFilesResponse>(packetMsg);

            var innerCallback = new UserSubscribedFilesCallback(response.Body);
            var callback      = new SteamClient.JobCallback <UserSubscribedFilesCallback>(response.TargetJobID, innerCallback);

            Client.PostCallback(callback);
        }
        void HandleEnumPublishedFiles(IPacketMsg packetMsg)
        {
            var response = new ClientMsgProtobuf <CMsgCREEnumeratePublishedFilesResponse>(packetMsg);

            var innerCallback = new PublishedFilesCallback(response.Body);
            var callback      = new SteamClient.JobCallback <PublishedFilesCallback>(response.TargetJobID, innerCallback);

            Client.PostCallback(callback);
        }
        void HandleNumberOfPlayersResponse(IPacketMsg packetMsg)
        {
            var msg = new ClientMsg <MsgClientGetNumberOfCurrentPlayersResponse>(packetMsg);

            var innerCallback = new NumberOfPlayersCallback(msg.Body);
            var callback      = new SteamClient.JobCallback <NumberOfPlayersCallback>(msg.Header.TargetJobID, innerCallback);

            Client.PostCallback(callback);
        }
Beispiel #6
0
        void HandleUGCDetailsResponse(IPacketMsg packetMsg)
        {
            var infoResponse = new ClientMsgProtobuf <CMsgClientUFSGetUGCDetailsResponse>(packetMsg);

            var innerCallback = new UGCDetailsCallback(infoResponse.Body);
            var callback      = new SteamClient.JobCallback <UGCDetailsCallback>(infoResponse.TargetJobID, innerCallback);

            this.Client.PostCallback(callback);
        }
Beispiel #7
0
        void HandleProfileInfoResponse(IPacketMsg packetMsg)
        {
            var response = new ClientMsgProtobuf <CMsgClientFriendProfileInfoResponse>(packetMsg);

            var innerCallback = new ProfileInfoCallback(response.Body);
            var callback      = new SteamClient.JobCallback <ProfileInfoCallback>(packetMsg.TargetJobID, innerCallback);

            Client.PostCallback(callback);
        }
Beispiel #8
0
        void HandleUploadFileFinished(IPacketMsg packetMsg)
        {
            var uploadFin = new ClientMsgProtobuf <CMsgClientUFSUploadFileFinished>(packetMsg);

            var innerCallback = new UploadFileFinishedCallback(uploadFin.Body);
            var callback      = new SteamClient.JobCallback <UploadFileFinishedCallback>(uploadFin.TargetJobID, innerCallback);

            steamClient.PostCallback(callback);
        }
Beispiel #9
0
        void HandleUploadFileResponse(IPacketMsg packetMsg)
        {
            var uploadResp = new ClientMsgProtobuf <CMsgClientUFSUploadFileResponse>(packetMsg);

            var innerCallback = new UploadFileResponseCallback(uploadResp.Body, uploadResp.SourceJobID);
            var callback      = new SteamClient.JobCallback <UploadFileResponseCallback>(uploadResp.TargetJobID, innerCallback);

            steamClient.PostCallback(callback);
        }
Beispiel #10
0
        void HandleAppOwnershipTicketResponse(IPacketMsg packetMsg)
        {
            var ticketResponse = new ClientMsgProtobuf <CMsgClientGetAppOwnershipTicketResponse>(packetMsg);

            var innerCallback = new AppOwnershipTicketCallback(ticketResponse.Body);
            var callback      = new SteamClient.JobCallback <AppOwnershipTicketCallback>(ticketResponse.TargetJobID, innerCallback);

            this.Client.PostCallback(callback);
        }
Beispiel #11
0
        void HandleServerQueryResponse(IPacketMsg packetMsg)
        {
            var queryResponse = new ClientMsgProtobuf <CMsgGMSClientServerQueryResponse>(packetMsg);

            var innerCallback = new QueryCallback(queryResponse.Body);
            var callback      = new SteamClient.JobCallback <QueryCallback>(queryResponse.TargetJobID, innerCallback);

            Client.PostCallback(callback);
        }
Beispiel #12
0
        void HandleAppInfoResponse(IPacketMsg packetMsg)
        {
            var infoResponse = new ClientMsgProtobuf <CMsgClientAppInfoResponse>(packetMsg);

            var innerCallback = new AppInfoCallback(infoResponse.Body);
            var callback      = new SteamClient.JobCallback <AppInfoCallback>(infoResponse.TargetJobID, innerCallback);

            this.Client.PostCallback(callback);
        }
Beispiel #13
0
        void HandleDepotKeyResponse(IPacketMsg packetMsg)
        {
            var keyResponse = new ClientMsgProtobuf <CMsgClientGetDepotDecryptionKeyResponse>(packetMsg);

            var innerCallback = new DepotKeyCallback(keyResponse.Body);
            var callback      = new SteamClient.JobCallback <DepotKeyCallback>(keyResponse.TargetJobID, innerCallback);

            this.Client.PostCallback(callback);
        }
Beispiel #14
0
        void HandleWebAPIUserNonce(IPacketMsg packetMsg)
        {
            var userNonce = new ClientMsgProtobuf <CMsgClientRequestWebAPIAuthenticateUserNonceResponse>(packetMsg);

            var innerCallback = new WebAPIUserNonceCallback(userNonce.Body);
            var callback      = new SteamClient.JobCallback <WebAPIUserNonceCallback>(userNonce.TargetJobID, innerCallback);

            this.Client.PostCallback(callback);
        }
Beispiel #15
0
        void HandleCDNAuthTokenResponse(IPacketMsg packetMsg)
        {
            var response = new ClientMsgProtobuf <CMsgClientGetCDNAuthTokenResponse>(packetMsg);

            var innerCallback = new CDNAuthTokenCallback(response.Body);
            var callback      = new SteamClient.JobCallback <CDNAuthTokenCallback>(response.TargetJobID, innerCallback);

            this.Client.PostCallback(callback);
        }
Beispiel #16
0
        void HandleUpdateMachineAuth(IPacketMsg packetMsg)
        {
            var machineAuth = new ClientMsgProtobuf <CMsgClientUpdateMachineAuth>(packetMsg);

            var innerCallback = new UpdateMachineAuthCallback(machineAuth.Body);
            var callback      = new SteamClient.JobCallback <UpdateMachineAuthCallback>(packetMsg.SourceJobID, innerCallback);

            Client.PostCallback(callback);
        }
Beispiel #17
0
        void HandlePICSChangesSinceResponse(IPacketMsg packetMsg)
        {
            var changesResponse = new ClientMsgProtobuf <CMsgClientPICSChangesSinceResponse>(packetMsg);

            var innerCallback = new PICSChangesCallback(changesResponse.Body);
            var callback      = new SteamClient.JobCallback <PICSChangesCallback>(changesResponse.TargetJobID, innerCallback);

            this.Client.PostCallback(callback);
        }
Beispiel #18
0
        void HandlePICSProductInfoResponse(IPacketMsg packetMsg)
        {
            var productResponse = new ClientMsgProtobuf <CMsgClientPICSProductInfoResponse>(packetMsg);

            var innerCallback = new PICSProductInfoCallback(productResponse.Body);
            var callback      = new SteamClient.JobCallback <PICSProductInfoCallback>(productResponse.TargetJobID, innerCallback);

            this.Client.PostCallback(callback);
        }
Beispiel #19
0
        void HandleLoginResponse(IPacketMsg packetMsg)
        {
            var loginResp = new ClientMsgProtobuf <CMsgClientUFSLoginResponse>(packetMsg);

            var innerCallback = new LoggedOnCallback(loginResp.Body);
            var callback      = new SteamClient.JobCallback <LoggedOnCallback>(loginResp.TargetJobID, innerCallback);

            steamClient.PostCallback(callback);
        }
Beispiel #20
0
        void HandlePICSAccessTokenResponse(IPacketMsg packetMsg)
        {
            var tokensResponse = new ClientMsgProtobuf <CMsgClientPICSAccessTokenResponse>(packetMsg);

            var innerCallback = new PICSTokensCallback(tokensResponse.Body);
            var callback      = new SteamClient.JobCallback <PICSTokensCallback>(tokensResponse.TargetJobID, innerCallback);

            this.Client.PostCallback(callback);
        }
Beispiel #21
0
        void HandleIgnoreFriendResponse(IPacketMsg packetMsg)
        {
            var response = new ClientMsg <MsgClientSetIgnoreFriendResponse>(packetMsg);

            var innerCallback = new IgnoreFriendCallback(response.Body);
            var callback      = new SteamClient.JobCallback <IgnoreFriendCallback>(response.TargetJobID, innerCallback);

            this.Client.PostCallback(callback);
        }
Beispiel #22
0
        void HandleClientServiceMethodResponse(IPacketMsg packetMsg)
        {
            var response = new ClientMsgProtobuf <CMsgClientServiceMethodResponse>(packetMsg);

            var responseCallback = new ServiceMethodResponse((EResult)response.ProtoHeader.eresult, response.Body);
            var jobCallback      = new SteamClient.JobCallback <ServiceMethodResponse>(response.TargetJobID, responseCallback);

            Client.PostCallback(jobCallback);
        }
        void HandleUCMAddScreenshot(IPacketMsg packetMsg)
        {
            var resp = new ClientMsgProtobuf <CMsgClientUCMAddScreenshotResponse>(packetMsg);

            var innerCallback = new ScreenshotAddedCallback(resp.Body);
            var callback      = new SteamClient.JobCallback <ScreenshotAddedCallback>(resp.TargetJobID, innerCallback);

            Client.PostCallback(callback);
        }
Beispiel #24
0
        void HandleCallback(SteamClient.JobCallback <TCall> callback)
        {
            // handle the callback if it's our jobid, or if we haven't set one yet
            if (callback.JobID == JobID || JobID == JobID.Invalid)
            {
                if (OnRun != null)
                {
                    OnRun(callback.Callback, callback.JobID);
                }

                Completed = true;
            }
        }
Beispiel #25
0
        void HandlePICSChangesSinceResponse(IPacketMsg packetMsg)
        {
            var changesResponse = new ClientMsgProtobuf <CMsgPICSChangesSinceResponse>(packetMsg);

#if STATIC_CALLBACKS
            var innerCallback = new PICSChangesCallback(Client, changesResponse.Body);
            var callback      = new SteamClient.JobCallback <PICSChangesCallback>(Client, changesResponse.TargetJobID, innerCallback);
            SteamClient.PostCallback(callback);
#else
            var innerCallback = new PICSChangesCallback(changesResponse.Body);
            var callback      = new SteamClient.JobCallback <PICSChangesCallback>(changesResponse.TargetJobID, innerCallback);
            this.Client.PostCallback(callback);
#endif
        }
Beispiel #26
0
        void HandleEnumUserPublishedFiles(IPacketMsg packetMsg)
        {
            var response = new ClientMsgProtobuf <CMsgClientUCMEnumerateUserPublishedFilesResponse>(packetMsg);

#if STATIC_CALLBACKS
            var innerCallback = new UserPublishedFilesCallback(Client, response.Body);
            var callback      = new SteamClient.JobCallback <UserPublishedFilesCallback>(Client, response.TargetJobID, innerCallback);
            SteamClient.PostCallback(callback);
#else
            var innerCallback = new UserPublishedFilesCallback(response.Body);
            var callback      = new SteamClient.JobCallback <UserPublishedFilesCallback>(response.TargetJobID, innerCallback);
            Client.PostCallback(callback);
#endif
        }
Beispiel #27
0
        void HandleUpdateMachineAuth(IPacketMsg packetMsg)
        {
            var machineAuth = new ClientMsgProtobuf <CMsgClientUpdateMachineAuth>(packetMsg);

#if STATIC_CALLBACKS
            var innerCallback = new UpdateMachineAuthCallback(Client, machineAuth.Body);
            var callback      = new SteamClient.JobCallback <UpdateMachineAuthCallback>(Client, packetMsg.SourceJobID, innerCallback);
            SteamClient.PostCallback(callback);
#else
            var innerCallback = new UpdateMachineAuthCallback(machineAuth.Body);
            var callback      = new SteamClient.JobCallback <UpdateMachineAuthCallback>(packetMsg.SourceJobID, innerCallback);
            Client.PostCallback(callback);
#endif
        }
Beispiel #28
0
        void HandlePackageInfoResponse(IPacketMsg packetMsg)
        {
            var response = new ClientMsgProtobuf <CMsgClientPackageInfoResponse>(packetMsg);

#if STATIC_CALLBACKS
            var innerCallback = new PackageInfoCallback(Client, response.Body);
            var callback      = new SteamClient.JobCallback <PackageInfoCallback>(Client, response.TargetJobID, innerCallback);
            SteamClient.PostCallback(callback);
#else
            var innerCallback = new PackageInfoCallback(response.Body);
            var callback      = new SteamClient.JobCallback <PackageInfoCallback>(response.TargetJobID, innerCallback);
            this.Client.PostCallback(callback);
#endif
        }
        void HandleServerQueryResponse(IPacketMsg packetMsg)
        {
            var queryResponse = new ClientMsgProtobuf <CMsgGMSClientServerQueryResponse>(packetMsg);

#if STATIC_CALLBACKS
            var innerCallback = new QueryCallback(Client, queryResponse.Body);
            var callback      = new SteamClient.JobCallback <QueryCallback>(Client, queryResponse.TargetJobID, innerCallback);
            SteamClient.PostCallback(callback);
#else
            var innerCallback = new QueryCallback(queryResponse.Body);
            var callback      = new SteamClient.JobCallback <QueryCallback>(queryResponse.TargetJobID, innerCallback);
            Client.PostCallback(callback);
#endif
        }
Beispiel #30
0
        void HandlePICSAccessTokenResponse(IPacketMsg packetMsg)
        {
            var tokensResponse = new ClientMsgProtobuf <CMsgPICSAccessTokenResponse>(packetMsg);

#if STATIC_CALLBACKS
            var innerCallback = new PICSTokensCallback(Client, tokensResponse.Body);
            var callback      = new SteamClient.JobCallback <PICSTokensCallback>(Client, tokensResponse.TargetJobID, innerCallback);
            SteamClient.PostCallback(callback);
#else
            var innerCallback = new PICSTokensCallback(tokensResponse.Body);
            var callback      = new SteamClient.JobCallback <PICSTokensCallback>(tokensResponse.TargetJobID, innerCallback);
            this.Client.PostCallback(callback);
#endif
        }