extends MvpView {
25 |
26 | /**
27 | * Display a loading view while loading data in background.
28 | * The loading view must have the id = R.id.loadingView
29 | *
30 | * @param pullToRefresh true, if pull-to-refresh has been invoked loading.
31 | */
32 | void showLoading(boolean pullToRefresh);
33 |
34 | void showContent();
35 |
36 | void showError(Throwable e, boolean pullToRefresh);
37 |
38 | void setData(V data);
39 |
40 | /**
41 | * Load the data. Typically invokes the presenter method to load the desired data.
42 | *
43 | * Should not be called from presenter to prevent infinity loops. The method is declared
44 | * in
45 | * the views interface to add support for view state easily.
46 | *
47 | *
48 | * @param pullToRefresh true, if triggered by a pull to refresh. Otherwise false.
49 | */
50 | void loadData(boolean pullToRefresh);
51 | }
52 |
--------------------------------------------------------------------------------
/mvp/src/main/java/com/yeungeek/mvp/core/delegate/ActivityMvpDelegate.java:
--------------------------------------------------------------------------------
1 | package com.yeungeek.mvp.core.delegate;
2 |
3 | import android.app.Activity;
4 | import android.os.Bundle;
5 | import android.support.v4.app.FragmentActivity;
6 |
7 | import com.yeungeek.mvp.common.MvpPresenter;
8 | import com.yeungeek.mvp.common.MvpView;
9 |
10 | /**
11 | * A delegate for Activities to attach them to mosbies mvp.
12 | *
13 | *
14 | * The following methods must be invoked from the corresponding Activities lifecycle methods:
15 | *
16 | * - {@link #onCreate(Bundle)}
17 | * - {@link #onDestroy()}
18 | * - {@link #onPause()}
19 | * - {@link #onResume()}
20 | * - {@link #onStart()}
21 | * - {@link #onStop()}
22 | * - {@link #onRestart()}
23 | * - {@link #onContentChanged()}
24 | * - {@link #onSaveInstanceState(Bundle)}
25 | * - {@link #onPostCreate(Bundle)}
26 | *
27 | *
28 | *
29 | *
30 | * @param The type of {@link MvpView}
31 | * @param The type of {@link MvpPresenter}
32 | * @author Hannes Dorfmann
33 | * @since 1.1.0
34 | */
35 | public interface ActivityMvpDelegate> {
36 |
37 | /**
38 | * This method must be called from {@link Activity#onCreate(Bundle)}.
39 | * This method internally creates the presenter and attaches the view to it.
40 | */
41 | void onCreate(Bundle bundle);
42 |
43 | /**
44 | * This method must be called from {@link Activity#onDestroy()}}.
45 | * This method internally detaches the view from presenter
46 | */
47 | void onDestroy();
48 |
49 | /**
50 | * This method must be called from {@link Activity#onPause()}
51 | */
52 | void onPause();
53 |
54 | /**
55 | * This method must be called from {@link Activity#onResume()}
56 | */
57 | void onResume();
58 |
59 | /**
60 | * This method must be called from {@link Activity#onStart()}
61 | */
62 | void onStart();
63 |
64 | /**
65 | * This method must be called from {@link Activity#onStop()}
66 | */
67 | void onStop();
68 |
69 | /**
70 | * This method must be called from {@link Activity#onRestart()}
71 | */
72 | void onRestart();
73 |
74 | /**
75 | * This method must be called from {@link Activity#onContentChanged()}
76 | */
77 | void onContentChanged();
78 |
79 | /**
80 | * This method must be called from {@link Activity#onSaveInstanceState(Bundle)}
81 | */
82 | void onSaveInstanceState(Bundle outState);
83 |
84 | /**
85 | * This method must be called from {@link Activity#onPostCreate(Bundle)}
86 | */
87 | void onPostCreate(Bundle savedInstanceState);
88 |
89 | /**
90 | * This method must be called from {@link FragmentActivity#onRetainCustomNonConfigurationInstance()}
91 | *
92 | * @return Don't forget to return the value returned by this delegate method
93 | */
94 | Object onRetainCustomNonConfigurationInstance();
95 |
96 | /**
97 | * @return the value returned from {@link ActivityMvpDelegateCallback#onRetainNonMosbyCustomNonConfigurationInstance()}
98 | */
99 | Object getNonMosbyLastCustomNonConfigurationInstance();
100 | }
101 |
--------------------------------------------------------------------------------
/mvp/src/main/java/com/yeungeek/mvp/core/delegate/ActivityMvpDelegateCallback.java:
--------------------------------------------------------------------------------
1 | package com.yeungeek.mvp.core.delegate;
2 |
3 | import android.support.v4.app.FragmentActivity;
4 |
5 | import com.yeungeek.mvp.common.MvpPresenter;
6 | import com.yeungeek.mvp.common.MvpView;
7 |
8 | /**
9 | * The MvpDelegate callback that will be called from {@link
10 | * ActivityMvpDelegate}. This interface must be implemented by all
11 | * Activities that you want to support mosby's mvp.
12 | *
13 | * @author Hannes Dorfmann
14 | * @see BaseMvpDelegateCallback
15 | * @since 2.0.0
16 | */
17 | public interface ActivityMvpDelegateCallback>
18 | extends BaseMvpDelegateCallback {
19 |
20 | /**
21 | * Return any Object holding the desired state to propagate to the next activity instance. Please
22 | * note that mosby internals like the presenter are already saved internally and you don't have
23 | * to take them into account. You can retrieve this value later with {@link
24 | * ActivityMvpDelegate#getNonMosbyLastCustomNonConfigurationInstance()}.
25 | *
26 | *
27 | * This mechanism works pretty the same way as {@link FragmentActivity#onRetainCustomNonConfigurationInstance()}
28 | * and {@link #getNonMosbyLastCustomNonConfigurationInstance()}
29 | *
30 | *
31 | * @return Object holding state.
32 | */
33 | Object onRetainNonMosbyCustomNonConfigurationInstance();
34 |
35 | /**
36 | * @return Return the value previously returned from {@link FragmentActivity#onRetainCustomNonConfigurationInstance()}.
37 | */
38 | Object getLastCustomNonConfigurationInstance();
39 |
40 | /**
41 | * This method should invoke {@link
42 | * ActivityMvpDelegate#getNonMosbyLastCustomNonConfigurationInstance()}.
43 | *
44 | *
45 | * This method is not really a "callback" method (will not invoked from delegate somehow).
46 | * However, it's part of this interface to ensure that no custom implementation will miss this
47 | * method since this method is the counterpart to {@link #onRetainNonMosbyCustomNonConfigurationInstance()}
48 | *
49 | */
50 | Object getNonMosbyLastCustomNonConfigurationInstance();
51 | }
52 |
--------------------------------------------------------------------------------
/mvp/src/main/java/com/yeungeek/mvp/core/delegate/ActivityMvpDelegateImpl.java:
--------------------------------------------------------------------------------
1 | package com.yeungeek.mvp.core.delegate;
2 |
3 | import android.os.Bundle;
4 |
5 | import com.yeungeek.mvp.common.MvpPresenter;
6 | import com.yeungeek.mvp.common.MvpView;
7 |
8 | /**
9 | * The concrete implementation of {@link}
10 | */
11 | public class ActivityMvpDelegateImpl>
12 | implements ActivityMvpDelegate {
13 | protected MvpInternalDelegate internalDelegate;
14 | protected ActivityMvpDelegateCallback delegateCallback;
15 |
16 | public ActivityMvpDelegateImpl(ActivityMvpDelegateCallback delegateCallback) {
17 | if (delegateCallback == null) {
18 | throw new NullPointerException("MvpDelegateCallback is null!");
19 | }
20 | this.delegateCallback = delegateCallback;
21 | }
22 |
23 | /**
24 | * Get the internal delegate.
25 | */
26 | protected MvpInternalDelegate getInternalDelegate() {
27 | if (internalDelegate == null) {
28 | internalDelegate = new MvpInternalDelegate<>(delegateCallback);
29 | }
30 |
31 | return internalDelegate;
32 | }
33 |
34 | @Override
35 | public void onCreate(Bundle bundle) {
36 | ActivityMvpNonConfigurationInstances nci =
37 | (ActivityMvpNonConfigurationInstances) delegateCallback.getLastCustomNonConfigurationInstance();
38 |
39 | if (null != nci && null != nci.presenter) {
40 | delegateCallback.setPresenter(nci.presenter);
41 | } else {
42 | getInternalDelegate().createPresenter();
43 | }
44 |
45 | getInternalDelegate().attachView();
46 | }
47 |
48 | @Override
49 | public void onDestroy() {
50 | getInternalDelegate().detachView();
51 | }
52 |
53 | @Override
54 | public void onPause() {
55 |
56 | }
57 |
58 | @Override
59 | public void onResume() {
60 |
61 | }
62 |
63 | @Override
64 | public void onStart() {
65 |
66 | }
67 |
68 | @Override
69 | public void onStop() {
70 |
71 | }
72 |
73 | @Override
74 | public void onRestart() {
75 |
76 | }
77 |
78 | @Override
79 | public void onContentChanged() {
80 |
81 | }
82 |
83 | @Override
84 | public void onSaveInstanceState(Bundle outState) {
85 |
86 | }
87 |
88 | @Override
89 | public void onPostCreate(Bundle savedInstanceState) {
90 |
91 | }
92 |
93 | @Override
94 | public Object onRetainCustomNonConfigurationInstance() {
95 | P presenter = delegateCallback.shouldInstanceBeRetained() ? delegateCallback.getPresenter() : null;
96 | Object nonMosbyConfiguraionInstance =
97 | delegateCallback.onRetainNonMosbyCustomNonConfigurationInstance();
98 |
99 | if (presenter == null && nonMosbyConfiguraionInstance == null) {
100 | return null;
101 | }
102 |
103 | return new ActivityMvpNonConfigurationInstances<>(presenter, nonMosbyConfiguraionInstance);
104 | }
105 |
106 | @Override
107 | public Object getNonMosbyLastCustomNonConfigurationInstance() {
108 | ActivityMvpNonConfigurationInstances last =
109 | (ActivityMvpNonConfigurationInstances) delegateCallback.getLastCustomNonConfigurationInstance();
110 | return last == null ? null : last.nonMosbyCustomConfigurationInstance;
111 | }
112 | }
113 |
--------------------------------------------------------------------------------
/mvp/src/main/java/com/yeungeek/mvp/core/delegate/ActivityMvpNonConfigurationInstances.java:
--------------------------------------------------------------------------------
1 | package com.yeungeek.mvp.core.delegate;
2 |
3 |
4 | import com.yeungeek.mvp.common.MvpPresenter;
5 | import com.yeungeek.mvp.common.MvpView;
6 |
7 | /**
8 | * This kind of class is used in Activities to save the presenter in retaining activities. It's a
9 | * mosby internal class.
10 | *
11 | * @author Hannes Dorfmann
12 | * @since 2.0.0
13 | */
14 | class ActivityMvpNonConfigurationInstances> {
15 |
16 | /**
17 | * The reference to the presenter
18 | */
19 | P presenter;
20 |
21 | /**
22 | * The reference to the custom non configuration.
23 | */
24 | Object nonMosbyCustomConfigurationInstance;
25 |
26 | /**
27 | * Constructor
28 | *
29 | * @param presenter The retaining presenter
30 | * @param nonMosbyCustomConfigurationInstance the other custom object
31 | */
32 | ActivityMvpNonConfigurationInstances(P presenter, Object nonMosbyCustomConfigurationInstance) {
33 | this.presenter = presenter;
34 | this.nonMosbyCustomConfigurationInstance = nonMosbyCustomConfigurationInstance;
35 | }
36 | }
37 |
--------------------------------------------------------------------------------
/mvp/src/main/java/com/yeungeek/mvp/core/delegate/BaseMvpDelegateCallback.java:
--------------------------------------------------------------------------------
1 | package com.yeungeek.mvp.core.delegate;
2 |
3 | import android.app.Activity;
4 |
5 | import com.yeungeek.mvp.common.MvpPresenter;
6 | import com.yeungeek.mvp.common.MvpView;
7 |
8 | /**
9 | * The MvpDelegate callback that will be called from {@link
10 | * FragmentMvpDelegate} or {@link ViewGroupMvpDelegate}. This interface must be implemented by all
11 | * Fragment or android.view.View that you want to support mosbys mvp. Please note that Activties
12 | * need a special callback {@link ActivityMvpDelegateCallback}
13 | *
14 | * @param The type of {@link MvpView}
15 | * @param The type of {@link MvpPresenter}
16 | */
17 | public interface BaseMvpDelegateCallback> {
18 | P createPresenter();
19 |
20 | P getPresenter();
21 |
22 | void setPresenter(P presenter);
23 |
24 | V getMvpView();
25 |
26 | /**
27 | * Indicate whether the retain instance feature is enabled by this view or not
28 | */
29 | boolean isRetainInstance();
30 |
31 | /**
32 | * Mark this instance as retaining. This means that the feature of a retaining instance is
33 | * enabled.
34 | */
35 | void setRetainInstance(boolean retainingInstance);
36 |
37 | /**
38 | * Indicates whether or not the the view will be retained during next screen orientation change.
39 | * This boolean flag is used for {@link MvpPresenter#detachView(boolean)}
40 | * as parameter. Usually you should take {@link Activity#isChangingConfigurations()} into
41 | * account. The difference between {@link #shouldInstanceBeRetained()} and {@link
42 | * #isRetainInstance()} is that {@link #isRetainInstance()} indicates that retain instance
43 | * feature is enabled or disabled while {@link #shouldInstanceBeRetained()} indicates if the
44 | * view is going to be destroyed permanently and hence should no more be retained (i.e. Activity
45 | * is finishing and not just screen orientation changing)
46 | *
47 | * @return true if the instance should be retained, otherwise false
48 | */
49 | boolean shouldInstanceBeRetained();
50 | }
51 |
--------------------------------------------------------------------------------
/mvp/src/main/java/com/yeungeek/mvp/core/delegate/FragmentMvpDelegateImpl.java:
--------------------------------------------------------------------------------
1 | package com.yeungeek.mvp.core.delegate;
2 |
3 | import android.app.Activity;
4 | import android.os.Bundle;
5 | import android.support.annotation.Nullable;
6 | import android.view.View;
7 |
8 | import com.yeungeek.mvp.common.MvpPresenter;
9 | import com.yeungeek.mvp.common.MvpView;
10 |
11 | /**
12 | * The default implementation of {@link FragmentMvpDelegate}
13 | */
14 | public class FragmentMvpDelegateImpl>
15 | implements FragmentMvpDelegate {
16 | protected BaseMvpDelegateCallback delegateCallback;
17 | protected MvpInternalDelegate internalDelegate;
18 |
19 | public FragmentMvpDelegateImpl(final BaseMvpDelegateCallback delegateCallback) {
20 | if (null == delegateCallback) {
21 | throw new NullPointerException("MvpDelegateCallback is null!");
22 | }
23 |
24 | this.delegateCallback = delegateCallback;
25 | }
26 |
27 | protected MvpInternalDelegate getInternalDelegate() {
28 | if (internalDelegate == null) {
29 | internalDelegate = new MvpInternalDelegate<>(delegateCallback);
30 | }
31 | return internalDelegate;
32 | }
33 |
34 | @Override
35 | public void onCreate(Bundle saved) {
36 |
37 | }
38 |
39 | @Override
40 | public void onDestroy() {
41 |
42 | }
43 |
44 | @Override
45 | public void onViewCreated(View view, @Nullable Bundle savedInstanceState) {
46 | getInternalDelegate().createPresenter();
47 | getInternalDelegate().attachView();
48 | }
49 |
50 | @Override
51 | public void onDestroyView() {
52 | getInternalDelegate().detachView();
53 | }
54 |
55 | @Override
56 | public void onPause() {
57 |
58 | }
59 |
60 | @Override
61 | public void onResume() {
62 |
63 | }
64 |
65 | @Override
66 | public void onStart() {
67 |
68 | }
69 |
70 | @Override
71 | public void onStop() {
72 |
73 | }
74 |
75 | @Override
76 | public void onActivityCreated(Bundle savedInstanceState) {
77 |
78 | }
79 |
80 | @Override
81 | public void onAttach(Activity activity) {
82 |
83 | }
84 |
85 | @Override
86 | public void onDetach() {
87 |
88 | }
89 |
90 | @Override
91 | public void onSaveInstanceState(Bundle outState) {
92 |
93 | }
94 | }
95 |
--------------------------------------------------------------------------------
/mvp/src/main/java/com/yeungeek/mvp/core/delegate/MvpInternalDelegate.java:
--------------------------------------------------------------------------------
1 | package com.yeungeek.mvp.core.delegate;
2 |
3 | import com.yeungeek.mvp.common.MvpPresenter;
4 | import com.yeungeek.mvp.common.MvpView;
5 |
6 | /**
7 | * This is just the internal implementation for the delegate. Don't use it by your own.
8 | */
9 | class MvpInternalDelegate> {
10 | protected BaseMvpDelegateCallback delegateCallback;
11 |
12 | MvpInternalDelegate(BaseMvpDelegateCallback delegateCallback) {
13 | if (delegateCallback == null) {
14 | throw new NullPointerException("MvpDelegateCallback is null!");
15 | }
16 | this.delegateCallback = delegateCallback;
17 | }
18 |
19 | /**
20 | * Called to create the presenter (if no other one already exisits)
21 | */
22 | void createPresenter() {
23 | P presenter = delegateCallback.getPresenter();
24 | if (presenter == null) {
25 | presenter = delegateCallback.createPresenter();
26 | }
27 | if (presenter == null) {
28 | throw new NullPointerException("Presenter is null! Do you return null in createPresenter()?");
29 | }
30 |
31 | delegateCallback.setPresenter(presenter);
32 | }
33 |
34 | /**
35 | * Attaches the view to the presenter
36 | */
37 | void attachView() {
38 | getPresenter().attachView(delegateCallback.getMvpView());
39 | }
40 |
41 | /**
42 | * Called to detach the view from presenter
43 | */
44 | void detachView() {
45 | getPresenter().detachView(delegateCallback.shouldInstanceBeRetained());
46 | }
47 |
48 | private P getPresenter() {
49 | P presenter = delegateCallback.getPresenter();
50 | if (presenter == null) {
51 | throw new NullPointerException("Presenter returned from getPresenter() is null");
52 | }
53 | return presenter;
54 | }
55 | }
56 |
--------------------------------------------------------------------------------
/mvp/src/main/res/values/ids.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |