Need Context in Model in MVP

Question

I need to use the Context of activity in the model while using MVP in android to get the list of all the installed application.what is the correct way to access the context or any alternative to achieve the same while following the MVP pattern.

Here are the classes:

Main Activity.java

public class MainActivity extends BaseActivity
    implements MainView,View.OnClickListener {

    private MainPresenter mPresenter;
    private Button sendButton;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_main);
       init();
       createPresenter();
    }

    private void init(){
       sendButton= (Button) findViewById(R.id.button_send);
       sendButton.setOnClickListener(this);
    }

    private void createPresenter() {
       mPresenter=new MainPresenter();
       mPresenter.addView(this);
    }

    @Override
    public void onClick(View view) {
       switch (view.getId()){
          case R.id.button_send:
             mPresenter.onSendButtonClick();
             break;
        }
    }

   @Override
   public void openOptionsActivity() {
        Intent intent=new Intent(this,OptionsActivity.class);
        startActivity(intent);
   }
}

Main Presenter.java

public class MainPresenter extends BasePresenter {

    MainModel model;

    public void onSendButtonClick() {
       model.getListOfAllApps();
    }

    @Override
    public void addView(MainView view) {
        super.addView(view);
        model = new MainModel();
    }

}

Main Model.java

public class MainModel {

    public void getListOfAllApps(){
        final Intent mainIntent = new Intent(Intent.ACTION_MAIN, null);
        mainIntent.addCategory(Intent.CATEGORY_LAUNCHER);
        final List pkgAppsList = getPackageManager().queryIntentActivities(mainIntent, 0);
  
    }

}

Having issue in getPackageManager().queryIntentActivities(mainIntent, 0) .how to do it as not having any context here.

Answer 1

I answered a similar question here which you may want to have a look at too. I'll give the breakdown of how I think you could solve this particular problem though.

Use a static context from the Application class

This method would work but I'm not fond of it. It makes testing harder and couples your code together.

public class App extends Application {

    private static Context context;

    public static Context getContext() {
        return context;
    }

    @Override
    public void onCreate() {
        super.onCreate();
        context = getApplicationContext();
    }
}

Then in your MainModel:

public class MainModel {

    public List<String> getListOfAllApps(){

        final Intent mainIntent = new Intent(Intent.ACTION_MAIN, null);
        mainIntent.addCategory(Intent.CATEGORY_LAUNCHER);
        final List<ResolveInfo> pkgAppsList = App.getContext().getPackageManager().queryIntentActivities(mainIntent, 0);

        List<String> results = new ArrayList<>();
        for (ResolveInfo app : pkgAppsList) {
            results.add(app.resolvePackageName);
        }
        return results;
    }
}

Now we've got that out the way, let's look at some better options.

Do it in the Activity

So your Activity implements your View. It's probably doing a few Anrdoidy things too such as onActivityResult. There's an argument for keeping Android code in the Activity and just accessing it through the View interface:

public interface MainView {

    List<String> getListOfAllApps();
}

The Activity:

public class MainActivity extends BaseActivity implements MainView {

    //..

    @Override
    public List<String> getListOfAllApps(){

        final Intent mainIntent = new Intent(Intent.ACTION_MAIN, null);
        mainIntent.addCategory(Intent.CATEGORY_LAUNCHER);
        final List<ResolveInfo> pkgAppsList = getPackageManager().queryIntentActivities(mainIntent, 0);

        List<String> results = new ArrayList<>();
        for (ResolveInfo app : pkgAppsList) {
            results.add(app.resolvePackageName);
        }
        return results;
    }

    //..
}

And the Presenter:

public class MainPresenter extends BasePresenter {

    public void onSendButtonClick(){

        view.getListOfAllApps();
    }
}

Abstract the details in a separate class

Whilst the last option doesn't break the rules of MVP it doesn't feel quite right as getting a list of packages isn't really a View operation. My preferred option is to hide the use of Context behind an interface/class.

Create a class PackageModel (or whatever name takes your fancy):

public class PackageModel {

    private Context context;

    public PackageModel(Context context) {
        this.context = context;
    }

    public List<String> getListOfAllApps(){

        final Intent mainIntent = new Intent(Intent.ACTION_MAIN, null);
        mainIntent.addCategory(Intent.CATEGORY_LAUNCHER);
        final List<ResolveInfo> pkgAppsList = context.getPackageManager().queryIntentActivities(mainIntent, 0);

        List<String> results = new ArrayList<>();
        for (ResolveInfo app : pkgAppsList) {
            results.add(app.resolvePackageName);
        }
        return results;
    }
} 

Now have your Presenter require this as a constructor parameter:

public class MainPresenter extends BasePresenter {

    private PackageModel packageModel;

    public MainPresenter(PackageModel packageModel) {
        this.packageModel = packageModel;
    }

    public void onSendButtonClick(){

        packageModel.getListOfAllApps();
    }
}

Finally in your Activity:

public class MainActivity extends BaseActivity implements MainView {

    private MainPresenter presenter;

    private void createPresenter() {

        PackageModel packageModel = new PackageModel(this);
        presenter = new MainPresenter(packageModel);
        presenter.addView(this);
    }
}

Now the use of Context is hidden from the Presenter and it can carry on without any knowledge of Android. This is known as constructor injection. If you're using a dependency injection framework it can build all the dependencies for you.

If you wanted to you could make an interface for PackageModel but I don't think it's really necessary as a mocking framework like Mockito can create a stub without using an interface.

Answer 2

Basically, you have the following options:

1) Always pass a Context to the Model. Whatever event happens in Android, you always have some kind of Context available. (And your code is invoked only in response to events.)

2) getApplicationContext() and store it for future use in a static variable.

There are the following gotchas:

An Activity is a Context, but if you store a link to an Activity, you get a memory leak. Activities are re-created when for example the screen turns. The same about contexts passed to BroadcastReceivers and other kinds of Context. All of them have a lifetime, and that lifetime is not what you need for Model.

It is possible that your application is killed and restarted by Android. In this case, some global (static) variables may be set to null. That is, they will be null unless your application happens to write something to them. In particular, a static variable pointing to the application context may become null in one of restart scenarios. Such problems are difficult to test against.