public void Search(string path, DirItem parent)
{
string[] filePaths;
string[] dirPaths;
try
{
filePaths = dirAccess.GetFiles(path);
dirPaths = dirAccess.GetDirectories(path);
}
catch (Exception ex)
{
Console.WriteLine("Try to access " + path + " " + ex.Message);
return;
}
parent.Init(filePaths.Length, dirPaths.Length);
for (int i = 0; i < filePaths.Length; ++i)
{
var item = new FileItem(filePaths[i]);
parent.AddFile(item);
}
for (int i = 0; i < dirPaths.Length; ++i)
{
var dirPath = dirPaths[i];
var item = new DirItem(dirPath, parent.Level + 1);
parent.AddDir(item);
Search(dirPath, item);
}
}
private static async Task ProvideThumbnail(HttpListenerRequest request, HttpListenerResponse response)
{
var param = request.RequestUri.ParseQueryParameters();
var sessionId = param.GetByKey(Consts.SessionId);
var itemId = param.GetByKey(Consts.ItemId);
//Env.Logger.Log("Get Thumbnail start " + itemId, "Http");
bool provided = false;
BrowseResponder br = SuperDriveCore.Conversations.GetByKey(sessionId) as BrowseResponder;
if (br != null)
{
DirItem dir = br.CurrentFolder;
var f = dir?.Children.FirstOrDefault(d => d.Id == itemId) as FileItem;
if (f != null)
{
//不能在这里关闭流。因为response的close函数里面会使用这个流。想要关闭，除非
//把内容复制给OutputStream.
using (var rep = response)
{
response.OutputStream = await Env.FileSystem.GetThumbnailStream(f);
provided = true;
Env.Logger.Log("Get Thumbnail End " + itemId, "Http");
}
}
}
if (!provided)
{
response.NotFound();
response.Dispose();
}
}
//如果用户先请求浏览一个目录，等一下又请求浏览另外的目录，那怎么操作？
public Task <IEnumerable <Item> > GetDirChildren(DirItem dir, TaskCompletionSource <ConversationMessage> response = null)
{
if (dir.Equals(CurrentDir) && _listResult != null)
{
return(_listResult.Task); //如果已经请求过了，而且两次请求的内容相同，就等待上次返回结果。
}
//表示别人请求过。让上一次的请求返回null。
_listResult?.TrySetResult(null);
CurrentDir = dir;
_listResult = new TaskCompletionSource <IEnumerable <Item> >();
_listResult.SetValueWhenTimeout(TimeSpan.FromSeconds(Consts.DefaultConnectTimeoutSeconds), null);
_currentRequest = new BrowseRequestMessage {
DirItemId = dir.Id
};
//Env.Logger.Log($"Post Message {_currentRequest}", nameof(RemoteBrowser));
var postTask = _conversation.PostMessage(_currentRequest);
postTask.ConfigureAwait(false);
if (postTask.Result)
{
return(_listResult.Task);
}
_listResult.TrySetResult(null);
response?.TrySetResult(null);
return(_listResult.Task);
}
internal void ProcessReceiveListChildItems(DirItem item)
{
if (item == null)
{
return;
}
var items = receiveList.Where(o => o.Value != null && o.Value.Type == ItemType.File);
if (items.Count() > 0)
{
foreach (var i in items)
{
var parent = i.Value.Parent;
while (parent != null)
{
lock (i.Value)
{
if (parent != null && parent.ID == item.ID)
{
i.Value.TransferState = item.TransferState;
break;
}
else
{
parent = parent.Parent;
}
}
}
}
}
}
public Dir ReadDir(int index)
{
Dir dir = new Dir();
dir.DirItems = new List <DirItem>();
byte[] bytes = ReadBiteFile(index);
int i, count = 4;
//字节解析为目录
dir.Size = BitConverter.ToInt32(bytes, 0);
for (i = 0; i < dir.Size; i++)
{
DirItem dirItem = new DirItem();
dirItem.NameSize = BitConverter.ToInt32(bytes, count);
count += 4;
dirItem.Name = System.Text.Encoding.Default.GetString(bytes, count, dirItem.NameSize);
count += dirItem.NameSize;
dirItem.Inode = BitConverter.ToInt32(bytes, count);
count += 4;
dir.DirItems.Add(dirItem);
}
return(dir);
}
public DirItem(string dirPath)
{
DirPath = dirPath;
Files = new List <FileItem>();
IsConfig = false;
Altas = false;
NearestConfigParent = null;
}
internal async Task <List <AbstractFileItem> > GetChildren(DirItem dir)
{
var result = await GetChildrenImpl(dir);
foreach (var af in result)
{
af.ConversationID = dir.ConversationID;
}
return(result);
}
public byte[] ToBytes(DirItem dirItem)
{
List <byte> bytes = new List <byte>();
bytes.AddRange(BitConverter.GetBytes(dirItem.NameSize).ToList());
bytes.AddRange(System.Text.Encoding.Default.GetBytes(dirItem.Name).ToList());
bytes.AddRange(BitConverter.GetBytes(dirItem.Inode));
return(bytes.ToArray());
}
public DirItem Load(string rootPath)
{
var dir = new DirectoryInfo(rootPath);
var root = new DirItem {
Path = rootPath
};
LoadRecursive(root, dir);
return(root);
}
public MainViewModel()
{
ExitCommand = new Command(() => Application.Current.Shutdown());
SelectItemCommand = new Command(SelectItem);
if (DesignerProperties.GetIsInDesignMode(new DependencyObject()))
{
Root = new DirItem();
}
else
{
WinConsole.Initialize();
Root = FileTreeLoader.Instance.Load(@"U:\Data");
}
}
internal void ProcessResponse(BrowseResponseMessage rep)
{
if (rep == null || rep.BrowserId != _currentRequest?.BrowserId)
{
return;
}
CurrentDir = rep.CurrentDir;
foreach (var item in rep.Items)
{
item.Parent = rep.CurrentDir;
}
_listResult?.TrySetResult(rep.Items);
_listResult = null;
}
public Task <IEnumerable <Item> > GetDirChildren(DirItem dir)
{
CurrentDir = dir;
//为上一次的GetItems请求返回null。
_getItemsTcs?.TrySetResult(null);
_getItemsTcs = new TaskCompletionSource <IEnumerable <Item> >();
_getItemsTcs.SetValueWhenTimeout(TimeSpan.FromSeconds(DefaultConnectTimeoutSeconds), null);
Task.Run(() =>
{
var ch = dir.Children;
_getItemsTcs.SetResult(ch);
});
return(_getItemsTcs.Task);
}
public void AddDirItems(string folderPath, IList <FSItem> items)
{
lok.EnterWriteLock();
try
{
pathToDirItem[folderPath] = new DirItem(items.Select(i => i.Path).ToList(), DirItemsExpirationSeconds);
foreach (var item in items)
{
pathToNode[item.Path] = item;
}
}
finally
{
lok.ExitWriteLock();
}
}
void LoadRecursive(DirItem dirItem, DirectoryInfo dir)
{
dirItem.Items.AddRange(GetFiles(dir));
foreach (var currentDir in dir.EnumerateDirectories())
{
var childdir = new DirItem
{
Name = currentDir.Name,
Path = currentDir.FullName
};
dirItem.Items.Add(childdir);
LoadRecursive(childdir, currentDir);
}
}
protected internal override async void OnMessageReceived(ConversationMessage message)
{
var brMessage = message as BrowseRequestMessage;
if (brMessage == null)
{
return;
}
#region comment
//TODO 如果是安卓又该如何处理？首先需要搞清楚这是在分类浏览，还是在浏览目录，如果是在浏览目录，这个代码可用
//如果是在分类浏览，那么需要去数据库中查询，并返回列表。
//如果安卓做分类浏览，那么分类浏览中有没有子目录的概念？有的图库中有多个相册，是如何处理的？多个相册看起来像是文件夹的概念。
//TODO 新拍摄的图片之类的，没有立即存储到MediaStore，如何处理？
//TODO 如果有生成并缓存缩略图，那些缩略图要被MediaStore忽略才行。
//http://blog.csdn.net/yhcelebrite/article/details/11714925
//http://blog.csdn.net/bgc525725278/article/details/8131657
#endregion
var respondMessage = await BrowseResponseUtil.Response(this, brMessage);
if (CurrentFolder?.Children.FirstOrDefault(c => c.Id == respondMessage.CurrentDir?.Id) != null)
{
//如果这次要求浏览的目录是上次浏览的目录的子目录
//CurrentFolder.FolderString
respondMessage.CurrentDir.Parent = CurrentFolder;
}
CurrentFolder = respondMessage.CurrentDir;
if (CurrentFolder != null)
{
if (NamedFolders.IsNamedFolderId(CurrentFolder.Id))
{
_browseHistories.Clear(); //已经到顶层目录，不会再有返回操作。
}
_browseHistories.Add(CurrentFolder);
}
PostMessageAsync(respondMessage);
}
private static void GroupNearestConfig()
{
// 非配置项 dir
foreach (var pair in dirItems)
{
DirItem origin = pair.Value;
DirItem item = origin;
string dirName = item.DirPath;
while (item != null)
{
if (item.IsConfig)
{
origin.NearestConfigParent = item;
break;
}
item = null;
dirName = Path.GetDirectoryName(dirName).Replace("\\", "/");
if (dirItems.ContainsKey(dirName))
{
item = dirItems[dirName];
}
}
}
}
private static void GetDependences(string path, bool recursive, Dictionary <string, DirItem> dirItems, Dictionary <string, FileItem> fileItems)
{
string[] dependencies = AssetDatabase.GetDependencies(path.Replace("\\", "/"), recursive);
foreach (string dependence in dependencies)
{
string filePath = dependence.Replace("\\", "/");
string fileKey = filePath.Replace("Assets/", "");
if (!fileItems.ContainsKey(fileKey))
{
fileItems.Add(fileKey, new FileItem()
{
FilePath = filePath, Levels = 0
});
string dirName = Path.GetDirectoryName(fileKey).Replace("\\", "/");
if (!dirItems.ContainsKey(dirName))
{
DirItem result = new DirItem(dirName);
dirItems.Add(dirName, result);
}
dirItems[dirName].Files.Add(fileItems[fileKey]);
}
fileItems[fileKey].Levels++;
}
}
public Task <IEnumerable <Item> > GetDirChildren(DirItem dir) => _rbu.GetDirChildren(dir);
/// <summary>
/// 如果已经存在，或者创建成功，都返回true
/// </summary>
/// <param name="dir"></param>
/// <returns></returns>
internal bool GetOrCreateDir(DirItem dir)
{
DirectoryInfo di = Directory.CreateDirectory(dir.AbsolutePath);
return(di != null);
}
protected abstract Task <List <AbstractFileItem> > GetChildrenImpl(DirItem dir);
public static async Task <List <AbstractFileItem> > GetFiles(DirItem dir)
{
return(await _instance.GetFilesImpl(dir));
}
private BaseItem CreateItem(NodeItem item, byte[] buffer, int offset)
{
var data = EndianUtilities.ToByteArray(buffer, (int)(offset + item.DataOffset), (int)item.DataSize);
BaseItem result;
switch (item.Key.ItemType)
{
case ItemType.ChunkItem:
result = new ChunkItem(item.Key);
break;
case ItemType.DevItem:
result = new DevItem(item.Key);
break;
case ItemType.RootItem:
result = new RootItem(item.Key);
break;
case ItemType.InodeRef:
result = new InodeRef(item.Key);
break;
case ItemType.InodeItem:
result = new InodeItem(item.Key);
break;
case ItemType.DirItem:
result = new DirItem(item.Key);
break;
case ItemType.DirIndex:
result = new DirIndex(item.Key);
break;
case ItemType.ExtentData:
result = new ExtentData(item.Key);
break;
case ItemType.RootRef:
result = new RootRef(item.Key);
break;
case ItemType.RootBackref:
result = new RootBackref(item.Key);
break;
case ItemType.XattrItem:
result = new XattrItem(item.Key);
break;
case ItemType.OrphanItem:
result = new OrphanItem(item.Key);
break;
default:
throw new IOException($"Unsupported item type {item.Key.ItemType}");
}
result.ReadFrom(data, 0);
return(result);
}
public Task <IEnumerable <Item> > GetDirChildren(DirItem dir) => _browseRequestHelper.GetDirChildren(dir);
protected abstract Task <List <AbstractFileItem> > GetFilesImpl(DirItem dir);
