Player Cloud Save - Code

{
   "id":"1366764038702081",
   "manifest":[
      {
         "bucketName":"beam-cloud-saving",
         "key":"ComplexFile.json",
         "size":642,
         "lastModified":20210602112148,
         "eTag":"B0FAB230EE1DB774FFE1DE866309D720"
      }
   ],
   "replacement":false
}

[BeamContextSystem]
public class PlayerCloudSaveCustomRegister
{
	[RegisterBeamableDependencies]
	public static void RegisterServices(IDependencyBuilder builder)
	{
		// Replace the old PlayerCloudSavingConfiguration with the new instance
		builder.ReplaceSingleton<PlayerCloudSavingConfiguration>(new PlayerCloudSavingConfiguration
		{
			// UseAutoCloud = true, // Uncomment to enable AutoCloud. Check UseAutoCloud summary for more information
			//CustomSerializer = CustomSerializer, // Uncomment to apply a CustomSerializer, the example method is returning an empty string
			//CustomDeserializer = CustomDeserializer, // Uncomment to apply a CustomDeserializer, the example method is returning a null ref
			//HandleConflicts = ResolveUsingLargerFile, // Uncomment to apply a Custom Handle Conflict, the example method is resolving the conflicts using the larget file
			//HandleDownloadFileError = HandleDownloadError,
		});
	}

	private static Promise<Unit> HandleDownloadError(Exception arg)
	{
		throw new NotImplementedException();
	}

	private static void ResolveUsingLargerFile(IConflictResolver resolver)
	{
		var conflicts = new List<DataConflictDetail>(resolver.Conflicts);
		foreach (DataConflictDetail dataConflictDetail in conflicts)
		{
			bool isLocalLarger = dataConflictDetail.LocalSaveEntry.size >= dataConflictDetail.CloudSaveEntry.size;
			ConflictResolveType conflictResolveType = isLocalLarger ? ConflictResolveType.UseLocal :  ConflictResolveType.UseCloud;
			resolver.Resolve(dataConflictDetail, conflictResolveType);
		}
	}

	private static string CustomSerializer(object arg)
	{
		// Apply any Serialization, like https://www.newtonsoft.com/json/help/html/serializingjson.htm
		return string.Empty;
	}

	private static object CustomDeserializer(string arg)
	{
		// Apply any Deserializer, like https://www.newtonsoft.com/json/help/html/serializingjson.htm
		return null;
	}
}

using Beamable;
using Beamable.Api.CloudSaving;
using Beamable.Common;
using Beamable.Player.CloudSaving;
using System;
using System.Globalization;
using System.Text;
using UnityEngine;
using Random = UnityEngine.Random;

public class CloudSaving_Sample : MonoBehaviour
{
	private const string MAIN_SAVE_TXT = "main_save.txt";
	private const string BACKUP_SAVE_TXT = "backup_save.txt";
	private const string BYTE_SAVE_DAT = "byte_save.dat";
	private const string GAME_SAVE_JSON = "game_save.json";
	private ICloudSavingService _cloudSavingService;
	private bool _init;

	private void Awake()
	{
		InitServiceAsync();
	}

	[ContextMenu("Check Save Data")]
	public void CheckSaveData()
	{
		CheckSaveDataAsync();
	}
	
	[ContextMenu("Update Save File")]
	public void SaveFile()
	{
		_ = SaveFileAsync();
	}

	[ContextMenu("Force Upload Save File")]
	public void ForceUploadSaveFile()
	{
		ForceUploadSaveFileAsync();
	}
	
	[ContextMenu("Force Download Save File")]
	public void ForceDownloadSaveFile()
	{
		ForceDownloadSaveFileAsync();
	}

	[ContextMenu("Update Save Files")]
	public void UpdateSaveFiles()
	{
		// Use Update Function to Handle Manifest Changes that require to commit them to Cloud
		_cloudSavingService.Update(builder =>
		{
			builder.ArchiveSaveData(BACKUP_SAVE_TXT);
			builder.RenameSaveData(GAME_SAVE_JSON, "Player_Save.json");
			builder.ForgetSaveData(BYTE_SAVE_DAT);
		});
	}

	private async void InitServiceAsync()
	{
		// Get BeamContext
		BeamContext context = await BeamContext.Default.Instance;
		
		_cloudSavingService = context.CloudSaving;
		// Register to CloudSavingError and OnManifestUpdate | This is optional, use it if you need to handle it by yourself
		_cloudSavingService.OnCloudSavingError += OnCloudSavingError;
		_cloudSavingService.OnManifestUpdated += OnManifestUpdated;
		
		// Init System and start to check for Local and Remote Changes
		await _cloudSavingService.Init(3);
		
		Debug.Log("Cloud Saving Service Initialized");

	}

	private void OnManifestUpdated(CloudSavingManifest manifest)
	{
		Debug.Log($"Manifest Updated. Items Count: {manifest.manifest.Count}");
	}

	private void OnCloudSavingError(CloudSavingError error)
	{
		Debug.Log($"Cloud Saving Error: {error.Message}");
	}

	private async void CheckSaveDataAsync()
	{
		// Load Data from Save and Check their contents
		string mainSaveContent = await _cloudSavingService.LoadDataString(MAIN_SAVE_TXT);
		Debug.Log($"Main Save Data: {mainSaveContent}");
		string backupSaveContent = await _cloudSavingService.LoadDataString(BACKUP_SAVE_TXT);
		Debug.Log($"Backup Save Data: {backupSaveContent}");

		byte[] byteDataContent = await _cloudSavingService.LoadDataByte(BYTE_SAVE_DAT);
		Debug.Log($"Byte Save Data: {byteDataContent}");

		var gameSaveContent = await _cloudSavingService.LoadData<GameSave>(GAME_SAVE_JSON);
		Debug.Log(
			$"Game Save Data: Level: {gameSaveContent.level} |  Score: {gameSaveContent.score} | ExtraData: {gameSaveContent.extraData}");
	}

	private async Promise SaveFileAsync(string forceContent = null)
	{
		// Save files with random with Forced value or with random values
		
		string contents = string.IsNullOrEmpty(forceContent)
			? DateTime.UtcNow.ToString(CultureInfo.InvariantCulture)
			: forceContent;
		await _cloudSavingService.SaveData(MAIN_SAVE_TXT, contents);
		await _cloudSavingService.SaveData(BACKUP_SAVE_TXT, contents);

		GameSave gameSave = new GameSave()
		{
			level = Random.Range(1, 11), score = Random.Range(1, 100), extraData = Guid.NewGuid().ToString(),
		};
		await _cloudSavingService.SaveData(GAME_SAVE_JSON, gameSave);

		byte[] encodedBytes = Encoding.Default.GetBytes(contents);
		await _cloudSavingService.SaveData(BYTE_SAVE_DAT, encodedBytes);
	}

	private async void ForceUploadSaveFileAsync()
	{
		// Force change Files Values and Force them to be uploaded to Cloud
		await SaveFileAsync($"ForcedContent-{DateTime.Now.ToString(CultureInfo.InvariantCulture)}");
		await _cloudSavingService.ForceUploadLocalData();
	}
	
	private async void ForceDownloadSaveFileAsync()
	{
		// Force download Cloud Values replacing any Local Changes.
		await _cloudSavingService.ForceDownloadCloudData();
	}
	
	[Serializable]
	private class GameSave
	{
		public int level;
		public float score;
		public string extraData;
	}
}