What are Android Annotations and what are they used for?

Android Annotations is an annotation-driven framework that allows you to simplify the code in your applications and reduces the boilerplate of common patterns, such as setting click listeners, enforcing ui/background thread executions, etc.

You could go from having something like this:

public class MainActivity extends AppCompatActivity {    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_main);        final TextView descriptionTextView = (TextView) findViewById(R.id.tv_description);        final Button hideButton = (Button) findViewById(R.id.btn_hide);        hideButton.setOnClickListener(new View.OnClickListener() {            @Override            public void onClick(View v) {                descriptionTextView.setVisibility(View.INVISIBLE);            }        });    }}

To something like this:

@EActivity(R.layout.activity_main)public class MainActivity extends AppCompatActivity {    @ViewById(R.id.tv_description)    TextView mDescriptionTextView;    @Click(R.id.btn_hide)    protected void onHideButtonClick() {        mDescriptionTextView.setVisibility(View.INVISIBLE);    }}

How it works

You annotate your activities and components, the annotations processor then generates classes (at compilation time) that extend your activities and components (i.e. your activities cannot be final) with an underscore suffix by default, so if you have MainActivity, now you will also have a MainActivity_ class.

This new class contains a well-written boilerplate code that does whatever the annotation specifies.

How to implement

I wrote this tutorial about how to integrate Android Annotations and even include an example on how integration tests get updated, check here.

That tutorial is valid as of today, using Android Studio ~1.5.1, and it tries to explain a little bit on how the internal works.

Should you use it?

I would say that if you have a small-medium project its fine. It will make your code easier to read. But if your application is bigger and contains a lot of navigation flows with complex activity/component life cycles, it can get a little bit hard to implement or difficult to debug and understand errors if something is not appropriately annotated.

Because of how Android Annotations operate, they embed themselves in the life cycle and doing so, you are now dependent of their lifecycle (e.g. if you annotate your views with @ViewById, then you cannot reference them in onCreate(), you need to make a method and annotate it with @AfterViews and when this method gets executed then your views are ready to be used). This is not necessarily a problem, you just need to have a good understanding of Android's behaviors and well, Android Annotations behaviors as well.

In summary, as in any library, if you depend on it, well you depend on it, so you might as well understand very thoroughly how it works. Your project now depends on someone else's.

I don't use Android Annotations, not anymore. When I used this library, it was buggy and made debugging a nightmare. Another downside is that it lowers the portability of your code. If you're working alone on the project, then it's okay, you don't have this issue, but when you work in a team, you have to give this a second thought.

If you want to use it, there are plenty of tutorials right on their site.

An alternative:If you want to decrease the amount of code while making it really easy to use and understand, I suggest you the Butter Knife library. I use is a lot and didn't encounter any bugs so far. Very easy to use and read.

Android Annotations is a library that "autogenerates" code for us by using some attributes or anotations like @EActivity, @ViewById, @OnClick. It's intended to facilitate and decrease coding time.

"AndroidAnnotations is an Open Source framework that speeds up Android development. It takes care of the plumbing, and lets you concentrate on what's really important. By simplifying your code, it facilitates its maintenance."

(Documentation here: https://github.com/excilys/androidannotations/wiki)

But... We don't use it, I completely agree with DDsix answer. Use SOLID principles and code what should be coded when and where it should be...