public void ExportProject(string projectPath, string targetPath, StorageEventHandler callback) { QueueUserWorkItem(() => { try { string projectFullPath = FullPath(projectPath); FastZip fastZip = new FastZip(); fastZip.CompressionLevel = Deflater.CompressionLevel.NO_COMPRESSION; fastZip.CreateZip(targetPath, projectFullPath, true, null); Callback(() => { callback(new Error(Error.OK)); }); } catch (Exception e) { Callback(() => { callback(new Error(Error.E_Exception) { ErrorText = e.ToString() }); }); } }); }
public void GetProject(string projectPath, StorageEventHandler <ProjectInfo> callback) { projectPath = Path.Combine(FullPath(projectPath), "Project.rtmeta"); ProjectInfo projectInfo; Error error = new Error(); ISerializer serializer = RTSL2Deps.Get.Serializer; if (!File.Exists(projectPath)) { projectInfo = new ProjectInfo(); } else { try { using (FileStream fs = File.OpenRead(projectPath)) { projectInfo = serializer.Deserialize <ProjectInfo>(fs); } } catch (Exception e) { projectInfo = new ProjectInfo(); error.ErrorCode = Error.E_Exception; error.ErrorText = e.ToString(); } } callback(error, projectInfo); }
public void CreateProject(string projectName, StorageEventHandler <ProjectInfo> callback) { string projectDir = FullPath(projectName); if (Directory.Exists(projectDir)) { Error error = new Error(Error.E_AlreadyExist); error.ErrorText = "Project with the same name already exists " + projectName; callback(error, null); } else { ISerializer serializer = IOC.Resolve <ISerializer>(); Directory.CreateDirectory(projectDir); ProjectInfo projectInfo = null; using (FileStream fs = File.OpenWrite(projectDir + "/Project.rtmeta")) { projectInfo = new ProjectInfo { Name = projectName, LastWriteTime = DateTime.UtcNow }; serializer.Serialize(projectInfo, fs); } callback(new Error(Error.OK), projectInfo); } }
public void Delete(string projectPath, string[] paths, StorageEventHandler callback) { string fullPath = FullPath(projectPath); for (int i = 0; i < paths.Length; ++i) { string path = fullPath + paths[i]; if (File.Exists(path)) { File.Delete(path); if (File.Exists(path + MetaExt)) { File.Delete(path + MetaExt); } if (File.Exists(path + PreviewExt)) { File.Delete(path + PreviewExt); } } else if (Directory.Exists(path)) { Directory.Delete(path, true); } } callback(new Error(Error.OK)); }
public void GetProjects(StorageEventHandler <ProjectInfo[]> callback) { string projectsRoot = FullPath(string.Empty); string[] projectDirs = Directory.GetDirectories(projectsRoot); List <ProjectInfo> result = new List <ProjectInfo>(); ISerializer serializer = IOC.Resolve <ISerializer>(); for (int i = 0; i < projectDirs.Length; ++i) { string projectDir = projectDirs[i]; if (File.Exists(projectDir + "/Project.rtmeta")) { ProjectInfo projectInfo; using (FileStream fs = File.OpenRead(projectDir + "/Project.rtmeta")) { projectInfo = serializer.Deserialize <ProjectInfo>(fs); } projectInfo.Name = Path.GetFileName(projectDir); projectInfo.LastWriteTime = File.GetLastWriteTimeUtc(projectDir + "/Project.rtmeta"); result.Add(projectInfo); } } callback(new Error(Error.OK), result.ToArray()); }
public void Load(string projectPath, string bundleName, StorageEventHandler <AssetBundleInfo> callback) { QueueUserWorkItem(() => { string assetBundleInfoPath = bundleName.Replace("/", "_").Replace("\\", "_"); assetBundleInfoPath += ".rtbundle"; assetBundleInfoPath = FullPath(projectPath) + "/" + assetBundleInfoPath; ISerializer serializer = IOC.Resolve <ISerializer>(); if (File.Exists(assetBundleInfoPath)) { AssetBundleInfo result = null; using (FileStream fs = File.OpenRead(assetBundleInfoPath)) { result = serializer.Deserialize <AssetBundleInfo>(fs); } Callback(() => callback(new Error(Error.OK), result)); } else { Callback(() => callback(new Error(Error.E_NotFound), null)); } }); }
public void DeleteProject(string projectPath, StorageEventHandler callback) { string projectDir = FullPath(projectPath); Directory.Delete(projectDir, true); callback(new Error(Error.OK)); }
public void GetValues(string projectPath, string searchPattern, Type type, StorageEventHandler <PersistentObject[]> callback) { QueueUserWorkItem(() => { string fullPath = FullPath(projectPath); string path = fullPath + "/" + KeyValueStorage; if (!Directory.Exists(path)) { Directory.CreateDirectory(path); } string[] files = Directory.GetFiles(path, searchPattern); PersistentObject[] result = new PersistentObject[files.Length]; ISerializer serializer = IOC.Resolve <ISerializer>(); for (int i = 0; i < files.Length; ++i) { using (FileStream fs = File.OpenRead(files[i])) { result[i] = (PersistentObject)serializer.Deserialize(fs, type); } } Callback(() => callback(Error.NoError, result)); }); }
public void GetValue(string projectPath, string key, Type type, StorageEventHandler <PersistentObject> callback) { string fullPath = FullPath(projectPath); string path = fullPath + "/" + KeyValueStorage; if (!Directory.Exists(path)) { Directory.CreateDirectory(path); } path = path + "/" + key; if (File.Exists(path)) { ISerializer serializer = IOC.Resolve <ISerializer>(); object result = null; using (FileStream fs = File.OpenRead(path)) { result = serializer.Deserialize(fs, type); } callback(new Error(Error.OK), (PersistentObject)result); } else { callback(new Error(Error.E_NotFound), null); return; } }
public void GetPreviews(string projectPath, string[] folderPath, StorageEventHandler <Preview[][]> callback) { projectPath = AssetsFolderPath(projectPath); ISerializer serializer = RTSL2Deps.Get.Serializer; Preview[][] result = new Preview[folderPath.Length][]; for (int i = 0; i < folderPath.Length; ++i) { string path = Path.Combine(projectPath, folderPath[i]); if (!Directory.Exists(path)) { continue; } string[] files = Directory.GetFiles(path, "*" + PreviewExt); Preview[] previews = new Preview[files.Length]; for (int j = 0; j < files.Length; ++j) { previews[j] = Load <Preview>(serializer, files[j]); } result[i] = previews; } callback(new Error(), result); }
public void DeleteValue(string projectPath, string key, StorageEventHandler callback) { string fullPath = FullPath(projectPath); string path = fullPath + "/" + KeyValueStorage + "/" + key; File.Delete(path); callback(Error.NoError); }
public void Load(string projectPath, string[] assetPaths, Type[] types, StorageEventHandler <PersistentObject[]> callback) { QueueUserWorkItem(() => { PersistentObject[] result = new PersistentObject[assetPaths.Length]; for (int i = 0; i < assetPaths.Length; ++i) { string assetPath = assetPaths[i]; assetPath = FullPath(projectPath) + assetPath; ISerializer serializer = IOC.Resolve <ISerializer>(); try { if (File.Exists(assetPath)) { if (types[i] == typeof(PersistentRuntimeTextAsset)) { PersistentRuntimeTextAsset textAsset = new PersistentRuntimeTextAsset(); textAsset.name = Path.GetFileName(assetPath); textAsset.Text = File.ReadAllText(assetPath); textAsset.Ext = Path.GetExtension(assetPath); result[i] = textAsset; } else if (types[i] == typeof(PersistentRuntimeBinaryAsset)) { PersistentRuntimeBinaryAsset binAsset = new PersistentRuntimeBinaryAsset(); binAsset.name = Path.GetFileName(assetPath); binAsset.Data = File.ReadAllBytes(assetPath); binAsset.Ext = Path.GetExtension(assetPath); result[i] = binAsset; } else { using (FileStream fs = File.OpenRead(assetPath)) { result[i] = (PersistentObject)serializer.Deserialize(fs, types[i]); } } } else { Callback(() => callback(new Error(Error.E_NotFound), new PersistentObject[0])); return; } } catch (Exception e) { Debug.LogErrorFormat("Unable to load asset: {0} -> got exception: {1} ", assetPath, e.ToString()); Callback(() => callback(new Error(Error.E_Exception) { ErrorText = e.ToString() }, new PersistentObject[0])); return; } } Callback(() => callback(new Error(Error.OK), result)); }); }
public void DeleteFile(string path, StorageEventHandler <string> callback) { CombineWithBasePath(ref path); File.Delete(path); if (callback != null) { callback(new StoragePayload <string>(path)); } }
public void DeleteFolder(string path, StorageEventHandler <string> callback) { CombineWithBasePath(ref path); Directory.Delete(path, true); if (callback != null) { callback(new StoragePayload <string>(path)); } }
public void SaveFile(string path, byte[] data, StorageEventHandler <string> callback) { CombineWithBasePath(ref path); File.WriteAllBytes(path, data); if (callback != null) { callback(new StoragePayload <string>(path)); } }
public void GetProject(string projectName, StorageEventHandler <ProjectInfo, AssetBundleInfo[]> callback) { string projectDir = FullPath(projectName); string projectPath = projectDir + "/Project.rtmeta"; ProjectInfo projectInfo; Error error = new Error(); ISerializer serializer = IOC.Resolve <ISerializer>(); AssetBundleInfo[] result = new AssetBundleInfo[0]; if (!File.Exists(projectPath)) { Directory.CreateDirectory(projectDir); using (FileStream fs = File.OpenWrite(projectDir + "/Project.rtmeta")) { projectInfo = new ProjectInfo { Name = projectName, LastWriteTime = DateTime.UtcNow }; serializer.Serialize(projectInfo, fs); } } else { try { using (FileStream fs = File.OpenRead(projectPath)) { projectInfo = serializer.Deserialize <ProjectInfo>(fs); } projectInfo.Name = projectName; projectInfo.LastWriteTime = File.GetLastWriteTimeUtc(projectPath); string[] files = Directory.GetFiles(projectDir).Where(fn => fn.EndsWith(".rtbundle")).ToArray(); result = new AssetBundleInfo[files.Length]; for (int i = 0; i < result.Length; ++i) { using (FileStream fs = File.OpenRead(files[i])) { result[i] = serializer.Deserialize <AssetBundleInfo>(fs); } } } catch (Exception e) { projectInfo = new ProjectInfo(); error.ErrorCode = Error.E_Exception; error.ErrorText = e.ToString(); } } callback(error, projectInfo, result); }
public void CheckFolderExists(string path, StorageEventHandler <string, bool> callback) { CombineWithBasePath(ref path); bool result = Directory.Exists(path); if (callback != null) { callback(new StoragePayload <string, bool>(path, result)); } }
public void MoveFile(string sourcePath, string destinationPath, StorageEventHandler <string, string> callback) { CombineWithBasePath(ref sourcePath); CombineWithBasePath(ref destinationPath); File.Move(sourcePath, destinationPath); if (callback != null) { callback(new StoragePayload <string, string>(sourcePath, destinationPath)); } }
public void ImportProject(string projectPath, string sourcePath, StorageEventHandler callback) { QueueUserWorkItem(() => { try { string projectFullPath = FullPath(projectPath); if (Directory.Exists(projectFullPath)) { callback(new Error(Error.E_AlreadyExist) { ErrorText = string.Format("Project {0} already exist", projectPath) }); } else { FastZip fastZip = new FastZip(); fastZip.ExtractZip(sourcePath, projectFullPath, null); ProjectInfo projectInfo; using (FileStream fs = File.OpenRead(projectFullPath + "/Project.rtmeta")) { projectInfo = Serializer.Deserialize <ProjectInfo>(fs); } projectInfo.Name = Path.GetFileNameWithoutExtension(projectPath); projectInfo.LastWriteTime = File.GetLastWriteTimeUtc(projectFullPath + "/Project.rtmeta"); using (FileStream fs = File.OpenWrite(projectFullPath + "/Project.rtmeta")) { Serializer.Serialize(fs, projectInfo); } Callback(() => { callback(new Error(Error.OK)); }); } } catch (Exception e) { Callback(() => { callback(new Error(Error.E_Exception) { ErrorText = e.ToString() }); }); } }); }
public void SaveFiles(string[] path, byte[][] data, StorageEventHandler <string[]> callback) { CombineWithBasePath(ref path); for (int i = 0; i < path.Length; ++i) { File.WriteAllBytes(path[i], data[i]); } if (callback != null) { callback(new StoragePayload <string[]>(path)); } }
public void LoadFile(string path, StorageEventHandler <string, byte[]> callback) { CombineWithBasePath(ref path); byte[] data = null; if (File.Exists(path)) { data = File.ReadAllBytes(path); } if (callback != null) { callback(new StoragePayload <string, byte[]>(path, data)); } }
public void Create(string projectPath, string[] paths, string[] names, StorageEventHandler callback) { string fullPath = FullPath(projectPath); for (int i = 0; i < paths.Length; ++i) { string path = fullPath + paths[i] + "/" + names[i]; if (!Directory.Exists(path)) { Directory.CreateDirectory(path); } } callback(new Error(Error.OK)); }
public void DeleteFolders(string[] path, StorageEventHandler <string[]> callback) { CombineWithBasePath(ref path); for (int i = 0; i < path.Length; ++i) { Directory.Delete(path[i], true); } if (callback != null) { callback(new StoragePayload <string[]>(path)); } }
public void CreateFolder(string path, StorageEventHandler <string> callback) { CombineWithBasePath(ref path); if (!Directory.Exists(path)) { Directory.CreateDirectory(path); } if (callback != null) { callback(new StoragePayload <string>(path)); } }
public void GetProjectTree(string projectPath, StorageEventHandler <ProjectItem> callback) { projectPath = AssetsFolderPath(projectPath); ProjectItem assets = new ProjectItem(); assets.ItemID = 0; assets.Children = new List <ProjectItem>(); assets.Name = "Assets"; GetProjectTree(projectPath, assets); callback(new Error(), assets); }
public void MoveFolders(string[] sourcePath, string[] destinationPath, StorageEventHandler <string[], string[]> callback) { CombineWithBasePath(ref sourcePath); CombineWithBasePath(ref destinationPath); for (int i = 0; i < sourcePath.Length; ++i) { Directory.Move(sourcePath[i], destinationPath[i]); } if (callback != null) { callback(new StoragePayload <string[], string[]>(sourcePath, destinationPath)); } }
public void DeleteProject(string projectPath, StorageEventHandler callback) { QueueUserWorkItem(() => { string projectDir = FullPath(projectPath); if (Directory.Exists(projectDir)) { Directory.Delete(projectDir, true); } Callback(() => { callback(new Error(Error.OK)); }); }); }
public void CopyFolder(string sourcePath, string destinationPath, StorageEventHandler <string, string> callback) { CombineWithBasePath(ref sourcePath); CombineWithBasePath(ref destinationPath); DirectoryInfo source = new DirectoryInfo(sourcePath); DirectoryInfo destination = new DirectoryInfo(destinationPath); CopyAll(source, destination); if (callback != null) { callback(new StoragePayload <string, string>(sourcePath, destinationPath)); } }
private TrinityErrorCode RaiseStorageEvent(StorageEventHandler handler, string handlerName) { var ret = TrinityErrorCode.E_SUCCESS; var listeners = handler.GetInvocationList(); foreach (var listener in listeners) { try { listener.DynamicInvoke(); } catch (Exception ex) { Log.WriteLine(LogLevel.Error, $"An error oucurred in {handlerName}: {{0}}", ex.ToString()); ret = TrinityErrorCode.E_FAILURE; } } return(ret); }
public void GetValue(string projectPath, string key, Type type, StorageEventHandler <PersistentObject> callback) { string fullPath = FullPath(projectPath); string path = fullPath + "/" + KeyValueStorage; if (!Directory.Exists(path)) { Directory.CreateDirectory(path); } path = path + "/" + key; if (File.Exists(path)) { object result = null; if (type == typeof(PersistentRuntimeTextAsset)) { PersistentRuntimeTextAsset textAsset = new PersistentRuntimeTextAsset(); textAsset.name = Path.GetFileName(path); textAsset.Text = File.ReadAllText(path); textAsset.Ext = Path.GetExtension(path); result = textAsset; } else if (type == typeof(PersistentRuntimeBinaryAsset)) { PersistentRuntimeBinaryAsset binaryAsset = new PersistentRuntimeBinaryAsset(); binaryAsset.name = Path.GetFileName(path); binaryAsset.Data = File.ReadAllBytes(path); binaryAsset.Ext = Path.GetExtension(path); result = binaryAsset; } else { ISerializer serializer = IOC.Resolve <ISerializer>(); using (FileStream fs = File.OpenRead(path)) { result = serializer.Deserialize(fs, type); } } callback(new Error(Error.OK), (PersistentObject)result); } else { callback(new Error(Error.E_NotFound), null); return; } }