Android Destroying Activities, Killing Processes

When does Android destroy activity without destroying the entire process?

I want to make Android destroy my activity on it's own.

Android does not do that, other than through your actions (e.g., finish()) or user actions (e.g., BACK navigation, configuration changes).

So which one is it?

The former (Android kills processes, not activities). See this answer from the woman who wrote this stuff. FWIW, also see this decade-old blog post of mine.

Difference between Activity destroyed and process killed

When onDestroy method is called then only activity is destroyed

Yes.

...or process is killed?

No.

When system destroys activity

Android will destroy an activity when it is finished, such as when the user presses the BACK button (assuming nothing else handles that BACK press). Android will destroy visible activities when the device has undergone a configuration change since the activity became visible (assuming that you have not disabled this in the manifest). Android may destroy activities as part of terminating a process, but this is not guaranteed.

when it kills process?

Android will terminate processes as needed to free up system RAM, when the amount of free system RAM gets low. See the documentation for more.

what is difference between activity is destroyed and process is killed?

They are not closely related.

Should I clear my ArrayList when activity is destroyed

We have no idea what ArrayList you are referring to.

If System kills app without calling onDestroy method, will there be any memory leak because I am not able to close cursor(which I close in onDestroy method)

No. Once a process is terminated, all memory associated with that process is freed.

Android:Is killing of each activity is equivalent to destroying whole app?

Lets start with a bit of background: What happens when you start an application?
The OS starts a process and assigns it a unique process id and allocates a process table.A process start an instance of DVM(Dalvik VM); Each application runs inside a DVM.
A DVM manages class loading unloading, instance lifecycle, GC etc.

Lifetime of a static variable: A static variable comes into existence when a class is loaded by the JVM and dies when the class is unloaded.

So if you create an android application and initialize a static variable, it will remain in the JVM until one of the following happens:

the class is unloaded
the JVM shuts down
the process dies

Note that the value of the static variable will persist when you switch to a different activity of another application and none of the above three happens. Should any of the above three happen the static will lose its value.

You can test this with a few lines of code:

print the uninitialized static in onCreate of your activity -> should print null
initialize the static. print it -> value would be non null
Hit the back button and go to home screen. Note: Home screen is another activity.
Launch your activity again -> the static variable will be non-null
Kill your application process from DDMS(stop button in the devices window).
Restart your activity -> the static will have null value.

The answer to your question.
yes, if all of your activities are destroyed your application process will be killed.

Credits Samuh

When memory is low, does android destroy individual activities or the entire stack?

It kills the whole process and not just some activities. Your app will be killed as a whole, if OS decides to kill the process in which your app in running.

If you go through Processes and Application Lifecycle

In most cases, every Android application runs in its own Linux process. This process is created for the application when some of its code needs to be run, and will remain running until it is no longer needed and the system needs to reclaim its memory for use by other applications.

Also if you go through Processes and Threads

By default, all components of the same application run in the same process and most applications should not change this.
...
Android might decide to shut down a process at some point, when memory is low and required by other processes that are more immediately serving the user.

Hope it helps.

activity onStop() and destroying process

The wording in the documentation is not good. When your OS process is killed, all memory is reclaimed. There are no memory leaks possible in this case.

How to kill an Android activity when leaving it so that it cannot be accessed from the back button?

You just need to call finish()

Intent intent = new Intent(this, NextActivity.class);
startActivity(intent);
finish();