|
private CreateFolderAsync ( [ desiredName ) : IAsyncOperation |
||
| desiredName | [ | |
| return | IAsyncOperation |
|
public async void InitFolders()
{
_localFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
var folderName = "";
try
{
folderName = "medium";
if (Directory.Exists($"{_localFolder.Path}\\{folderName}"))
{
_mediumFolder = await _localFolder.GetFolderAsync(folderName);
}
else
{
_mediumFolder = await _localFolder.CreateFolderAsync(folderName);
}
folderName = "thumb";
if (Directory.Exists($"{_localFolder.Path}\\{folderName}"))
{
_thumbFolder = await _localFolder.GetFolderAsync(folderName);
}
else
{
_thumbFolder = await _localFolder.CreateFolderAsync(folderName);
}
folderName = "original";
if (Directory.Exists($"{_localFolder.Path}\\{folderName}"))
{
_originalFolder = await _localFolder.GetFolderAsync(folderName);
}
else
{
_originalFolder = await _localFolder.CreateFolderAsync(folderName);
}
folderName = "tile";
if (Directory.Exists($"{_localFolder.Path}\\{folderName}"))
{
_tileFolder = await _localFolder.GetFolderAsync(folderName);
}
else
{
_tileFolder = await _localFolder.CreateFolderAsync(folderName);
}
}
catch //(System.IO.FileNotFoundException ex)
{
//todo: what would ever cause this ??! need to work out how to handle this type of error
}
}
/// <summary>
/// 要下载调用这个方法
/// </summary>
/// <param name="url">下载的文件网址的来源</param>
/// <returns></returns>
public static async Task Start(string filename,string url,DownloadType type,StorageFolder folder=null)
{
try
{
Uri uri = new Uri(Uri.EscapeUriString(url), UriKind.RelativeOrAbsolute);
BackgroundDownloader downloader = new BackgroundDownloader();
if (folder==null)
{
folder = await KnownFolders.MusicLibrary.CreateFolderAsync("kgdownload", CreationCollisionOption.OpenIfExists);
switch (type)
{
case DownloadType.song:
folder = await folder.CreateFolderAsync("song", CreationCollisionOption.OpenIfExists);
downloader.TransferGroup = BackgroundTransferGroup.CreateGroup("song");
break;
case DownloadType.mv:
folder = await folder.CreateFolderAsync("mv", CreationCollisionOption.OpenIfExists);
downloader.TransferGroup = BackgroundTransferGroup.CreateGroup("mv");
break;
case DownloadType.other:
folder = await folder.CreateFolderAsync("other", CreationCollisionOption.OpenIfExists);
downloader.TransferGroup = BackgroundTransferGroup.CreateGroup("other");
break;
default:
break;
}
}else
{
downloader.TransferGroup = BackgroundTransferGroup.CreateGroup("other");
}
//string name = uri.ToString().Substring(uri.ToString().LastIndexOf("/"), uri.ToString().Length);
string name = filename;
StorageFile file = await folder.CreateFileAsync(name, CreationCollisionOption.GenerateUniqueName);
downloader.FailureToastNotification = DownloadedToast.Done(filename, DownloadedToast.DownResult.Fa);
downloader.SuccessToastNotification = DownloadedToast.Done(filename, DownloadedToast.DownResult.Su);
var download = downloader.CreateDownload(new Uri(url), file);
TransferModel transfer = new TransferModel();
transfer.DownloadOperation = download;
transfer.Source = download.RequestedUri.ToString();
transfer.Destination = download.ResultFile.Path;
transfer.BytesReceived = download.Progress.BytesReceived;
transfer.TotalBytesToReceive = download.Progress.TotalBytesToReceive;
transfer.Progress = 0;
transfers.Add(transfer);
Progress<DownloadOperation> progressCallback = new Progress<DownloadOperation>(DownloadProgress);
download.StartAsync().AsTask(cancelToken.Token, progressCallback);
}
catch
{
await new MessageDialog("链接已失效！").ShowAsync();
}
}
public async static Task ExtractTarArchiveAsync( Stream archiveStream, StorageFolder destinationFolder )
{
using( TarReader reader = TarReader.Open( archiveStream ) )
{
while( reader.MoveToNextEntry() )
{
if( !reader.Entry.IsDirectory )
{
using( var entryStream = reader.OpenEntryStream() )
{
string fileName = Path.GetFileName( reader.Entry.Key );
string folderName = Path.GetDirectoryName( reader.Entry.Key );
StorageFolder folder = destinationFolder;
if( string.IsNullOrWhiteSpace( folderName ) == false )
{
folder = await destinationFolder.CreateFolderAsync( folderName, CreationCollisionOption.OpenIfExists );
}
StorageFile file = await folder.CreateFileAsync( fileName, CreationCollisionOption.OpenIfExists );
using( Stream fileStream = await file.OpenStreamForWriteAsync().ConfigureAwait( false ) )
{
await entryStream.CopyToAsync( fileStream );
}
}
}
}
}
}
protected StorageCacheBase(StorageFolder sf, string cacheDirectory, ICacheGenerator cacheFileNameGenerator, long cacheMaxLifetimeInMillis = DefaultCacheMaxLifetimeInMillis)
{
if (sf == null)
{
throw new ArgumentNullException("isf");
}
if (string.IsNullOrEmpty(cacheDirectory))
{
throw new ArgumentException("cacheDirectory name could not be null or empty");
}
if (cacheDirectory.StartsWith("\\"))
{
throw new ArgumentException("cacheDirectory name shouldn't starts with double slashes: \\");
}
if (cacheFileNameGenerator == null)
{
throw new ArgumentNullException("cacheFileNameGenerator");
}
SF = sf;
CacheDirectory = cacheDirectory;
CacheFileNameGenerator = cacheFileNameGenerator;
CacheMaxLifetimeInMillis = cacheMaxLifetimeInMillis;
// Creating cache directory if it not exists
SF.CreateFolderAsync(CacheDirectory).AsTask();
}
private async void InitProfiles()
{
var profileFolders = await _localFolder.CreateFolderAsync("Profiles", CreationCollisionOption.OpenIfExists);
var Files = await profileFolders.GetFilesAsync(CommonFileQuery.OrderByName); //Getting Text files
if (Files.Count == 0)
{
// there are noe profile files
// create one
_profile = new Profile();
string json = JsonConvert.SerializeObject(_profile, Formatting.Indented);
ProfileTextBox.Text = new StringBuilder(ProfileTextBox.Text)
.Append(json + "\n")
.ToString();
var textFile = await profileFolders.CreateFileAsync("default.json");
await FileIO.WriteTextAsync(textFile, json);
Files = await profileFolders.GetFilesAsync(CommonFileQuery.OrderByName);
}
ProfilesComboBox.Items?.Clear();
// there are profiles
string str = "";
foreach (StorageFile file in Files)
{
str = str + ", " + file.Name;
ProfilesComboBox.Items?.Add(file.Name);
}
ProfileTextBox.Text = new StringBuilder(ProfileTextBox.Text)
.Append("Profiles found:" + str + "\n")
.ToString();
//TODO may be save
if (ProfilesComboBox.Items?.Count > 0)
{
ProfilesComboBox.SelectedIndex = 0;
}
SwitchProfile(true);
}
async Task <StorageFile> GetStorageFile(string tag, byte[] byteArray, string fileName)
{
Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
var tmpFolder = await storageFolder.CreateFolderAsync($"tmp-{tag}", CreationCollisionOption.ReplaceExisting);
Windows.Storage.StorageFile sampleFile = await tmpFolder.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting);
await Windows.Storage.FileIO.WriteBytesAsync(sampleFile, byteArray);
return(sampleFile);
}
public async Task Init(string appname) {
var devices = Windows.Storage.KnownFolders.RemovableDevices;
var sdCards = await devices.GetFoldersAsync();
if (sdCards.Count == 0) return;
_SDCard = sdCards[0];
string foldername = string.Format("{0}_Log", appname);
_LogFolder = await _SDCard.CreateFolderAsync(foldername, CreationCollisionOption.OpenIfExists);
_FileName = string.Format("{0:yyyy-MM-dd}.txt", DateTime.Now);
_Stream = await _LogFolder.OpenStreamForWriteAsync(_FileName, CreationCollisionOption.OpenIfExists);
}
private async Task <StorageFolder> OpenDataFolder()
{
// 寻找该文件夹中的文件
Windows.Storage.StorageFolder storageFolder = ApplicationData.Current.LocalFolder;
if (Directory.Exists(storageFolder.Path + "\\Data"))
{
return(await storageFolder.GetFolderAsync("Data"));
}
await storageFolder.CreateFolderAsync("Data");
return(await storageFolder.GetFolderAsync("Data"));
}
internal async static Task MergeFolders(StorageFolder source, StorageFolder target)
{
foreach (StorageFile sourceFile in await source.GetFilesAsync())
{
await sourceFile.CopyAndReplaceAsync(await target.CreateFileAsync(sourceFile.Name, CreationCollisionOption.OpenIfExists));
}
foreach (StorageFolder sourceDirectory in await source.GetFoldersAsync())
{
StorageFolder nextTargetSubDir = await target.CreateFolderAsync(sourceDirectory.Name, CreationCollisionOption.OpenIfExists);
await MergeFolders(sourceDirectory, nextTargetSubDir);
}
}
/// <summary>
/// Unzips ZipArchiveEntry asynchronously.
/// </summary>
/// <param name="entry">The entry which needs to be unzipped</param>
/// <param name="filePath">The entry's full name</param>
/// <param name="unzipFolder">The unzip folder</param>
/// <returns></returns>
public static async Task UnzipZipArchiveEntryAsync(ZipArchiveEntry entry, string filePath, StorageFolder unzipFolder)
{
if (IfPathContainDirectory(filePath))
{
// Create sub folder
string subFolderName = Path.GetDirectoryName(filePath);
bool isSubFolderExist = await IfFolderExistsAsync(unzipFolder, subFolderName);
StorageFolder subFolder;
if (!isSubFolderExist)
{
// Create the sub folder.
subFolder =
await unzipFolder.CreateFolderAsync(subFolderName, CreationCollisionOption.ReplaceExisting);
}
else
{
// Just get the folder.
subFolder =
await unzipFolder.GetFolderAsync(subFolderName);
}
// All sub folders have been created. Just pass the file name to the Unzip function.
string newFilePath = Path.GetFileName(filePath);
if (!string.IsNullOrEmpty(newFilePath))
{
// Unzip file iteratively.
await UnzipZipArchiveEntryAsync(entry, newFilePath, subFolder);
}
}
else
{
// Read uncompressed contents
using (Stream entryStream = entry.Open())
{
byte[] buffer = new byte[entry.Length];
entryStream.Read(buffer, 0, buffer.Length);
// Create a file to store the contents
StorageFile uncompressedFile = await unzipFolder.CreateFileAsync
(entry.Name, CreationCollisionOption.ReplaceExisting);
// Store the contents
using (IRandomAccessStream uncompressedFileStream =
await uncompressedFile.OpenAsync(FileAccessMode.ReadWrite))
{
using (Stream outstream = uncompressedFileStream.AsStreamForWrite())
{
outstream.Write(buffer, 0, buffer.Length);
outstream.Flush();
}
}
}
}
}
private static async Task<StorageFolder> GetOrCreateSubFolder(StorageFolder pOutFolder, string pDirectoryName)
{
try
{
var folder = await pOutFolder.GetFolderAsync(pDirectoryName);
if (folder != null)
return folder;
}
catch (Exception)
{
}
return await pOutFolder.CreateFolderAsync(pDirectoryName, CreationCollisionOption.ReplaceExisting);
}
private static async Task InflateEntryAsync(ZipArchiveEntry entry, StorageFolder destFolder, bool createSub = false)
{
string filePath = entry.FullName;
if (!string.IsNullOrEmpty(filePath) && filePath.Contains("/") && !createSub)
{
// Create sub folder
string subFolderName = Path.GetDirectoryName(filePath);
StorageFolder subFolder;
// Create or return the sub folder.
subFolder = await destFolder.CreateFolderAsync(subFolderName, CreationCollisionOption.OpenIfExists);
string newFilePath = Path.GetFileName(filePath);
if (!string.IsNullOrEmpty(newFilePath))
{
// Unzip file iteratively.
await InflateEntryAsync(entry, subFolder, true);
}
}
else
{
// Read uncompressed contents
using (Stream entryStream = entry.Open())
{
byte[] buffer = new byte[entry.Length];
entryStream.Read(buffer, 0, buffer.Length);
// Create a file to store the contents
StorageFile uncompressedFile = await destFolder.CreateFileAsync(entry.Name, CreationCollisionOption.ReplaceExisting);
// Store the contents
using (IRandomAccessStream uncompressedFileStream =
await uncompressedFile.OpenAsync(FileAccessMode.ReadWrite))
{
using (Stream outstream = uncompressedFileStream.AsStreamForWrite())
{
outstream.Write(buffer, 0, buffer.Length);
outstream.Flush();
}
}
}
}
}
async public static void copyFolder(StorageFolder from, StorageFolder _to)
{
StorageFolder to = await _to.CreateFolderAsync(from.Name, CreationCollisionOption.OpenIfExists);
IReadOnlyList<StorageFile> storageFiles = await from.GetFilesAsync();
foreach (var storageFile in storageFiles)
{
await storageFile.CopyAsync(to, storageFile.Name, NameCollisionOption.ReplaceExisting);
}
//IReadOnlyList<StorageFolder> storageFolders = await from.GetFoldersAsync();
var queryResult = from.CreateFolderQuery();
IReadOnlyList<StorageFolder> storageFolders = await queryResult.GetFoldersAsync();
foreach (var storageFolder in storageFolders)
{
copyFolder(storageFolder, to);
}
}
public ImageFileCache(string name = null, StorageFolder folder = null)
{
if (string.IsNullOrEmpty(name))
{
name = TileImageLoader.DefaultCacheName;
}
if (folder == null)
{
folder = TileImageLoader.DefaultCacheFolder;
}
this.name = name;
folder.CreateFolderAsync(name, CreationCollisionOption.OpenIfExists).Completed = (o, s) =>
{
rootFolder = o.GetResults();
Debug.WriteLine("Created ImageFileCache in {0}.", rootFolder.Path);
};
}
private async void InitializeLibrary()
{
var myMusic = await Windows.Storage.StorageLibrary.GetLibraryAsync
(Windows.Storage.KnownLibraryId.Music);
Windows.Storage.StorageFolder saveMusicFolder = myMusic.SaveFolder;
try
{
MediaManager.Instance.SaveFolder = await StorageFolder.GetFolderFromPathAsync(saveMusicFolder.Path + @"\naive_media");
}
catch (Exception e)
{
MediaManager.Instance.SaveFolder = await saveMusicFolder.CreateFolderAsync("naive_media");
}
MediaManager.Instance.PlayHistories = _playHistories;
MediaManager.Instance.CachedItems = _cachedItems;
MediaManager.Instance.CloudResources = new ObservableCollection <CloudResource>();
MediaManager.Instance.MediaElement = MediaElement;
MediaManager.Instance.LoadCachedItems();
LoadCloudResources();
}
/// <summary>
/// Creates a directory into a specified <see cref="StorageFolder"/> by creating all missing <see cref="StorageFolder"/>
/// </summary>
/// <param name="storageFolder">the folder where the function has to check</param>
/// <param name="path">the directory path</param>
/// <returns>true in case of success. false otherwise</returns>
public async Task<bool> CreateDirectory(StorageFolder storageFolder, string path)
{
using (await InstanceLock.LockAsync())
{
var isCreated = true;
try
{
var folderNames = path.Split(new []{'/'}, StringSplitOptions.RemoveEmptyEntries).ToList();
// Cleans ".." in uri
while (folderNames.Any(f => f.Equals("..")) == true)
{
var index = folderNames.FindIndex(f => f.Equals(".."));
if (index == 0)
{
throw new ArgumentException("Invalid specified path, can't access of the parent of the source folder.");
}
folderNames.RemoveRange(index - 1, 2);
}
// Creates all missing folders
foreach(var folderName in folderNames)
{
storageFolder = await storageFolder.CreateFolderAsync(folderName, CreationCollisionOption.OpenIfExists);
}
}
catch
{
isCreated = false;
}
return isCreated;
}
}
// Extract files from a downloaded zip archive stream
private async Task ExtractZipArchive(Stream zipStream, StorageFolder folder)
{
using (var zip = new ZipArchive(zipStream, ZipArchiveMode.Read))
{
foreach (var entry in zip.Entries)
{
CurrentFileName = entry.FullName;
if (String.IsNullOrEmpty(entry.Name))
{
string dir = Path.GetDirectoryName(entry.FullName);
await folder.CreateFolderAsync(dir, CreationCollisionOption.ReplaceExisting);
}
else
{
await ExtractZipEntryAsync(entry, folder);
}
}
}
}
private static async Task<StorageFolder> getInkingFolder(StorageFolder dataFolder)
{
StorageFolder inkingFolder = await dataFolder.CreateFolderAsync(INKING_FOLDER, CreationCollisionOption.OpenIfExists);
return inkingFolder;
}
/// <summary>
/// Download a whole directory.
/// </summary>
private async void DownloadFTPDirectoryAsync(
BackgroundDownloader downloader,
NetworkCredential credential,
FTPFileSystem item,
StorageFolder targetFolder)
{
// List the sub folders and files.
var subItems = await this.ListFtpContentAsync(item.Url, credential);
// Download the sub folders and files.
foreach (var subitem in subItems)
{
if (subitem.IsDirectory)
{
// Create a local folder.
var subFolder = await targetFolder.CreateFolderAsync(subitem.Name,
CreationCollisionOption.ReplaceExisting);
// Download the whole folder.
DownloadFTPDirectoryAsync(downloader, credential, subitem, subFolder);
}
else
{
// Create a local file.
var file = await targetFolder.CreateFileAsync(subitem.Name,
CreationCollisionOption.GenerateUniqueName);
// Download the file.
DownloadFTPFileAsync(downloader, credential, subitem, file);
}
}
}
/// <summary>
/// Download files, directories and their subdirectories.
/// </summary>
public async void DownloadFTPItemsAsync(IEnumerable<FTPFileSystem> itemsToDownload,
StorageFolder targetFolder, NetworkCredential credential)
{
// Create a BackgroundDownloader
BackgroundDownloader downloader = new BackgroundDownloader();
// Download sub folders and files.
foreach (var item in itemsToDownload.ToList())
{
if (item.IsDirectory)
{
// Create a local folder.
var subFolder = await targetFolder.CreateFolderAsync(item.Name,
CreationCollisionOption.OpenIfExists);
// Download the whole folder.
DownloadFTPDirectoryAsync(downloader, credential, item, subFolder);
}
else
{
// Create a local file.
var file = await targetFolder.CreateFileAsync(item.Name,
CreationCollisionOption.ReplaceExisting);
// Download the file.
DownloadFTPFileAsync(downloader, credential, item, file);
}
}
}
private async void OpenComicCollection(StorageFolder chosenFolder, StorageFolder collections)
{
LoadingGridVisible(true);
List<StorageFile> files = await RecursivelySearchForFiles(chosenFolder);
StorageFolder collectionFolder = (StorageFolder)await collections.TryGetItemAsync(chosenFolder.Name);
if (collectionFolder == null)
{
collectionFolder = await collections.CreateFolderAsync(chosenFolder.Name);
}
else
{
ShowWarning("Collection already exist!", "Adding new comics");
}
foreach (StorageFile sourceFile in files)
{
StorageFolder destFolder = (StorageFolder)await collectionFolder.TryGetItemAsync(sourceFile.Name);
if (destFolder == null)
{
destFolder = await collectionFolder.CreateFolderAsync(sourceFile.Name);
try
{
DefaultViewModel["LoadingFile"] = sourceFile.Name;
if (sourceFile.FileType.Equals("cbz") || sourceFile.FileType.Equals(".cbz"))
await FolderZip.UnZipFile(sourceFile, destFolder);
else if (sourceFile.FileType.Equals("cbr") || sourceFile.FileType.Equals(".cbr"))
await FolderZip.UnRarFile(sourceFile, destFolder);
}
catch (InvalidFormatException exception)
{
ShowWarning("Error opening file:" + sourceFile.Name, "Please try again");
}
}
LoadingBar.Value += (1.0 / files.Count()) * 100;
}
await CreateCollectionTiles();
CollectionViews.Clear();
foreach (CollectionTile tile in CollectionTiles)
{
CollectionViews.Add(new CollectionView(tile));
}
defaultViewModel["ComicTiles"] = ComicTiles;
defaultViewModel["CollectionViews"] = CollectionViews;
LoadingGridVisible(false);
}
private async Task CopyFiles(StorageFolder pSource, StorageFolder pDestination)
{
foreach (var file in await pSource.GetFilesAsync())
file.CopyAsync(pDestination);
foreach (var folder in await pSource.GetFoldersAsync())
{
var newFolder = await pDestination.CreateFolderAsync(folder.Name);
await CopyFiles(folder, newFolder);
}
}
public async Task<bool> ExportBinderAsync(string dbName, StorageFolder fromDirectory, StorageFolder toRootDirectory)
{
try
{
if (string.IsNullOrWhiteSpace(dbName) /*|| _dbNames?.Contains(dbName) == false */ || fromDirectory == null || toRootDirectory == null) return false;
//var fromDirectory = await BindersDirectory
// .GetFolderAsync(dbName)
// .AsTask().ConfigureAwait(false);
//if (fromDirectory == null) return false;
//// what if you copy a directory to an existing one? Shouldn't you delete the contents first? No! But then, shouldn't you issue a warning?
//var toDirectoryTest = await toRootDirectory.TryGetItemAsync(dbName).AsTask().ConfigureAwait(false);
//if (toDirectoryTest != null)
//{
// var confirmation = await UserConfirmationPopup.GetInstance().GetUserConfirmationBeforeExportingBinderAsync().ConfigureAwait(false);
// if (confirmation == null || confirmation.Item1 == false || confirmation.Item2 == false) return false;
//}
var toDirectory = await toRootDirectory
.CreateFolderAsync(dbName, CreationCollisionOption.ReplaceExisting)
.AsTask().ConfigureAwait(false);
if (toDirectory == null) return false;
Windows.Storage.AccessCache.StorageApplicationPermissions.FutureAccessList.AddOrReplace("PickedFolderToken", toDirectory);
await fromDirectory.CopyDirContentsAsync(toDirectory, CancToken).ConfigureAwait(false);
return true;
}
catch (OperationCanceledException) { }
catch (Exception ex)
{
Logger.Add_TPL(ex.ToString(), Logger.FileErrorLogFilename);
}
return false;
}
private async Task storage(StorageFolder folder)
{
if (string.IsNullOrEmpty(name))
{
string str = "请输入标题.md";
file = await folder.CreateFileAsync(str, CreationCollisionOption.GenerateUniqueName);
//name = file.Name;
int n;
n = name.IndexOf(".md");
if (n > 0)
{
str = name.Substring(0, n);
}
this.folder = await folder.CreateFolderAsync(str, CreationCollisionOption.GenerateUniqueName);
}
else
{
if (name == "README.md")
{
this.folder = await folder.CreateFolderAsync("image", CreationCollisionOption.OpenIfExists);
}
else
{
this.folder = await folder.CreateFolderAsync(name, CreationCollisionOption.OpenIfExists);
}
}
}
public async Task InitializeFolder(string userID)
{
UsersFolder = await ApplicationData.Current.LocalFolder.CreateFolderAsync("Users", CreationCollisionOption.OpenIfExists);
PersonalFolder = await UsersFolder.CreateFolderAsync(userID, CreationCollisionOption.OpenIfExists);
}
async void doInit(StorageFolder root, string directory) {
folder = await root.CreateFolderAsync(directory, CreationCollisionOption.OpenIfExists);
}
private async void PackageInstallDeploy()
{
if (PackageFile == null)
return;
//Clipboard "\\\\minwinpc\\c$" setText ??
//Windows.ApplicationModel.DataTransfer.DataPackage dp = new Windows.ApplicationModel.DataTransfer.DataPackage();
//dp.SetText("\\\\minwinpc\\c$");
FolderPicker fp = new FolderPicker();
fp.SuggestedStartLocation = PickerLocationId.ComputerFolder;
fp.FileTypeFilter.Add("*");
fp.CommitButtonText = "Select " + RemoteFileSystem.Text + " only.";
RootRemoteCDrive = await fp.PickSingleFolderAsync();
StorageFolder fldrRemotePackage = null;
StorageFolder RemoteWindows = null;
StorageFolder System32 = null;
//Create or clean out remote folder
try
{
fldrRemotePackage = await RootRemoteCDrive.CreateFolderAsync(InstallDir, CreationCollisionOption.OpenIfExists);
if (fldrRemotePackage != null)
{
var files = await fldrRemotePackage.GetFilesAsync();
foreach (StorageFile fi in files)
await fi.DeleteAsync();
RemoteWindows = await RootRemoteCDrive.GetFolderAsync("Windows");
if (RemoteWindows != null)
{
System32 = await RemoteWindows.GetFolderAsync("System32");
}
}
if ((fldrRemotePackage == null) || (System32 == null))
//Need a popup here
return;
}
catch (Exception ex)
{
//A folder not found
string msg = ex.Message;
}
//Copy files to remote system
StorageFolder fldrLocal = ApplicationData.Current.LocalFolder;
try
{
var fldr = await fldrLocal.GetFolderAsync(PackageFile.Name);
if (fldr != null)
{
var files = await fldr.GetFilesAsync();
foreach (StorageFile fi in files)
{
if (fi.Name != "oemcustomization.cmd")
await fi.CopyAsync(fldrRemotePackage);
else
await fi.CopyAsync(System32, "oemcustomization.cmd", NameCollisionOption.ReplaceExisting);
}
}
}
catch (Exception ex)
{
//Will be folder not found
string msg = ex.Message;
}
}
private async void Button_Click(object sender, RoutedEventArgs e)
{
Tot.Text = "";
Vot.Text = "";
Button button = sender as Button;
button.IsEnabled = false;
StorageFolder vere = imagefolder;
StorageFolder hore = imagefolder;
if (imgfiles == null)
{
return;
}
//Tot.Text = imagefile.Path;
Tot.Text = imagefile.FileType;
//若存在则获取，不存在则新建
if (null == await imagefolder.TryGetItemAsync("Hor"))
{
hore = await imagefolder.CreateFolderAsync("Hor");
}
hore = await imagefolder.GetFolderAsync("Hor");
if (await imagefolder.TryGetItemAsync("Ver") == null)
{
vere = await imagefolder.CreateFolderAsync("Ver");
}
vere = await imagefolder.GetFolderAsync("Ver");
int a = 0;
int b = 0;
float t = 0;
float p = 0;
double c = 0;
Tot.Text = a.ToString();
Vot.Text = b.ToString();
//Windows.Storage.StorageFolder imgfld = await imagefile.GetParentAsync();
StorageApplicationPermissions.FutureAccessList.Add(imagefolder);
IReadOnlyList <StorageFile> filelist = await imagefolder.GetFilesAsync();
foreach (StorageFile file in filelist)
{
progrb.Visibility = Visibility.Visible;
p = filelist.Count;
if (file.FileType == ".jpg" || file.FileType == ".png" || file.FileType == ".bmp")
{
var varfil = await file.GetBasicPropertiesAsync();
if (varfil.Size == 0)
{
continue;
}
filename = file.Name;
filename = varfil.Size.ToString();
errtag.Text = filename;
ImageProperties imageProperties = await file.Properties.GetImagePropertiesAsync();
if (imageProperties.Width >= imageProperties.Height)
{
if (await hore.TryGetItemAsync(file.Name) != null)
{
continue;
}
inputstream = await file.OpenReadAsync();
await horbitmap.SetSourceAsync(inputstream);
HorImagePlace.Source = horbitmap;
await file.CopyAsync(hore);
a++;
}
else
{
if (await vere.TryGetItemAsync(file.Name) != null)
{
continue;
}
inputstream = await file.OpenReadAsync();
await verbitmap.SetSourceAsync(inputstream);
VerImagePlace.Visibility = Visibility.Visible;
VerImagePlace.Source = verbitmap;
await file.CopyAsync(vere);
b++;
}
Tot.Text = a.ToString();
Vot.Text = b.ToString();
}
Tot.Text += " Hor Pictures Copyed";
Vot.Text += " Ver Pictures Copyed";
button.IsEnabled = true;
btnOpn.IsEnabled = true;
t++;
c = t / p;
progrb.Value = c * 100;
}
StorageApplicationPermissions.FutureAccessList.Clear();
}
async Task<bool> _createFolder(List<string> path, StorageFolder currentFolder)
{
if (path.Count == 0)
{
return false;
}
var current = path.FirstOrDefault();
if (current == null)
{
return false;
}
path.RemoveAt(0);
try
{
if (!await _folderExists(current, currentFolder))
{
await currentFolder.CreateFolderAsync(current);
}
}
catch { }
if (path.Count == 0)
{
return await _folderExists(current, currentFolder);
}
return await _createFolder(path, await currentFolder.GetFolderAsync(current));
}
/// <summary>
/// Сохраняет развертку в локальную папку
/// </summary>
/// <param name="data"></param>
/// <param name="Tail"></param>
/// <param name="time"></param>
/// <param name="nameFile"></param>
/// <returns></returns>
public async Task saveAsync(int[,] data, int[,] Tail, string time, string nameFile, bool Taill)
{
string cul = "en-US";
var folderPicker = new Windows.Storage.Pickers.FolderPicker();
folderPicker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.Desktop;
folderPicker.FileTypeFilter.Add("*");
Windows.Storage.StorageFolder folder = await folderPicker.PickSingleFolderAsync();
if (folder != null)
{
// Application now has read/write access to all contents in the picked folder
// (including other sub-folder contents)
Windows.Storage.AccessCache.StorageApplicationPermissions.
FutureAccessList.AddOrReplace("PickedFolderToken", folder);
StorageFolder storageFolderRazvertka = await folder.CreateFolderAsync("Развертка", CreationCollisionOption.OpenIfExists);
StorageFile sampleFile = await storageFolderRazvertka.CreateFileAsync(nameFile + time + ".txt", CreationCollisionOption.ReplaceExisting);
var stream = await sampleFile.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite);
using (var outputStream = stream.GetOutputStreamAt(0))
{
using (var dataWriter = new Windows.Storage.Streams.DataWriter(outputStream))
{
string s = "i" + "\t" + "Ch1" + "\t" + "Ch2" + "\t" + "Ch3" + "\t" + "Ch4" + "\t" + "Ch5" + "\t" + "Ch6" + "\t" + "Ch7" + "\t" + "Ch8" + "\t" + "Ch9" + "\t" + "Ch10" + "\t" + "Ch11" + "\t" + "Ch12" + "\r\n";
for (int i = 0; i < 1024; i++)
{
s = s + (i + 1).ToString() + "\t";
for (int j = 0; j < 12; j++)
{
s = s + data[j, i] + "\t";
}
if (i < 1023)
{
s = s + "\r\n";
}
else
{
}
}
dataWriter.WriteString(s);
s = null;
await dataWriter.StoreAsync();
await outputStream.FlushAsync();
}
}
stream.Dispose(); // Or use the stream variable (see previous code snippet) with a using statement as well.
if (Taill)
{
// storageFolderRazvertka = await storageFolderRazvertka.CreateFolderAsync("Развертка", CreationCollisionOption.OpenIfExists);
sampleFile = await storageFolderRazvertka.CreateFileAsync(nameFile + time + "Хвост" + ".txt", CreationCollisionOption.ReplaceExisting);
stream = await sampleFile.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite);
using (var outputStream = stream.GetOutputStreamAt(0))
{
using (var dataWriter = new Windows.Storage.Streams.DataWriter(outputStream))
{
string s = "i" + "\t" + "Ch1" + "\t" + "Ch2" + "\t" + "Ch3" + "\t" + "Ch4" + "\t" + "Ch5" + "\t" + "Ch6" + "\t" + "Ch7" + "\t" + "Ch8" + "\t" + "Ch9" + "\t" + "Ch10" + "\t" + "Ch11" + "\t" + "Ch12" + "\r\n";
for (int i = 0; i < 20000; i++)
{
s = s + (i + 1).ToString() + "\t";
for (int j = 0; j < 12; j++)
{
s = s + Tail[j, i] + "\t";
}
if (i < 19999)
{
s = s + "\r\n";
}
else
{
}
dataWriter.WriteString(s);
s = null;
}
await dataWriter.StoreAsync();
await outputStream.FlushAsync();
}
}
stream.Dispose();
}
}
}
private async void Init()
{
await _local_folder.CreateFolderAsync("images_cache", CreationCollisionOption.OpenIfExists);
await _local_folder.CreateFolderAsync("data_cache", CreationCollisionOption.OpenIfExists);
}
/// <summary>
/// Create a folder in the current rootFolder.
/// </summary>
/// <param name="folderName">Name of the folder to be created. This does not have to be an immediate sub-folder of the current folder.</param>
/// <param name="rootFolder">The current folder.</param>
/// <returns>None.</returns>
public async Task<StorageFolder> CreateFolder(string folderName, StorageFolder rootFolder)
{
if (string.IsNullOrEmpty(folderName))
{
return rootFolder;
}
rootFolder = rootFolder ?? AntaresBaseFolder.Instance.RoamingFolder;
folderName = NormalizePath(folderName);
var startIndex = folderName.IndexOf('\\');
if (startIndex == -1)
{
return await rootFolder.CreateFolderAsync(folderName, CreationCollisionOption.OpenIfExists);
}
rootFolder = await rootFolder.CreateFolderAsync(folderName.Substring(0, startIndex), CreationCollisionOption.OpenIfExists);
folderName = folderName.Substring(startIndex + 1);
return await CreateFolder(folderName, rootFolder);
}
/// <summary>
/// Render ObjectDetector skill results
/// </summary>
/// <param name="frame"></param>
/// <param name="objectDetections"></param>
/// <returns></returns>
private async Task DisplayFrameAndResultAsync(VideoFrame frame, int CCTVIndex)
{
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async() =>
{
try
{
SoftwareBitmap savedBmp = null;
if (frame.SoftwareBitmap != null)
{
await m_processedBitmapSource[CCTVIndex].SetBitmapAsync(frame.SoftwareBitmap);
savedBmp = frame.SoftwareBitmap;
}
else
{
var bitmap = await SoftwareBitmap.CreateCopyFromSurfaceAsync(frame.Direct3DSurface, BitmapAlphaMode.Ignore);
await m_processedBitmapSource[CCTVIndex].SetBitmapAsync(bitmap);
savedBmp = bitmap;
}
// Retrieve and filter results if requested
IReadOnlyList <ObjectDetectorResult> objectDetections = m_binding.DetectedObjects;
if (m_objectKinds?.Count > 0)
{
objectDetections = objectDetections.Where(det => m_objectKinds.Contains(det.Kind)).ToList();
}
if (objectDetections != null)
{
// Update displayed results
m_bboxRenderer[CCTVIndex].Render(objectDetections);
bool PersonDetected = false;
int PersonCount = 0;
var rects = new List <Rect>();
foreach (var obj in objectDetections)
{
if (obj.Kind.ToString().ToLower() == "person")
{
PersonCount++;
PersonDetected = true;
rects.Add(obj.Rect);
}
}
if (PersonDetected)
{
bool KeepDistance = false;
if ((bool)ChkSocialDistancing.IsChecked)
{
//make sure there is more than 1 person
if (rects.Count > 1)
{
var res = SocialDistanceHelpers.Detect(rects.ToArray());
if (res.Result)
{
KeepDistance = true;
m_bboxRenderer[CCTVIndex].DistanceLineRender(res.Lines);
await speech.Read($"Please keep distance in {DataConfig.RoomName[CCTVIndex]}");
}
}
else
{
m_bboxRenderer[CCTVIndex].ClearLineDistance();
}
}
else
{
m_bboxRenderer[CCTVIndex].ClearLineDistance();
}
var msg = $"I saw {PersonCount} person in {DataConfig.RoomName[CCTVIndex]}";
if ((bool)ChkMode.IsChecked)
{
PlaySound(Sounds[Rnd.Next(0, Sounds.Count - 1)]);
}
else if (!KeepDistance)
{
await speech.Read(msg);
}
if ((bool)ChkPatrol.IsChecked)
{
await NotificationService.SendMail("Person Detected in BMSpace", msg, DataConfig.MailTo, DataConfig.MailFrom);
await NotificationService.SendSms(DataConfig.SmsTo, msg);
}
bool IsFaceDetected = false;
if ((bool)ChkDetectMask.IsChecked)
{
SoftwareBitmap softwareBitmapInput = frame.SoftwareBitmap;
// Retrieve a SoftwareBitmap to run face detection
if (softwareBitmapInput == null)
{
if (frame.Direct3DSurface == null)
{
throw (new ArgumentNullException("An invalid input frame has been bound"));
}
softwareBitmapInput = await SoftwareBitmap.CreateCopyFromSurfaceAsync(frame.Direct3DSurface);
}
// We need to convert the image into a format that's compatible with FaceDetector.
// Gray8 should be a good type but verify it against FaceDetector’s supported formats.
const BitmapPixelFormat InputPixelFormat = BitmapPixelFormat.Gray8;
if (FaceDetector.IsBitmapPixelFormatSupported(InputPixelFormat))
{
using (var detectorInput = SoftwareBitmap.Convert(softwareBitmapInput, InputPixelFormat))
{
// Run face detection and retrieve face detection result
var faceDetectionResult = await m_faceDetector.DetectFacesAsync(detectorInput);
// If a face is found, update face rectangle feature
if (faceDetectionResult.Count > 0)
{
IsFaceDetected = true;
// Retrieve the face bound and enlarge it by a factor of 1.5x while also ensuring clamping to frame dimensions
BitmapBounds faceBound = faceDetectionResult[0].FaceBox;
var additionalOffset = faceBound.Width / 2;
faceBound.X = Math.Max(0, faceBound.X - additionalOffset);
faceBound.Y = Math.Max(0, faceBound.Y - additionalOffset);
faceBound.Width = (uint)Math.Min(faceBound.Width + 2 * additionalOffset, softwareBitmapInput.PixelWidth - faceBound.X);
faceBound.Height = (uint)Math.Min(faceBound.Height + 2 * additionalOffset, softwareBitmapInput.PixelHeight - faceBound.Y);
var maskdetect = await MaskDetect.PredictImageAsync(frame);
var noMaskCount = maskdetect.Where(x => x.TagName == "no-mask").Count();
if (noMaskCount > 0)
{
if (!KeepDistance)
{
await speech.Read($"please wear a face mask in {DataConfig.RoomName[CCTVIndex]}");
}
}
}
}
}
}
if (!IsFaceDetected)
{
m_bboxRenderer[CCTVIndex].ClearMaskLabel();
}
//save to picture libs
/*
* String path = Environment.GetFolderPath(Environment.SpecialFolder.MyPictures);
* path += "\\CCTV";
* if (!Directory.Exists(path))
* {
* Directory.CreateDirectory(path);
* }*/
var TS = DateTime.Now - LastSaved[CCTVIndex];
if (savedBmp != null && TS.TotalSeconds > DataConfig.CaptureIntervalSecs && (bool)ChkCapture.IsChecked)
{
var myPictures = await Windows.Storage.StorageLibrary.GetLibraryAsync(Windows.Storage.KnownLibraryId.Pictures);
Windows.Storage.StorageFolder rootFolder = myPictures.SaveFolder;
Windows.Storage.StorageFolder storageFolder = rootFolder;
var folderName = "cctv";
try
{
storageFolder = await rootFolder.GetFolderAsync(folderName);
}
catch
{
storageFolder = await rootFolder.CreateFolderAsync(folderName);
}
//if (Directory.Exists($"{rootFolder.Path}\\{folderName}"))
//else
// Create sample file; replace if exists.
//Windows.Storage.StorageFolder storageFolder = await Windows.Storage.StorageFolder.GetFolderFromPathAsync(path);
Windows.Storage.StorageFile sampleFile =
await storageFolder.CreateFileAsync($"cctv_{DateTime.Now.ToString("dd_MM_yyyy_HH_mm_ss")}_{CCTVIndex}.jpg",
Windows.Storage.CreationCollisionOption.ReplaceExisting);
ImageHelpers.SaveSoftwareBitmapToFile(savedBmp, sampleFile);
LastSaved[CCTVIndex] = DateTime.Now;
}
}
}
// Update the displayed performance text
StatusLbl.Text = $"bind: {m_bindTime.ToString("F2")}ms, eval: {m_evalTime.ToString("F2")}ms";
}
catch (TaskCanceledException)
{
// no-op: we expect this exception when we change media sources
// and can safely ignore/continue
}
catch (Exception ex)
{
NotifyUser($"Exception while rendering results: {ex.Message}");
}
});
}
private async Task<StorageFolder> CreateFolderToLocalStorageAsync(string path, StorageFolder folder)
{
string name;
string[] list = ParseHelper.ParsePathAndName(path, ParseHelper.Mode.DIRECTORY, out name);
foreach (string s in list)
{
folder = await folder.CreateFolderAsync(s, CreationCollisionOption.OpenIfExists);
}
return folder;
}
public static async Task setSdFolder()
{
if(debug)
{
}
sdFolder = (await Windows.Storage.KnownFolders.RemovableDevices.GetFoldersAsync() as IReadOnlyList<StorageFolder>).FirstOrDefault();
if (sdFolder == null) return;
fil = await (await sdFolder.CreateFolderAsync("Followshows", CreationCollisionOption.OpenIfExists)).CreateFileAsync("FollowshowsCrash.txt", CreationCollisionOption.OpenIfExists);
}
/// <summary>
/// Private Methods & Testing Methods.
/// </summary>
private async Task<StorageFile> CreateFileToLocalStorageAsync(string path, StorageFolder folder)
{
string name;
string[] list = ParseHelper.ParsePathAndName(path, ParseHelper.Mode.FULL_PATH, out name); // changed DIRECTORY to FULL_PATH
foreach (string s in list)
{
folder = await folder.CreateFolderAsync(s, CreationCollisionOption.OpenIfExists);
}
return await folder.CreateFileAsync(name, CreationCollisionOption.OpenIfExists);
}
/// <summary>
/// Creates a <see cref="StorageFolder"/> into a specified <see cref="StorageFolder"/>
/// </summary>
/// <param name="storageFolder">the folder where the function has to check</param>
/// <param name="folderName">the folder name</param>
/// <param name="creationOption">the <see cref="CreationCollisionOption"/></param>
/// <returns>true in case of success. false otherwise</returns>
public async Task<bool> CreateFolder(StorageFolder storageFolder, string folderName, CreationCollisionOption creationOption)
{
using (await InstanceLock.LockAsync())
{
var isCreated = true;
try
{
folderName = folderName.Replace("/", "\\");
var folder = await storageFolder.CreateFolderAsync(Path.GetDirectoryName(folderName), creationOption);
}
catch
{
isCreated = false;
}
return isCreated;
}
}
private static async Task<StorageFolder> _EnsureFolderExistsAsync(string name, StorageFolder parent)
{
if (parent == null) throw new ArgumentNullException(nameof(parent));
return
await
parent.CreateFolderAsync(name, CreationCollisionOption.OpenIfExists).AsTask().ConfigureAwait(false);
}
public async void InitFolders()
{
_localFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
var folderName = "";
try
{
folderName = "medium";
if (Directory.Exists($"{_localFolder.Path}\\{folderName}")) _mediumFolder = await _localFolder.GetFolderAsync(folderName);
else _mediumFolder = await _localFolder.CreateFolderAsync(folderName);
folderName = "thumb";
if (Directory.Exists($"{_localFolder.Path}\\{folderName}")) _thumbFolder = await _localFolder.GetFolderAsync(folderName);
else _thumbFolder = await _localFolder.CreateFolderAsync(folderName);
folderName = "original";
if (Directory.Exists($"{_localFolder.Path}\\{folderName}")) _originalFolder = await _localFolder.GetFolderAsync(folderName);
else _originalFolder = await _localFolder.CreateFolderAsync(folderName);
folderName = "tile";
if (Directory.Exists($"{_localFolder.Path}\\{folderName}")) _tileFolder = await _localFolder.GetFolderAsync(folderName);
else _tileFolder = await _localFolder.CreateFolderAsync(folderName);
}
catch //(System.IO.FileNotFoundException ex)
{
//todo: what would ever cause this ??! need to work out how to handle this type of error
}
}
