private void Move(ProjectItem item, ProjectEventHandler callback, string srcPath, string dstPath) { if (item.IsFolder) { m_storage.MoveFolder(srcPath, dstPath, payload => { if (callback != null) { callback(new ProjectPayload()); } }); } else { m_storage.MoveFiles( new[] { srcPath, srcPath + "." + FileMetaExt }, new[] { dstPath, dstPath + "." + FileMetaExt }, payload => { if (callback != null) { callback(new ProjectPayload()); } }); } }
public void Delete(ProjectItem item, ProjectEventHandler callback) { if (item == null) { callback(new ProjectPayload()); return; } string path = item.ToString(); if (item.IsFolder) { m_storage.DeleteFolder(path, payload => { if (callback != null) { callback(new ProjectPayload()); } }); } else { string[] filePath = new[] { path, path + "." + FileMetaExt }; m_storage.DeleteFiles(filePath, payload => { if (callback != null) { callback(new ProjectPayload()); } }); } }
public void Parallel(Action <ProjectEventHandler>[] actions, ProjectEventHandler callback) { if (actions == null || actions.Length == 0) { callback(new ProjectPayload()); } int counter = actions.Length; bool hasError = false; foreach (Action <ProjectEventHandler> action in actions) { action(actionCallback => { hasError |= actionCallback.HasError; counter--; if (counter == 0) { callback(new ProjectPayload { HasError = hasError }); } }); } }
public ProjectAsyncOperation SetValue <T>(string key, T obj, ProjectEventHandler callback = null) { ProjectAsyncOperation ao = new ProjectAsyncOperation(); ITypeMap typeMap = IOC.Resolve <ITypeMap>(); Type persistentType = typeMap.ToPersistentType(typeof(T)); if (persistentType == null) { ao.Error = new Error(Error.E_NotFound); if (callback != null) { callback(ao.Error); } ao.IsCompleted = true; } else { PersistentSurrogate surrogate = (PersistentSurrogate)Activator.CreateInstance(persistentType); surrogate.ReadFrom(obj); ISerializer serializer = IOC.Resolve <ISerializer>(); byte[] bytes = serializer.Serialize(surrogate); string data = Convert.ToBase64String(bytes); PlayerPrefs.SetString(key, data); ao.Error = Error.NoError; if (callback != null) { callback(ao.Error); } ao.IsCompleted = true; } return(ao); }
public void Save(ProjectItem[] items, bool metaOnly, ProjectEventHandler callback) { ProjectItem[] folders = items.Where(item => item.IsFolder).ToArray(); string[] folderPath = folders.Select(item => item.ToString()).ToArray(); ProjectItem[] files = items;//items.Where(item => !item.IsFolder).ToArray(); byte[][] fileData = metaOnly ? files.Select(item => m_serializer.Serialize(item.Internal_Meta)).ToArray() : files.Where(item => item.Internal_Data != null).Select(item => m_serializer.Serialize(item.Internal_Data)). Union(files.Select(item => m_serializer.Serialize(item.Internal_Meta))).ToArray(); string[] filePath = metaOnly ? files.Select(item => item.ToString() + "." + FileMetaExt).ToArray() : files.Where(item => item.Internal_Data != null).Select(item => item.ToString()).Union(files.Select(item => item.ToString() + "." + FileMetaExt)).ToArray(); m_storage.CreateFolders(folderPath, foldersCreatedCallback => { m_storage.SaveFiles(filePath, fileData, saveFilesCallback => { if (callback != null) { callback(new ProjectPayload()); } }); }); }
public ProjectAsyncOperation Open(string project, ProjectEventHandler callback) { ProjectAsyncOperation ao = new ProjectAsyncOperation(); m_projectPath = project; m_assetDB.UnloadLibraries(); m_storage.GetProject(m_projectPath, (error, projectInfo) => { if (error.HasError) { if (callback != null) { callback(error); } ao.Error = error; ao.IsCompleted = true; return; } OnOpened(project, projectInfo, ao, callback); }); return(ao); }
/// <summary> /// 加载工程之前的操作 /// </summary> private static void BeforeLoadProject() { if (!Isinitialized) { Isinitialized = true; ProjectService.ProjectLoaded += ProjectSeviceProjectLoaded; } }
public ProjectAsyncOperation Save(AssetItem assetItem, object obj, ProjectEventHandler callback) { if (m_root == null) { throw new InvalidOperationException("Project is not opened. Use OpenProject method"); } if (obj == null) { throw new ArgumentNullException("obj"); } Type persistentType = m_typeMap.ToPersistentType(obj.GetType()); if (persistentType == null) { throw new ArgumentException(string.Format("PersistentClass for {0} does not exist", obj.GetType()), "obj"); } if (persistentType == typeof(PersistentGameObject)) { persistentType = typeof(PersistentRuntimePrefab); } PersistentObject persistentObject = (PersistentObject)Activator.CreateInstance(persistentType); persistentObject.ReadFrom(obj); if (persistentObject is PersistentRuntimePrefab) { PersistentRuntimePrefab persistentPrefab = (PersistentRuntimePrefab)persistentObject; if (persistentPrefab.Descriptors != null) { List <PrefabPart> prefabParts = new List <PrefabPart>(); PersistentDescriptorsToPrefabPartItems(persistentPrefab.Descriptors, prefabParts); assetItem.Parts = prefabParts.ToArray(); } } GetDepsContext getDepsCtx = new GetDepsContext(); persistentObject.GetDeps(getDepsCtx); assetItem.Dependencies = getDepsCtx.Dependencies.ToArray(); ProjectAsyncOperation ao = new ProjectAsyncOperation(); m_storage.Save(m_projectPath, assetItem.Parent.ToString(), assetItem, persistentObject, m_projectInfo, error => { if (callback != null) { callback(error); } ao.Error = error; ao.IsCompleted = true; }); return(ao); }
public void Delete(ProjectItem[] items, ProjectEventHandler callback) { items = ProjectItem.GetRootItems(items); string[] folderPath = items.Where(item => item.IsFolder).Select(item => item.ToString()).ToArray(); ProjectItem[] files = items.Where(item => !item.IsFolder).ToArray(); string[] filePath = files.Select(item => item.ToString()).Union(files.Select(item => item.ToString() + "." + FileMetaExt)).ToArray(); GroupOperation(folderPath, filePath, m_storage.DeleteFolders, m_storage.DeleteFiles, callback); }
public void Move(ProjectItem item, ProjectItem parent, ProjectEventHandler callback) { string srcPath = item.ToString(); parent.AddChild(item); item.Name = ProjectItem.GetUniqueName(item.Name, item, item.Parent); string dstPath = item.ToString(); Move(item, callback, srcPath, dstPath); }
private void OnOpened(string project, ProjectEventHandler callback, ProjectInfo projectInfo) { if (projectInfo == null) { projectInfo = new ProjectInfo(); } m_projectInfo = projectInfo; GetProjectTree(project, callback); }
public void SaveProjectMeta(string name, ProjectMeta meta, ProjectEventHandler callback) { m_storage.SaveFile(name + "." + ProjectMetaExt, m_serializer.Serialize(meta), saveMetaCompleted => { if (callback != null) { callback(new ProjectPayload()); } }); }
public AsyncOperation Unload(ProjectEventHandler callback = null) { UnloadUnregisterDestroy(); return(m_assetDB.UnloadUnusedAssets(ao => { if (callback != null) { callback(new Error()); } })); }
private void GroupOperation( string[] folderPath, string[] filePath, string[] folderDstPath, string[] fileDstPath, Action <string[], string[], StorageEventHandler <string[], string[]> > folderOperation, Action <string[], string[], StorageEventHandler <string[], string[]> > fileOperation, ProjectEventHandler callback) { if (folderPath.Length > 0) { folderOperation(folderPath, folderDstPath, folderOperationCompleted => { if (filePath.Length > 0) { fileOperation(filePath, fileDstPath, fileOperationCompleted => { if (callback != null) { callback(new ProjectPayload()); } }); } else { if (callback != null) { callback(new ProjectPayload()); } } }); } else { if (filePath.Length > 0) { fileOperation(filePath, fileDstPath, fileOperationCompleted => { if (callback != null) { callback(new ProjectPayload()); } }); } else { if (callback != null) { callback(new ProjectPayload()); } } } }
public void GetAssetItems(ProjectItem[] folders, ProjectEventHandler <ProjectItem[]> callback) { m_storage.GetPreviews(m_projectPath, folders.Select(f => f.ToString()).ToArray(), (error, result) => { if (error.HasError) { callback(error, new AssetItem[0]); return; } OnGetPreviewsCompleted(folders, callback, error, result); }); }
public ProjectAsyncOperation DeleteValue <T>(string key, ProjectEventHandler callback = null) { ProjectAsyncOperation ao = new ProjectAsyncOperation(); PlayerPrefs.DeleteKey(key); if (callback != null) { callback(Error.NoError); } ao.Error = Error.NoError; ao.IsCompleted = true; return(ao); }
private void GetProjectTree(string project, ProjectEventHandler callback) { m_storage.GetProjectTree(project, (error, rootFolder) => { if (error.HasError) { callback(error); return; } OnGetProjectTreeCompleted(error, rootFolder, callback); }); }
private void OnExhausted(ProjectEventHandler <AssetItem> callback, ProjectAsyncOperation <AssetItem> ao, int assetIdBackup) { m_projectInfo.AssetIdentifier = assetIdBackup; Error error = new Error(Error.E_InvalidOperation); if (callback != null) { callback(error, null); } ao.Error = error; ao.Result = null; ao.IsCompleted = true; }
public void Open(string project, ProjectEventHandler callback) { m_projectPath = project; m_assetDB.UnloadLibraries(); m_storage.GetProject(m_projectPath, (error, projectInfo) => { if (error.HasError) { callback(error); return; } OnOpened(project, callback, projectInfo); }); }
public ProjectAsyncOperation <UnityObject> Load(AssetItem assetItem, ProjectEventHandler <UnityObject> callback) { Type type = m_typeMap.ToType(assetItem.TypeGuid); if (type == null) { throw new ArgumentException("assetItem", string.Format("Unable to resolve type using TypeGuid {0}", assetItem.TypeGuid)); } if (type == typeof(Scene)) { m_assetDB.UnregisterSceneObjects(); } HashSet <AssetItem> loadAssetItemsHs = new HashSet <AssetItem>(); GetAssetItemsToLoad(assetItem, loadAssetItemsHs); Type[] persistentTypes = loadAssetItemsHs.Select(item => m_typeMap.ToPersistentType(m_typeMap.ToType(item.TypeGuid))).ToArray(); for (int i = 0; i < persistentTypes.Length; ++i) { if (persistentTypes[i] == typeof(PersistentGameObject)) { persistentTypes[i] = typeof(PersistentRuntimePrefab); } } ProjectAsyncOperation <UnityObject> ao = new ProjectAsyncOperation <UnityObject>(); m_storage.Load(m_projectPath, loadAssetItemsHs.Select(item => item.ToString()).ToArray(), persistentTypes, (error, persistentObjects) => { if (error.HasError) { if (callback != null) { callback(error, null); } ao.Error = error; return; } OnLoadCompleted(assetItem, loadAssetItemsHs.ToArray(), persistentObjects, ao, callback); }); return(ao); }
public ProjectAsyncOperation <ProjectItem> LoadAssetLibrary(int index, ProjectEventHandler <ProjectItem> callback = null) { ProjectAsyncOperation <ProjectItem> pao = new ProjectAsyncOperation <ProjectItem>(); ResourceRequest request = Resources.LoadAsync <AssetLibraryAsset>(AssetLibraries[index]); Action <AsyncOperation> completed = null; completed = ao => { request.completed -= completed; ProjectItem result = new ProjectItem(); AssetLibraryAsset asset = (AssetLibraryAsset)request.asset; Error error = new Error(Error.OK); if (asset == null) { error.ErrorCode = Error.E_NotFound; error.ErrorText = "Asset Library " + AssetLibraries[index] + " does not exist"; if (callback != null) { callback(error, result); } pao.Result = null; pao.IsCompleted = true; return; } TreeModel <AssetFolderInfo> model = new TreeModel <AssetFolderInfo>(asset.AssetLibrary.Folders); BuildTree(result, (AssetFolderInfo)model.root.children[0], index); if (callback != null) { callback(error, result); } pao.Result = result; pao.IsCompleted = true; }; request.completed += completed; return(pao); }
//public void SaveProjectData(string name, ProjectData data, ProjectEventHandler callback) //{ // m_storage.SaveFile(name + ".rtpdata", m_serializer.Serialize(data), saveDataCompleted => // { // if (callback != null) // { // callback(new ProjectPayload()); // } // }); //} //public void Load(ProjectItem folder, ProjectEventHandler<ProjectItem[]> callback, params int[] exceptTypes) //{ // string folderPath = folder.ToString(); // m_storage.GetFiles(folderPath, getFilesResult => // { // string[] path = getFilesResult.Data.Where(filePath => filePath.EndsWith("." + FileMetaExt)).ToArray(); // Array.Resize(ref path, path.Length + path.Length); // for (int i = path.Length; i < path.Length + path.Length; ++i) // { // path[path.Length + i] = path[i]; // path[i] = path[i].Remove(path[i].LastIndexOf("." + FileMetaExt)); // } // HashSet<int> exceptTypesHs = null; // if(exceptTypes != null && exceptTypes.Length > 0) // { // exceptTypesHs = new HashSet<int>(); // for(int i = 0; i < exceptTypes.Length; ++i) // { // if(!exceptTypesHs.Contains(exceptTypes[i])) // { // exceptTypesHs.Add(exceptTypes[i]); // } // } // } // m_storage.LoadFiles(path, loadFilesResult => // { // List<ProjectItem> loadedItems = new List<ProjectItem>(); // for (int i = 0; i < path.Length; ++i) // { // byte[] dataRaw = loadFilesResult.Data[i]; // byte[] metaRaw = loadFilesResult.Data[path.Length + i]; // if (dataRaw != null && metaRaw != null) // { // ProjectItemMeta meta = m_serializer.Deserialize<ProjectItemMeta>(metaRaw); // bool loadData = exceptTypesHs == null || !exceptTypesHs.Contains(meta.Type); // ProjectItemData data = loadData ? m_serializer.Deserialize<ProjectItemData>(dataRaw) : null; // loadedItems.Add(new ProjectItem(meta, data) { Parent = folder }); // } // } // callback(new ProjectPayload<ProjectItem[]>(loadedItems.ToArray())); // }); // }); //} public void Load(string[] path, ProjectEventHandler <ProjectItem[]> callback, params int[] exceptTypes) { int pathLength = path.Length; Array.Resize(ref path, pathLength + pathLength); for (int i = 0; i < pathLength; ++i) { path[pathLength + i] = path[i] + "." + FileMetaExt; } HashSet <int> exceptTypesHs = null; if (exceptTypes != null && exceptTypes.Length > 0) { exceptTypesHs = new HashSet <int>(); for (int i = 0; i < exceptTypes.Length; ++i) { if (!exceptTypesHs.Contains(exceptTypes[i])) { exceptTypesHs.Add(exceptTypes[i]); } } } m_storage.LoadFiles(path, loadFilesResult => { List <ProjectItem> loadedItems = new List <ProjectItem>(); for (int i = 0; i < pathLength; ++i) { byte[] dataRaw = loadFilesResult.Data[i]; byte[] metaRaw = loadFilesResult.Data[pathLength + i]; if (dataRaw != null && metaRaw != null) { ProjectItemMeta meta = m_serializer.Deserialize <ProjectItemMeta>(metaRaw); bool loadData = exceptTypesHs == null || !exceptTypesHs.Contains(meta.TypeCode); ProjectItemData data = loadData ? m_serializer.Deserialize <ProjectItemData>(dataRaw) : null; loadedItems.Add(new ProjectItem(meta, data)); } } callback(new ProjectPayload <ProjectItem[]>(loadedItems.ToArray())); }); }
public void Move(ProjectItem[] items, ProjectItem parent, ProjectEventHandler callback) { items = ProjectItem.GetRootItems(items); string[] folderSrcPath = items.Where(item => item.IsFolder).Select(item => item.ToString()).ToArray(); ProjectItem[] files = items.Where(item => !item.IsFolder).ToArray(); string[] fileSrcPath = files.Select(item => item.ToString()).Union(files.Select(item => item.ToString() + "." + FileMetaExt)).ToArray(); foreach (ProjectItem item in items) { parent.AddChild(item); item.Name = ProjectItem.GetUniqueName(item.Name, item, item.Parent); } string[] folderDstPath = items.Where(item => item.IsFolder).Select(item => item.ToString()).ToArray(); string[] fileDstPath = files.Select(item => item.ToString()).Union(files.Select(item => item.ToString() + "." + FileMetaExt)).ToArray(); GroupOperation(folderSrcPath, fileSrcPath, folderDstPath, fileDstPath, m_storage.MoveFolders, m_storage.MoveFiles, callback); }
private void GetProjectTree(string project, ProjectAsyncOperation ao, ProjectEventHandler callback) { m_storage.GetProjectTree(project, (error, rootFolder) => { if (error.HasError) { if (callback != null) { callback(error); } ao.Error = error; ao.IsCompleted = true; return; } OnGetProjectTreeCompleted(error, rootFolder, ao, callback); }); }
public void Rename(ProjectItem item, string name, ProjectEventHandler callback) { string srcPath = item.ToString(); string srcName = item.Name; item.Name = ProjectItem.GetUniqueName(name, item, item.Parent); string dstPath = item.ToString(); if (!item.IsFolder && !item.IsScene) { m_storage.LoadFile(srcPath, loadFilesResult => { byte[] dataRaw = loadFilesResult.Data; if (dataRaw != null) { ProjectItemData data = m_serializer.Deserialize <ProjectItemData>(dataRaw); item.Internal_Data = data; item.Rename(name); } Save(item, srcPath, false, saveCompleted => { UnloadData(item); Move(item, callback, srcPath, dstPath); }); }); } else { if (!item.IsFolder) { Save(item, srcPath, true, saveCompleted => { Move(item, callback, srcPath, dstPath); }); } else { Move(item, callback, srcPath, dstPath); } } }
private void LoadFolders(ProjectItem item, ProjectEventHandler callback) { m_storage.GetFolders(item.ToString(), getFoldersCompleted => { string[] names = getFoldersCompleted.Data; if (names != null && names.Length > 0) { Action <ProjectEventHandler>[] loadFoldersActions = new Action <ProjectEventHandler> [names.Length]; if (item.Children == null) { item.Children = new List <ProjectItem>(names.Length); } for (int i = 0; i < names.Length; ++i) { string name = names[i]; ProjectItem childItem = ProjectItem.CreateFolder(name); item.AddChild(childItem); loadFoldersActions[i] = cb => LoadFolders(childItem, cb); } Parallel(loadFoldersActions, parallelCallback => { if (callback != null) { callback(new ProjectPayload()); } }); } else { if (callback != null) { callback(new ProjectPayload()); } } }, false); }
private void Save(ProjectItem item, string path, bool metaOnly, ProjectEventHandler callback) { if (item.IsFolder) { ProjectItem[] filesAndFolders = item.FlattenHierarchy(true); Save(filesAndFolders, metaOnly, callback); } else { m_storage.SaveFile(path + "." + FileMetaExt, m_serializer.Serialize(item.Internal_Meta), saveMetaCompleted => { if (item.Internal_Data != null) { if (metaOnly) { if (callback != null) { callback(new ProjectPayload()); } } else { m_storage.SaveFile(path, m_serializer.Serialize(item.Internal_Data), saveDataCompleted => { if (callback != null) { callback(new ProjectPayload()); } }); } } else { if (callback != null) { callback(new ProjectPayload()); } } }); } }
public void Save(AssetItem assetItem, object obj, ProjectEventHandler callback) { if (obj == null) { throw new ArgumentNullException("obj"); } Type persistentType = m_typeMap.ToPersistentType(obj.GetType()); if (persistentType == null) { throw new ArgumentException(string.Format("PersistentClass for {0} does not exist", obj.GetType()), "obj"); } PersistentObject persistentObject = (PersistentObject)Activator.CreateInstance(persistentType); persistentObject.ReadFrom(obj); if (persistentObject is PersistentPrefab) { PersistentPrefab persistentPrefab = (PersistentPrefab)persistentObject; if (persistentPrefab.Descriptors != null) { List <PrefabPart> prefabParts = new List <PrefabPart>(); PersistentDescriptorsToPrefabPartItems(persistentPrefab.Descriptors, prefabParts); assetItem.Parts = prefabParts.ToArray(); } } GetDepsContext getDepsCtx = new GetDepsContext(); persistentObject.GetDeps(getDepsCtx); assetItem.Dependencies = getDepsCtx.Dependencies.ToArray(); m_storage.Save(m_projectPath, assetItem.Parent.ToString(), assetItem, persistentObject, m_projectInfo, error => { callback(error); }); }
private void OnGetPreviewsCompleted(ProjectItem[] folders, ProjectEventHandler <ProjectItem[]> callback, Error error, Preview[][] result) { for (int i = 0; i < result.Length; ++i) { ProjectItem folder = folders[i]; Preview[] previews = result[i]; if (previews != null && previews.Length > 0) { for (int j = 0; j < previews.Length; ++j) { Preview preview = previews[j]; AssetItem assetItem; if (m_idToAssetItem.TryGetValue(preview.ItemID, out assetItem)) { if (assetItem.Parent == null) { Debug.LogErrorFormat("asset item {0} parent is null", assetItem.ToString()); continue; } if (assetItem.Parent.ItemID != folder.ItemID) { Debug.LogErrorFormat("asset item {0} with wrong parent selected. Expected parent {1}. Actual parent {2}", folder.ToString(), assetItem.Parent.ToString()); continue; } assetItem.Preview = preview; } else { Debug.LogWarningFormat("AssetItem with ItemID {0} does not exists", preview.ItemID); } } } } callback(error, folders.Where(f => f.Children != null).SelectMany(f => f.Children).ToArray()); }
public ProjectAsyncOperation Open(string project, ProjectEventHandler callback) { m_staticReferencesMapping = new MappingInfo(); /* * for (int i = 0; i < StaticReferences.Length; ++i) * { * AssetLibraryAsset reference = StaticReferences[i]; * if (reference != null) * { * reference.LoadIDMappingTo(m_staticReferencesMapping, false, true); * } * } */ ProjectAsyncOperation ao = new ProjectAsyncOperation(); m_projectPath = project; m_assetDB.UnloadLibraries(); m_storage.GetProject(m_projectPath, (error, projectInfo) => { if (error.HasError) { if (callback != null) { callback(error); } ao.Error = error; ao.IsCompleted = true; return; } OnOpened(project, projectInfo, ao, callback); }); return(ao); }