You’re right – there is no nice API for this. You’re also right on your second point – it’s trivially easy to design a function that does this for you using threading. import threading import subprocess def popen_and_call(on_exit, popen_args): “”” Runs the given args in a subprocess.Popen, and then calls the function on_exit when the … Read more
Try the ProcessExit event of AppDomain: using System; class Test { static void Main(string[] args) { AppDomain.CurrentDomain.ProcessExit += new EventHandler (OnProcessExit); // Do something here } static void OnProcessExit (object sender, EventArgs e) { Console.WriteLine (“I’m out of here”); } }
exit(1) (usually) indicates unsuccessful termination. However, its usage is non-portable. For example, on OpenVMS, exit(1) actually indicates success. Only EXIT_FAILURE is the standard value for returning unsuccessful termination, but 1 is used for the same in many implementations. So to summarize: If you want to write perfectly portable code use, EXIT_FAILURE for failure case. While, … Read more
It’s an argument to quit(). See ?quit. Arguments: status: the (numerical) error status to be returned to the operating system, where relevant. Conventionally ‘0’ indicates successful completion. Details: Some error statuses are used by R itself. The default error handler for non-interactive use effectively calls ‘q(“no”, 1, FALSE)’ and returns error code 1. Error status … Read more
You can call os._exit() to directly exit, without throwing an exception: import os os._exit(1) This bypasses all of the python shutdown logic, such as the atexit module, and will not run through the exception handling logic that you’re trying to avoid in this situation. The argument is the exit code that will be returned by … Read more
You need the return statement: return [n] Causes a function to exit with the return value specified by n. If n is omitted, the return status is that of the last command executed in the function body. If used outside a function, but during execution of a script by the . (source) command, it causes … Read more
There are two ways to exit a method early (without quitting the program): Use the return keyword. Throw an exception. Exceptions should only be used for exceptional circumstances – when the method cannot continue and it cannot return a reasonable value that would make sense to the caller. Usually though you should just return when … Read more
I’ll focus on answering how to resolve your workround so that it behaves as you want. To capture actions performed on one Activity within another requires three steps. Launch the secondary Activity (your ‘camera Activity’) as a subactivity by using startActivityForResult instead of startActivity. Intent i = new Intent(this,CameraActivity.class); startActivityForResult(i, STATIC_INTEGER_VALUE); Within the subactivity (camera … Read more
Return is how you exit out of a function body. You are using the correct approach. I suppose, depending on how your application is structured, you could also use throw. That would typically require that your calls to your function are wrapped in a try / catch block.
I do something along these lines in most of my real main packages, so that the return err convention is adopted as soon as possible, and has a proper termination: func main() { if err := run(); err != nil { fmt.Fprintf(os.Stderr, “error: %v\n”, err) os.Exit(1) } } func run() error { err := something() … Read more