/**
* View mandatory methods. Available to Presenter
* Presenter -> View
*/
interface RequiredViewOps {
void showToast(String msg);
void showAlert(String msg);
// any other ops
}
Interface PresenterOps
/**
* Operations offered from Presenter to View
* View -> Presenter
*/
interface PresenterOps{
void onConfigurationChanged(RequiredViewOps view);
void onDestroy(boolean isChangingConfig);
void addGrade(Grade grade);
// any other ops to be called from View
}
Interface RequiredPresenterOps
/**
* Operations offered from Presenter to Model
* Model -> Presenter
*/
interface RequiredPresenterOps {
void onAddGrade(Grade grade);
void onError(String errorMsg);
// Any other returning operation Model -> Presenter
}
Interface ModelOps
/**
* Model operations offered to Presenter
* Presenter -> Model
*/
interface ModelOps {
void insertGrade(Grade grade);
void onDestroy();
// Any other data operation
}
GradePresenter Class
publicclassGradePresenterimplementsRequiredPresenterOps,PresenterOps {// Layer View referenceprivate RequiredViewOps mView;
// Layer Model referenceprivate ModelOps mModel;
// Configuration change stateprivateboolean mIsChangingConfig;
public GradePresenterRequiredViewOps mView) {
this.mView = mView;
this.mModel = new MainModel(this);
}
/**
* Sent from Activity after a configuration changes
* @param view View reference
*/@OverridepublicvoidonConfigurationChanged(RequiredViewOps view) {
this.mView =view;
}
/**
* Receives {@link MainActivity#onDestroy()} event
* @param isChangingConfig Config change state
*/@OverridepublicvoidonDestroy(boolean isChangingConfig) {
mView = null;
mIsChangingConfig = isChangingConfig;
if ( !isChangingConfig ) {
mModel.onDestroy();
}
}
/**
* Called by user interaction from {@link MainActivity}
* creates a new Note
*/@OverridepublicvoidaddGrade(Grade grade) {
mModel.insertGrade(grade);
}
/**
* Called from {@link MainModel}
* when a Note is inserted successfully
*/@OverridepublicvoidonAddGrade(Grade grade){
mView.get().showToast("New grade added");
}
/**
* receive errors
*/@OverridepublicvoidonError(String errorMsg) {
mView.get().showAlert(errorMsg);
}
}
GradeModel Class
publicclassGradeModelimplementsModelOps {// Presenter referenceprivate RequiredPresenterOps mPresenter;
publicMainModel(RequiredPresenterOps mPresenter) {
this.mPresenter = mPresenter;
}
/**
* Sent from {@link MainPresenter#onDestroy(boolean)}
* Should stop/kill operations that could be running
* and aren't needed anymore
*/@OverridepublicvoidonDestroy() {
// destroying actions
}
// Insert grade in DB@OverridepublicvoidinsertGrade(Grade grade) {
// data business logic// ...
mPresenter.onAddGrade(grade);
}
}
publicclassStateMaintainer {protectedfinal String TAG = getClass().getSimpleName();
privatefinal String mStateMaintenerTag;
privatefinal WeakReference<FragmentManager> mFragmentManager;
private StateMngFragment mStateMaintainerFrag;
/**
* Constructor
* @param fragmentManager FragmentManager reference
* @param stateMaintainerTAG the TAG used to insert the state maintainer fragment
*/publicStateMaintainer(FragmentManager fragmentManager, String stateMaintainerTAG) {
mFragmentManager = new WeakReference<>(fragmentManager);
mStateMaintenerTag = stateMaintainerTAG;
}
/**
* Create the state maintainer fragment
* @return true: the frag was created for the first time
* false: recovering the object
*/publicbooleanfirstTimeIn() {
try {
// Recovering the reference
mStateMaintainerFrag = (StateMngFragment)
mFragmentManager.get().findFragmentByTag(mStateMaintenerTag);
// Creating a new RetainedFragmentif (mStateMaintainerFrag == null) {
Log.d(TAG, "Creating a new RetainedFragment " + mStateMaintenerTag);
mStateMaintainerFrag = new StateMngFragment();
mFragmentManager.get().beginTransaction()
.add(mStateMaintainerFrag, mStateMaintenerTag).commit();
returntrue;
} else {
Log.d(TAG, "Returns a existent retained fragment existente " + mStateMaintenerTag);
returnfalse;
}
} catch (NullPointerException e) {
Log.w(TAG, "Error firstTimeIn()");
returnfalse;
}
}
/**
* Insert Object to be preserved during configuration change
* @param key Object's TAG reference
* @param obj Object to maintain
*/publicvoidput(String key, Object obj) {
mStateMaintainerFrag.put(key, obj);
}
/**
* Insert Object to be preserved during configuration change
* Uses the Object's class name as a TAG reference
* Should only be used one time by type class
* @param obj Object to maintain
*/publicvoidput(Object obj) {
put(obj.getClass().getName(), obj);
}
/**
* Recovers saved object
* @param key TAG reference
* @param <T> Class type
* @return Objects
*/@SuppressWarnings("unchecked")
public <T> T get(String key) {
return mStateMaintainerFrag.get(key);
}
/**
* Verify the object existence
* @param key Obj TAG
*/publicbooleanhasKey(String key) {
return mStateMaintainerFrag.get(key) != null;
}
/**
* Save and manages objects that show be preserved
* during configuration changes.
*/publicstaticclassStateMngFragmentextendsFragment {private HashMap<String, Object> mData = new HashMap<>();
@OverridepublicvoidonCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// Grants that the frag will be preserved
setRetainInstance(true);
}
/**
* Insert objects
* @param key reference TAG
* @param obj Object to save
*/publicvoidput(String key, Object obj) {
mData.put(key, obj);
}
/**
* Insert obj using class name as TAG
* @param object obj to save
*/publicvoidput(Object object) {
put(object.getClass().getName(), object);
}
/**
* Recover obj
* @param key reference TAG
* @param <T> Class
* @return Obj saved
*/@SuppressWarnings("unchecked")
public <T> T get(String key) {
return (T) mData.get(key);
}
}
}
MainActivity Activity (View layer)
publicclassMainActivityextendsAppCompatActivityimplementsRequiredViewOps {protectedfinal String TAG = getClass().getSimpleName();
// Responsible to maintain the Objects state// during changing configurationprivatefinal StateMaintainer mStateMaintainer =
new StateMaintainer( this.getFragmentManager(), TAG );
// Presenter operationsprivate PresenterOps mPresenter;
@OverrideprotectedvoidonCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
startMVPOps();
setContentView(R.layout.activity_main);
Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
setSupportActionBar(toolbar);
FloatingActionButton fab = (FloatingActionButton) findViewById(R.id.fab);
}
/**
* Initialize and restart the Presenter.
* This method should be called after {@link Activity#onCreate(Bundle)}
*/publicvoidstartMVPOps() {
try {
if ( mStateMaintainer.firstTimeIn() ) {
Log.d(TAG, "onCreate() called for the first time");
initialize(this);
} else {
Log.d(TAG, "onCreate() called more than once");
reinitialize(this);
}
} catch ( InstantiationException | IllegalAccessException e ) {
Log.d(TAG, "onCreate() " + e );
thrownew RuntimeException( e );
}
}
/**
* Initialize relevant MVP Objects.
* Creates a Presenter instance, saves the presenter in {@link StateMaintainer}
*/privatevoidinitialize( RequiredViewOps view )
throws InstantiationException, IllegalAccessException{
mPresenter = new MainPresenter(view);
mStateMaintainer.put(PresenterOps.class.getSimpleName(), mPresenter);
}
/**
* Recovers Presenter and informs Presenter that occurred a config change.
* If Presenter has been lost, recreates a instance
*/privatevoidreinitialize( RequiredViewOps view)
throws InstantiationException, IllegalAccessException {
mPresenter = mStateMaintainer.get(PresenterOps.class.getSimpleName() );
if ( mPresenter == null ) {
Log.w(TAG, "recreating Presenter");
initialize( view );
} else {
mPresenter.onConfigurationChanged( view );
}
}
// Show AlertDialog@OverridepublicvoidshowAlert(String msg) {
// show alert Box
}
// Show Toast@OverridepublicvoidshowToast(String msg) {
Toast.makeText(getApplicationContext(), msg, Toast.LENGTH_SHORT).show;
}
}
转播
