L'objectif principal de la mise en œuvre du motif MVC est que cela vous permet de le faire, puis de «sortir» de l'un d'entre eux et de la gifler dans une nouvelle sans peu ni peu de changement nécessaire aux deux autres.

Modèle strong>: tout sur les données. Ce qui est manipulé, ce qui est stocké et comment? P>

Vue forte>: Tout sur l'interface utilisateur ou la présentation. Ce qui est affiché et comment. P>

contrôleur fort>: le gestionnaire d'événements. Dicte lorsque les deux autres sont exécutés en réponse aux événements. P>

dans Android, cette implémentation de MVC a le contrôleur sous la forme d'une classe qui étend la classe d'activité. Après tout, c'est cette classe qui reçoit initialement les «événements» qui constituent le cycle de vie d'une activité Android (c'est-à-dire surstart (), Oncreate (), ONSUSPEND (), ONESTOP (), OnResume (), Ondestroy). Ce cycle de vie changera probablement comme l'evolves Android, il est donc logique de le représenter comme composant du contrôleur du motif MVC. P>

à nouveau, avec cette implémentation MVC, je peux tirer n'importe lequel des trois composants et mettre Dans une toute nouvelle interface (vue) ou une nouvelle base de données (modèle) ou un nouveau cycle de vie d'activité (contrôleur) sans changement aux deux autres. La seule nécessité est que chaque composant respecte le modèle de la batterie répertorié ci-dessous. P>

Dans cette implémentation, les trois composants MVC sont représentés séparément par trois classes Java: venvie.java, appcontroller.java, Appmodel.java P>

Lors de la révision de chaque classe, notez les variables de membre, MController, Mappview et Mappmodel, et voir comment et quand ils sont référencés dans chaque fichier Java. Ces variables de membre sont des "crochets" qui permettent à chaque composant de se réferner mutuellement. P>

En outre, vous remarquerez que Mappmodel tombe encore plus loin et utilise une classe supplémentaire appelée DBHelper. Cela vous permet de séparer "Quelles" données est manipulée à partir de "Comment" que les données sont manipulées et stockées. P>

public class dbHelper extends SQLiteOpenHelper {

    private SQLiteDatabase mDB;

    private Context mContext;


    static final String DATABASE_NAME = "whatever";

    static final String DATABASE_FILE = DATABASE_NAME + ".db";

    static final String DBKEY_FIELD = "rowid";

    static final int DATABASE_VERSION = 5;

    // SQL Statement to create a new database.
    private static final String DATABASE_CREATE = "CREATE TABLE IF NOT EXISTS " + DATABASE_NAME
            + "(....  );";

    // SQL statement used to upgrade the database.
    private final String ALTER_TABLE = "ALTER TABLE " + DATABASE_NAME + " ADD COLUMN anewfield VARCHAR;";

    private final String SELECT_ALL = "SELECT " + DBKEY_FIELD + " AS _id, * FROM " + DATABASE_NAME + " ORDER BY somefield ASC";

    private static final String DROP_TABLE = "DROP TABLE IF EXISTS " + DATABASE_NAME;


    public dbHelper(Context controller) {
        super(controller, DATABASE_FILE, null, DATABASE_VERSION);

        mContext = controller;
    }

    // Called when no database exists or if there is a new 'version' indicated.
    @Override
    public void onCreate(SQLiteDatabase db) {

        db.execSQL(DATABASE_CREATE);
    }


    public dbHelper open() {

        try {

            mDB = getWritableDatabase();

        } catch (SQLException ex) {

            if (mDB != null && mDB.isOpen()) {

                mDB.close();
            }

            if (mDB != null) {

                mDB = null;
            }
        }

        return this;
    }


    public boolean isOpen() {

        return mDB != null && mDB.isOpen();
    }


    public void close() {
        super.close();

        // It's good to lose the reference here with the connection closed.
        mDB = null;
    }


    protected void onDestroy() {

        close();

        // Just making sure.
        mDB = null;

        mContext = null;
    }


    public SQLiteDatabase getDatabaseInstance() {

        return mDB;
    }



    private Cursor runQuery(String sqlStmt) {

        Cursor records;

        try {

            records = mDB.rawQuery(sqlStmt, null);

        } catch (RuntimeException ex) {

            // If something goes wrong, return an empty cursor.
            records = new MatrixCursor(new String[]{"empty"});
        }

        return records;
    }


    protected boolean dropTable() {

        boolean dropped;

        try {

            mDB.execSQL("DROP TABLE IF EXISTS " + DATABASE_NAME);

            dropped = true;

        } catch (SQLException ex) {

            dropped = false;
        }

        return dropped;
    }


    @Override
    public void onConfigure(SQLiteDatabase db) {
    }

    @Override
    public void onOpen(SQLiteDatabase db) {
    }

    // Called when the database needs to be upgraded to the current version.
@Override
    public void onUpgrade(SQLiteDatabase _db, int _oldVersion, int _newVersion) {

        if ( _oldVersion >= _newVersion){

            Log.w(mContext.getClass().getSimpleName(), "Cannot 'upgrade' from version " + _newVersion + " to " + _oldVersion + ". Upgrade attempt failed.");
        }

        try {

            _db.execSQL(ALTER_TABLE);

        }catch(RuntimeException ex){

            Log.e(mContext.getClass().getSimpleName(), "Database upgrade failed. Version " + _oldVersion + " to " + _newVersion);

            throw ex;
        }

        // Log the version upgrade.
        Log.i(mContext.getClass().getSimpleName(), "Database upgrade. Version " + _oldVersion + " to " + _newVersion);
    }

}

Pas vraiment mvc mais de devenir plus mvc avec la chambre et la Liveta

Dans Classique MVC, le contrôleur concerne la prise de décision, quelle action à exécuter ensuite. La vue lit les données du modèle et met à jour ses propres champs.

Dans les activités Android font les deux, ils prennent des décisions sur quelles mesures pour courir en réponse à un événement et définissent les champs des mises en page. Ils lisent également des données du modèle et des widgets de métro. Les activités combinent les tâches logiques des deux, le contrôleur classique et la vue classique.

C'est pourquoi je ne parlerais pas de MVC dans la plupart des cas. Il n'y a pas de séparation propre entre le contrôleur et la vue. Il y a une séparation propre entre Java Code et XML Ressources. Cela a du sens, comme dans les plus grandes équipes, différentes personnes sont responsables de la mise en page visuelle et de la programmation.

Vous pouvez toujours coder vos propres composants d'affichage et aborder cette partie du code comme vue. Ce n'est que la partie passive de la vue classique, tandis que la logique a rejoint le contrôleur dans les activités et les fragments. Je ne parlerais pas d'une vue mais de composants ou de widgets. Les widgets les plus intelligents sont, plus la logique de la vue classique est à nouveau.

D'autre part, si vous appliquez des bibliothèques telles que la chambre, Android devient encore beaucoup plus mvc. Chambre et LiveData Activez les vues pour observer les modifications du modèle jusqu'à modification de la base de données. Si vous séparez de manière proprement des affaires et réduisez les contrôleurs à la prise de décision, vous pouvez structurer votre architecture d'une manière, qu'elle mérite vraiment le nom MVC.

Bottom Line

Cela dépend du développeur. Il est possible d'appliquer un vrai MVC à Android, mais ce n'est pas le cas par défaut.