private void InstallApp(string appPath)
{
var appManifestInfo = this.InstallApplicationPackage(appPath);
this.installed = true;
this.RemoteApplication = this.Device.GetApplication(appManifestInfo.ProductId);
}
/// <summary>
/// Destruction
/// </summary>
/// <param name="application"></param>
/// <param name="directory"></param>
public static void DeleteDirectoryOrFile(IRemoteApplication application, IRemoteFileInfo directoryOrFile)
{
GetParentDirectory(application, directoryOrFile);
if (application == null || directoryOrFile == null)
{
return;
}
var isolatedStore = application.GetIsolatedStore();
if (isolatedStore != null)
{
string path = GetSearchPattern(application, directoryOrFile);
if (directoryOrFile.IsDirectory() == true)
{
isolatedStore.DeleteDirectory(path);
}
else
{
//TODO isolatedStore.DeleteFile(path);
}
}
}
public void Uninstall()
{
if (!this.installed)
{
Logger.Debug("Could not uninstall application that is already uninstalled.");
return;
}
this.remoteApplication.Uninstall();
this.remoteApplication = null;
this.device.Disconnect();
}
/// <summary>
/// Creation du répertoire
/// </summary>
/// <param name="fileInfo"></param>
public static IRemoteFileInfo CreateDirectory(IRemoteApplication application, IRemoteFileInfo directoryParent, string newDirectoryName)
{
if (application == null || string.IsNullOrWhiteSpace(newDirectoryName) == true)
{
return null;
}
var isolatedStore = application.GetIsolatedStore();
if (isolatedStore != null)
{
string path = Path.Combine(GetSearchPattern(application, directoryParent), newDirectoryName);
isolatedStore.CreateDirectory(path);
return SearchRemoteFileInfo(application, directoryParent, newDirectoryName);
}
return null;
}
internal static string GenerateNDeployMdil(
string packageFile,
IRemoteApplication app,
TypeOfApp appType,
IAppManifestInfo appManifest)
{
var generateMdil = (IGenerateMDIL) new MDILGeneratorFromPackage(packageFile, appType, appManifest);
generateMdil.GenerateMDILTask();
if (app != null)
{
try
{
app.UpdateInstalledFilesInfo(
generateMdil.MSILFileList.ToArray(),
generateMdil.RelativeMSILFileList.ToArray());
var num = app.UpdateInstalledFiles(
generateMdil.MDILFileList.ToArray(),
generateMdil.RelativeMDILFileList.ToArray());
if (num != 0)
{
throw new Exception(
string.Format(Resources.MDILDeploymentFailure, num));
}
}
finally
{
generateMdil.Cleanup();
}
}
else
{
generateMdil.Cleanup();
}
return(generateMdil.RepackedPackage);
}
private void InstallXapSynchronous(object pathToXap)
{
Guid? guid;
Version version;
bool flag;
_device.Activate();
var tempFile = Path.GetTempFileName();
File.Copy((string)pathToXap, tempFile, true);
Utils.ReadWMAppManifestXaml(tempFile, out guid, out version, out flag);
var iconFile = Utils.ExtractIconFile(tempFile);
if (_device.GetInstalledApplications().Any(x => x.ProductID == guid.Value))
{
_lastApp = _device.GetApplication(guid.Value);
}
else
{
_lastApp = _device.InstallApplication(guid.Value, guid.Value, "NormalApp", iconFile, tempFile);
}
_lastApp.Launch();
XapInstalled(this, null);
}
/// <summary>
/// Obtenir la search pattern à partir des informations d'un fichier
/// </summary>
/// <param name="application"></param>
/// <param name="fileInfo"></param>
/// <returns></returns>
public static string GetSearchPattern(IRemoteApplication application, IRemoteFileInfo fileInfo)
{
if (fileInfo == null)
return string.Empty;
string root = GetRootPath(application).ToLower();
if (fileInfo.Name.ToLower().StartsWith(root) == true)
{
return fileInfo.Name.Substring(root.Length);
}
return null;
}
/// <summary>
/// Upload du fichier
/// </summary>
/// <param name="application"></param>
/// <param name="directoryToUpload"></param>
/// <param name="desktopfilename"></param>
public static void UploadFileToDevice(IRemoteApplication application, IRemoteFileInfo directoryToUpload, string desktopfilename)
{
if (application == null || desktopfilename == null)
{
return;
}
if (directoryToUpload == null || directoryToUpload.IsDirectory() == true)
{
var isolatedStore = application.GetIsolatedStore();
if (isolatedStore != null)
{
string searchPattern = GetSearchPattern(application, directoryToUpload);
// on rajoute le nom du fichier
string devicefilename = Path.Combine(searchPattern, new FileInfo(desktopfilename).Name);
isolatedStore.SendFile(desktopfilename, devicefilename, true);
}
}
}
/// <summary>
/// Upload d'un fichier ou d'un répertoire entier
/// </summary>
/// <param name="application"></param>
/// <param name="directoryOrFileToDownload"></param>
/// <param name="desktopPath"></param>
public static IRemoteFileInfo UploadFileOrDirectoryToDevice(IRemoteApplication application, IRemoteFileInfo directoryToUpload, string desktopPathOrFilename, bool includeRootDirectory = false)
{
if (application == null || desktopPathOrFilename == null)
{
return null;
}
if (directoryToUpload == null || directoryToUpload.IsDirectory() == true)
{
var isolatedStore = application.GetIsolatedStore();
if (isolatedStore != null)
{
bool isDirectory = Directory.Exists(desktopPathOrFilename);
string searchPattern = GetSearchPattern(application, directoryToUpload);
if (isDirectory == true)
{
string directoryName = new DirectoryInfo(desktopPathOrFilename).Name;
IRemoteFileInfo newDirectory = directoryToUpload;
if (includeRootDirectory == true)
{
newDirectory = CreateDirectory(application, directoryToUpload, directoryName);
}
foreach (string directory in Directory.GetDirectories(desktopPathOrFilename))
{
string desktopDirectoryPath = Path.Combine(desktopPathOrFilename, directory);
UploadFileOrDirectoryToDevice(application, newDirectory, desktopDirectoryPath, true);
}
foreach (string file in Directory.GetFiles(desktopPathOrFilename))
{
string desktopFilename = Path.Combine(desktopPathOrFilename, file);
UploadFileToDevice(application, newDirectory, desktopFilename);
}
return newDirectory;
}
else
{
// fichier
UploadFileToDevice(application, directoryToUpload, desktopPathOrFilename);
}
}
}
return null;
}
private void InstallApp(string appPath)
{
var appManifestInfo = this.InstallApplicationPackage(appPath);
this.installed = true;
this.RemoteApplication = this.Device.GetApplication(appManifestInfo.ProductId);
}
public RemoteApplicationEx(IRemoteApplication remoteApplication)
{
RemoteApplication = remoteApplication;
}
static void Main(string[] args)
{
int deviceIndex = 0;
string iconFilePath = "";
string xapFilePath = "";
Guid appID = Guid.Empty;
bool uninstallFirst = args.Contains("-uninstall");
bool awaitAppClose = args.Contains("-wait");
string root = Directory.GetCurrentDirectory();
if (args.Length < 1)
{
Usage();
ReadWait();
return;
}
else if (args.Contains("-devices"))
{
ListDevices();
ReadWait();
return;
}
else if (args.Length > 1 && args[1].StartsWith("-d:"))
{
deviceIndex = int.Parse(args[1].Substring(3));
}
if (Directory.Exists(args[0]))
{
var info = new DirectoryInfo(args[0]);
root = info.FullName;
try
{
xapFilePath = Directory.GetFiles(root + @"\Bin\Debug", "*.xap").FirstOrDefault();
}
catch (DirectoryNotFoundException)
{
try
{
xapFilePath = Directory.GetFiles(root + @"\Bin\Release", "*.xap").FirstOrDefault();
}
catch (DirectoryNotFoundException)
{
Log(string.Format("Error: could not find project build directoy in {0}", root), true);
Log("make sure your app has been successfully built before deploying.", true);
}
}
}
if (File.Exists(args[0]))
{
var info = new FileInfo(args[0]);
if (info.Extension == ".xap")
{
root = info.DirectoryName;
xapFilePath = info.FullName;
}
}
appID = ReadAppId(root);
if (appID == Guid.Empty)
{
return; // Logging of errors is done in ReadAppId
}
if (File.Exists(root + @"\ApplicationIcon.png"))
{
iconFilePath = root + @"\ApplicationIcon.png";
}
else
{
Log(string.Format("Error: could not find application icon at {0}", root + @"\ApplicationIcon.png"), true);
ReadWait();
return;
}
if (string.IsNullOrEmpty(xapFilePath))
{
Log(string.Format("Error: could not find application .xap in folder {0}", root), true);
ReadWait();
return;
}
ConnectableDevice deviceConn = GetDeviceAtIndex(deviceIndex);
Log("Connecting to device :: " + deviceConn.Id + " : " + deviceConn.Name);
try
{
IDevice device = deviceConn.Connect();
IRemoteApplication app = null;
if (device.IsApplicationInstalled(appID))
{
app = device.GetApplication(appID);
if (uninstallFirst)
{
Log("Uninstalling app on " + deviceConn.Name);
app.Uninstall();
Log("Installing app on " + deviceConn.Name);
app = device.InstallApplication(appID, appID, "NormalApp", iconFilePath, xapFilePath);
}
else
{
Log("Updating app on " + deviceConn.Name);
app.UpdateApplication("NormalApp", iconFilePath, xapFilePath);
}
}
else
{
Log("Installing app on " + deviceConn.Name);
app = device.InstallApplication(appID, appID, "NormalApp", iconFilePath, xapFilePath);
}
Log("Launching app on " + deviceConn.Name);
app.Launch();
if (awaitAppClose)
{
// wait for the app to launch
Thread.Sleep(4000);
bool isExiting = false;
string tempFileName = Path.GetTempFileName();
try
{
IRemoteIsolatedStorageFile isoFile = app.GetIsolatedStore();
int index = 0;
while (!isExiting) //app.IsRunning()) // not implemented ... wtf?
{
char[] buffer = new char[1000];
isoFile.ReceiveFile((object)Path.DirectorySeparatorChar + "debugOutput.txt", tempFileName, true);
using (StreamReader reader = System.IO.File.OpenText(tempFileName))
{
try
{
int newLinesRead = 0;
for (int lineNum = 0; ; lineNum++)
{
if (reader.Peek() > -1)
{
string str = reader.ReadLine();
if (lineNum >= index)
{
newLinesRead++;
if (str == "EXIT")
{
isExiting = true;
}
Log(str);
}
}
else
{
break;
}
}
index += newLinesRead;
}
catch (Exception)
{
// at end of stream most likely, no worries, ... move along.
}
}
Thread.Sleep(1000);
}
System.IO.File.Delete(tempFileName);
}
catch (Exception ex)
{
Log(ex.Message);
}
}
// To Stop :
//app.TerminateRunningInstances();
device.Disconnect();
ReadWait();
}
catch (Exception ex)
{
Log("Error :: " + ex.Message, true);
}
}
/// <summary>
/// Constructeur
/// </summary>
/// <param name="fileInfo"></param>
public RemoteFileInfoManager(IRemoteApplication application, IRemoteFileInfo fileInfo, string tempDirectory)
{
this.RemoteFileInfo = fileInfo;
this.TempDirectory = tempDirectory;
this.RemoteApplication = application;
}
/// <summary>
/// Download a file
/// </summary>
/// <param name="application"></param>
/// <param name="fileToDownload"></param>
/// <param name="desktopPath"></param>
public static void DownloadFileFromDevice(IRemoteApplication application, IRemoteFileInfo fileToDownload, string desktopPath)
{
if (application == null || fileToDownload == null || desktopPath == null)
{
return;
}
if (fileToDownload.IsDirectory() == false)
{
var isolatedStore = application.GetIsolatedStore();
if (isolatedStore != null)
{
// on rajoute le nom du fichier
desktopPath = Path.Combine(desktopPath, GetShortName(fileToDownload));
string searchPattern = GetSearchPattern(application, fileToDownload);
isolatedStore.ReceiveFile(searchPattern, desktopPath, true);
}
}
}
/// <summary>
/// Obtenir le chemin de base
/// </summary>
/// <param name="application"></param>
/// <returns></returns>
public static string GetRootPath(IRemoteApplication application)
{
return string.Format(@"%FOLDERID_APPID_ISOROOT%\{0}\", application.ProductID.ToString("B"));
//WP8 return string.Format(@"%FOLDERID_APPID_ISOROOT%\{{{0}}}\", application.ProductID);
//WP7 return string.Format(@"\Applications\Data\{0}\Data\IsolatedStore\", application.ProductID);
}
/// <summary>
/// Obtenir les informations
/// </summary>
/// <param name="application"></param>
/// <param name="searchPattern"></param>
/// <param name="isDirectoryPattern"></param>
/// <returns></returns>
public static List<IRemoteFileInfo> GetRemoteFileInfos(IRemoteApplication application, string searchPattern, bool? isDirectoryPattern)
{
var result = new List<IRemoteFileInfo>();
var isolatedStore = application.GetIsolatedStore();
if (isolatedStore != null)
{
var remoteFileInfos = new List<IRemoteFileInfo>();
try
{
remoteFileInfos = isolatedStore.GetDirectoryListing(searchPattern);
}
catch (FileNotFoundException)
{
}
catch (DirectoryNotFoundException)
{
}
foreach (var remoteFileInfo in remoteFileInfos)
{
if (isDirectoryPattern.HasValue == true)
{
if (remoteFileInfo.IsDirectory() != isDirectoryPattern)
{
continue;
}
}
result.Add(remoteFileInfo);
}
}
return result;
}
/// <summary>
/// Obtenir le parent
/// </summary>
/// <param name="application"></param>
/// <param name="remoteFileInfo"></param>
/// <returns></returns>
public static string GetParentDirectoryString(IRemoteApplication application, IRemoteFileInfo remoteFileInfo)
{
string filename = GetSearchPattern(application, remoteFileInfo);
string name = GetShortName(remoteFileInfo);
return filename.Substring(0, filename.Length - name.Length);
}
/// <summary>
/// Obtenir le repertoire parent
/// </summary>
/// <param name="application"></param>
/// <param name="remoteFileInfo"></param>
/// <returns></returns>
public static IRemoteFileInfo GetParentDirectory(IRemoteApplication application, IRemoteFileInfo remoteFileInfo)
{
if (application == null || remoteFileInfo == null)
return null;
string parent = GetParentDirectoryString(application, remoteFileInfo);
string parentName = new DirectoryInfo(parent).Name;
string parentOfParent = Path.GetPathRoot(parent);
var isolatedStore = application.GetIsolatedStore();
if (isolatedStore != null)
{
var remoteFileInfos = isolatedStore.GetDirectoryListing(parentOfParent);
foreach (var r in remoteFileInfos)
{
string name = RemoteIsolatedStoreTools.GetShortName(r);
if (r.IsDirectory() && name == parentName)
{
return r;
}
}
}
return null;
}
/// <summary>
/// le repertoire de nom Exist ou non
/// </summary>
/// <param name="application"></param>
/// <param name="directoryParent"></param>
/// <param name="directoryOrFilename"></param>
/// <returns></returns>
public static bool Exists(IRemoteApplication application, IRemoteFileInfo directoryParent, string directoryOrFilename)
{
if (application == null || string.IsNullOrWhiteSpace(directoryOrFilename) == true)
{
return false;
}
bool result = false;
var isolatedStore = application.GetIsolatedStore();
if (isolatedStore != null)
{
string searchPattern = GetSearchPattern(application, directoryParent);
string path = Path.Combine(searchPattern, directoryOrFilename);
result = isolatedStore.DirectoryExists(path);
if (result == false)
{
result = isolatedStore.FileExists(path);
}
}
return result;
}
/// <summary>
/// Telechargement
/// </summary>
/// <param name="application"></param>
/// <param name="directoryOrFileToDownload"></param>
/// <param name="desktopPath"></param>
public static void DownloadFileOrDirectoryFromDevice(IRemoteApplication application, IRemoteFileInfo directoryOrFileToDownload, string desktopPath, bool includeRootDirectory = true)
{
if (application == null || desktopPath == null)
{
return;
}
var isolatedStore = application.GetIsolatedStore();
if (isolatedStore != null)
{
if (directoryOrFileToDownload == null || directoryOrFileToDownload.IsDirectory() == true)
{
string searchPattern = GetSearchPattern(application, directoryOrFileToDownload);
List<IRemoteFileInfo> fileInfos = GetRemoteFileInfos(application, searchPattern, null);
desktopPath = Path.Combine(desktopPath, GetShortName(directoryOrFileToDownload));
if (includeRootDirectory == true)
{
Directory.CreateDirectory(desktopPath);
}
foreach (IRemoteFileInfo fileInfo in fileInfos)
{
if (fileInfo.IsDirectory() == true)
{
if (includeRootDirectory == false)
{
Directory.CreateDirectory(desktopPath);
}
// repertoire
DownloadFileOrDirectoryFromDevice(application, fileInfo, desktopPath, true);
}
else
{ // fichier
DownloadFileFromDevice(application, fileInfo, desktopPath);
}
}
}
else
{
// fichier
DownloadFileFromDevice(application, directoryOrFileToDownload, desktopPath);
}
}
}
public void UsePreInstalledApplication(string appPath)
{
var appManifest = Utils.ReadAppManifestInfoFromPackage(appPath);
this.RemoteApplication = this.Device.GetApplication(appManifest.ProductId);
}
/// <summary>
/// Chargement d'un fichier de nom FileInfo
/// </summary>
/// <returns></returns>
public static FileStream LoadFile(IRemoteApplication application, IRemoteFileInfo fileInfo, string desktopTempDirectory)
{
RemoteIsolatedStoreTools.DownloadFileFromDevice(application, fileInfo, desktopTempDirectory);
string filename = Path.Combine(desktopTempDirectory, RemoteIsolatedStoreTools.GetShortName(fileInfo));
return File.OpenRead(filename);
}
public void Uninstall()
{
if (!this.installed)
{
Logger.Debug("Could not uninstall application that is already uninstalled.");
return;
}
this.remoteApplication.Uninstall();
this.remoteApplication = null;
this.device.Disconnect();
}
/// <summary>
/// Chargement d'un fichier texte
/// </summary>
/// <param name="application"></param>
/// <param name="fileInfo"></param>
/// <param name="tempDirectory"></param>
/// <returns></returns>
public static string LoadFileText(IRemoteApplication application, IRemoteFileInfo fileInfo, string tempDirectory)
{
using (FileStream stream = LoadFile(application, fileInfo, tempDirectory))
{
using (StreamReader reader = new StreamReader(stream))
{
return reader.ReadToEnd();
}
}
}
internal static string GenerateNDeployMdil(
string packageFile,
IRemoteApplication app,
TypeOfApp appType,
IAppManifestInfo appManifest)
{
var generateMdil = (IGenerateMDIL)new MDILGeneratorFromPackage(packageFile, appType, appManifest);
generateMdil.GenerateMDILTask();
if (app != null)
{
try
{
app.UpdateInstalledFilesInfo(
generateMdil.MSILFileList.ToArray(),
generateMdil.RelativeMSILFileList.ToArray());
var num = app.UpdateInstalledFiles(
generateMdil.MDILFileList.ToArray(),
generateMdil.RelativeMDILFileList.ToArray());
if (num != 0)
{
throw new Exception(
string.Format(Resources.MDILDeploymentFailure, num));
}
}
finally
{
generateMdil.Cleanup();
}
}
else
{
generateMdil.Cleanup();
}
return generateMdil.RepackedPackage;
}
/// <summary>
/// Sauvegarde d'un fichier
/// </summary>
/// <param name="desktopStream"></param>
public static void SaveFile(IRemoteApplication application, IRemoteFileInfo directory, FileStream desktopStream)
{
RemoteIsolatedStoreTools.UploadFileToDevice(application, directory, desktopStream.Name);
}
static void Main(string[] args)
{
int deviceIndex = 0;
string iconFilePath = "";
string xapFilePath = "";
Guid appID = Guid.Empty;
string root = Directory.GetCurrentDirectory();
if (args.Length < 1)
{
Usage();
ReadWait();
return;
}
else if (args[0] == "-devices")
{
ListDevices();
ReadWait();
return;
}
else if (args.Length > 1 && args[1].StartsWith("-d:"))
{
deviceIndex = int.Parse(args[1].Substring(3));
}
if (Directory.Exists(args[0]))
{
DirectoryInfo info = new DirectoryInfo(args[0]);
root = info.FullName;
}
appID = ReadAppId(root);
if (appID == Guid.Empty)
{
return; // Logging of errors is done in ReadAppId
}
if (File.Exists(root + @"\ApplicationIcon.png"))
{
iconFilePath = root + @"\ApplicationIcon.png";
}
else
{
Log(string.Format("Error: could not find application icon at {0}", root + @"\ApplicationIcon.png"), true);
ReadWait();
return;
}
xapFilePath = Directory.GetFiles(root + @"\Bin\Debug", "*.xap").FirstOrDefault();
if (string.IsNullOrEmpty(xapFilePath))
{
Log(string.Format("Error: could not find application .xap in folder {0}", root), true);
ReadWait();
return;
}
ConnectableDevice deviceConn = GetDeviceAtIndex(deviceIndex);
Log("Connecting to device :: " + deviceConn.Id + " : " + deviceConn.Name);
try
{
IDevice device = deviceConn.Connect();
IRemoteApplication app = null;
if (device.IsApplicationInstalled(appID))
{
Log("Uninstalling XAP from " + deviceConn.Name);
app = device.GetApplication(appID);
app.Uninstall();
}
Log("Installing app on " + deviceConn.Name);
app = device.InstallApplication(appID, appID, "NormalApp", iconFilePath, xapFilePath);
Log("Launching app on " + deviceConn.Name);
app.Launch();
// To Stop :
//app.TerminateRunningInstances();
device.Disconnect();
ReadWait();
}
catch (Exception ex)
{
Log("Error :: " + ex.Message, true);
}
}
/// <summary>
/// Sauvegarde d'un fichier texte dans un repertoire temporaire puis envoi vers le device
/// </summary>
/// <param name="stream"></param>
public static void SaveFileText(IRemoteApplication application, IRemoteFileInfo directory, string tempFullFilename, string text)
{
using (FileStream stream = new FileStream(tempFullFilename, FileMode.Create))
{
using (StreamWriter writer = new StreamWriter(stream))
{
writer.Write(text);
SaveFile(application, directory, stream);
}
}
}
static int Main(string[] args)
{
if (args.Length == 0)
{
return(showHelp());
}
string command = null;
string wpsdk = null;
string udid = null;
Guid appid = Guid.Empty;
int i;
for (i = 0; i < args.Length; i++)
{
if (args[i] == "--wpsdk")
{
if (i + 1 < args.Length)
{
wpsdk = args[++i];
}
}
else if (command == null)
{
command = args[i];
if (command == "connect" && i + 1 < args.Length)
{
udid = args[++i];
}
else if (command == "launch" && i + 1 < args.Length)
{
udid = args[++i];
string rawAppId = args[++i];
try
{
appid = Guid.Parse(rawAppId);
} catch (FormatException fe)
{
return(showHelp("Invalid app GUID format: " + rawAppId));
}
}
}
}
if (wpsdk == null)
{
wpsdk = "10.0";
}
else
{
// trim whatever version number they pass in to 2 digits
string[] parts = wpsdk.Split(new Char [] { '.' });
wpsdk = "";
i = 0;
while (i < 2)
{
if (wpsdk.Length > 0)
{
wpsdk += '.';
}
if (i < parts.Length)
{
wpsdk += parts[i];
}
else
{
wpsdk += '0';
}
i++;
}
}
if (!wpsdk.Equals("10.0") && !wpsdk.Equals("8.1"))
{
return(showHelp("Unsupported wpsdk value. Please use '10.0' or '8.1'."));
}
int localeId = CultureInfo.CurrentUICulture.LCID;
MultiTargetingConnectivity multiTargetingConnectivity = new MultiTargetingConnectivity(localeId);
Collection <ConnectableDevice> devices = multiTargetingConnectivity.GetConnectableDevices();
List <ConnectableDevice> deviceList = new List <ConnectableDevice>();
i = 0;
foreach (ConnectableDevice dev in devices)
{
// Filter to device and emulators that match the given SDK. We use 6.3 Version as the marker for 8.1 emus, assume rest are 10.0
string versionString = dev.Version.ToString();
if (!dev.IsEmulator() || (wpsdk == "8.1" && versionString.Equals("6.3")) || (wpsdk == "10.0" && !versionString.Equals("6.3")))
{
deviceList.Add(dev);
i++;
}
}
if (command == "enumerate")
{
int id = 0;
int j = 0;
Console.WriteLine("{");
Console.WriteLine("\t\"devices\": [");
foreach (ConnectableDevice dev in deviceList)
{
string versionString = dev.Version.ToString();
if (!dev.IsEmulator())
{
if (j > 0)
{
Console.WriteLine(",");
}
string sdk = "null";
if (versionString == "6.3")
{
sdk = "\"8.1\"";
}
else if (versionString == "10.0")
{
sdk = "\"10.0\"";
}
Console.WriteLine("\t\t{\n");
Console.WriteLine("\t\t\t\"name\": \"" + dev.Name.Replace("\"", "\\\"") + "\",");
Console.WriteLine("\t\t\t\"udid\": " + id + ",");
Console.WriteLine("\t\t\t\"index\": " + id + ",");
Console.WriteLine("\t\t\t\"version\": \"" + versionString + "\","); // windows 8.1: "6.3", windows 10: "10.0"
Console.WriteLine("\t\t\t\"wpsdk\": " + sdk);
Console.Write("\t\t}");
j++;
}
id++;
}
Console.WriteLine("\n\t],");
id = 0;
j = 0;
Console.WriteLine("\t\"emulators\": [");
foreach (ConnectableDevice dev in deviceList)
{
if (dev.IsEmulator())
{
if (j > 0)
{
Console.WriteLine(",");
}
Console.WriteLine("\t\t{\n");
Console.WriteLine("\t\t\t\"name\": \"" + dev.Name.Replace("\"", "\\\"") + "\",");
Console.WriteLine("\t\t\t\"udid\": \"" + wpsdk.Replace('.', '-') + "-" + id + "\",");
Console.WriteLine("\t\t\t\"index\": " + id + ",");
Console.WriteLine("\t\t\t\"guid\": \"" + dev.Id + "\",");
Console.WriteLine("\t\t\t\"version\": \"" + dev.Version + "\","); // 6.3 for 8.1 emulators, 6.4 for 10 emulators, 2147483647.2147483647.2147483647.2147483647 for device
Console.WriteLine("\t\t\t\"uapVersion\": \"" + dev.UapVersion + "\","); // blank/empty for 8.1 emulators and device, 10.0.10586.0 for win 10 emulators
Console.WriteLine("\t\t\t\"wpsdk\": \"" + wpsdk + "\"");
Console.Write("\t\t}");
j++;
}
id++;
}
Console.WriteLine("\n\t]");
Console.WriteLine("}");
return(0);
}
// This won't just connect, it will launch the emulator!
if (command == "connect" || command == "launch")
{
if (udid == null)
{
return(showHelp("Missing device/emulator UDID"));
}
// TODO Validate that the udid is either our generated udid (i.e. 10-0-1), or it's GUID, or it's an integer index value!
int id = 0;
// Search devices for udid!
ConnectableDevice connectableDevice = null;
foreach (ConnectableDevice dev in deviceList)
{
// Is it a matching GUID, matching UDID or matching Index value?
if (dev.Id.Equals(udid) || (wpsdk.Replace('.', '-') + "-" + id).Equals(udid) || udid.Equals(id.ToString()))
{
connectableDevice = dev;
break;
}
id++;
}
if (connectableDevice == null)
{
return(showHelp(String.Format("Invalid device UDID '{0:D}'", udid)));
}
// ConnectableDevice throws an error when connecting to a physical Windows 10 device
// physical Windows 10 devices can be connected to using 127.0.0.1
if (command == "connect" && connectableDevice.Version.Major == 10 && !connectableDevice.IsEmulator())
{
Console.WriteLine("{");
Console.WriteLine("\t\"success\": true,");
Console.WriteLine("\t\"ip\": \"127.0.0.1\",");
Console.WriteLine("\t\"osVersion\": \"" + connectableDevice.Version.ToString() + "\"");
Console.WriteLine("}");
return(0);
}
try {
IDevice device = connectableDevice.Connect();
if (command == "launch")
{
IRemoteApplication app = device.GetApplication(appid);
app.Launch();
Console.WriteLine("{");
Console.WriteLine("\t\"success\": true");
Console.WriteLine("}");
}
else
{
string destinationIp;
string sourceIp;
int destinationPort;
device.GetEndPoints(0, out sourceIp, out destinationIp, out destinationPort);
var address = IPAddress.Parse(destinationIp);
ISystemInfo systemInfo = device.GetSystemInfo();
Version version = new Version(systemInfo.OSMajor, systemInfo.OSMinor, systemInfo.OSBuildNo);
Console.WriteLine("{");
Console.WriteLine("\t\"success\": true,");
Console.WriteLine("\t\"ip\": \"" + address.ToString() + "\",");
Console.WriteLine("\t\"port\": " + destinationPort.ToString() + ",");
Console.WriteLine("\t\"osVersion\": \"" + version.ToString() + "\",");
Console.WriteLine("\t\"availablePhysical\": " + systemInfo.AvailPhys.ToString() + ",");
Console.WriteLine("\t\"totalPhysical\": " + systemInfo.TotalPhys.ToString() + ",");
Console.WriteLine("\t\"availableVirtual\": " + systemInfo.AvailVirtual.ToString() + ",");
Console.WriteLine("\t\"totalVirtual\": " + systemInfo.TotalVirtual.ToString() + ",");
Console.WriteLine("\t\"architecture\": \"" + systemInfo.ProcessorArchitecture.ToString() + "\",");
Console.WriteLine("\t\"instructionSet\": \"" + systemInfo.InstructionSet.ToString() + "\",");
Console.WriteLine("\t\"processorCount\": " + systemInfo.NumberOfProcessors.ToString() + "");
Console.WriteLine("}");
}
return(0);
} catch (Exception ex) {
Console.WriteLine("{");
Console.WriteLine("\t\"success\": false,");
Console.WriteLine("\t\"message\": \"" + ex.Message.Trim().Replace("\"", "\\\"") + "\"");
Console.WriteLine("}");
return(1);
}
}
if (command != null)
{
return(showHelp(String.Format("Invalid command '{0}'", command)));
}
return(showHelp());
}
/// <summary>
/// Recherche d'un IRemoteFileInfo par son nom
/// </summary>
/// <param name="application"></param>
/// <param name="directoryParent"></param>
/// <param name="nameOfFileOrDirectory"></param>
/// <returns></returns>
public static IRemoteFileInfo SearchRemoteFileInfo(IRemoteApplication application, IRemoteFileInfo directoryParent, string nameOfFileOrDirectory)
{
if (application == null || string.IsNullOrWhiteSpace(nameOfFileOrDirectory) == true)
{
return null;
}
var isolatedStore = application.GetIsolatedStore();
if (isolatedStore != null)
{
string searchPattern = GetSearchPattern(application, directoryParent);
var result = GetRemoteFileInfos(application, searchPattern, null);
return result.FirstOrDefault(r => GetShortName(r) == nameOfFileOrDirectory);
}
return null;
}
public RemoteApplicationEx(IRemoteApplication remoteApplication)
{
RemoteApplication = remoteApplication;
}
public void UsePreInstalledApplication(string appPath)
{
var appManifest = Utils.ReadAppManifestInfoFromPackage(appPath);
this.RemoteApplication = this.Device.GetApplication(appManifest.ProductId);
}
