EigenDaksh: Presenters

Showing posts with label Presenters. Show all posts

PART 7. ADVANCED ANDROID TUTORIAL - IMPLEMENTING MVP FOR RECYCLERVIEW

Read

In the previous lesson, you have seen that implementing MVP for a Fragment is pretty straightforward and simple, especially if you are using Dependency Injection. But how do we implement a passive RecylerView (or any other adapter views for that matter)?

Generally, we create a collection within the adapter to hold the data. But this approach breaks the MVP principle because our RecyclerView is rendering View as well as handling the responsibility of holding the data. Ideally, the data should be stored in the Presenter.

In our sample application, we resolve this problem by treating each item in the collection as a separate MVP view.

public class WeatherAdapter extends RecyclerView.Adapter{

    private static final int LIST_ITEM_TODAY = 0;
    private static final int LIST_ITEM_GENERAL = 1;

    public interface OnWeatherItemClickListener {
        void onItemClick(long id);
    }

    private final WeatherItemPresenter mPresenter;
    private final OnWeatherItemClickListener mListener;


    public WeatherAdapter(WeatherItemPresenter presenter, OnWeatherItemClickListener listener) {
        this.mPresenter = presenter;
        this.mListener = listener;
    }

    @Override
    public WeatherViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
        View view;
        switch (viewType) {
            case LIST_ITEM_TODAY:
                view = LayoutInflater.from(parent.getContext()).inflate(R.layout.list_item_forecast_today,
                        parent, false);
                return new WeatherViewHolder(view, mListener);
            case LIST_ITEM_GENERAL:
                view = LayoutInflater.from(parent.getContext()).inflate(R.layout.list_item_forecast,
                        parent, false);
                return new WeatherViewHolder(view, mListener);
        }
        return null;
    }

    @Override
    public void onBindViewHolder(WeatherViewHolder holder, int position) {
        mPresenter.onBindWeatherRowViewAtPosition(holder, position);

    }

    @Override
    public int getItemCount() {
        return mPresenter.getRowCount();
    }

    @Override
    public int getItemViewType(int position) {
        if(position == 0) {
            return LIST_ITEM_TODAY;
        } else {
            return LIST_ITEM_GENERAL;
        }
    }

    public void renewItems(List items) {
        mPresenter.renewItems(items);
        notifyDataSetChanged();
    }

Then we can make our ViewHolder implement an interface which is a typical View interface of the MVP.

    public static class WeatherViewHolder extends RecyclerView.ViewHolder implements WeatherItemRowView {

        TextView dateTextView;
        TextView maxTempTextView;
        TextView minTempTextView;
        TextView cityTextView;
        ImageView iconImageView;
        TextView descriptionTextView;
        OnWeatherItemClickListener mListener;

        public WeatherViewHolder(View itemView, OnWeatherItemClickListener listener) {
            super(itemView);
            this.mListener = listener;
            dateTextView = itemView.findViewById(R.id.list_item_date_textview);
            maxTempTextView = itemView.findViewById(R.id.list_item_high_textview);
            minTempTextView = itemView.findViewById(R.id.list_item_low_textview);
            cityTextView = itemView.findViewById(R.id.list_item_cityname);
            iconImageView = itemView.findViewById(R.id.list_item_icon);
            descriptionTextView = itemView.findViewById(R.id.list_item_forecast_textview);
        }

        @Override
        public void setClickListener(final long id) {
            itemView.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View view) {
                    mListener.onItemClick(id);
                }
            });
        }

        @Override
        public void setDateString(String dateString) {
            dateTextView.setText(dateString);
        }

        @Override
        public void setCityName(String cityName) {
            cityTextView.setText(cityName);

        }

        @Override
        public void setMaxTemp(String maxTempString) {
            maxTempTextView.setText(maxTempString);

        }

        @Override
        public void setMinTemp(String minTempString) {
            minTempTextView.setText(minTempString);
        }

        @Override
        public void setIcon(int icon) {
            iconImageView.setImageResource(icon);

        }

        @Override
        public void setDescription(String description) {
            descriptionTextView.setText(description);
        }
    }

What is the advantage of this approach? If you look at the code in our sample application, you would clearly see that we have successfully moved the logic of providing data for each row to the presenter. Our Presenter knows nothing about the View layer's concrete implementation or about the Android framework! I would advise you to practice implementation of RecyclerView using this approach before moving forward. In the next lesson, we will discuss Room persistence library which is my favorite ORM. It plays very nicely with Rx as well!

Part 3. Advanced Android Tutorial - Dependency Injection

By apurushottam

Read

0 Comments

What is Dependency Injection?

First of all the term sounds frightening 😛. When I heard the term first, I thought it must be some very difficult design pattern meant only for very advanced developers. Now I can't imagine writing applications without it. So let's see a nice video about Dependency Injection and then we will discuss it further.

Let me bore you at the outset! These are some theories associated with dependency injection which you will find a bit easier to grasp because of the video you just watched. If you have not watched it, please go back and watch it.

Dependency Injection is a specific form of Inversion of Control. I know you feel like it, but do not pull your hair out yet. Have some patience and read on. So what is Inversion of Control? Inversion of Control has two principles which should not be violated.

The modules of top levels shouldn’t depend on modules of the lower levels. The modules of all levels should depend on abstractions.
The abstractions shouldn’t depend on details. The details should depend on abstractions.

In summary, you should avoid hard dependencies. A dependency is a coupling between two modules or classes of code. This leads to problems because if we make any change in one module, we must make corresponding changes in the coupled module as well. For example, let us look at this code:


public class Scooter {

   private Indicator indicator;

   public Scooter(){
      scooter = new Scooter();
   }
 
   public void turn(){
     .........
      indicator.switchOn();
   } 
}

Now how can we test 'turn' without testing ‘switchOn’? If the test fails, which method is failing? And things get worse if the method saves something in the database or performs an API call. Therefore, a class should not initiate a dependency by itself because it creates a high coupling that will be quite difficult to test. Whenever we create a new instance we introduce a hard dependency. Hard dependency should be avoided if we want to write testable and configurable code.

Solving Hard Dependency

To solve the problem of hard dependency we should make sure that these dependency objects should be “injected” from outside components like factories or builders. Basically, we need a Dependency Injector. Dependency Injector is a special module in our app that is in charge of providing instances of the rest of modules and "inject" their dependencies. So inside a module, we are not creating instances and we can follow the Single Responsibility Principle.

Dependency Injection in Android

All this sounds very nice. But how do we take advantage of Dependency Injection in Android? Dagger2 is an open-source framework for that purpose. The framework removes a lot of the boilerplate code and also provides a systematic way to apply dependency injection across our Android app. Dagger2 has some advantages which I would like to mention here. Do not worry if you do not understand every point. Once you have an understanding of Dagger2, you can come here and look at these points and agree or disagree with me.

Simple handling of complex dependencies: The big applications have several dependencies. Dagger2 makes it easier to handle dependency injections.
Code generation through annotations: Dagger2 generates codes required for Dependency Injection through simple annotations. The generated codes are concise and readable.
Small size of the library

I will discuss Dagger2 in detail in next lesson. But just as a preview of the goodies that Dagger2 offers, look at an example where I inject three dependencies in a Fragment. Once I have object injected in my class, I can use it for making API calls which are defined in one place. (Don't worry if you do not understand the above line. It is only an example.)


public class MobileVerificationProgressFragment extends RxFragment {


 @Inject
 UserPreferenceStore _mPreferenceStore;
 @Inject
 DeviceStore _mDeviceStore;
 @Inject
 IDFCUPIStore _mIDFCStore;

 private SendSMSIfc mActivity;

 BroadcastReceiver mDeliverReceiver;
 BroadcastReceiver mSentReceiver;
        ...............................
}

private void generateOtp() {
     _mIDFCStore.generateOTP(generateOTPReq)
     .compose(this.bindToLifecycle())
     .observeOn(AndroidSchedulers.mainThread())
     .subscribe(new Consumer() 
     .....................
}

EigenDaksh

PART 7. ADVANCED ANDROID TUTORIAL - IMPLEMENTING MVP FOR RECYCLERVIEW

Part 3. Advanced Android Tutorial - Dependency Injection

What is Dependency Injection?

Solving Hard Dependency

Dependency Injection in Android

Follow Us

Recent Posts

Facebook

Search This Blog

Labels

Social Media Icons 2

Report Abuse

About Me

Facebook