private bool AddNewProject()
{
var form = new ProjectWizard(false);
if (form.ShowDialog() == DialogResult.OK)
{
try
{
Cursor = Cursors.WaitCursor;
toolStripStatusText.Text = "Creating project...";
if (form.CopySourceFilesToTargetLocation)
{
FolderUtility.CopyRecursive(form.SourceLocation, form.ProjectLocation, FileExistsQuestion);
}
CrcsProject rsproj = CrcsProject.CreateProject(form.ProjectFileName, _solution);
rsproj.Save();
_solution.AddProject(rsproj);
return(true);
}
finally
{
Cursor = Cursors.Default;
}
}
return(false);
}
protected void Recompile(string compositFilePath, string inputFolder, CrcsProject project)
{
var ep = new ExecuteProgram();
var apiLevel = project.Properties.ApiLevel;
var arguments = new StringBuilder();
arguments.Append("-jar \"").Append(_smaliFile).Append("\"");
arguments.Append(" \"").Append(inputFolder).Append("\"");
string classesDexFile = Path.Combine(FolderUtility.CreateTempFolder(), "classes.dex");
arguments.Append(" -o \"").Append(classesDexFile).Append("\"");
if (_useSmaliApiLevel)
{
arguments.Append(" -a ").Append(apiLevel);
}
if (ep.Execute(_javaFile, arguments.ToString(), Path.GetDirectoryName(classesDexFile)) != 0)
{
throw ep.CreateException(Path.GetFileName(_smaliFile));
}
// add to program file apk/jar...
using (var zf = new AndroidArchive(compositFilePath))
{
zf.Add(classesDexFile, Path.GetFileName(classesDexFile));
}
}
private void OnLoaded()
{
if (InvokeRequired)
{
BeginInvoke(new Action(OnLoaded));
return;
}
try
{
Cursor = Cursors.WaitCursor;
var extension = (Path.GetExtension(_fileSystemPath) ?? "").ToUpperInvariant();
if (extension == ".RSSLN")
{
OpenSolution(_fileSystemPath);
}
else if (extension == ".RSPROJ")
{
bool solutionFound = false;
var fi = new FileInfo(_fileSystemPath);
var paths = new List <string>();
paths.Add(fi.Directory.FullName);
if (fi.Directory.Parent != null)
{
paths.Add(fi.Directory.Parent.FullName);
}
foreach (var path in paths)
{
foreach (var solution in Directory.GetFiles(path, "*.rssln"))
{
if (CrcsSolution.SolutionContainsProject(solution, _fileSystemPath))
{
OpenSolution(solution);
solutionFound = true;
}
}
}
if (!solutionFound)
{
var file = _fileSystemPath.Substring(0, _fileSystemPath.Length - 6) + "rssln";
_solution = CrcsSolution.CreateSolution(file);
_solution.AddProject(CrcsProject.OpenProject(_fileSystemPath, _solution));
solutionExplorer.SetSolution(_solution);
solutionExplorer.Refresh();
}
}
else
{
OpenFile(_fileSystemPath);
}
}
catch (Exception ex)
{
MessageEngine.ShowError(ex);
}
finally
{
Cursor = Cursors.Default;
}
}
public ProjectPropertiesEditor(CrcsProject project)
{
_project = project;
_buildDisplayId = project.Properties.BuildDisplayId;
_apiLevel = project.Properties.ApiLevel;
InitializeComponent();
labelTitle.Text = "Project '" + _project.Name + "' properties";
TabTitle = _project.Name;
TabToolTip = _project.FileSystemPath;
RefreshControls(project);
}
protected string GetLocationOfDependencies(CrcsProject project)
{
if (!_pathToDependencies.ContainsKey(project))
{
string pathToDependencies = "";
foreach (string path in project.LocationsOfDependencies)
{
pathToDependencies += " -d \"" + path + "\"";
}
_pathToDependencies.Add(project, pathToDependencies);
}
return(_pathToDependencies[project]);
}
private bool FindBootClassPathFile(string name, CrcsProject project, string missingClassName)
{
foreach (string location in project.LocationsOfDependencies)
{
string[] files = Directory.GetFiles(location, missingClassName + ".smali", SearchOption.AllDirectories);
if (files.Length > 0)
{
string folder = files[0].Substring(location.Length).TrimStart(Path.DirectorySeparatorChar).Substring(7).TrimStart(Path.DirectorySeparatorChar);
folder = folder.Split(Path.DirectorySeparatorChar)[0];
return(project.AddDependency(name, folder));
}
}
return(false);
}
private void MenuMainFileAddExistingProjectClick(object sender, EventArgs e)
{
try
{
OpenFileDialog ofd = FileUtility.CreateOpenFileDlg("", "Crcs project files (*.rsproj)|*.rsproj");
ofd.DefaultExt = "rsproj";
if (ofd.ShowDialog(this) == DialogResult.OK)
{
_solution.AddProject(CrcsProject.OpenProject(ofd.FileName, _solution));
solutionExplorer.Refresh();
}
}
catch (Exception ex)
{
MessageEngine.ShowError(ex);
}
}
private void RefreshControls(CrcsProject project)
{
try
{
_refreshingControls = true;
textBoxBuildDisplayId.Text = _buildDisplayId;
textBoxApiLevel.Text = _apiLevel;
checkBoxReSignApkFiles.Checked = project.Properties.ReSignApkFiles;
checkBoxIncludeInBuild.Checked = project.IncludeInBuild;
foreach (string file in _project.Properties.FrameWorkFiles)
{
listBoxFrameWorkFiles.Items.Add(Path.GetFileName(file) ?? "");
}
textBoxFrameWorkFile.Text = "";
}
finally
{
_refreshingControls = false;
}
}
public CrcsProject GetProject(ProjectTreeNode treeNode)
{
ProjectTreeNode node = treeNode;
if (node == null)
{
return(null);
}
CrcsProject proj = null;
while (node.Parent != null)
{
proj = node.ProjectItem as CrcsProject;
if (proj != null)
{
return(proj);
}
node = node.Parent as ProjectTreeNode;
}
return(proj);
}
public bool CanIncludeSelectedTreeNodes()
{
CrcsProject project = null;
if (SelectedNodes.Count() == 0)
{
return(false);
}
foreach (ProjectTreeNode node in SelectedNodes)
{
if (node.IsSolution || node.IsProject)
{
return(false);
}
if (node.IsIncluded)
{
return(false);
}
CrcsProject proj = GetProject(node);
if (project == null)
{
project = proj;
}
else if (!ReferenceEquals(proj, project))
{
return(false);
}
if (node.ProjectItem == null)
{
return(false);
}
if (node.ProjectItem.IsIncluded)
{
return(false);
}
}
return(true);
}
protected bool FindMissingDependency(string name, CrcsProject project, string baksmaliOutput)
{
string[] bootClassPathArray = GetBootClassPath(baksmaliOutput);
if (bootClassPathArray.Length == 0)
{
return(false);
}
if (bootClassPathArray[0].Equals("junit", StringComparison.OrdinalIgnoreCase) &&
project.LocationsOfDependencies.FirstOrDefault(x => File.Exists(Path.Combine(x, "core-junit.jar"))) !=
null)
{
return(project.AddDependency(name, "core-junit.jar"));
}
string missingClassName = bootClassPathArray[bootClassPathArray.Length - 1];
if (FindBootClassPathFile(name, project, missingClassName))
{
return(true);
}
int start = 0;
int count = bootClassPathArray.Length - 1;
while (count > 0)
{
string bootClassPath = string.Join(".", bootClassPathArray, start, count) + ".jar";
if (project.LocationsOfDependencies.FirstOrDefault(x => File.Exists(Path.Combine(x, bootClassPath))) !=
null)
{
return(project.AddDependency(name, bootClassPath));
}
start++;
count--;
}
return(false);
}
public QuestionForm(IEnumerable <IProjectFile> files, CrcsSolution solution)
{
InitializeComponent();
var dict = new Dictionary <string, List <IProjectFile> >();
foreach (IProjectFile file in files)
{
if (file is CrcsSolution)
{
continue;
}
CrcsProject rsproj = file as CrcsProject ?? file.Project;
string projName = rsproj == null ? "Misc Files" : rsproj.FileName;
if (!dict.ContainsKey(projName))
{
dict.Add(projName, new List <IProjectFile>());
}
if (!ReferenceEquals(file, rsproj))
{
dict[projName].Add(file);
}
}
var sb = new StringBuilder();
sb.AppendLine(solution.FileName);
foreach (string rsproj in dict.Keys)
{
sb.Append("\t").AppendLine(rsproj);
foreach (IProjectFile file in dict[rsproj])
{
sb.Append("\t\t").AppendLine(file.RelativePath);
}
}
textBox1.Text = sb.ToString();
textBox1.SelectionStart = textBox1.Text.Length;
}
public IEnumerable <string> GetExpandedTreeNodes(CrcsProject project)
{
return
(_nodes.Where(x => x.IsExpanded && (x.IsFolder || x.IsProject) && ReferenceEquals(x.ProjectItem.Project, project)).Select(
x => x.FileSystemPath).ToArray());
}
public MissingItem(string fileSystemPath, bool isFolder, CrcsProject project) : base(fileSystemPath, project)
{
_isIncluded = true;
_isFolder = isFolder;
}
public ProjectFolder(string fileSystemPath, bool included, CrcsProject project) : base(fileSystemPath, project)
{
_isIncluded = included;
_isFolder = true;
}
public void RefreshProjectNode(ProjectTreeNode rootNode)
{
if (rootNode == null)
{
return;
}
if (!Directory.Exists(rootNode.ParentFolder))
{
return;
}
if (InvokeRequired)
{
BeginInvoke(new Action <ProjectTreeNode>(RefreshProjectNode), rootNode);
return;
}
CrcsProject rsproj = GetProject(rootNode);
var folderStack = new Stack <ProjectTreeNode>();
folderStack.Push(rootNode);
int index = 1;
while (folderStack.Count > 0)
{
ProjectTreeNode childNode;
ProjectTreeNode node = folderStack.Pop();
string fileSystemPath = node.FolderPath;
foreach (string subFolder in Directory.GetDirectories(fileSystemPath))
{
if (FolderUtility.IsSystemFolder(subFolder))
{
continue;
}
string name = Path.GetFileName(subFolder);
if (name == ".rsproj")
{
continue;
}
bool isFolderIncluded = rsproj.IsFolderIncluded(subFolder);
childNode = node.Nodes.OfType <ProjectTreeNode>().FirstOrDefault(x => x.Text == name);
if (!isFolderIncluded && !ShowExcludedItems)
{
if (childNode != null)
{
RemoveNode(childNode);
}
continue;
}
if (childNode == null)
{
childNode = new ProjectTreeNode(new ProjectFolder(subFolder, isFolderIncluded, rsproj),
_iconManager);
_nodes.Add(childNode);
node.Nodes.Insert(index, childNode);
}
else
{
childNode.IsIncluded = isFolderIncluded;
childNode.RefreshIcon();
}
index++;
folderStack.Push(childNode);
}
foreach (IProjectItem projectFile in rsproj.GetProjectFiles(fileSystemPath))
{
childNode = projectFile.TreeNode;
if (!projectFile.IsIncluded && (!ShowExcludedItems || projectFile.IsDeleted || !projectFile.Exists))
{
if (childNode != null)
{
RemoveNode(childNode);
}
if (!projectFile.IsIncluded && !projectFile.Exists)
{
rsproj.RemoveMissingItem(projectFile.FileSystemPath);
}
continue;
}
if (childNode == null)
{
childNode = new ProjectTreeNode(projectFile, _iconManager);
_nodes.Add(childNode);
node.Nodes.Insert(index, childNode);
}
else
{
if (!projectFile.IsIncluded)
{
RemoveChildNodes(childNode);
}
childNode.RefreshIcon();
}
index++;
if (!projectFile.IsIncluded)
{
continue;
}
var compositFile = projectFile as CompositFile;
if (compositFile == null)
{
continue;
}
// compositFile.TreeNode.Collapse();
if (compositFile.IsDeCompiled)
{
if (compositFile.ClassesTreeNode == null)
{
var projectTreeNode =
new ProjectTreeNode(new ProjectFolder(compositFile.ClassesFolder, true, rsproj),
_iconManager);
_nodes.Add(projectTreeNode);
childNode.Nodes.Add(projectTreeNode);
}
else
{
foreach (ProjectTreeNode cstChild in compositFile.ClassesTreeNode.Nodes)
{
RemoveNode(cstChild, true);
}
}
}
else if (compositFile.ClassesTreeNode != null)
{
RemoveNode(compositFile.ClassesTreeNode);
}
var apkFile = projectFile as ApkFile;
if (apkFile == null)
{
continue;
}
if (apkFile.IsDeCoded)
{
if (apkFile.ResourceTreeNode == null)
{
var projectTreeNode =
new ProjectTreeNode(new ProjectFolder(apkFile.ResourceFolder, true, rsproj),
_iconManager);
_nodes.Add(projectTreeNode);
childNode.Nodes.Add(projectTreeNode);
}
else
{
foreach (ProjectTreeNode rstChild in apkFile.ResourceTreeNode.Nodes)
{
RemoveNode(rstChild, true);
}
}
}
else if (apkFile.ResourceTreeNode != null)
{
RemoveNode(apkFile.ResourceTreeNode);
}
}
index = 0;
}
}
public ProjectFolder(string fileSystemPath, bool included, CrcsProject project) : base(fileSystemPath, project)
{
_isIncluded = included;
_isFolder = true;
}
public JarFile(string fileSystemPath, bool included, CrcsProject project)
: base(fileSystemPath, included, project)
{
}
protected void Decompile(string name, string classesFile, string outputFolder, bool ignoreDecompileErrors, CrcsProject project)
{
var ep = new ExecuteProgram();
string locationOfDependencies = GetLocationOfDependencies(project);
var apiLevel = project.Properties.ApiLevel;
bool decompiled = false;
bool useIgnoreDecompileErrorsFlag = false;
while (!decompiled)
{
string additionalDependencies = project.GetAdditionalDependencies(name).Aggregate("",
(current, dependency)
=>
current +
(":" + dependency));
if (additionalDependencies.Length > 0)
{
additionalDependencies = " -c " + additionalDependencies;
}
var arguments = new StringBuilder();
arguments.Append("-Xmx512m -jar \"").Append(_baksmaliFile).Append("\"");
arguments.Append(locationOfDependencies);
arguments.Append(" -o \"").Append(outputFolder).Append("\"");
if (useIgnoreDecompileErrorsFlag)
{
arguments.Append(" -I");
}
arguments.Append(" -l -s");
arguments.Append(additionalDependencies);
if ((Path.GetExtension(classesFile) ?? "").ToUpperInvariant() == ".ODEX")
{
arguments.Append(" -x");
}
arguments.Append(" \"").Append(classesFile).Append("\"");
if (_useBaksmaliApiLevel)
{
arguments.Append(" -a ").Append(apiLevel);
}
if (ep.Execute(_javaFile, arguments.ToString(), Path.GetDirectoryName(classesFile)) == 0)
{
if (useIgnoreDecompileErrorsFlag)
{
MessageEngine.AddInformation(this, ep.Output);
}
decompiled = true;
}
else
{
if (!FindMissingDependency(name, project, ep.Output))
{
if (ignoreDecompileErrors)
{
useIgnoreDecompileErrorsFlag = true;
}
else
{
throw ep.CreateException(Path.GetFileName(_baksmaliFile));
}
}
}
}
}
public MissingItem(string fileSystemPath, bool isFolder, CrcsProject project) : base(fileSystemPath, project)
{
_isIncluded = true;
_isFolder = isFolder;
}
public JarFile(string fileSystemPath, bool included, CrcsProject project)
: base(fileSystemPath, included, project)
{
}
