private async void DeviceGrid_ItemClick(object sender, ItemClickEventArgs e)
{
LibraryGrid.SelectedIndex = -1;
if (!SettingControl.IsDoubleClickEnable && e.ClickedItem is HardDeviceInfo Device)
{
if (Device.IsLockedByBitlocker)
{
Retry:
BitlockerPasswordDialog Dialog = new BitlockerPasswordDialog();
if (await Dialog.ShowAsync().ConfigureAwait(true) == ContentDialogResult.Primary)
{
using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController())
{
await Exclusive.Controller.RunAsync("powershell.exe", true, true, true, "-Command", $"$BitlockerSecureString = ConvertTo-SecureString '{Dialog.Password}' -AsPlainText -Force;", $"Unlock-BitLocker -MountPoint '{Device.Folder.Path}' -Password $BitlockerSecureString").ConfigureAwait(true);
}
StorageFolder DeviceFolder = await StorageFolder.GetFolderFromPathAsync(Device.Folder.Path);
BasicProperties Properties = await DeviceFolder.GetBasicPropertiesAsync();
IDictionary <string, object> PropertiesRetrieve = await Properties.RetrievePropertiesAsync(new string[] { "System.Capacity", "System.FreeSpace", "System.Volume.FileSystem", "System.Volume.BitLockerProtection" });
HardDeviceInfo NewDevice = new HardDeviceInfo(DeviceFolder, await DeviceFolder.GetThumbnailBitmapAsync().ConfigureAwait(true), PropertiesRetrieve, Device.DriveType);
if (!NewDevice.IsLockedByBitlocker)
{
int Index = CommonAccessCollection.HardDeviceList.IndexOf(Device);
CommonAccessCollection.HardDeviceList.Remove(Device);
CommonAccessCollection.HardDeviceList.Insert(Index, NewDevice);
}
else
{
QueueContentDialog UnlockFailedDialog = new QueueContentDialog
{
Title = Globalization.GetString("Common_Dialog_ErrorTitle"),
Content = Globalization.GetString("QueueDialog_UnlockBitlockerFailed_Content"),
PrimaryButtonText = Globalization.GetString("Common_Dialog_RetryButton"),
CloseButtonText = Globalization.GetString("Common_Dialog_CancelButton")
};
if (await UnlockFailedDialog.ShowAsync().ConfigureAwait(true) == ContentDialogResult.Primary)
{
goto Retry;
}
}
}
}
else
{
await OpenTargetFolder(Device.Folder).ConfigureAwait(false);
}
}
}
public static async Task <DriveDataBase> CreateAsync(StorageFolder Drive, DriveType DriveType)
{
BasicProperties Properties = await Drive.GetBasicPropertiesAsync();
BitmapImage Thumbnail = await Drive.GetThumbnailBitmapAsync(ThumbnailMode.SingleItem);
IDictionary <string, object> PropertiesRetrieve = await Properties.RetrievePropertiesAsync(new string[] { "System.Capacity", "System.FreeSpace", "System.Volume.FileSystem", "System.Volume.BitLockerProtection" });
if (Drive.Path.StartsWith(@"\\wsl", StringComparison.OrdinalIgnoreCase))
{
return(new WslDriveData(Drive, Thumbnail, PropertiesRetrieve));
}
else
{
/*
* | System.Volume. | Control Panel | manage-bde conversion | manage-bde | Get-BitlockerVolume | Get-BitlockerVolume |
* | BitLockerProtection | | | protection | VolumeStatus | ProtectionStatus |
* | ------------------- | -------------------------------- | ------------------------- | -------------- | ---------------------------- | ------------------- |
* | 1 | BitLocker on | Used Space Only Encrypted | Protection On | FullyEncrypted | On |
* | 1 | BitLocker on | Fully Encrypted | Protection On | FullyEncrypted | On |
* | 1 | BitLocker on | Fully Encrypted | Protection On | FullyEncryptedWipeInProgress | On |
* | 2 | BitLocker off | Fully Decrypted | Protection Off | FullyDecrypted | Off |
* | 3 | BitLocker Encrypting | Encryption In Progress | Protection Off | EncryptionInProgress | Off |
* | 3 | BitLocker Encryption Paused | Encryption Paused | Protection Off | EncryptionSuspended | Off |
* | 4 | BitLocker Decrypting | Decryption in progress | Protection Off | DecyptionInProgress | Off |
* | 4 | BitLocker Decryption Paused | Decryption Paused | Protection Off | DecryptionSuspended | Off |
* | 5 | BitLocker suspended | Used Space Only Encrypted | Protection Off | FullyEncrypted | Off |
* | 5 | BitLocker suspended | Fully Encrypted | Protection Off | FullyEncrypted | Off |
* | 6 | BitLocker on (Locked) | Unknown | Unknown | $null | Unknown |
* | 7 | | | | | |
* | 8 | BitLocker waiting for activation | Used Space Only Encrypted | Protection Off | FullyEncrypted | Off |
*
* We could use Powershell command: Get-BitLockerVolume -MountPoint C: | Select -ExpandProperty LockStatus -------------->Locked / Unlocked
* But powershell might speed too much time to load. So we would not use it
*/
if (PropertiesRetrieve.TryGetValue("System.Volume.BitLockerProtection", out object BitlockerStateRaw) && BitlockerStateRaw is int BitlockerState)
{
if (BitlockerState == 6 && !PropertiesRetrieve.ContainsKey("System.Capacity") && !PropertiesRetrieve.ContainsKey("System.FreeSpace"))
{
return(new LockedDriveData(Drive, Thumbnail, PropertiesRetrieve, DriveType));
}
else
{
return(new NormalDriveData(Drive, Thumbnail, PropertiesRetrieve, DriveType));
}
}
else
{
return(new NormalDriveData(Drive, Thumbnail, PropertiesRetrieve, DriveType));
}
}
}
private static async Task <DateTimeOffset> GetLastAccessTimeAsync(IStorageItem item)
{
BasicProperties properties = await item.GetBasicPropertiesAsync().TranslateWinRTTask(item.Path);
var propertyMap = await properties.RetrievePropertiesAsync(s_dateAccessedKey).TranslateWinRTTask(item.Path);
// shell doesn't expose this metadata on all item types
if (propertyMap.ContainsKey(s_dateAccessedKey[0]))
{
return((DateTimeOffset)propertyMap[s_dateAccessedKey[0]]);
}
// fallback to modified date
return(properties.DateModified);
}
private async void AddDevice_Click(object sender, RoutedEventArgs e)
{
FolderPicker Picker = new FolderPicker
{
SuggestedStartLocation = PickerLocationId.ComputerFolder,
ViewMode = PickerViewMode.Thumbnail
};
Picker.FileTypeFilter.Add("*");
StorageFolder Device = await Picker.PickSingleFolderAsync();
if (Device != null)
{
if (Device.Path == Path.GetPathRoot(Device.Path) && DriveInfo.GetDrives().Where((Drive) => Drive.DriveType == DriveType.Fixed || Drive.DriveType == DriveType.Removable).Any((Item) => Item.RootDirectory.FullName == Device.Path))
{
if (CommonAccessCollection.HardDeviceList.All((Item) => Item.Folder.Path != Device.Path))
{
BasicProperties Properties = await Device.GetBasicPropertiesAsync();
IDictionary <string, object> PropertiesRetrieve = await Properties.RetrievePropertiesAsync(new string[] { "System.Capacity", "System.FreeSpace", "System.Volume.FileSystem" });
CommonAccessCollection.HardDeviceList.Add(new HardDeviceInfo(Device, await Device.GetThumbnailBitmapAsync().ConfigureAwait(true), PropertiesRetrieve, new DriveInfo(Device.Path).DriveType));
}
else
{
QueueContentDialog Dialog = new QueueContentDialog
{
Title = Globalization.GetString("Common_Dialog_TipTitle"),
Content = Globalization.GetString("QueueDialog_DeviceExist_Content"),
CloseButtonText = Globalization.GetString("Common_Dialog_CloseButton")
};
_ = await Dialog.ShowAsync().ConfigureAwait(true);
}
}
else
{
QueueContentDialog Dialog = new QueueContentDialog
{
Title = Globalization.GetString("Common_Dialog_TipTitle"),
Content = Globalization.GetString("QueueDialog_DeviceSelectError_Content"),
CloseButtonText = Globalization.GetString("Common_Dialog_TipTitle")
};
_ = await Dialog.ShowAsync().ConfigureAwait(true);
}
}
}
private async void UnlockBitlocker_Click(object sender, RoutedEventArgs e)
{
if (DeviceGrid.SelectedItem is DriveRelatedData Device)
{
Retry:
BitlockerPasswordDialog Dialog = new BitlockerPasswordDialog();
if (await Dialog.ShowAsync() == ContentDialogResult.Primary)
{
using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController())
{
await Exclusive.Controller.RunAsync("powershell.exe", string.Empty, WindowState.Normal, true, true, true, "-Command", $"$BitlockerSecureString = ConvertTo-SecureString '{Dialog.Password}' -AsPlainText -Force;", $"Unlock-BitLocker -MountPoint '{Device.Folder.Path}' -Password $BitlockerSecureString");
}
StorageFolder DeviceFolder = await StorageFolder.GetFolderFromPathAsync(Device.Folder.Path);
BasicProperties Properties = await DeviceFolder.GetBasicPropertiesAsync();
IDictionary <string, object> PropertiesRetrieve = await Properties.RetrievePropertiesAsync(new string[] { "System.Capacity", "System.FreeSpace", "System.Volume.FileSystem", "System.Volume.BitLockerProtection" });
DriveRelatedData NewDevice = await DriveRelatedData.CreateAsync(DeviceFolder, Device.DriveType);
if (!NewDevice.IsLockedByBitlocker)
{
int Index = CommonAccessCollection.DriveList.IndexOf(Device);
CommonAccessCollection.DriveList.Remove(Device);
CommonAccessCollection.DriveList.Insert(Index, NewDevice);
}
else
{
QueueContentDialog UnlockFailedDialog = new QueueContentDialog
{
Title = Globalization.GetString("Common_Dialog_ErrorTitle"),
Content = Globalization.GetString("QueueDialog_UnlockBitlockerFailed_Content"),
PrimaryButtonText = Globalization.GetString("Common_Dialog_RetryButton"),
CloseButtonText = Globalization.GetString("Common_Dialog_CancelButton")
};
if (await UnlockFailedDialog.ShowAsync() == ContentDialogResult.Primary)
{
goto Retry;
}
}
}
}
}
public static async Task <DriveRelatedData> CreateAsync(StorageFolder Drive, DriveType DriveType)
{
BasicProperties Properties = await Drive.GetBasicPropertiesAsync();
return(new DriveRelatedData(Drive, await Drive.GetThumbnailBitmapAsync(ThumbnailMode.SingleItem), await Properties.RetrievePropertiesAsync(new string[] { "System.Capacity", "System.FreeSpace", "System.Volume.FileSystem", "System.Volume.BitLockerProtection" }), DriveType));
}
public async void Refresh_Click(object sender, RoutedEventArgs e)
{
if (Interlocked.Exchange(ref LockResource, 1) == 0)
{
try
{
CommonAccessCollection.HardDeviceList.Clear();
bool AccessError = false;
foreach (DriveInfo Drive in DriveInfo.GetDrives().Where((Drives) => Drives.DriveType == DriveType.Fixed || Drives.DriveType == DriveType.Removable)
.Where((NewItem) => CommonAccessCollection.HardDeviceList.All((Item) => Item.Folder.Path != NewItem.RootDirectory.FullName)))
{
try
{
StorageFolder Device = await StorageFolder.GetFolderFromPathAsync(Drive.RootDirectory.FullName);
BasicProperties Properties = await Device.GetBasicPropertiesAsync();
IDictionary <string, object> PropertiesRetrieve = await Properties.RetrievePropertiesAsync(new string[] { "System.Capacity", "System.FreeSpace", "System.Volume.FileSystem" });
CommonAccessCollection.HardDeviceList.Add(new HardDeviceInfo(Device, await Device.GetThumbnailBitmapAsync().ConfigureAwait(true), PropertiesRetrieve, Drive.DriveType));
}
catch
{
AccessError = true;
}
}
foreach (DeviceInformation Device in await DeviceInformation.FindAllAsync(StorageDevice.GetDeviceSelector()))
{
try
{
StorageFolder DeviceFolder = StorageDevice.FromId(Device.Id);
if (CommonAccessCollection.HardDeviceList.All((Item) => (string.IsNullOrEmpty(Item.Folder.Path) || string.IsNullOrEmpty(DeviceFolder.Path)) ? Item.Folder.Name != DeviceFolder.Name : Item.Folder.Path != DeviceFolder.Path))
{
BasicProperties Properties = await DeviceFolder.GetBasicPropertiesAsync();
IDictionary <string, object> PropertiesRetrieve = await Properties.RetrievePropertiesAsync(new string[] { "System.Capacity", "System.FreeSpace", "System.Volume.FileSystem" });
if (PropertiesRetrieve["System.Capacity"] is ulong && PropertiesRetrieve["System.FreeSpace"] is ulong)
{
CommonAccessCollection.HardDeviceList.Add(new HardDeviceInfo(DeviceFolder, await DeviceFolder.GetThumbnailBitmapAsync().ConfigureAwait(true), PropertiesRetrieve, DriveType.Removable));
}
else
{
IReadOnlyList <IStorageItem> InnerItemList = await DeviceFolder.GetItemsAsync(0, 2);
if (InnerItemList.Count == 1 && InnerItemList[0] is StorageFolder InnerFolder)
{
BasicProperties InnerProperties = await InnerFolder.GetBasicPropertiesAsync();
IDictionary <string, object> InnerPropertiesRetrieve = await InnerProperties.RetrievePropertiesAsync(new string[] { "System.Capacity", "System.FreeSpace", "System.Volume.FileSystem" });
if (InnerPropertiesRetrieve["System.Capacity"] is ulong && InnerPropertiesRetrieve["System.FreeSpace"] is ulong)
{
CommonAccessCollection.HardDeviceList.Add(new HardDeviceInfo(DeviceFolder, await DeviceFolder.GetThumbnailBitmapAsync().ConfigureAwait(true), InnerPropertiesRetrieve, DriveType.Removable));
}
else
{
CommonAccessCollection.HardDeviceList.Add(new HardDeviceInfo(DeviceFolder, await DeviceFolder.GetThumbnailBitmapAsync().ConfigureAwait(true), PropertiesRetrieve, DriveType.Removable));
}
}
else
{
CommonAccessCollection.HardDeviceList.Add(new HardDeviceInfo(DeviceFolder, await DeviceFolder.GetThumbnailBitmapAsync().ConfigureAwait(true), PropertiesRetrieve, DriveType.Removable));
}
}
}
}
catch
{
AccessError = true;
}
}
if (AccessError && !ApplicationData.Current.LocalSettings.Values.ContainsKey("DisableAccessErrorTip"))
{
QueueContentDialog dialog = new QueueContentDialog
{
Title = Globalization.GetString("Common_Dialog_WarningTitle"),
Content = Globalization.GetString("QueueDialog_DeviceHideForError_Content"),
PrimaryButtonText = Globalization.GetString("Common_Dialog_DoNotTip"),
CloseButtonText = Globalization.GetString("Common_Dialog_CloseButton")
};
if (await dialog.ShowAsync().ConfigureAwait(true) == ContentDialogResult.Primary)
{
ApplicationData.Current.LocalSettings.Values["DisableAccessErrorTip"] = true;
}
}
}
finally
{
_ = Interlocked.Exchange(ref LockResource, 0);
}
}
}
public async void Refresh_Click(object sender, RoutedEventArgs e)
{
if (Interlocked.Exchange(ref LockResource, 1) == 0)
{
try
{
CommonAccessCollection.HardDeviceList.Clear();
foreach (DriveInfo Drive in DriveInfo.GetDrives().Where((Drives) => Drives.DriveType == DriveType.Fixed || Drives.DriveType == DriveType.Removable)
.Where((NewItem) => CommonAccessCollection.HardDeviceList.All((Item) => Item.Folder.Path != NewItem.RootDirectory.FullName)))
{
try
{
StorageFolder Device = await StorageFolder.GetFolderFromPathAsync(Drive.RootDirectory.FullName);
BasicProperties Properties = await Device.GetBasicPropertiesAsync();
IDictionary <string, object> PropertiesRetrieve = await Properties.RetrievePropertiesAsync(new string[] { "System.Capacity", "System.FreeSpace", "System.Volume.FileSystem", "System.Volume.BitLockerProtection" });
CommonAccessCollection.HardDeviceList.Add(new HardDeviceInfo(Device, await Device.GetThumbnailBitmapAsync().ConfigureAwait(true), PropertiesRetrieve, Drive.DriveType));
}
catch (Exception ex)
{
LogTracer.Log(ex, $"Hide the device \"{Drive.RootDirectory.FullName}\" for error");
}
}
foreach (DeviceInformation Device in await DeviceInformation.FindAllAsync(StorageDevice.GetDeviceSelector()))
{
try
{
StorageFolder DeviceFolder = StorageDevice.FromId(Device.Id);
if (CommonAccessCollection.HardDeviceList.All((Item) => (string.IsNullOrEmpty(Item.Folder.Path) || string.IsNullOrEmpty(DeviceFolder.Path)) ? Item.Folder.Name != DeviceFolder.Name : Item.Folder.Path != DeviceFolder.Path))
{
BasicProperties Properties = await DeviceFolder.GetBasicPropertiesAsync();
IDictionary <string, object> PropertiesRetrieve = await Properties.RetrievePropertiesAsync(new string[] { "System.Capacity", "System.FreeSpace", "System.Volume.FileSystem", "System.Volume.BitLockerProtection" });
if (PropertiesRetrieve["System.Capacity"] is ulong && PropertiesRetrieve["System.FreeSpace"] is ulong)
{
CommonAccessCollection.HardDeviceList.Add(new HardDeviceInfo(DeviceFolder, await DeviceFolder.GetThumbnailBitmapAsync().ConfigureAwait(true), PropertiesRetrieve, DriveType.Removable));
}
else
{
IReadOnlyList <IStorageItem> InnerItemList = await DeviceFolder.GetItemsAsync(0, 2);
if (InnerItemList.Count == 1 && InnerItemList[0] is StorageFolder InnerFolder)
{
BasicProperties InnerProperties = await InnerFolder.GetBasicPropertiesAsync();
IDictionary <string, object> InnerPropertiesRetrieve = await InnerProperties.RetrievePropertiesAsync(new string[] { "System.Capacity", "System.FreeSpace", "System.Volume.FileSystem", "System.Volume.BitLockerProtection" });
if (InnerPropertiesRetrieve["System.Capacity"] is ulong && InnerPropertiesRetrieve["System.FreeSpace"] is ulong)
{
CommonAccessCollection.HardDeviceList.Add(new HardDeviceInfo(DeviceFolder, await DeviceFolder.GetThumbnailBitmapAsync().ConfigureAwait(true), InnerPropertiesRetrieve, DriveType.Removable));
}
else
{
CommonAccessCollection.HardDeviceList.Add(new HardDeviceInfo(DeviceFolder, await DeviceFolder.GetThumbnailBitmapAsync().ConfigureAwait(true), PropertiesRetrieve, DriveType.Removable));
}
}
else
{
CommonAccessCollection.HardDeviceList.Add(new HardDeviceInfo(DeviceFolder, await DeviceFolder.GetThumbnailBitmapAsync().ConfigureAwait(true), PropertiesRetrieve, DriveType.Removable));
}
}
}
}
catch (Exception ex)
{
LogTracer.Log(ex, $"Hide the device \"{Device.Name}\" for error");
}
}
}
finally
{
_ = Interlocked.Exchange(ref LockResource, 0);
}
}
}
