void share_callback(RemoteStorageFileShareResult_t * result, bool fail) { if (result && (result->m_eResult != k_EResultOK || fail)) { error = "Error: " + number_to_string(result->m_eResult); call_fail(); return; } if (!(flags & SET_PREVIEW)) { preview_callback(NULL, false); return; } chowstring data; if (!read_file(preview.c_str(), data)) { error = "File not found"; call_fail(); return; } SteamRemoteStorage()->FileWrite(preview_cloud_file.c_str(), data.data(), data.size()); SteamAPICall_t call_handle; call_handle = SteamRemoteStorage()->FileShare( preview_cloud_file.c_str()); preview_call.Set(call_handle, this, &UploadCallback::preview_callback); }
SteamReadFile(const char * filename) { int32 size = SteamRemoteStorage()->GetFileSize(filename); std::string v; v.resize(size, 0); SteamRemoteStorage()->FileRead(filename, &v[0], size); stream.str(v); }
void FOnlineUserCloudSteam::DumpCloudState(const FUniqueNetId& UserId) { int32 TotalBytes, TotalAvailable; if (SteamRemoteStorage()->GetQuota(&TotalBytes, &TotalAvailable) == false) { TotalBytes = TotalAvailable = 0; } UE_LOG_ONLINE(Verbose, TEXT("Steam Disk Quota: %d / %d"), TotalAvailable, TotalBytes); UE_LOG_ONLINE(Verbose, TEXT("Game does %shave cloud storage enabled."), SteamRemoteStorage()->IsCloudEnabledForApp() ? TEXT("") : TEXT("NOT ")); UE_LOG_ONLINE(Verbose, TEXT("User does %shave cloud storage enabled."), SteamRemoteStorage()->IsCloudEnabledForAccount() ? TEXT("") : TEXT("NOT ")); }
void FOnlineAsyncTaskSteamReadSharedFile::Tick() { ISteamUtils* SteamUtilsPtr = SteamUtils(); check(SteamUtilsPtr); if (!bInit) { if (SteamRemoteStorage() && SharedHandle.IsValid()) { if (SteamUser()->BLoggedOn()) { // Actual request to download the file from Steam CallbackHandle = SteamRemoteStorage()->UGCDownload(*(UGCHandle_t*)SharedHandle.GetBytes(), 0); } else { UE_LOG_ONLINE(Warning, TEXT("Steam user not logged in.")); } } else { UE_LOG_ONLINE(Warning, TEXT("Steam remote storage API disabled.")); } bInit = true; } if (CallbackHandle != k_uAPICallInvalid) { bool bFailedCall = false; // Poll for completion status bIsComplete = SteamUtilsPtr->IsAPICallCompleted(CallbackHandle, &bFailedCall) ? true : false; if (bIsComplete) { bool bFailedResult; // Retrieve the callback data from the request bool bSuccessCallResult = SteamUtilsPtr->GetAPICallResult(CallbackHandle, &CallbackResults, sizeof(CallbackResults), CallbackResults.k_iCallback, &bFailedResult); bWasSuccessful = (bSuccessCallResult ? true : false) && (!bFailedCall ? true : false) && (!bFailedResult ? true : false) && ((CallbackResults.m_eResult == k_EResultOK) ? true : false); } } else { // Invalid API call bIsComplete = true; bWasSuccessful = false; } }
void FOnlineAsyncTaskSteamDeleteUserFile::Tick() { bWasSuccessful = false; if (SteamRemoteStorage() && FileName.Len() > 0) { CSteamID SteamId(*(uint64*)UserId.GetBytes()); if (SteamUser()->BLoggedOn() && SteamUser()->GetSteamID() == SteamId) { bool bCloudDeleteSuccess = true; if (bShouldCloudDelete) { // Remove the cloud flag, the file remains safely available on the local machine bCloudDeleteSuccess = SteamRemoteStorage()->FileForget(TCHAR_TO_UTF8(*FileName)); } bool bLocalDeleteSuccess = true; if (bShouldLocallyDelete) { bLocalDeleteSuccess = false; // Only clear the tables if we're permanently deleting the file // Need to make sure nothing async is happening first (this is a formality as nothing in Steam actually is) IOnlineUserCloudPtr UserCloud = Subsystem->GetUserCloudInterface(); if (UserCloud->ClearFile(UserId, FileName)) { // Permanent delete bLocalDeleteSuccess = SteamRemoteStorage()->FileDelete(TCHAR_TO_UTF8(*FileName)); Subsystem->ClearUserCloudMetadata(UserId, FileName); } } bWasSuccessful = bCloudDeleteSuccess && bLocalDeleteSuccess; } else { UE_LOG_ONLINE(Warning, TEXT("Can only delete cloud files for logged in user.")); } } else { UE_LOG_ONLINE(Warning, TEXT("Steam remote storage API disabled.")); } bIsComplete = true; }
void FOnlineAsyncTaskSteamEnumerateUserFiles::Tick() { bIsComplete = true; bWasSuccessful = false; if (SteamRemoteStorage()) { CSteamID SteamId(*(uint64*)UserId.GetBytes()); if (SteamUser()->BLoggedOn() && SteamUser()->GetSteamID() == SteamId) { //SteamSubsystem->GetUserCloudInterface()->DumpCloudState(UserId); FScopeLock ScopeLock(&Subsystem->UserCloudDataLock); // Get or create the user metadata entry and empty it FSteamUserCloudData* UserMetadata = Subsystem->GetUserCloudEntry(UserId); UserMetadata->CloudMetadata.Empty(); // Fill in the metadata entries const int32 FileCount = (int32) SteamRemoteStorage()->GetFileCount(); for (int32 FileIdx = 0; FileIdx < FileCount; FileIdx++) { int32 FileSize = 0; const char *FileName = SteamRemoteStorage()->GetFileNameAndSize(FileIdx, &FileSize); new (UserMetadata->CloudMetadata) FCloudFileHeader(UTF8_TO_TCHAR(FileName), UTF8_TO_TCHAR(FileName), int32(FileSize)); //SteamSubsystem->GetUserCloudInterface()->DumpCloudFileState(UserId, FileName); } bWasSuccessful = true; } else { UE_LOG_ONLINE(Warning, TEXT("Can only enumerate cloud files for logged in user.")); } } else { UE_LOG_ONLINE(Warning, TEXT("Steam remote storage API disabled.")); } }
void start() { uploading = true; if (!(flags & SET_FILE)) { share_callback(NULL, false); return; } chowstring data; if (!read_file(file.c_str(), data)) { error = "File not found"; call_fail(); return; } SteamRemoteStorage()->FileWrite(cloud_file.c_str(), data.data(), data.size()); SteamAPICall_t call_handle; call_handle = SteamRemoteStorage()->FileShare(cloud_file.c_str()); share_call.Set(call_handle, this, &UploadCallback::share_callback); }
void SteamObject::download(const chowstring & name) { #ifdef CHOWDREN_ENABLE_STEAM if (!global_steam_obj.initialized) return; chowstring filename = get_path_filename(name); const char * filename_c = filename.c_str(); if (!SteamRemoteStorage()->FileExists(filename_c)) return; int32 size = SteamRemoteStorage()->GetFileSize(filename_c); chowstring value; value.resize(size); SteamRemoteStorage()->FileRead(filename_c, &value[0], size); FSFile fp(name.c_str(), "w"); if (!fp.is_open()) return; fp.write(value.data(), value.size()); fp.close(); #endif }
void do_update() { PublishedFileUpdateHandle_t handle; handle = SteamRemoteStorage()->CreatePublishedFileUpdateRequest( current_id); if (flags & SET_TITLE) { if (!SteamRemoteStorage()->UpdatePublishedFileTitle( handle, title.c_str())) std::cout << "Could not set item title" << std::endl; } if (flags & SET_DESCRIPTION) { if (!SteamRemoteStorage()->UpdatePublishedFileDescription( handle, description.c_str())) std::cout << "Could not set item description" << std::endl; } if (flags & SET_PREVIEW) { if (!SteamRemoteStorage()->UpdatePublishedFilePreviewFile( handle, preview_cloud_file.c_str())) std::cout << "Could not set item preview" << std::endl; } if (flags & SET_FILE) { if (!SteamRemoteStorage()->UpdatePublishedFileFile( handle, cloud_file.c_str())) std::cout << "Could not set item content" << std::endl; } if (flags & SET_TAGS) { if (!SteamRemoteStorage()->UpdatePublishedFileTags( handle, &steam_tags)) std::cout << "Could not set item tags" << std::endl; } if (flags & SET_VISIBILITY) { ERemoteStoragePublishedFileVisibility vis = (ERemoteStoragePublishedFileVisibility)visibility; if (!SteamRemoteStorage()->UpdatePublishedFileVisibility( handle, vis)) std::cout << "Could not set item visibility" << std::endl; } flags = 0; uploading = true; SteamAPICall_t call_handle; call_handle = SteamRemoteStorage()->CommitPublishedFileUpdate(handle); update_call.Set(call_handle, this, &UploadCallback::on_update_callback); }
void SteamObject::upload(const chowstring & name) { #ifdef CHOWDREN_ENABLE_STEAM if (!global_steam_obj.initialized) return; chowstring filename = get_path_filename(name); const char * filename_c = filename.c_str(); char * data; size_t size; if (!read_file(filename_c, &data, &size)) return; SteamRemoteStorage()->FileWrite(filename_c, data, size); #endif }
void FOnlineUserCloudSteam::DumpCloudFileState(const FUniqueNetId& UserId, const FString& FileName) { if (FileName.Len() > 0) { UE_LOG_ONLINE(Log, TEXT("Cloud File State file %s:"), *FileName); { FScopeLock(&SteamSubsystem->UserCloudDataLock); FSteamUserCloudData* UserCloud = SteamSubsystem->GetUserCloudEntry(UserId); FCloudFileHeader* FileMetadata = UserCloud->GetFileMetadata(FileName); if (FileMetadata) { UE_LOG_ONLINE(Log, TEXT("\tMeta: FileName:%s DLName:%s FileSize:%d Hash:%s"), *FileMetadata->FileName, *FileMetadata->DLName, FileMetadata->FileSize, *FileMetadata->Hash); } else { UE_LOG_ONLINE(Log, TEXT("\tNo metadata found!")); } FCloudFile* FileData = UserCloud->GetFileData(FileName); if (FileData) { UE_LOG_ONLINE(Log, TEXT("\tFileCache: FileName:%s State:%s CacheSize:%d"), *FileData->FileName, EOnlineAsyncTaskState::ToString(FileData->AsyncState), FileData->Data.Num()); } else { UE_LOG_ONLINE(Log, TEXT("\tNo cache entry found!")); } } int32 FileSize = SteamRemoteStorage()->GetFileSize(TCHAR_TO_UTF8(*FileName)); UE_LOG_ONLINE(Log, TEXT("\tSteam: FileName:%s Size:%d Exists:%s Persistent:%s"), *FileName, FileSize, SteamRemoteStorage()->FileExists(TCHAR_TO_UTF8(*FileName)) ? TEXT("Y") : TEXT("N"), SteamRemoteStorage()->FilePersisted(TCHAR_TO_UTF8(*FileName)) ? TEXT("Y") : TEXT("N")); } }
void SteamObject::download(const chowstring & name, int priority, int content_id, Frame::EventFunction success, Frame::EventFunction fail) { #ifdef CHOWDREN_ENABLE_STEAM global_steam_obj.download_success = success; global_steam_obj.download_fail = fail; chowstring filename = convert_path(name); SteamAPICall_t handle; UGCHandle_t id = ugc_list_callback.details[content_id].m_hFile; handle = SteamRemoteStorage()->UGCDownloadToLocation(id, filename.c_str(), priority); DownloadCall * call = new DownloadCall(); call->call.Set(handle, call, &DownloadCall::on_callback); std::cout << "Download: " << id << " " << name << " " << priority << std::endl; #endif }
void FOnlineAsyncTaskSteamWriteSharedFile::Tick() { ISteamUtils* SteamUtilsPtr = SteamUtils(); check(SteamUtilsPtr); if (!bInit) { if (WriteUserFile(UserId, FileName, Contents)) { // Simply mark the file as shared, will trigger a delegate when upload is complete CallbackHandle = SteamRemoteStorage()->FileShare(TCHAR_TO_UTF8(*FileName)); } bInit = true; } if (CallbackHandle != k_uAPICallInvalid) { bool bFailedCall = false; // Poll for completion status bIsComplete = SteamUtilsPtr->IsAPICallCompleted(CallbackHandle, &bFailedCall) ? true : false; if (bIsComplete) { bool bFailedResult; // Retrieve the callback data from the request bool bSuccessCallResult = SteamUtilsPtr->GetAPICallResult(CallbackHandle, &CallbackResults, sizeof(CallbackResults), CallbackResults.k_iCallback, &bFailedResult); bWasSuccessful = (bSuccessCallResult ? true : false) && (!bFailedCall ? true : false) && (!bFailedResult ? true : false) && ((CallbackResults.m_eResult == k_EResultOK) ? true : false); } } else { // Invalid API call bIsComplete = true; bWasSuccessful = false; } }
void FOnlineAsyncTaskSteamReadSharedFile::Finalize() { FOnlineAsyncTaskSteam::Finalize(); FOnlineSharedCloudSteamPtr SharedCloud = StaticCastSharedPtr<FOnlineSharedCloudSteam>(Subsystem->GetSharedCloudInterface()); FCloudFileSteam* SharedFile = SharedCloud->GetSharedCloudFile(SharedHandle); if (SharedFile) { if (bWasSuccessful) { // Currently don't support greater than 1 chunk (we read everything in at once) if (FSharedContentHandleSteam(CallbackResults.m_hFile) == SharedHandle && CallbackResults.m_nSizeInBytes > 0 && CallbackResults.m_nSizeInBytes <= k_unMaxCloudFileChunkSize) { SharedFile->Data.Empty(CallbackResults.m_nSizeInBytes); SharedFile->Data.AddUninitialized(CallbackResults.m_nSizeInBytes); uint32 FileOffset = 0; // This call only works once per call to UGCDownload() if (SteamRemoteStorage()->UGCRead(CallbackResults.m_hFile, SharedFile->Data.GetData(), SharedFile->Data.Num(), FileOffset, k_EUGCRead_ContinueReadingUntilFinished) != CallbackResults.m_nSizeInBytes) { // Failed to read the data from disk SharedFile->Data.Empty(); bWasSuccessful = false; } } else { // Bad handle or bad filesize bWasSuccessful = false; } } SharedFile->AsyncState = bWasSuccessful ? EOnlineAsyncTaskState::Done : EOnlineAsyncTaskState::Failed; } else { // No file found bWasSuccessful = false; } }
void preview_callback(RemoteStorageFileShareResult_t * result, bool fail) { if (result && (result->m_eResult != k_EResultOK || fail)) { error = "Error: " + number_to_string(result->m_eResult); call_fail(); return; } if (has_id) { do_update(); return; } ERemoteStoragePublishedFileVisibility vis = (ERemoteStoragePublishedFileVisibility)visibility; SteamAPICall_t call_handle; call_handle = SteamRemoteStorage()->PublishWorkshopFile( cloud_file.c_str(), preview_cloud_file.c_str(), appid, title.c_str(), description.c_str(), vis, &steam_tags, k_EWorkshopFileTypeCommunity); new_call.Set(call_handle, this, &UploadCallback::new_callback); }
bool FOnlineAsyncTaskSteamWriteUserFile::WriteUserFile(const FUniqueNetId& InUserId, const FString& InFileToWrite, const TArray<uint8>& InContents) { bool bSuccess = false; if (InFileToWrite.Len() > 0 && InContents.Num() > 0) { if (SteamRemoteStorage() && FileName.Len() > 0) { CSteamID SteamId(*(uint64*)InUserId.GetBytes()); if (SteamUser()->BLoggedOn() && SteamUser()->GetSteamID() == SteamId) { // Currently don't support greater than 1 chunk if (InContents.Num() < k_unMaxCloudFileChunkSize) { if (SteamRemoteStorage()->FileWrite(TCHAR_TO_UTF8(*InFileToWrite), InContents.GetData(), InContents.Num())) { FScopeLock ScopeLock(&Subsystem->UserCloudDataLock); FSteamUserCloudData* UserCloud = Subsystem->GetUserCloudEntry(InUserId); if (UserCloud) { // Update the metadata table to reflect this write (might be new entry) FCloudFileHeader* UserCloudFileMetadata = UserCloud->GetFileMetadata(InFileToWrite, true); check(UserCloudFileMetadata); UserCloudFileMetadata->FileSize = SteamRemoteStorage()->GetFileSize(TCHAR_TO_UTF8(*InFileToWrite)); UserCloudFileMetadata->Hash = FString(TEXT("0")); // Update the file table to reflect this write FCloudFile* UserCloudFileData = UserCloud->GetFileData(InFileToWrite, true); check(UserCloudFileData); UserCloudFileData->Data = InContents; bSuccess = true; } } else { UE_LOG_ONLINE(Warning, TEXT("Failed to write file to Steam cloud \"%s\"."), *InFileToWrite); } } else { UE_LOG_ONLINE(Warning, TEXT("File too large %d to write to Steam cloud."), InContents.Num()); } } else { UE_LOG_ONLINE(Warning, TEXT("Can only write cloud files for logged in user.")); } } else { UE_LOG_ONLINE(Warning, TEXT("Steam remote storage API disabled.")); } } { FScopeLock ScopeLock(&Subsystem->UserCloudDataLock); FSteamUserCloudData* UserCloud = Subsystem->GetUserCloudEntry(InUserId); if (UserCloud) { FCloudFile* UserCloudFileData = UserCloud->GetFileData(InFileToWrite, true); check(UserCloudFileData); UserCloudFileData->AsyncState = bSuccess ? EOnlineAsyncTaskState::Done : EOnlineAsyncTaskState::Failed; } } //SteamSubsystem->GetUserCloudInterface()->DumpCloudFileState(InUserId, InFileToWrite); return bSuccess; }
void FOnlineAsyncTaskSteamReadUserFile::Tick() { // Going to be complete no matter what bIsComplete = true; if (SteamRemoteStorage() && FileName.Len() > 0) { CSteamID SteamId(*(uint64*)UserId.GetBytes()); if (SteamUser()->BLoggedOn() && SteamUser()->GetSteamID() == SteamId) { // Currently don't support greater than 1 chunk const int32 FileSize = SteamRemoteStorage()->GetFileSize(TCHAR_TO_UTF8(*FileName)); if (FileSize >= 0 && FileSize <= k_unMaxCloudFileChunkSize) { FScopeLock ScopeLock(&Subsystem->UserCloudDataLock); // Create or get the current entry for this file FSteamUserCloudData* UserCloud = Subsystem->GetUserCloudEntry(UserId); if (UserCloud) { FCloudFile* UserCloudFile = UserCloud->GetFileData(FileName, true); check(UserCloudFile); // Allocate and read in the file UserCloudFile->Data.Empty(FileSize); UserCloudFile->Data.AddUninitialized(FileSize); if (SteamRemoteStorage()->FileRead(TCHAR_TO_UTF8(*FileName), UserCloudFile->Data.GetData(), FileSize) == FileSize) { bWasSuccessful = true; } else { UserCloudFile->Data.Empty(); } } } else { UE_LOG_ONLINE(Warning, TEXT("Requested file %s has invalid size %d."), *FileName, FileSize); } } else { UE_LOG_ONLINE(Warning, TEXT("Can only read cloud files for logged in user.")); } } else { UE_LOG_ONLINE(Warning, TEXT("Steam remote storage API disabled.")); } { FScopeLock ScopeLock(&Subsystem->UserCloudDataLock); FSteamUserCloudData* UserCloud = Subsystem->GetUserCloudEntry(UserId); if (UserCloud) { FCloudFile* UserCloudFileData = UserCloud->GetFileData(FileName); if (UserCloudFileData) { UserCloudFileData->AsyncState = bWasSuccessful ? EOnlineAsyncTaskState::Done : EOnlineAsyncTaskState::Failed; } } } }
void close() { stream.seekp(0, std::ios_base::end); std::string v = stream.str(); SteamRemoteStorage()->FileWrite(filename.c_str(), &v[0], v.size()); }