public void BindMediaDeviceCollection(MediaDevice[] devices)
{
BindingSource binding = new BindingSource()
{
DataSource = devices
};
this.DeviceBox.DataSource = binding.DataSource;
this.DeviceBox.DisplayMember = "DisplayName";
}
public static Item FindItem(MediaDevice device, string path)
{
var item = Item.GetRoot(device);
if (path == @"\")
{
return(item);
}
var folders = path.Split(new char[] { Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar }, StringSplitOptions.RemoveEmptyEntries);
foreach (var folder in folders)
{
item = item.GetChildren().FirstOrDefault(i => device.EqualsName(i.Name, folder));
if (item == null)
{
return(null);
}
}
return(item);
}
public void RenameFileTest()
{
var devices = MediaDevice.GetDevices();
var device = devices.FirstOrDefault(this.deviceSelect);
Assert.IsNotNull(device, "Device");
device.Connect();
string filePath = Path.Combine(this.workingFolder, "RenameTest.txt");
string newName = "NewName.txt";
string newPath = Path.Combine(this.workingFolder, newName);
if (device.FileExists(filePath))
{
device.DeleteFile(filePath);
}
if (device.FileExists(newPath))
{
device.DeleteFile(newPath);
}
using (MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes("This is a test.")))
{
device.UploadFile(stream, filePath);
}
var exists1 = device.FileExists(filePath);
device.Rename(filePath, newName);
var exists2 = device.FileExists(newPath);
device.DeleteFile(newPath);
var exists3 = device.FileExists(newPath);
device.Disconnect();
Assert.IsTrue(exists1, "exists1");
Assert.IsTrue(exists2, "exists2");
Assert.IsFalse(exists3, "exists3");
}
async Task StartRecordingAsync()
{
try
{
recordingFile = await ApplicationData.Current.LocalFolder.CreateFileAsync(Constants.AudioFilename, CreationCollisionOption.ReplaceExisting);
Debug.WriteLine(recordingFile.Path);
var result = await AudioGraph.CreateAsync(new AudioGraphSettings(AudioRenderCategory.Media));
if (result.Status == AudioGraphCreationStatus.Success)
{
audioGraph = result.Graph;
var microphone = await DeviceInformation.CreateFromIdAsync(MediaDevice.GetDefaultAudioCaptureId(AudioDeviceRole.Default));
var outputProfile = MediaEncodingProfile.CreateWav(AudioEncodingQuality.Low); // 1 channel, 16 bits per sample, 16K sample rate
outputProfile.Audio = AudioEncodingProperties.CreatePcm(16000, 1, 16);
var inputProfile = MediaEncodingProfile.CreateWav(AudioEncodingQuality.High);
var outputResult = await audioGraph.CreateFileOutputNodeAsync(recordingFile, outputProfile);
if (outputResult.Status == AudioFileNodeCreationStatus.Success)
{
audioFileOutputNode = outputResult.FileOutputNode;
var inputResult = await audioGraph.CreateDeviceInputNodeAsync(MediaCategory.Media, inputProfile.Audio, microphone);
if (inputResult.Status == AudioDeviceNodeCreationStatus.Success)
{
inputResult.DeviceInputNode.AddOutgoingConnection(audioFileOutputNode);
audioGraph.Start();
}
}
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
private async Task GetDefaultAudioEndpoint()
{
// get the default device if it is there!
this.device = MediaDevice.GetDefaultAudioRenderId(AudioDeviceRole.Default);
if (this.device != null)
{
this.EventWriterDLL.BuildLine("+1a start => WasapiOutRT::GetDefaultAudioEndpoint => GetDefaultAudioRenderId found: " + this.device);
return;
}
// if there is no default or it is disconnected, get the XMOS device specifically!!!
string audioRenderSelector = MediaDevice.GetAudioRenderSelector();
var playbackDevices = await DeviceInformation.FindAllAsync(audioRenderSelector);
foreach (DeviceInformation di in playbackDevices)
{
this.EventWriterDLL.BuildLine("+1a start => WasapiOutRT::GetDefaultAudioEndpoint => Playback device found: " + di.Name);
if (di.Name.Contains("XMOS") == true)
{
this.device = di.Id;
NativeMethods.SetEvent(initSync);
this.EventWriterDLL.BuildLine("+1b start => WasapiOutRT::GetDefaultAudioEndpoint => Using playback device: " + di.Name);
return;
}
//if (di.Name.Contains("XMOS") != true && di.Name.Contains("Digital Audio") != true)
//{
// this.device = di.Id;
// NativeMethods.SetEvent(initSync);
// this.EventWriterDLL.WriteLine(EventWriterDLL.SeverityTypes.Information, 0x01, "+1b start => WasapiOutRT::GetDefaultAudioEndpoint => Using playback device: " + di.Name);
// return;
//}
}
this.EventWriterDLL.BuildLine("+1c start => WasapiOutRT::GetDefaultAudioEndpoint => NO APPROPRIATE SPEAKER DEVICE FOUND - Check your sound settings!");
NativeMethods.SetEvent(initSync);
this.device = null;
}
public void RenameFolderTest()
{
var devices = MediaDevice.GetDevices();
var device = devices.FirstOrDefault(this.deviceSelect);
Assert.IsNotNull(device, "Device");
device.Connect();
string filePath = Path.Combine(this.workingFolder, "RenameFolder");
string newName = "NewFolder";
string newPath = Path.Combine(this.workingFolder, newName);
if (device.DirectoryExists(filePath))
{
device.DeleteDirectory(filePath);
}
if (device.DirectoryExists(newPath))
{
device.DeleteDirectory(newPath);
}
device.CreateDirectory(filePath);
var exists1 = device.DirectoryExists(filePath);
device.Rename(filePath, newName);
var exists2 = device.DirectoryExists(newPath);
device.DeleteDirectory(newPath);
var exists3 = device.DirectoryExists(newPath);
device.Disconnect();
Assert.IsTrue(exists1, "exists1");
Assert.IsTrue(exists2, "exists2");
Assert.IsFalse(exists3, "exists3");
}
public async Task StartRecordAsync()
{
_filePath = Path.GetTempFileName();
var file = await StorageFile.GetFileFromPathAsync(_filePath);
var result = await AudioGraph.CreateAsync(new AudioGraphSettings(AudioRenderCategory.Speech));
if (result.Status != AudioGraphCreationStatus.Success)
{
throw new Exception("Couldn't open recorder!");
}
_graph = result.Graph;
var microphone = await DeviceInformation.CreateFromIdAsync(MediaDevice.GetDefaultAudioCaptureId(AudioDeviceRole.Default));
var outProfile = MediaEncodingProfile.CreateWav(AudioEncodingQuality.Low);
outProfile.Audio = AudioEncodingProperties.CreatePcm(16000, 1, 16);
var outputResult = await _graph.CreateFileOutputNodeAsync(file, outProfile);
if (outputResult.Status != AudioFileNodeCreationStatus.Success)
{
throw new Exception("Couldn't create output!");
}
_outputNode = outputResult.FileOutputNode;
var inProfile = MediaEncodingProfile.CreateWav(AudioEncodingQuality.High);
var inputResult = await _graph.CreateDeviceInputNodeAsync(
MediaCategory.Speech,
inProfile.Audio,
microphone);
if (inputResult.Status != AudioDeviceNodeCreationStatus.Success)
{
throw new Exception("Couldn't create device node!");
}
inputResult.DeviceInputNode.AddOutgoingConnection(_outputNode);
_graph.Start();
}
/// <summary>
/// Method which gets all usb-devices
/// </summary>
/// <returns>List of usb-devices</returns>
public static List <UsbDevice> GetDevices()
{
var devices = new List <UsbDevice>();
var drives = DriveInfo.GetDrives().Where(d => d.IsReady && d.DriveType == DriveType.Removable).ToList();
var mtpDevices = MediaDevice.GetDevices().ToList();
foreach (var device in mtpDevices)
{
device.Connect();
if (device.DeviceType != DeviceType.Generic)
{
devices.Add(new UsbDevice(device.Manufacturer + " " + device.Model, null, null, null, true));
}
}
devices.AddRange(drives.Select(drive => new UsbDevice(drive.Name,
BytesToMegaBytesString(drive.TotalFreeSpace),
BytesToMegaBytesString(drive.TotalSize - drive.TotalFreeSpace),
BytesToMegaBytesString(drive.TotalSize),
false)));
return(devices);
}
private async void EnumerateDevices(Object sender, Windows.UI.Xaml.RoutedEventArgs evt)
{
string AudioSelector = MediaDevice.GetAudioCaptureSelector();
DeviceInformationCollection DeviceInfoCollection;
DeviceInfoCollection = await DeviceInformation.FindAllAsync(AudioSelector);
var noteList = new ObservableCollection <DeviceView>();
m_DeviceInfo = DeviceInfoCollection;
for (int i = 0; i < DeviceInfoCollection.Count; i++)
{
noteList.Add(new DeviceView {
DeviceName = DeviceInfoCollection[i].Name
});
}
DevicesList.ItemsSource = noteList;
DevicesList.IsEnabled = true;
}
/// <summary>
/// 오디오 피드 초기화
/// </summary>
/// <returns></returns>
private async Task InitialiseAudioFeed()
{
if (_audioGraph == null || _audioFileOutputNode == null)
{
return;
}
var defaultAudioCaptureId = MediaDevice.GetDefaultAudioCaptureId(AudioDeviceRole.Default);
var microphone = await DeviceInformation.CreateFromIdAsync(defaultAudioCaptureId);
var inputProfile = MediaEncodingProfile.CreateWav(AudioEncodingQuality.High);
var inputResult =
await _audioGraph.CreateDeviceInputNodeAsync(MediaCategory.Speech, inputProfile.Audio, microphone);
if (inputResult.Status != AudioDeviceNodeCreationStatus.Success)
{
throw new InvalidOperationException("AudioDeviceNode creation error !");
}
inputResult.DeviceInputNode.AddOutgoingConnection(_audioFileOutputNode);
}
public void SpeedTest()
{
var devices = MediaDevice.GetDevices();
var device = devices.FirstOrDefault(this.deviceSelect);
Assert.IsNotNull(device, "Device");
device.Connect();
var root = device.GetRootDirectory();
var stopwatch = Stopwatch.StartNew();
var list = root.EnumerateFileSystemInfos("*", SearchOption.AllDirectories).ToList();
stopwatch.Stop();
device.Disconnect();
double milliseconds = ((double)stopwatch.ElapsedTicks / Stopwatch.Frequency) * 1000;
//Assert.AreEqual(0.0, milliseconds, "time");
}
public void Disconnect()
{
service.Disconnect();
if (videoForm != null)
{
MediaDevice device = service.MediaDevice;
//device.AVProcessor.ShowVideo -= videoForm.ShowVideo;
//device.AVProcessor.PlayAudio -= videoForm.PlayAudio;
//device.AVProcessor.ShowVideo -= videoForm.ShowVideo;
//device.AVProcessor.PlayAudio -= videoForm.PlayAudio;
videoForm.Close();
MediaFormManager.RemoveForm(videoForm);
}
;
MediaFormManager.UpdateControls();
}
public void UploadTreeTest()
{
var devices = MediaDevice.GetDevices();
var device = devices.FirstOrDefault(this.deviceSelect);
Assert.IsNotNull(device, "Device");
device.Connect();
UploadTestTree(device);
string destFolder = Path.Combine(this.workingFolder, "UploadTree");
int pathLen = this.workingFolder.Length;
var list = device.EnumerateFileSystemEntries(destFolder, null, SearchOption.AllDirectories).ToList();
device.Disconnect();
CollectionAssert.AreEquivalent(this.treeListFull, list, "EnumerateFileSystemEntries");
//CollectionAssert.AreEquivalent(pathes, list, "EnumerateFileSystemEntries");
}
/// <summary>
/// recording audio
/// </summary>
/// <param name="outputFile"></param>
public RecordingAudio(string outputFile)
{
// register all device
MediaDevice.InitializeDevice();
var dshowInput = new InFormat("dshow");
// list all "dshow" device at console output, ffmpeg does not support direct reading of device names
MediaDevice.GetDeviceInfos(dshowInput, MediaDevice.ListDevicesOptions);
// get your audio input device name from console output
// NOTE: DO NOT delete "audio="
using (MediaReader reader = new MediaReader("audio=change to your audio input device name", dshowInput))
using (MediaWriter writer = new MediaWriter(outputFile))
{
var stream = reader.Where(_ => _.Codec.Type == AVMediaType.AVMEDIA_TYPE_AUDIO).First();
writer.AddStream(MediaEncode.CreateAudioEncode(writer.Format, stream.Codec.AVCodecContext.channel_layout, stream.Codec.AVCodecContext.sample_rate));
writer.Initialize();
AudioFrame dstFrame = AudioFrame.CreateFrameByCodec(writer[0].Codec);
SampleConverter converter = new SampleConverter(dstFrame);
long pts = 0;
foreach (var packet in reader.ReadPacket())
{
foreach (var frame in stream.ReadFrame(packet))
{
foreach (var dstframe in converter.Convert(frame))
{
pts += dstFrame.AVFrame.nb_samples;
dstFrame.Pts = pts;
foreach (var dstpacket in writer[0].WriteFrame(dstFrame))
{
writer.WritePacket(dstpacket);
}
}
}
}
writer.FlushMuxer();
}
}
private void RefreshList(Object sender, Windows.UI.Xaml.RoutedEventArgs evt)
{
AudioCaptureEffectsManager CaptureEffectsManagerLocal;
IReadOnlyList <AudioEffect> Effectslist;
int deviceIndex = DevicesList.SelectedIndex;
MediaCategory Category;
if (CategoriesList.SelectedIndex < 0)
{
Category = MediaCategory.Communications;
}
else
{
Category = (MediaCategory)CategoriesList.SelectedIndex;
}
if (deviceIndex < 0)
{
CaptureEffectsManagerLocal = AudioEffectsManager.CreateAudioCaptureEffectsManager(
MediaDevice.GetDefaultAudioCaptureId(AudioDeviceRole.Communications),
Category,
Windows.Media.AudioProcessing.Default);
lblEffects.DataContext = new EffectLabelView {
EffectLabelName = "Effects Active on {Default Device}"
};
}
else
{
CaptureEffectsManagerLocal = AudioEffectsManager.CreateAudioCaptureEffectsManager(
m_DeviceInfo[deviceIndex].Id,
Category,
Windows.Media.AudioProcessing.Default);
lblEffects.DataContext = new EffectLabelView {
EffectLabelName = "Effects Active on {" + m_DeviceInfo[deviceIndex].Name + "}"
};
}
Effectslist = CaptureEffectsManagerLocal.GetAudioCaptureEffects();
DisplayEffectsList(Effectslist);
}
public async Task StartRecordToFileAsync(StorageFile file)
{
var result = await AudioGraph.CreateAsync(
new AudioGraphSettings(AudioRenderCategory.Media));
if (result.Status == AudioGraphCreationStatus.Success)
{
this.graph = result.Graph;
var microphone = await DeviceInformation.CreateFromIdAsync(
MediaDevice.GetDefaultAudioCaptureId(AudioDeviceRole.Default));
// Low gives us 1 channel, 16-bits per sample, 16K sample rate.
var outProfile = MediaEncodingProfile.CreateWav(AudioEncodingQuality.Low);
outProfile.Audio = AudioEncodingProperties.CreatePcm(16000, 1, 16);
var inProfile = MediaEncodingProfile.CreateWav(AudioEncodingQuality.High);
var outputResult = await this.graph.CreateFileOutputNodeAsync(file,
outProfile);
if (outputResult.Status == AudioFileNodeCreationStatus.Success)
{
this.outputNode = outputResult.FileOutputNode;
var inputResult = await this.graph.CreateDeviceInputNodeAsync(
MediaCategory.Media,
inProfile.Audio,
microphone);
if (inputResult.Status == AudioDeviceNodeCreationStatus.Success)
{
inputResult.DeviceInputNode.AddOutgoingConnection(
this.outputNode);
this.graph.Start();
}
}
}
}
public List <UsbDevice> GetDevices()
{
List <UsbDevice> devices = new List <UsbDevice>();
List <DriveInfo> drives = DriveInfo.GetDrives().Where(d => d.IsReady && d.DriveType == DriveType.Removable).ToList();
List <MediaDevice> mtpDevices = MediaDevice.GetDevices().ToList();
foreach (MediaDevice device in mtpDevices)
{
device.Connect();
if (device.DeviceType != DeviceType.Generic)
{
devices.Add(new UsbDevice(device.FriendlyName, null, null, null, true));
}
}
foreach (DriveInfo drive in drives)
{
devices.Add(new UsbDevice(drive.Name, BytesToMegaBytesString(drive.TotalFreeSpace),
BytesToMegaBytesString(drive.TotalSize - drive.TotalFreeSpace),
BytesToMegaBytesString(drive.TotalSize), false));
}
return(devices);
}
public void DownloadIconTest()
{
string filePath = Path.Combine(testDataFolder, Path.GetFileName("MTPTestPic.jpg"));
File.Delete(filePath);
var devices = MediaDevice.GetDevices();
var device = devices.FirstOrDefault(this.deviceSelect);
Assert.IsNotNull(device, "Device");
device.Connect();
var exists1 = device.FileExists(@"\Card\MTPTestPic.jpg");
device.DownloadIcon(@"\Card\MTPTestPic.jpg", filePath);
device.Disconnect();
Assert.IsTrue(exists1);
Assert.IsTrue(File.Exists(filePath), "Exists");
Assert.IsTrue(new FileInfo(filePath).Length > 100, "Length");
}
public void ExistsTest()
{
string existingDirectory = Path.GetDirectoryName(this.existingFile);
var devices = MediaDevice.GetDevices();
var device = devices.FirstOrDefault(this.deviceSelect);
Assert.IsNotNull(device, "Device");
device.Connect();
var exists1 = device.DirectoryExists(existingDirectory);
var exists2 = device.DirectoryExists(this.existingFile);
var exists3 = device.FileExists(existingDirectory);
var exists4 = device.FileExists(this.existingFile);
device.Disconnect();
Assert.IsTrue(exists1, "exists1");
Assert.IsFalse(exists2, "exists2");
Assert.IsFalse(exists3, "exists3");
Assert.IsTrue(exists4, "exists4");
}
internal MediaDriveInfo(MediaDevice device, string objectId)
{
this.device = device;
this.objectId = objectId;
this.info = device.GetStorageInfo(objectId);
if (this.info == null)
{
return;
}
this.TotalSize = (long)this.info.Capacity;
this.TotalFreeSpace = this.AvailableFreeSpace = (long)this.info.FreeSpaceInBytes;
this.DriveFormat = this.info.FileSystemType;
switch (this.info.Type)
{
case StorageType.FixedRam:
case StorageType.FixedRom:
this.DriveType = DriveType.Fixed;
break;
case StorageType.RemovableRam:
case StorageType.RemovableRom:
this.DriveType = DriveType.Removable;
break;
case StorageType.Undefined:
default:
this.DriveType = DriveType.Unknown;
break;
}
this.RootDirectory = new MediaDirectoryInfo(this.device, Item.Create(this.device, this.objectId));
this.Name = this.RootDirectory.FullName;
this.VolumeLabel = this.info.Description;
}
public void DownloadThumbnailTest()
{
string filePath = Path.Combine(testDataFolder, Path.ChangeExtension(Path.GetFileName(this.FilePersistentUniqueIdPath), ".gif"));
File.Delete(filePath);
var devices = MediaDevice.GetDevices();
var device = devices.FirstOrDefault(this.deviceSelect);
Assert.IsNotNull(device, "Device");
device.Connect();
var exists1 = device.FileExists(this.FilePersistentUniqueIdPath);
device.DownloadThumbnail(this.FilePersistentUniqueIdPath, filePath);
device.Disconnect();
Assert.IsTrue(exists1);
Assert.IsTrue(File.Exists(filePath), "Exists");
Assert.IsTrue(new FileInfo(filePath).Length > 100, "Length");
}
public void DownloadTreeTest()
{
var devices = MediaDevice.GetDevices();
var device = devices.FirstOrDefault(this.deviceSelect);
Assert.IsNotNull(device, "Device");
device.Connect();
#if NETCOREAPP
string sourceFolder = Path.GetFullPath(@".\..\..\..\..\TestData\UploadTree");
#else
string sourceFolder = Path.GetFullPath(@".\..\..\..\TestData\UploadTree");
#endif
string destFolder = Path.Combine(this.workingFolder, "UploadTree");
var exists1 = device.DirectoryExists(destFolder);
if (exists1)
{
device.DeleteDirectory(destFolder, true);
}
device.UploadFolder(sourceFolder, destFolder);
string downloadFolder = Path.GetFullPath(@".\..\..\..\TestData\DownloadTree");
if (Directory.Exists(downloadFolder))
{
Directory.Delete(downloadFolder, true);
}
device.DownloadFolder(destFolder, downloadFolder);
device.Disconnect();
//Assert.IsTrue(File.Exists(tempFile), "Exists");
}
public List <usbDevice> GetDevices()
{
List <usbDevice> devices = new List <usbDevice>();
List <DriveInfo> drives = DriveInfo.GetDrives().Where(d => d.IsReady && d.DriveType == DriveType.Removable).ToList();
List <MediaDevice> mtpDevice = MediaDevice.GetDevices().ToList();
foreach (MediaDevice device in mtpDevice)
{
device.Connect();
if (device.DeviceType != DeviceType.Generic)
{
devices.Add(new usbDevice(device.Manufacturer + " " + device.Model, null, null, null, true));
}
}
foreach (DriveInfo drive in drives)
{
devices.Add(new usbDevice(drive.Name + drive.VolumeLabel, BytesToMegabytesString(drive.TotalFreeSpace),
BytesToMegabytesString(drive.TotalSize - drive.TotalFreeSpace),
BytesToMegabytesString(drive.TotalSize), false));
}
return(devices);
}
public void DeviceTest()
{
var devices = MediaDevice.GetDevices().ToArray();
var device = devices.FirstOrDefault(d => d.Description == this.deviceDescription);
Assert.IsNotNull(device, "Device");
string description = device.Description;
string friendlyName = device.FriendlyName;
string manufacture = device.Manufacturer;
device.Connect();
string firmwareVersion = device.FirmwareVersion;
PowerSource powerSource = device.PowerSource;
int powerLevel = device.PowerLevel;
string model = device.Model;
string serialNumber = device.SerialNumber;
DeviceType deviceType = device.DeviceType;
DeviceTransport transport = device.Transport;
string pnPDeviceID = device.PnPDeviceID;
device.Disconnect();
Assert.AreEqual(this.deviceDescription, description, "Description");
Assert.AreEqual(this.deviceFriendlyName, friendlyName, "FriendlyName");
Assert.AreEqual(this.deviceManufacture, manufacture, "Manufacture");
Assert.AreEqual(this.deviceFirmwareVersion, firmwareVersion, "FirmwareVersion");
Assert.AreEqual(this.deviceModel, model, "Model");
Assert.AreEqual(this.deviceSerialNumber, serialNumber, "SerialNumber");
Assert.AreEqual(this.deviceDeviceType, deviceType, "DeviceType");
Assert.AreEqual(this.deviceTransport, transport, "Transport");
Assert.AreEqual(this.devicePowerSource, powerSource, "PowerSource");
Assert.AreEqual(this.devicePnPDeviceID, pnPDeviceID, "PnPDeviceID");
if (this.supDevicePowerLevel)
{
Assert.IsTrue(powerLevel > 0, "PowerLevel");
}
}
public List <Usb> DeviseListCreate()
{
List <Usb> usbDevices = new List <Usb>();
var diskDrives = DriveInfo.GetDrives().Where(d => d.IsReady && d.DriveType == DriveType.Removable);
var mtpDrives = MediaDevice.GetDevices();
foreach (MediaDevice device in mtpDrives)
{
device.Connect();
if (device.DeviceType != DeviceType.Generic)
{
usbDevices.Add(new Usb(device.FriendlyName, null, null, null, true));
}
}
foreach (DriveInfo drive in diskDrives)
{
usbDevices.Add(new Usb(drive.Name, Convert(drive.TotalFreeSpace),
Convert(drive.TotalSize - drive.TotalFreeSpace),
Convert(drive.TotalSize), false));
}
return(usbDevices);
}
public void PersistentUniqueIdTest()
{
var devices = MediaDevice.GetDevices();
var device = devices.FirstOrDefault(this.deviceSelect);
Assert.IsNotNull(device, "Device");
device.Connect();
MediaDirectoryInfo dir = device.GetFileSystemInfoFromPersistentUniqueId(this.FolderPersistentUniqueId) as MediaDirectoryInfo;
MediaFileInfo file = device.GetFileSystemInfoFromPersistentUniqueId(this.FilePersistentUniqueId) as MediaFileInfo;
device.Disconnect();
Assert.IsNotNull(dir, "Dir");
Assert.IsTrue(dir.Attributes.HasFlag(MediaFileAttributes.Directory), "dir.IsDirectory");
Assert.AreEqual(this.FolderPersistentUniqueIdPath, dir.FullName, "dir.FullName");
Assert.IsNotNull(file, "File");
Assert.IsTrue(file.Attributes.HasFlag(MediaFileAttributes.Normal), "file.IsFile");
Assert.AreEqual(this.FilePersistentUniqueIdPath, file.FullName, "file.FullName");
}
public List <DeviceInfo> GetDevices()
{
List <DeviceInfo> devices = new List <DeviceInfo>();
List <DriveInfo> drives = DriveInfo.GetDrives().Where(d => d.IsReady && d.DriveType == DriveType.Removable).ToList();
List <MediaDevice> mtpDevices = MediaDevice.GetDevices().ToList();
foreach (MediaDevice device in mtpDevices)
{
device.Connect();
if (device.DeviceType != DeviceType.Generic)
{
devices.Add(new DeviceInfo(string.Empty /*device.Manufacturer + " " + device.Model + " " + */, device.FriendlyName, null, null, null, true));
}
}
foreach (DriveInfo drive in drives)
{
devices.Add(new DeviceInfo(drive.Name.Split('\\')[0], drive.VolumeLabel, BytesToMegaBytesString(drive.TotalSize),
BytesToMegaBytesString(drive.TotalFreeSpace),
BytesToMegaBytesString(drive.TotalSize - drive.TotalFreeSpace), false));
}
return(devices);
}
public List <Device> GetDevices()
{
Devices.Clear();
try
{
foreach (var device in MediaDevice.GetDevices())
{
device.Connect();
IEnumerable <MediaDirectoryInfo> rootDirectory = device.GetRootDirectory().EnumerateDirectories();
Devices.Add(new Device
{
Name = device.FriendlyName,
DeviceType = device.DeviceType
});
var volumes = device.DeviceType == DeviceType.Generic ? GetGenericVolumes(rootDirectory, Devices.Last()) : GetMtpVolumes(rootDirectory);
Devices.Last().Volumes = volumes;
device.Disconnect();
}
}
catch (Exception e) { }
return(Devices);
}
/// <summary>
/// Gets the default audio capture device
/// </summary>
/// <returns>The default audio capture device</returns>
private async Task GetDefaultCaptureDevice()
{
// get the default device if available
this.device = MediaDevice.GetDefaultAudioCaptureId(AudioDeviceRole.Default);
IEnumerable <DeviceInformation> captureDevices = await GetCaptureDevices();
if (this.device != null)
{
foreach (DeviceInformation di in captureDevices)
{
if (di.Name.Contains("XMOS") == true && this.device.Equals(di.Id))
{
this.isXMOS = true;
this.EventWriterDLL.BuildLine("1a start => WasapiCapture::GetDefaultCaptureDevice => Using XMOS capture device: " + di.Name);
return;
}
}
this.EventWriterDLL.BuildLine("1b start => WasapiCapture::GetDefaultCaptureDevice => Using non-XMOS capture device.");
return;
}
else
{
// If there is no defualt device, then pick the first device that is the XMOS device
foreach (DeviceInformation di in captureDevices)
{
if (di.Name.Contains("XMOS") == true)
{
this.device = di.Id;
this.isXMOS = true;
this.EventWriterDLL.BuildLine("1c start => WasapiCapture::GetDefaultCaptureDevice => Using capture device: " + di.Name);
return;
}
}
}
this.EventWriterDLL.BuildLine("1d start fail => WasapiCapture::GetDefaultCaptureDevice =>NO APPROPRIATE MICROPHONE DEVICE FOUND - Check your sound settings!");
this.device = null;
}
public void CreateFolderTest()
{
var devices = MediaDevice.GetDevices();
var device = devices.FirstOrDefault(this.deviceSelect);
Assert.IsNotNull(device, "Device");
device.Connect();
string newFolder = Path.Combine(this.workingFolder, "Test");
var exists1 = device.DirectoryExists(this.workingFolder);
device.CreateDirectory(newFolder);
var exists2 = device.DirectoryExists(newFolder);
device.DeleteDirectory(newFolder, true);
var exists3 = device.DirectoryExists(newFolder);
device.Disconnect();
Assert.IsTrue(exists1, "exists1");
Assert.IsTrue(exists2, "exists2");
Assert.IsFalse(exists3, "exists3");
}
private async Task CreateDeviceInputNode()
{
// Create a device output node
var microphone = await DeviceInformation.CreateFromIdAsync(
MediaDevice.GetDefaultAudioCaptureId(AudioDeviceRole.Default));
var inProfile = MediaEncodingProfile.CreateWav(AudioEncodingQuality.High);
var inputResult = await this._audioGraph.CreateDeviceInputNodeAsync(
MediaCategory.Speech,
inProfile.Audio,
microphone);
if (inputResult.Status != AudioDeviceNodeCreationStatus.Success)
{
// Cannot create device output node
Debug.WriteLine(inputResult.Status.ToString());
return;
}
_deviceInputNode = inputResult.DeviceInputNode;
}
