I came across the Epoxy library while looking for information about RecyclerView.
Epoxy is a library that makes RecyclerView easier to use.
I haven't applied it to my app yet, but I think it will be easier if I apply it.
Because the RecyclerView I use is based on two view types, and both items are dynamically added/removed frequently (DiffUitl is also used).
However, while reading the description of the Epoxy library in Git,
I came across the following:
Additionally, Epoxy adds support for saving view state and automatic diffing of item changes.
I'm curious as to what automatic diffing you're talking about here works based on.
Is it DiffUtil internally or simply notifyDatasetChanged()?
If it uses DiffUtil then I'm going to use Epoxy or I'll consider it.
or simply notifyDatasetChanged()?
They are not using notifyDatasetChanged() as per the documentation:
Epoxy's automatic diffing to reduce the overhead, while also efficiently only updating the views that changed.
Is it DiffUtil internally
DiffUtil is used for the EpoxyController class, but not for EpoxyAdapter class, the documentation says:
The Android Support Library class DiffUtil is used for diffing in
EpoxyController. For legacy reasons, the older EpoxyAdapter uses a
custom solution for diffing.
So, As you still designing your app, I expect that you'll be using EpoxyController rather than the legacy EpoxyAdapter; and therefore, DiffUtil is already utilized.
If it uses DiffUtil then I'm going to use Epoxy or I'll consider it
It's up to you; using libraries in general has pros and cons in terms of continuity, security, limitations, complexity .. etc.
i just read an article about view binding in Android and I was thinking to use it in my App as it has many benefits over conventional "findViewById" method. I tried to search a way that if I can use it only in some of the activities(as I have so many activities and fragments that I cant simply write ignore this for view binding).I was thinking to make changes gradually so I need to know the best way from the experienced persons who also switched to this in a big project. Thank you
Enabling ViewBinding in your Gradle file will not break your existing code. If you want to incorporate ViewBinding with a specific activity or fragment, you will just have to implement it properly within that activity/fragment.
If you worry about creating many new classes, the best way is to enable R8 shrinking in release builds. This way all unused view binding classes will be removed from release builds, so they won't impact the size of your app.
I want to know that is viewModel necessary to use. Is there any alternative of ViewModel.
can I use only xml files for UI.
Model View ViewModel (MVVM) is a software architectural pattern so no its not necessary you can just throw everything in your activity/fragment if you wanted and it would work the same but typically you don't want to do that. There are a bunch of different patterns that you can use.
For your second question yes you can only use xml files to create your layout
Both are possible to make application. But I recommend for you to use Android Architecture Components including ViewModel by google.
The simple answer is No, it's not necessary you can make complete Application Architecture by using fragments but in this way you might face many problems.
Android Architecture Components
you can use the only XML for UI
Both of my colleague and I have experience in MVVM of Web App, while we are new to native android development. Now we have contrary opinions about android data-binding -- I'm a fan of it while he is not.
My Arguments:
Reduces boilerplate code which in turns brings
Less coupling
Stronger readability
Powerful, easy to implement custom attribute and custom view
Even faster than findViewById (details)
His Arguments:
The auto-generated .class increases app size.
Harder to debug
I've made some investigation but there are not many discussions about it. Now I want to collect the pros and cons of android data-binding.
Aspects of discussion include but are not limited to:
unit test
app size
performance
learning curve
readability
coupling
I will comment on your arguments first then I will state my opinion:
1.Remove boilerplate code - it will remove some it will just move some in the xml or it will require additional classes. So you have to be careful and balance the use of data binding.
2.Stronger readability - depends if you are a new developer then you may find it easy to learn it but if you previously worked on android you will need extra time to learn it.
3.Powerful - the code has more power, you can implement whatever you like in code. Think about it like this, everything you implement using data binding has a code equivalent (it might be longer and more code to write), but the revers is not valid.
4.Even faster than findViewById - comparing the speed between these two, in my opinion is useless, you will never notice the difference, if you see some difference, then one of the implementation is wrong.
5.Auto generated class - it's true it will increase the app size, but again only if you have tons of it it will matter. It's true that on the android dev web site they state that it's kind of bad to use libraries that create autogenerated code or annotations that will generate extra code.
6.Hard to debug - depends, like readability, of what you are used to, heck debugging is hard either way for some problems, and you will get better by debugging not by using a different library.
So this is pure my opinion, I've developed many apps using different libraries and different approaches, and they all had pros and cons, but what I've learn: balance everything, don't use tons of libraries, don't waste time implementing things that are implemented already and work well, don't "decouple everything", don't "couple" everything, don't use code only, don't try to "generate" everything.
I think it's quite wrong, and you can get a wrong idea, if you ask for 'pros & cons' about some library/implementation, because usually it won't be impartial, you will get a lot of pros from somebody who used the library in a specific way and it worked and others will give you cons because they used different and it didn't work.
So in conclusion, I think you should check what the library can do for you and what can't do for you and decide if it's good for your setup. In other words, you should decide if a library is good for you not other people ;).
Update - 8 August 2018
First of all I still stand with my initial conclusion, balance is the key in these kind of situations, but in my case, data-binding speed-up a little bit the development process and also improved it. Here are a few new points that you should all think about.
Testing the UI -- with data-binding it's much more easy to test the UI, but data-binding it's not enough for that, you also need a good architecture and using the Google suggested architecture will show the actual power of data-binding.
The most visible changes were provided for points 2 & 5 from my original answer. It kind of was easier to read the code after we decided to use data-binding, and the most important thing here is: we as a team decided that we will use data-binding and after that, we kind of expected to have most of the trivial and basic UI setup in the XML file.
For the debugging part, here's a little bit tricky, Android Studio has a lot to improve on the errors and autocomplete for the data-binding but the most common errors you'll get them after the first 2-3 occurrences. Also I've learned that a "clean project" form time to time, helps A LOT.
Another point that you'll have to take in consideration is the project configuration to use data-binding, right now AS (3.1) supports by default data-binding (just set a flag in graddle) for Java, but I had some issues with Kotlin, after a bit of search here on SO, I managed to fix everything.
As a second conclusion (from my original post), if you can and the project deadline/requirements/etc allows you to try data-binding, go for it it will worth (unless you do some really stupid stuff :)) ).
I am working on a huge Android project and the team has decided to phase out Data Binding library. Why? The primary reason is that it is exacerbating build time(10+ mins), by generating a lot of classes in the build process.
Even if i like danypata's answer i would like to add/edit some of his statements to android databinding.
1.Remove boilerplate code - As written in danypatas answer it removes some code and adds some code somewhere else like in layouts. That doesnt mean that the boilercode isnt reduced because usually it is reduced.
For example you may want to create a bindingadapter, which handles several custom arrayadapters for your spinner/recyclerview/listview/.. but requires only one simple adapter. You may want to use the adapter in your layout by using e.g.
app:myCoolAdaptersData="#{model.mydata}"
Now you can create your generic adapter and (re)use your bindingadapter in all your layouts instead of using for example:
ListView lv = findViewById(...);
CoolGenericAdapter<MyModel> coolAdapter = new CoolGenericAdapter<>(...);
lv.setAdapter(coolAdapter);
This is just one simple example which recudes the code alot in larger projects. Another sample to recude code is, that you bind your model to your layout. Updating field-values of your model usually updates your model aswell (if its at least a BaseObservable/ObservableField).
That means that you dont need to find all your views, update your views, update your models, ...
2.Stronger readability - The extra time spent for learning databinding doesnt really matter. Since the layouts are not really different except that you wrap them into a layout tag and put your namespaces there, it doesnt really differs from "regular" layouts. Using bindingadapters and accessing the model in the layout may take some time, but usually you can start beginning with the basics which are easy and beautiful to use aswell. Learning new stuff always takes time, but you will easy overhaul the time when using databinding after a while.
3.Powerful - Yes, its very powerful. Its easier to reuse existing code, reuse existing bindingadapters and may lead to more generated code but thats not always true. For example you may create multiple adapters within several classes instead of creating one bindingadapter, it may be hard to "optimize" it later. Optimizing the Bindingadapter means that it gets updated everywhere. Optimizing may decrease the "lines of code" since the boilerplace is reduced anyway.
I agree to 4. and 5.
6. Hard to Debug Since AS 3.0+ outputs useful hints like syntax issues in your layout (line number and file) its easy to debug databinding generated code. If you have problems finding the issue you may also want to check for errors in the generated code. Some librarys like dagger 2 or android architecture library may confuse you because the error lines doesnt match with the real "error". This is due generated code by other annotation processors. If you know that those annotation processors may get in trouble with databindings error outputs, you can easy fix that.
7. Unit Testing Its possible like if you dont use databinding by using executePendingBindings.
8. Readability Readability may be better without databinding. Since you put some business logic into your layout, some into your real code, it may lead to spaghetti-code. Another problem is that using lambdas in your layout may be very confused if the "layout-designer" doesnt know which param may be used.
Another very big problem is that bindingadapter can be everywhere. Using BindingAdapter annotation generates the code. That means that using this in your layout may lead to problems to find the proper code. If you want to update a bindingadapter you need to "find" it.
When should you use what? For larger projects it is a really good idea to use databinding together with the mvvm or mvp pattern. This is a really clean solution and very easy to extend. If you just want to create a small simple application you'r fine using MVC Pattern without databinding. If you have existing generic bindingadapters which can be used from other projects you may want to use databinding, because its easy to reuse this code.
Data binding, concept wise looks promising to me, but I do not like the implementation part.
I would appreciate a bit more simpler and direct approach to it.
Thus I feel lot more comfortable in keeping it old school.
Model classes, mutable objects, observers feel like too much to me, if some how the data variables used for binding are received as Objects that are mutable and observable directly in a class , then that would make the process lot more cleaner, simpler and concise.
What are some pros and cons of using RoboBinding vs Android Binding.
eg.
can RoboBinding be used on fragments ?
What about Android binding for fragments ?
Does any use reflection to slow down Android at run time ?
Also which ones can be obfuscated with proguard ?
Can any of the two auto generate a viewModel interface ?
Android Binding info
RoboBinding cast
I've used both and although I like RoboBinding (I even have some contributions to the code) I've switched to Data Binding for all my binding needs.
http://developer.android.com/tools/data-binding/guide.html
It doesn't have some of the bi-directional binding goodness that I like in RoboBinding but it's really solid at this point and from Google directly. It allows you to do some pretty cool stuff
Here's a post I have that goes into Data binding as well as other stuff
http://blog.liffft.com/2016/01/19/rx-java-spock-groovy-android-bindings-android-might-now-be-testable-say-what/
I didn't use Android Binding, but have some experience with robobinding
yes, quite seemlessly
don't know
I didn't notice any problems with forms binding up to 30 properties
to some extent. you have to preserve all PM properties you bind to, constructors and annotations
no
please note that robobinding is not working well with material design and is not working at all with AppCompat 22+
May I also suggest Anvil (https://github.com/zserge/anvil)? The whole library API is only ~10 most important methods. Inspired by React.js.
No reflection used (other than creating views, but XML inflaters use that as well). Can be used with Proguard, but it's only ~100KB when unstripped, so I normally use with without Proguard. Best used with Kotlin, but also supports Java 6/8.
And if you're familiar with React and are looking for Redux implementation - here's one I normally use with Anvil: https://github.com/trikita/jedux
Just want to let people know who may have Googled this as I did today, that RoboBinding is no longer maintained.
Some alternatives could be RoboMVVM or Anvil, but not sure if either of those are maintained either (last commits were in 2014 and 2019 respectively).
At this point I think the safest option is to use Android Data Binding directly, then you don't have dependencies on third-party frameworks that you might have to remove later. And Android Data Binding does now support two-way data binding, contrary to one of the other answers here.