Est-il bon d'avoir une classe BaseActivity et qui agira comme une super classe pour toutes les autres activités. J'en ai besoin pour avoir des implémentations communes pour les activités.

BaseActivity:

public class BaseActivity extends Activity
{
     //All Common implementations goes here
}

Activités

public class HomeActivity extends BaseActivity
{
}
6
user1618825 27 nov. 2017 à 12:26

3 réponses

Meilleure réponse

Dans ce cas, je suggère d'avoir une activité abstraite de base et deux sous-classes héritées concrètes. Vous définissez tous les comportements communs dans l'activité de base et disposez de méthodes abstraites pour les différences, que vous remplacez ensuite dans vos implémentations réelles.

Par exemple, pour deux activités avec des ressources de mise en page différentes:

public abstract class BaseActivity extends Activity { 
    @Override
    public void onCreate(Bundle savedInstanceState) { 
        super.onCreate(savedInstanceState);
        setContentView(getLayoutResourceId()); 
    } 
    protected abstract int getLayoutResourceId(); 
} 



public class Activity1 extends BaseActivity { 
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState); // do extra stuff on your resources, using findViewById on your layout_for_activity1 
    } 
     @Override
    protected int getLayoutResourceId(){ 
        return R.layout.layout_for_activity1;
    } 
}

Vous pouvez avoir beaucoup plus de méthodes abstraites, pour chaque élément que vous voulez spécifique à vos sous-classes.

Faire cela est, à mon avis, beaucoup mieux que d'avoir une sous-classe concrète à une superclasse concrète: cela peut conduire à de nombreux problèmes et est généralement difficile à déboguer.

Bon codage. Faites-moi savoir besoin de plus d'aide !!

12
Farrokh 15 août 2018 à 11:29

J'ai utilisé ce type de BaseActivity pour toutes les couvertures de méthodes courantes.

public abstract class AbstractBaseActivity extends AppCompatActivity{



    private ProgressDialog mProgressDialog;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(getContentView());
        ButterKnife.bind(this);
        onViewReady(savedInstanceState, getIntent());
    }

    @CallSuper
    protected void onViewReady(Bundle savedInstanceState, Intent intent) {
        //To be used by child activities
    }

    @Override
    protected void onDestroy() {
        ButterKnife.bind(this);
        super.onDestroy();
    }

    protected void hideKeyboard() {
        try {
            InputMethodManager imm = (InputMethodManager) getSystemService(INPUT_METHOD_SERVICE);
            if (getCurrentFocus() != null)
                imm.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);
        } catch (Exception e) {
            Log.e("MultiBackStack", "Failed to add fragment to back stack", e);
        }
    }


    public void noInternetConnectionAvailable() {
        showToast(getString(R.string.noNetworkFound));
    }


    protected void showBackArrow() {
        ActionBar supportActionBar = getSupportActionBar();
        if (supportActionBar != null) {
            supportActionBar.setDisplayHomeAsUpEnabled(true);
            supportActionBar.setDisplayShowHomeEnabled(true);
        }
    }

    public void showProgressDialog(String title, @NonNull String message) {
        if (mProgressDialog == null) {
            mProgressDialog = new ProgressDialog(this);
            if (title != null)
                mProgressDialog.setTitle(title);
            mProgressDialog.setIcon(R.mipmap.ic_launcher);
            mProgressDialog.setProgressStyle(ProgressDialog.STYLE_SPINNER);
            mProgressDialog.setCancelable(false);
        }
        if (!mProgressDialog.isShowing()) {
            mProgressDialog.setMessage(message);
            mProgressDialog.show();
        }
    }


    public void hideDialog() {
        if (mProgressDialog != null && mProgressDialog.isShowing()) {
            mProgressDialog.dismiss();
        }
    }

    protected void showAlertDialog(String msg) {
        AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this);
        dialogBuilder.setTitle(null);
        dialogBuilder.setIcon(R.mipmap.ic_launcher);
        dialogBuilder.setMessage(msg);
        dialogBuilder.setPositiveButton(getString(R.string.dialog_ok_btn), new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int which) {
                dialog.cancel();
            }
        });

        dialogBuilder.setCancelable(false);
        dialogBuilder.show();
    }

    protected void showToast(String mToastMsg) {
        Toast.makeText(this, mToastMsg, Toast.LENGTH_LONG).show();
    }

    protected abstract int getContentView();

}

Dans chacune de mes activités.

public class MainActivity extends AbstractBaseActivity
{
      @Override
    protected int getContentView() {
        return R.layout.main_activity;//your layout
    }

    @Override
    protected void onViewReady(Bundle savedInstanceState, Intent intent) {
        super.onViewReady(savedInstanceState, intent);
        //your code
        //get baseclass methods like this
        //showToast("hello");

    }
}

Bon codage :)

7
Mitesh Vanaliya 27 nov. 2017 à 09:37

Tout dépend de vos besoins, mais pour des raisons d'évolutivité, il a toujours été pratique d'avoir une classe de base pour mettre toutes vos fonctions partagées. Je suggérerai énormément d'utiliser une classe abstraite juste au cas où vous auriez besoin de définir différentes implémentations de comportements partagés, comme obtenir le nom de la classe ou le nom d'écran.

1
CodeDaily 27 nov. 2017 à 09:36
47507531