@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.line_list);
// Setup the list
adapter = new IconAdapter<FileWrapper>(this, R.layout.line_list_item);
ListView list = (ListView) findViewById(R.id.list);
list.setAdapter(adapter);
list.setOnItemClickListener(this);
// Load Directory
if (savedInstanceState != null) {
backStack = savedInstanceState.getParcelableArrayList("BACKSTACK");
}
if (backStack == null || backStack.size() == 0) {
backStack = new ArrayList<BackStackItem>();
String startPath =
(startDirectory == null || startDirectory.isEmpty())
? Environment.getExternalStorageDirectory().getPath()
: startDirectory;
backStack.add(new BackStackItem(startPath, false));
}
wrapFiles();
this.setVolumeControlStream(AudioManager.STREAM_MUSIC);
}
private ThreadReference findThread(String idToken) throws NoSessionException {
String id;
ThreadReference thread = null;
if (idToken.startsWith("t@")) {
id = idToken.substring(2);
} else {
id = idToken;
}
try {
ThreadReference[] threads = threads();
long threadID = Long.parseLong(id, 16);
for (ThreadReference thread2 : threads) {
if (thread2.uniqueID() == threadID) {
thread = thread2;
break;
}
}
if (thread == null) {
// env.failure("No thread for id \"" + idToken + "\"");
env.failure("\"" + idToken + "\" is not a valid thread id.");
}
} catch (NumberFormatException e) {
env.error("Thread id \"" + idToken + "\" is ill-formed.");
thread = null;
}
return thread;
}
private void commandMethods(StringTokenizer t) throws NoSessionException {
if (!t.hasMoreTokens()) {
env.error("No class specified.");
return;
}
String idClass = t.nextToken();
ReferenceType cls = findClass(idClass);
if (cls != null) {
List<Method> methods = cls.allMethods();
OutputSink out = env.getOutputSink();
for (int i = 0; i < methods.size(); i++) {
Method method = methods.get(i);
out.print(method.declaringType().name() + " " + method.name() + "(");
Iterator<String> it = method.argumentTypeNames().iterator();
if (it.hasNext()) {
while (true) {
out.print(it.next());
if (!it.hasNext()) {
break;
}
out.print(", ");
}
}
out.println(")");
}
out.show();
} else {
// ### Should validate class name syntax.
env.failure("\"" + idClass + "\" is not a valid id or class name.");
}
}
/** Command: unmonitor Unmonitor an expression */
private void commandUnmonitor(StringTokenizer t) throws NoSessionException {
if (!t.hasMoreTokens()) {
env.error("Argument required");
} else {
env.getMonitorListModel().remove(t.nextToken(""));
}
}
private void commandKill(StringTokenizer t) throws NoSessionException {
// ### Should change the way in which thread ids and threadgroup names
// ### are distinguished.
if (!t.hasMoreTokens()) {
env.error("Usage: kill <threadgroup name> or <thread id>");
return;
}
while (t.hasMoreTokens()) {
String idToken = t.nextToken();
ThreadReference thread = findThread(idToken);
if (thread != null) {
runtime.stopThread(thread);
env.notice("Thread " + thread.name() + " killed.");
return;
} else {
/* Check for threadgroup name, NOT skipping "system". */
// ### Should skip "system"? Classic 'jdb' does this.
// ### Should deal with possible non-uniqueness of threadgroup names.
ThreadGroupIterator itg = allThreadGroups();
while (itg.hasNext()) {
ThreadGroupReference tg = itg.nextThreadGroup();
if (tg.name().equals(idToken)) {
ThreadIterator it = new ThreadIterator(tg);
while (it.hasNext()) {
runtime.stopThread(it.nextThread());
}
env.notice("Threadgroup " + tg.name() + "killed.");
return;
}
}
env.failure("\"" + idToken + "\" is not a valid threadgroup or id.");
}
}
}
void accept(Environment env) throws TemplateException, IOException {
boolean processedCase = false;
Iterator iterator = nestedElements.iterator();
try {
while (iterator.hasNext()) {
Case cas = (Case) iterator.next();
boolean processCase = false;
// Fall through if a previous case tested true.
if (processedCase) {
processCase = true;
} else if (!cas.isDefault) {
// Otherwise, if this case isn't the default, test it.
ComparisonExpression equalsOp =
new ComparisonExpression(testExpression, cas.expression, "==");
processCase = equalsOp.isTrue(env);
}
if (processCase) {
env.visit(cas);
processedCase = true;
}
}
// If we didn't process any nestedElements, and we have a default,
// process it.
if (!processedCase && defaultCase != null) {
env.visit(defaultCase);
}
} catch (BreakInstruction.Break br) {
}
}
@Override
@SuppressWarnings({"unchecked", "rawtypes"})
public void execute(
Environment env, Map params, TemplateModel[] loopVars, TemplateDirectiveBody body)
throws TemplateException, IOException {
Site site = FrontUtils.getSite(env);
List<Content> list = getList(params, env);
Map<String, TemplateModel> paramWrap = new HashMap<String, TemplateModel>(params);
paramWrap.put(OUT_LIST, DEFAULT_WRAPPER.wrap(list));
Map<String, TemplateModel> origMap = DirectiveUtils.addParamsToVariable(env, paramWrap);
InvokeType type = DirectiveUtils.getInvokeType(params);
String listStyle = DirectiveUtils.getString(PARAM_STYLE_LIST, params);
if (InvokeType.sysDefined == type) {
if (StringUtils.isBlank(listStyle)) {
throw new ParamsRequiredException(PARAM_STYLE_LIST);
}
env.include(TPL_STYLE_LIST + listStyle + TPL_SUFFIX, UTF8, true);
} else if (InvokeType.userDefined == type) {
if (StringUtils.isBlank(listStyle)) {
throw new ParamsRequiredException(PARAM_STYLE_LIST);
}
FrontUtils.includeTpl(TPL_STYLE_LIST, site, env);
} else if (InvokeType.custom == type) {
FrontUtils.includeTpl(TPL_NAME, site, params, env);
} else if (InvokeType.body == type) {
body.render(env.getOut());
} else {
throw new RuntimeException("invoke type not handled: " + type);
}
DirectiveUtils.removeParamsFromVariable(env, paramWrap, origMap);
}
private void commandClear(StringTokenizer t) throws NoSessionException {
if (!t.hasMoreTokens()) {
// Print set breakpoints
listEventRequests();
return;
}
// ### need 'clear all'
BreakpointSpec bpSpec = parseBreakpointSpec(t.nextToken());
if (bpSpec != null) {
List<EventRequestSpec> specs = runtime.eventRequestSpecs();
if (specs.isEmpty()) {
env.notice("No breakpoints set.");
} else {
List<EventRequestSpec> toDelete = new ArrayList<EventRequestSpec>();
for (EventRequestSpec spec : specs) {
if (spec.equals(bpSpec)) {
toDelete.add(spec);
}
}
// The request used for matching should be found
if (toDelete.size() <= 1) {
env.notice("No matching breakpoint set.");
}
for (EventRequestSpec spec : toDelete) {
runtime.delete(spec);
}
}
} else {
env.error("Ill-formed breakpoint specification.");
}
}
private void commandStop(StringTokenizer t) throws NoSessionException {
String token;
if (!t.hasMoreTokens()) {
listEventRequests();
} else {
token = t.nextToken();
// Ignore optional "at" or "in" token.
// Allowed for backward compatibility.
if (token.equals("at") || token.equals("in")) {
if (t.hasMoreTokens()) {
token = t.nextToken();
} else {
env.error("Missing breakpoint specification.");
return;
}
}
BreakpointSpec bpSpec = parseBreakpointSpec(token);
if (bpSpec != null) {
// ### Add sanity-checks for deferred breakpoint.
runtime.install(bpSpec);
} else {
env.error("Ill-formed breakpoint specification.");
}
}
}
public CommandInterpreter(Environment env, boolean echo) {
this.env = env;
this.echo = echo;
this.runtime = env.getExecutionManager();
this.context = env.getContextManager();
this.classManager = env.getClassManager();
this.sourceManager = env.getSourceManager();
}
private void dumpStack(ThreadReference thread, boolean showPC) {
// ### Check for these.
// env.failure("Thread no longer exists.");
// env.failure("Target VM must be in interrupted state.");
// env.failure("Current thread isn't suspended.");
// ### Should handle extremely long stack traces sensibly for user.
List<StackFrame> stack = null;
try {
stack = thread.frames();
} catch (IncompatibleThreadStateException e) {
env.failure("Thread is not suspended.");
}
// ### Fix this!
// ### Previously mishandled cases where thread was not current.
// ### Now, prints all of the stack regardless of current frame.
int frameIndex = 0;
// int frameIndex = context.getCurrentFrameIndex();
if (stack == null) {
env.failure("Thread is not running (no stack).");
} else {
OutputSink out = env.getOutputSink();
int nFrames = stack.size();
for (int i = frameIndex; i < nFrames; i++) {
StackFrame frame = stack.get(i);
Location loc = frame.location();
Method meth = loc.method();
out.print(" [" + (i + 1) + "] ");
out.print(meth.declaringType().name());
out.print('.');
out.print(meth.name());
out.print(" (");
if (meth.isNative()) {
out.print("native method");
} else if (loc.lineNumber() != -1) {
try {
out.print(loc.sourceName());
} catch (AbsentInformationException e) {
out.print("<unknown>");
}
out.print(':');
out.print(loc.lineNumber());
}
out.print(')');
if (showPC) {
long pc = loc.codeIndex();
if (pc != -1) {
out.print(", pc = " + pc);
}
}
out.println();
}
out.show();
}
}
private void commandNext() throws NoSessionException {
ThreadReference current = context.getCurrentThread();
if (current == null) {
env.failure("No current thread.");
return;
}
try {
runtime.stepOverLine(current);
} catch (AbsentInformationException e) {
env.failure(
"No linenumber information available -- " + "Try \"nexti\" to step by instructions.");
}
}
private void commandThreadGroup(StringTokenizer t) throws NoSessionException {
if (!t.hasMoreTokens()) {
env.error("Threadgroup name not specified.");
return;
}
String name = t.nextToken();
ThreadGroupReference tg = findThreadGroup(name);
if (tg == null) {
env.failure(name + " is not a valid threadgroup name.");
} else {
// ### Should notify user.
setDefaultThreadGroup(tg);
}
}
private void listEventRequests() throws NoSessionException {
// Print set breakpoints
List<EventRequestSpec> specs = runtime.eventRequestSpecs();
if (specs.isEmpty()) {
env.notice("No breakpoints/watchpoints/exceptions set.");
} else {
OutputSink out = env.getOutputSink();
out.println("Current breakpoints/watchpoints/exceptions set:");
for (EventRequestSpec bp : specs) {
out.println("\t" + bp);
}
out.show();
}
}
private void commandConnect(StringTokenizer t) {
try {
LaunchTool.queryAndLaunchVM(runtime);
} catch (VMLaunchFailureException e) {
env.failure("Attempt to connect failed.");
}
}
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
if (Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState())) {
// We can read and write the media
try {
url = (String) getIntent().getExtras().get(Intent.EXTRA_TEXT) + "#view:list";
} catch (Exception e) {
url = "https://www.dropbox.com/s/8owsfcia59ko76i#view:list";
// Used for testing if it's not opened from the dropox action menu
// Obviously what needs to happen here is a message suggesting that the user use the dropbox
// app, and a textbox in case they've got the url copied.
}
showDialog(
PROGRESS_DIALOG); // Do the work in a separate thread so we can update the UI
// simultaneously.
} else {
// Can't write files, so show a message and quit.
}
}
private static Properties searchPropertiesForEnvironment(
String envName, EnvParamDescriptor descriptor) {
Properties properties = new Properties();
try {
List<Environment> environments = descriptor.getEnvironments();
for (Environment environment : environments) {
if (environment.getName().equals(envName)) {
properties.load(new StringReader(environment.getProperties()));
break;
}
}
} catch (IOException e) {
// never happened
}
return properties;
}
private void commandWhere(StringTokenizer t, boolean showPC) throws NoSessionException {
ThreadReference current = context.getCurrentThread();
if (!t.hasMoreTokens()) {
if (current == null) {
env.error("No thread specified.");
return;
}
dumpStack(current, showPC);
} else {
String token = t.nextToken();
if (token.toLowerCase().equals("all")) {
ThreadIterator it = allThreads();
while (it.hasNext()) {
ThreadReference thread = it.next();
out.println(thread.name() + ": ");
dumpStack(thread, showPC);
}
} else {
ThreadReference thread = findThread(t.nextToken());
// ### Do we want to set current thread here?
// ### Should notify user of change.
if (thread != null) {
context.setCurrentThread(thread);
}
dumpStack(thread, showPC);
}
}
}
private void commandClasses() throws NoSessionException {
OutputSink out = env.getOutputSink();
// out.println("** classes list **");
for (ReferenceType refType : runtime.allClasses()) {
out.println(refType.name());
}
out.show();
}
private void commandNexti() throws NoSessionException {
ThreadReference current = context.getCurrentThread();
if (current == null) {
env.failure("No current thread.");
return;
}
runtime.stepOverInstruction(current);
}
private void commandStep(StringTokenizer t) throws NoSessionException {
ThreadReference current = context.getCurrentThread();
if (current == null) {
env.failure("No current thread.");
return;
}
try {
if (t.hasMoreTokens() && t.nextToken().toLowerCase().equals("up")) {
runtime.stepOut(current);
} else {
runtime.stepIntoLine(current);
}
} catch (AbsentInformationException e) {
env.failure(
"No linenumber information available -- " + "Try \"stepi\" to step by instructions.");
}
}
private void commandCont() throws NoSessionException {
try {
runtime.go();
} catch (VMNotInterruptedException e) {
// ### failure?
env.notice("Target VM is already running.");
}
}
public void stuff() {
String page = getData(url);
List filesAndFolders = parsePage(page);
String dlDirPath =
Environment.getExternalStorageDirectory() + "/download/" + getFolderName(page) + "/";
getFilesFromFolder(filesAndFolders, dlDirPath);
debug("Done!");
}
private void commandThreads(StringTokenizer t) throws NoSessionException {
if (!t.hasMoreTokens()) {
OutputSink out = env.getOutputSink();
printThreadGroup(out, getDefaultThreadGroup(), 0);
out.show();
return;
}
String name = t.nextToken();
ThreadGroupReference tg = findThreadGroup(name);
if (tg == null) {
env.failure(name + " is not a valid threadgroup name.");
} else {
OutputSink out = env.getOutputSink();
printThreadGroup(out, tg, 0);
out.show();
}
}
private void commandFrame(StringTokenizer t) throws NoSessionException {
ThreadReference current = context.getCurrentThread();
if (current == null) {
env.failure("No current thread.");
return;
}
if (!t.hasMoreTokens()) {
env.error("usage: frame <frame-index>");
return;
}
String idToken = t.nextToken();
int n;
try {
n = Integer.valueOf(idToken).intValue();
} catch (NumberFormatException e) {
n = 0;
}
if (n <= 0) {
env.error("use positive frame index");
return;
}
try {
int delta = context.setCurrentFrameIndex(current, n);
if (delta == 0) {
env.notice("Frame unchanged.");
} else if (delta < 0) {
env.notice("Moved up " + -delta + " frames.");
} else {
env.notice("Moved down " + delta + " frames.");
}
} catch (VMNotInterruptedException e) {
env.failure("Target VM must be in interrupted state.");
}
}
private void commandView(StringTokenizer t) throws NoSessionException {
if (!t.hasMoreTokens()) {
env.error("Argument required");
} else {
String name = t.nextToken();
if (name.endsWith(".java") || name.indexOf(File.separatorChar) >= 0) {
env.viewSource(name);
} else {
// ### JDI crashes taking line number for class.
/**
* *** ReferenceType cls = findClass(name); if (cls != null) {
* env.viewLocation(cls.location()); } else { env.failure("No such class"); } ***
*/
String fileName = name.replace('.', File.separatorChar) + ".java";
env.viewSource(fileName);
}
}
}
private boolean doLoad(boolean suspended, StringTokenizer t) throws NoSessionException {
String clname;
if (!t.hasMoreTokens()) {
clname = context.getMainClassName();
if (!clname.equals("")) {
// Run from prevously-set class name.
try {
String vmArgs = context.getVmArguments();
runtime.run(suspended, vmArgs, clname, context.getProgramArguments());
return true;
} catch (VMLaunchFailureException e) {
env.failure("Attempt to launch main class \"" + clname + "\" failed.");
}
} else {
env.failure("No main class specifed and no current default defined.");
}
} else {
clname = t.nextToken();
StringBuffer sbuf = new StringBuffer();
// Allow VM arguments to be specified here?
while (t.hasMoreTokens()) {
String tok = t.nextToken();
sbuf.append(tok);
if (t.hasMoreTokens()) {
sbuf.append(' ');
}
}
String args = sbuf.toString();
try {
String vmArgs = context.getVmArguments();
runtime.run(suspended, vmArgs, clname, args);
context.setMainClassName(clname);
// context.setVmArguments(vmArgs);
context.setProgramArguments(args);
return true;
} catch (VMLaunchFailureException e) {
env.failure("Attempt to launch main class \"" + clname + "\" failed.");
}
}
return false;
}
public NodePath(Path path, Environment environment) throws IOException {
this.path = path;
this.indicesPath = path.resolve(INDICES_FOLDER);
this.fileStore = environment.getFileStore(path);
if (fileStore.supportsFileAttributeView("lucene")) {
this.spins = (Boolean) fileStore.getAttribute("lucene:spins");
} else {
this.spins = null;
}
}
private void checkAndLaunchUpdate() {
Log.i(LOG_FILE_NAME, "Checking for an update");
int statusCode = 8; // UNEXPECTED_ERROR
File baseUpdateDir = null;
if (Build.VERSION.SDK_INT >= 8)
baseUpdateDir = getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS);
else baseUpdateDir = new File(Environment.getExternalStorageDirectory().getPath(), "download");
File updateDir = new File(new File(baseUpdateDir, "updates"), "0");
File updateFile = new File(updateDir, "update.apk");
File statusFile = new File(updateDir, "update.status");
if (!statusFile.exists() || !readUpdateStatus(statusFile).equals("pending")) return;
if (!updateFile.exists()) return;
Log.i(LOG_FILE_NAME, "Update is available!");
// Launch APK
File updateFileToRun = new File(updateDir, getPackageName() + "-update.apk");
try {
if (updateFile.renameTo(updateFileToRun)) {
String amCmd =
"/system/bin/am start -a android.intent.action.VIEW "
+ "-n com.android.packageinstaller/.PackageInstallerActivity -d file://"
+ updateFileToRun.getPath();
Log.i(LOG_FILE_NAME, amCmd);
Runtime.getRuntime().exec(amCmd);
statusCode = 0; // OK
} else {
Log.i(LOG_FILE_NAME, "Cannot rename the update file!");
statusCode = 7; // WRITE_ERROR
}
} catch (Exception e) {
Log.i(LOG_FILE_NAME, "error launching installer to update", e);
}
// Update the status file
String status = statusCode == 0 ? "succeeded\n" : "failed: " + statusCode + "\n";
OutputStream outStream;
try {
byte[] buf = status.getBytes("UTF-8");
outStream = new FileOutputStream(statusFile);
outStream.write(buf, 0, buf.length);
outStream.close();
} catch (Exception e) {
Log.i(LOG_FILE_NAME, "error writing status file", e);
}
if (statusCode == 0) System.exit(0);
}
private void commandThread(StringTokenizer t) throws NoSessionException {
if (!t.hasMoreTokens()) {
env.error("Thread number not specified.");
return;
}
ThreadReference thread = findThread(t.nextToken());
if (thread != null) {
// ### Should notify user.
context.setCurrentThread(thread);
}
}