Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

What are Android Annotations and what are they used for?

I want to know about Android Annotations, is it better way to use in all android projects?.

If correct, how to implement it. Is there any good tutorial for it?

If it is a wrong way. what are the drawbacks of Android Annotations?

Thanks in advance for the help.

like image 202
Android Tutorial Avatar asked Sep 09 '15 14:09

Android Tutorial


People also ask

What are annotations used for?

Annotations are used to provide supplemental information about a program. Annotations start with '@'. Annotations do not change the action of a compiled program. Annotations help to associate metadata (information) to the program elements i.e. instance variables, constructors, methods, classes, etc.

What is annotation and its types?

An annotated bibliography describes the field of research on a topic and should include sources that reflect the range of approaches to the subject. There are four main types of annotations. Descriptive. A descriptive (also called an indicative) annotation gives a brief overview or summary of the text.

What are annotations in software?

Annotations in programming languages are, similar to those in linguistics, structural elements containing additional or meta-information in the source code of a program.

How do you annotate on a phone?

Annotating on a shared screenStart sharing your screen. Tap the pen icon on your screen. This will open the annotation tools. Tap the pen icon again to close the annotation tools.


2 Answers

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.

like image 67
rastadrian Avatar answered Sep 20 '22 05:09

rastadrian


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.

like image 31
DDsix Avatar answered Sep 20 '22 05:09

DDsix