public FileInfo CppJniReflectionJavaP(string file, string currDir, string directory = "")
{
lock (this)
{
JavaCppReflectionOutput = "";
CurrentCppReflectionFile = Path.Combine(currDir, file);
if (!CurrentCppReflectionFile.Contains(".class"))
{
CurrentCppReflectionFile += ".class";
}
else if (CurrentCppReflectionFile == "")
{
CurrentCppReflectionFile = file;
}
JavaCppReflectionProcess = new Process();
JavaCppReflectionMessageBox = new MessageScreenScrollable();
JavaCppReflectionMessageBox.Text = "javap Output";
JavaCppReflectionMessageBox.AddOnCloseDelegate(JavaCppReflectionProcess_Exit);
JavaCppReflectionProcess.Exited += new EventHandler(JavaCppReflectionProcess_Exited);
JavaCppReflectionProcess.OutputDataReceived += new DataReceivedEventHandler(JavaCppReflectionProcess_OutputDataReceived);
JavaCppReflectionProcess.ErrorDataReceived += new DataReceivedEventHandler(JavaCppReflectionProcess_ErrorDataReceived);
try
{
JavaCppReflectionMessageBox.Show();
JavaCppReflectionMessageBox.AppendText("Processing 1 File\n");
JavaCppReflectionMessageBox.AppendText("Calling argument:\n" + MainWindow.Instance.SelectedJdkEnvironment.JavaPLocation + " -s " + file + "\nWorking Directory:\t" + currDir + "\n\n----------------\n");
JavaCppReflectionProcess.StartInfo = new ProcessStartInfo(MainWindow.Instance.SelectedJdkEnvironment.JavaPLocation);
JavaCppReflectionProcess.StartInfo.WindowStyle = ProcessWindowStyle.Minimized;
JavaCppReflectionProcess.StartInfo.WorkingDirectory = currDir;
JavaCppReflectionProcess.StartInfo.Arguments = "-s " + file;
JavaCppReflectionProcess.StartInfo.UseShellExecute = false;
JavaCppReflectionProcess.StartInfo.CreateNoWindow = true;
JavaCppReflectionProcess.StartInfo.RedirectStandardOutput = true;
JavaCppReflectionProcess.StartInfo.RedirectStandardError = true;
JavaCppReflectionProcess.Start();
JavaCppReflectionProcess.BeginOutputReadLine();
JavaCppReflectionProcess.BeginErrorReadLine();
}
catch (Exception e) { }
}
return null;
}
private void RunReadElfButton_Click(object sender, EventArgs e)
{
ReadElfProcess = new Process();
string args = CheckBoxes();
ReadElfMessageBox = new MessageScreenScrollable();
ReadElfMessageBox.Text = "readelf Utility Output (" + args + " )";
ReadElfMessageBox.ColorFormatting = false;
ReadElfMessageBox.AddOnCloseDelegate(StringsProcess_Exit);
ReadElfProcess.Exited += new EventHandler(StringsProcess_Exited);
ReadElfProcess.OutputDataReceived += new DataReceivedEventHandler(StringsProcess_OutputDataReceived);
ReadElfProcess.ErrorDataReceived += new DataReceivedEventHandler(StringsProcess_ErrorDataReceived);
string readElfExec = NdkEnvironment.GetBinUtilsPrefixForArchitcture(SelectedArch);
if (NUtilityGlobalContext.OSType == (int)NUtilityGlobalContext.OS.Windows)
{
readElfExec += "readelf.exe";
}
else
{
readElfExec += "readelf";
}
ReadElfMessageBox.Show();
ReadElfProcess.StartInfo = new ProcessStartInfo(readElfExec);
ReadElfProcess.StartInfo.WindowStyle = ProcessWindowStyle.Minimized;
ReadElfProcess.StartInfo.WorkingDirectory = BinaryFile.Directory.FullName;
ReadElfProcess.StartInfo.Arguments = args + " " + BinaryFile.FullName;
ReadElfProcess.StartInfo.UseShellExecute = false;
ReadElfProcess.StartInfo.CreateNoWindow = true;
ReadElfProcess.StartInfo.RedirectStandardOutput = true;
ReadElfProcess.StartInfo.RedirectStandardError = true;
ReadElfProcess.Start();
ReadElfProcess.BeginOutputReadLine();
ReadElfProcess.BeginErrorReadLine();
}
public static void JavaHBatchForProjectModule(ref ProjectEnvironment.ProjectModule tanner, ref MessageScreenScrollable mockConsole, FileInfo javaH)
{
string arg = "-classpath ";
string classPaths = "";
ProjectEnvironment project = tanner.Project;
List<string> allClasses = new List<string>();
int numberOfClasses = 0;
foreach (ProjectEnvironment.ProjectModule module in project.ProjectModules)
{
classPaths += module.JavaBinDirectory + Path.PathSeparator;
allClasses.AddRange(module.JniClasses);
}
arg += classPaths.Substring(0, classPaths.Length - 1) + " -d jni ";
numberOfClasses = allClasses.Count;
if (mockConsole != null)
{
mockConsole.AppendText(Environment.NewLine + "found " + numberOfClasses + " classes with native methods");
}
RunBatch(allClasses.ToArray(), arg, javaH.FullName, tanner.ModuleRootDirectory, ref mockConsole);
}
public void CreateCppReflection()
{
if (JavaPOutput == null)
{
MainWindow.PrintMessageInMessageBoxInst("Tried to Generate C++ JNI Reflection code from file without Javap output!", context: MESSAGE_CONTEXT, severity: (int)nUtility.MainWindow.TextSeverity.ERROR);
return;
}
else
{
JavaPToCppMessageWindow = new MessageScreenScrollable();
JavaPToCppMessageWindow.Text = "C++ JNI Reflection for \"" + ReadableClassName + "\"";
JavaPToCppMessageWindow.Show();
JavaPToCppMessageWindow.AddOnCloseDelegate(JavaPToCppMessageWindow_OnClose);
BackgroundRegexThread = new Thread(new ThreadStart(CppReflectionProcessing)); // Do processing on background thread in order to not freeze up UI
BackgroundRegexThread.Start();
}
}
public JavaHBatchIncrementer(int size, ref MessageScreenScrollable mockConsole)
{
Progress = 0;
Count = size;
}
public static void RunBatch(string[] files, string[] args, string javaH, string[] cwd, ref MessageScreenScrollable mockConsole)
{
if (files == null)
{
return;
}
if (args == null)
{
return;
}
if (cwd == null)
{
return;
}
if (files.Length != args.Length || files.Length != cwd.Length)
{
return;
}
int numberOfFiles = files.Length;
JavaHBatchEntry[] batches = new JavaHBatchEntry[numberOfFiles];
Thread[] threads = new Thread[numberOfFiles];
JavaHBatchIncrementer incrementer = new JavaHBatchIncrementer(numberOfFiles, ref mockConsole);
for (int i = 0; i < numberOfFiles; i++)
{
FileInfo file = new FileInfo(files[i]);
batches[i] = new JavaHBatchEntry(file, args[i], javaH, cwd[i], ref mockConsole, ref threads[i], ref incrementer);
batches[i].Execute();
}
while (!AllThreadsDone(threads))
{
Thread.Sleep(1000);
}
}
public static void RunBatch(string[] files, string arg, string javaH, string cwd, ref MessageScreenScrollable mockConsole)
{
if (files == null)
{
return;
}
int numberOfFiles = files.Length;
JavaHBatchEntry[] batches = new JavaHBatchEntry[numberOfFiles];
Thread[] threads = new Thread[numberOfFiles];
JavaHBatchIncrementer incrementer = new JavaHBatchIncrementer(numberOfFiles, ref mockConsole);
for (int i = 0; i < numberOfFiles; i++)
{
FileInfo file = new FileInfo(files[i]);
batches[i] = new JavaHBatchEntry(file, arg, javaH, cwd, ref mockConsole, ref threads[i], ref incrementer);
batches[i].Execute();
}
while (!AllThreadsDone(threads))
{
if (mockConsole != null)
{
mockConsole.AppendText(Environment.NewLine + "...");
}
Thread.Sleep(1000);
}
}
public JavaHBatchEntry(FileInfo _file, string _args, string _javaHExec, string _workingDirectory, ref MessageScreenScrollable _mockConsole, ref Thread _runOnThread, ref JavaHBatchIncrementer _incrementer)
{
ClassFile = _file;
Args = _args;
JavaHExec = _javaHExec;
WorkingDirectory = _workingDirectory;
MockConsole = _mockConsole;
RunOnThread = _runOnThread;
Incrementer = _incrementer;
}
private void NdkStack()
{
ProjectEnvironment.ProjectModule theModule = ((ProjectEnvironment.ProjectModule)AndroidStudioModuleComboBox.SelectedItem);
NdkStackProcess = new Process();
NdkStackWindow = new MessageScreenScrollable();
NdkStackWindow.ColorFormatting = false;
NdkStackWindow.AddOnCloseDelegate(NdkStackProcess_Exit);
NdkStackWindow.Text = "(NDK) Stack Output";
NdkStackWindow.Show();
string ndk_stack = "";
if (NUtilityGlobalContext.OSType == (int)NUtilityGlobalContext.OS.Windows)
{
ndk_stack = Path.Combine(SelectedNdkEnvironment.RootDirectory, "ndk-stack.exe");
}
else
{
ndk_stack = Path.Combine(SelectedNdkEnvironment.RootDirectory, "ndk-stack");
}
try
{
NdkStackProcess.Exited += new EventHandler(NdkStackProcess_Exited);
NdkStackProcess.OutputDataReceived += new DataReceivedEventHandler(NdkStackProcess_OutputDataReceived);
NdkStackProcess.ErrorDataReceived += new DataReceivedEventHandler(NdkStackProcess_ErrorDataReceived);
NdkStackProcess.StartInfo = new ProcessStartInfo(ndk_stack);
NdkStackProcess.StartInfo.WindowStyle = ProcessWindowStyle.Minimized;
NdkStackProcess.StartInfo.WorkingDirectory = theModule.ModuleRootDirectory;
NdkStackProcess.StartInfo.Arguments = "-sym " + theModule.BinDirectory + Path.DirectorySeparatorChar + "local" + Path.DirectorySeparatorChar + ArchBinaryList.SelectedText;
NdkStackProcess.StartInfo.UseShellExecute = false;
NdkStackProcess.StartInfo.CreateNoWindow = true;
NdkStackProcess.StartInfo.RedirectStandardInput = true;
NdkStackProcess.StartInfo.RedirectStandardOutput = true;
NdkStackProcess.StartInfo.RedirectStandardError = true;
NdkStackProcess.Start();
NdkStackProcess.BeginOutputReadLine();
NdkStackProcess.BeginErrorReadLine();
}
catch (Exception e) { }
}
private void CleanButton_Click(object sender, EventArgs e)
{
ICommandCommunicator mockConsole = new MessageScreenScrollable();
List<Command> commands = new List<Command>();
mockConsole.SetName("(NDK-Build clean) Output");
try
{
MessageScreenScrollable msg = (MessageScreenScrollable)mockConsole;
msg.Show();
}
catch (Exception ex) { }
ProjectEnvironmentContext ctx = GetProjectContext();
NdkBuild verbose = new NdkBuild(ref mockConsole, ref ctx, ref SelectedProjectModule);
verbose.SetCommand(NdkBuild.Defaults.CLEAN);
commands.Add(new NdkBuild(ref mockConsole, ref ctx, ref SelectedProjectModule));
BuildCommandDispatch dispatch = new BuildCommandDispatch(ref mockConsole, commands);
dispatch.Execute();
}
private void GenerateCppCodeToolStripMenuItem_Click(object sender, EventArgs e)
{
// public DexToJni(ref ICommandCommunicator communicator, ref ProjectEnvironmentContext context, ref ProjectEnvironment.ProjectModule module, List<string> filesAndDirs, string additionalArgs = "", bool printInfo = true)
// : base(ref communicator, ref context)
List<string> files = new List<string>();
foreach (TreeNode node in JavaClassFileTreeView.Nodes)
{
GetAllClickedFileNodes(node, ref files);
}
ICommandCommunicator mockConsole = new MessageScreenScrollable();
List<Command> commands = new List<Command>();
mockConsole.SetName("DexToJni Output");
try
{
MessageScreenScrollable msg = (MessageScreenScrollable)mockConsole;
msg.Show();
}
catch (Exception ex) { }
ProjectEnvironmentContext ctx = GetProjectContext();
DexToJni build = new DexToJni(ref mockConsole, ref ctx, ref SelectedProjectModule, ref files);
build.SetArgs(new FileInfo(SelectedSdkEnvironment.DexDumpExecLocation), NUtilityGlobalContext.DexToJniExecLocation, new DirectoryInfo(Path.Combine(SelectedProjectModule.ModuleRootDirectory, "DexToJni Output")));
commands.Add(build);
BuildCommandDispatch dispatch = new BuildCommandDispatch(ref mockConsole, commands);
dispatch.Execute();
}
// Returns StdOut from javap for the given argumenbt in the current directory
private void Javap(string arg, string currDir, int numFiles)
{
JavaPProcess = new Process();
JavaPMessageBox = new MessageScreenScrollable();
JavaPMessageBox.Text = "javap Output";
JavaPMessageBox.AddOnCloseDelegate(JavaPProcess_Exit);
JavaPProcess.Exited += new EventHandler(JavaPProcess_Exited);
JavaPProcess.OutputDataReceived += new DataReceivedEventHandler(JavaPProcess_OutputDataReceived);
JavaPProcess.ErrorDataReceived += new DataReceivedEventHandler(JavaPProcess_ErrorDataReceived);
try
{
JavaPMessageBox.Show();
if (numFiles == 1)
{
JavaPMessageBox.AppendText("Processing 1 File\n");
}
else
{
JavaPMessageBox.AppendText("Processing " + numFiles + " Files\n");
}
JavaPMessageBox.AppendText("Calling argument:\n" + MainWindow.Instance.SelectedJdkEnvironment.JavaPLocation + " -s " + arg + "\nWorking Directory:\t" + currDir + "\n\n----------------\n");
JavaPProcess.StartInfo = new ProcessStartInfo(MainWindow.Instance.SelectedJdkEnvironment.JavaPLocation);
JavaPProcess.StartInfo.WindowStyle = ProcessWindowStyle.Minimized;
JavaPProcess.StartInfo.WorkingDirectory = currDir;
JavaPProcess.StartInfo.Arguments = "-s " + arg;
JavaPProcess.StartInfo.UseShellExecute = false;
JavaPProcess.StartInfo.CreateNoWindow = true;
JavaPProcess.StartInfo.RedirectStandardOutput = true;
JavaPProcess.StartInfo.RedirectStandardError = true;
JavaPProcess.Start();
JavaPProcess.BeginOutputReadLine();
JavaPProcess.BeginErrorReadLine();
}
catch (Exception e) {}
}
