Develop Reference

Android intents are launched in reverse order

I am working on an android app where I from one activity create and start a number of activities using intents (and close these using the finish() method()) however when I run the app the order the activities are launched in is the reversed of the creation order. I realize this is because the intents are not launched imminently on the startActivity(Intent) call, but added to a queue, but I would really like to preserve the order. My question is, is there any way to keep the order of the activities as they are created? See pseudo code for better explanation
**Main Class**
Intent intent1 = new Intent(this, activity1);
startActivity(intent1);
Intent intent2 = new Intent(this, activity2);
startActivity(intent2);
Intent intent3 = new Intent(this, activity3);
startActivity(intent3);
**Intent class**
....
finish()
However when I launch the app the activity 3 is launched first, followed by 2 and finally 1 ---> how do I preserve the order so they launch 1->2->3?
Thanks a lot in advance

You can start first activity, in it's onCreate(...) method start second and then in onCreate(...) of second activity start third. So you will get 1->2->3 and 3 will be on the top of the stack

Does the Intents get killed after i pass to another Intent Android

I'm working on an android application and in the application I have a couple buttons that let user to pass to another activity. Now the way I'm doing the transitions between this Intents is like below:
Intent intent = new Intent(this,user_area.class);
intent.putExtra("user",user_name.getText().toString());
startActivity(intent);
With the above content I start an activity and from that activity I'm getting back to the MainActivity using this code:
Intent intent = new Intent(context,MainActivity.class);
startActivity(intent);
But i suspect this cause memory to be over used because I'm not actually getting back to the Main Activity that created when application started, I'm just creating another instance of MainActivity I guess. Is this really as i thought and if it is how can I get back to the activity that created in the beginning or if I can't do such thing how can I make app to let the previous activity go?

Passing an intent to startActivity() will create a new instance of the activity and add it to the front of the stack. So:
Intent intent = new Intent(context,MainActivity.class);
startActivity(intent);
is basically asking to create a new instance. If you want to go back to the activity just before the current one, call either:
finish();
Or,
super.onBackPressed();

In your solution you just have to press back button and you'll be back in first activity.
If you want to close it and after open new instance like you are doing in second activity just add
finish();
at the end of
Intent intent = new Intent(this,user_area.class);
intent.putExtra("user",user_name.getText().toString());
startActivity(intent);

You just need to call finish(); method
Intent intent = new Intent(this, DestinationActivity.class);
startActivity(intent);
finish();

How to open the same running Activity as a new one?

I have an Activity that used to launch another one according to a button pressed, the new one will be either a whole new one or as like the currently running one, So, when launching a new one I'm getting the creation animation as the following:
but when launching the same Activity I got one of two behaviors:
1- when launching it vie recreate() the activity just blinks to change the statistics.(which is pretty normal to have)
2- when dealing with it as if it's another activity by using intent() with CLEAR_TOP flag I got the following :
ways I already used:
Intent intent;
// 1 (dealing with it as a whole new one by passing the Activity Class)
intent = new Intent(v.getContext(),
MyActivity.class);
intent.putExtra("EXIT", false);
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(intent);
finish();
// 2 (just getting the current one directly)
intent = getIntent();
finish();
startActivity(intent);
result for the two ways :
So, how to open the same Opened Activity with the animation of opening a new one?(i.e. like in the first pic)

found the solution by using CLEAR_TASK intent flag which according to that link will cause any existing task that would be associated with the activity to be cleared before the activity is started.
So, it will be the following way:
Intent intent = new Intent(v.getContext(),
MyActivity.class);
intent.putExtra("EXIT", false);
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK); // Here We Are
startActivity(intent);
finish();

activity started by other apps, use existing instance

My app has two activities MainActivity and ExternEntry. ExternEntry gets called by some other app as a way to launch my app. ExternEntry will then call startActivity on MainActivity, which may have already been launched before. My question is, how to resume the MainActivity instance in the background?
Note that this is different from switching activities in the same application. Every time ExternEntry gets called, does it create a new stack as well?
I tried
Intent i = new Intent(this, MainActivity.class);
i.setAction(Intent.ACTION_MAIN);
i.addCategory(Intent.CATEGORY_LAUNCHER);
startActivity(i);
and
Intent i = new Intent(this, MainActivity.class);
i.addFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT);
startActivity(i);
in ExternEntry, but both create a new instance of MainActivity.
I also tried setting MainActivity to 'singleTask', but that didn't work either.

I think you should declare launch mode in the android manifest files.
<activity
android:name=".name"
android:launchMode="singleTask"
>
i hope it will help you.

Which is the correct way to start an Activity?

Let's say the Activity I want to start is named "OccupyThePieShop"
I was previously using this methodology to start an Activity:
Intent oTPS = new Intent();
timeIntervalConfigIntent.setClassName("com.aXX3AndSpace.KeepInTouch",
"com.aXX3AndSpace.KeepInTouch.OccupyThePieShop");
startActivity(oTPS);
...but was told that this is more the norm:
Intent oTPS = new
Intent(KeepInTouchActivity.this, OccupyThePieShop.class);
KeepInTouchActivity.this.startActivity(oTPS);
...and so I replaced my calls to startActivity() with that usage.
Now, I've come across a couple more ways which seem quite "elegant," namely:
startActivity(new Intent(getApplicationContext(), OccupyThePieShop.class));
...and:
Intent intent = new Intent(this, OccupyThePieShop.class);
startActivity(intent);
Is one way preferred over the others, and if so, why?

I think this is probably an issue of personal preference. I like startActivity(new Intent(this, OccupyThePieShop.class)); because, as you said, it is elegant.