Activity, AppCompatActivity, FragmentActivity, and ActionBarActivity: When to Use Which?
AndroidAndroid FragmentsAndroid ActivityAndroid ActionbaractivityAppcompatactivityAndroid Problem Overview
I'm coming from iOS where it's easy and you simply use a UIViewController. However, in Android things seem much more complicated, with certain UIComponents for specific API Levels. I'm reading BigNerdRanch for Android (the book is roughly 2 years old) and they suggest I use Activity
to host my FragmentActivities
. However, I thought Activity
was deprecated.
So for API Level 22 (with a minimum support for API Level 15 or 16), what exactly should I use both to host the components, and for the components themselves? Are there uses for all of these, or should I be using one or two almost exclusively?
Android Solutions
Solution 1 - Android
> I thought Activity was deprecated
No.
> So for API Level 22 (with a minimum support for API Level 15 or 16), what exactly should I use both to host the components, and for the components themselves? Are there uses for all of these, or should I be using one or two almost exclusively?
Activity
is the baseline. Every activity inherits from Activity
, directly or indirectly.
FragmentActivity
is for use with the backport of fragments found in the support-v4
and support-v13
libraries. The native implementation of fragments was added in API Level 11, which is lower than your proposed minSdkVersion
values. The only reason why you would need to consider FragmentActivity
specifically is if you want to use nested fragments (a fragment holding another fragment), as that was not supported in native fragments until API Level 17.
AppCompatActivity
is from the appcompat-v7
library. Principally, this offers a backport of the action bar. Since the native action bar was added in API Level 11, you do not need AppCompatActivity
for that. However, current versions of appcompat-v7
also add a limited backport of the Material Design aesthetic, in terms of the action bar and various widgets. There are pros and cons of using appcompat-v7
, well beyond the scope of this specific Stack Overflow answer.
ActionBarActivity
is the old name of the base activity from appcompat-v7
. For various reasons, they wanted to change the name. Unless some third-party library you are using insists upon an ActionBarActivity
, you should prefer AppCompatActivity
over ActionBarActivity
.
So, given your minSdkVersion
in the 15-16 range:
-
If you want the backported Material Design look, use
AppCompatActivity
-
If not, but you want nested fragments, use
FragmentActivity
-
If not, use
Activity
Just adding from comment as note: AppCompatActivity
extends FragmentActivity
, so anyone who needs to use features of FragmentActivity
can use AppCompatActivity
.
Solution 2 - Android
Activity
is the base class of all other activities, I don't think it will be deprecated. The relationship among them is:
Activity
<- FragmentActivity
<- AppCompatActivity
<- ActionBarActivity
'<-' means inheritance here. The reference said ActionBarActivity
is deprecated, use AppCompatActivity
instead.
So basically, using AppCompatActivity
is always the right choice. The differences between them are:
-
Activity
is the basic one. -
Based on
Activity
,FragmentActivity
provides the ability to useFragment
. -
Based on
FragmentActivity
,AppCompatActivity
provides features toActionBar
.
Solution 3 - Android
##2019: Use AppCompatActivity
At the time of this writing (check the link to confirm it is still true), the Android Documentation recommends using AppCompatActivity
if you are using an App Bar.
This is the rational given:
> Beginning with Android 3.0 (API level 11), all activities that use > the default theme have an ActionBar as an app bar. However, app bar > features have gradually been added to the native ActionBar over > various Android releases. As a result, the native ActionBar behaves > differently depending on what version of the Android system a device > may be using. By contrast, the most recent features are added to the > support library's version of Toolbar, and they are available on any > device that can use the support library. > > For this reason, you should use the support library's Toolbar class to > implement your activities' app bars. Using the support library's > toolbar helps ensure that your app will have consistent behavior > across the widest range of devices. For example, the Toolbar widget > provides a material design experience on devices running Android 2.1 > (API level 7) or later, but the native action bar doesn't support > material design unless the device is running Android 5.0 (API level > 21) or later.
The general directions for adding a ToolBar are
- Add the v7 appcompat support library
- Make all your activities extend
AppCompatActivity
- In the Manifest declare that you want
NoActionBar
. - Add a
ToolBar
to each activity's xml layout. - Get the
ToolBar
in each activity'sonCreate
.
See the documentation directions for more details. They are quite clear and helpful.
Solution 4 - Android
For a minimum API level of 15, you'd want to use AppCompatActivity
. So for example, your MainActivity
would look like this:
public class MainActivity extends AppCompatActivity {
....
....
}
To use the AppCompatActivity
, make sure you have the Google Support Library downloaded (you can check this in your Tools -> Android -> SDK manager). Then just include the gradle dependency in your app's gradle.build file:
compile 'com.android.support:appcompat-v7:22:2.0'
You can use this AppCompat
as your main Activity
, which can then be used to launch Fragments or other Activities (this depends on what kind of app you're building).
The BigNerdRanch book is a good resource, but yeah, it's outdated. Read it for general information on how Android works, but don't expect the specific classes they use to be up to date.
Solution 5 - Android
Activity
class is the basic class. (The original) It supports Fragment management (Since API 11). Is not recommended anymore its pure use because its specializations are far better.
ActionBarActivity
was in a moment the replacement to the Activity class because it made easy to handle the ActionBar in an app.
AppCompatActivity
is the new way to go because the ActionBar is not encouraged anymore and you should use Toolbar instead (that's currently the ActionBar replacement). AppCompatActivity inherits from FragmentActivity so if you need to handle Fragments you can (via the Fragment Manager). AppCompatActivity is for ANY API, not only 16+ (who said that?). You can use it by adding compile 'com.android.support:appcompat-v7:24:2.0'
in your Gradle file. I use it in API 10 and it works perfect.
Solution 6 - Android
There is a lot of confusion here, especially if you read outdated sources.
The basic one is Activity
, which can show Fragments. You can use this combination if you're on Android version > 4.
However, there is also a support library which encompasses the other classes you mentioned: FragmentActivity
, ActionBarActivity
and AppCompat
. Originally they were used to support fragments on Android versions < 4, but actually they're also used to backport functionality from newer versions of Android (material design for example).
The latest one is AppCompat
, the other 2 are older. The strategy I use is to always use AppCompat
, so that the app will be ready in case of backports from future versions of Android.
Solution 7 - Android
Since the name is likely to change in future versions of Android (currently the latest is AppCompatActivity
but it will probably change at some point), I believe a good thing to have is a class Activity
that extends AppCompatActivity
and then all your activities extend from that one. If tomorrow, they change the name to AppCompatActivity2
for instance you will have to change it just in one place.