Modèle MVC sur Android

il n'y a pas de modèle MVC universellement unique. MVC est un concept plutôt qu'un cadre de programmation solide. Vous pouvez mettre en œuvre votre propre MVC sur n'importe quelle plate-forme. Aussi longtemps que vous vous en tenez à l'idée de base suivante, vous mettez en œuvre MVC:

• Modèle: Quoi rendre
• : Comment rendre
• contrôleur: événements, entrée utilisateur

pensez aussi à cela de cette façon: lorsque vous programmez votre modèle, le modèle ne devrait pas avoir à se soucier du rendu (ou du code spécifique à la plate-forme). Le modèle dirait à la vue, Je ne me soucie pas si votre rendu est Android ou iOS ou Windows Phone, c'est ce que j'ai besoin de vous pour rendre. La vue ne traiterait que le code de rendu spécifique à la plate-forme.

cela est particulièrement utile lorsque vous utilisez Mono pour partager le modèle dans l'ordre développer des applications multiplateformes.

les actions, les vues et les activités sur Android sont la cuite-dans la façon de travailler avec L'interface utilisateur Android et sont une mise en œuvre du modèle modèle–vue–viewmodel (MVVM) , qui est structurellement similaire (dans la même famille que) modèle–Vue–Contrôleur.

à ma connaissance, il n'y a aucun moyen de sortir de ce modèle. Il peut probablement être fait, mais vous auriez probablement à perdre tous les avantages que le modèle a et réécrire votre propre couche UI pour le faire fonctionner.

après quelques recherches, la réponse la plus raisonnable est la suivante:

MVC est déjà mis en œuvre sur Android comme:

1. View = mise en page, les ressources et les classes intégrées comme Button , dérivé de android.view.View .
2. Controller = Activité
3. Modèle = les classes qui implémentent la logique de l'application

logique du domaine d'application dans l'activité.)

la chose la plus raisonnable pour un petit développeur est de suivre ce modèle et de ne pas essayer de faire ce que Google a décidé de ne pas faire.

PS notez que L'activité est parfois redémarrée, de sorte qu'il n'y a pas de place pour les données de modèle (la façon la plus simple de provoquer un redémarrage est d'omettre android:configChanges="keyboardHidden|orientation" du XML et de tourner votre appareil).

EDIT

nous pouvons être en train de parler de MVC , mais il en sera ainsi pour dire FMVC , Framework-Modèle-Vue--Contrôleur . Le Framework (L'OS Android) impose son idée du cycle de vie des composants et des événements connexes, et dans la pratique le contrôleur ( Activity / Service / BroadcastReceiver ) est d'abord responsable de faire face à ces cadre événements imposés (tels que onCreate () ). Les commentaires des utilisateurs devraient-ils être traités séparément? Même s'il devrait, vous ne pouvez pas le séparer, les événements d'entrée d'utilisateur viennent aussi D'Android.

de toute façon, le moins de code qui n'est pas spécifique à Android que vous mettez dans votre Activity / Service / BroadcastReceiver , le meilleur.

il n'y a pas de modèle MVC unique auquel vous pourriez obéir. MVC se contente d'indiquer plus ou moins que vous ne devez pas mélanger les données et les vues, de sorte que par exemple les vues sont responsables du maintien des données ou les classes qui traitent les données affectent directement la vue.

mais néanmoins, la façon dont Android traite avec les classes et les ressources, vous êtes parfois même forcé de suivre le modèle MVC. A mon avis, les activités qui sont parfois responsables de la voir, mais néanmoins agir en tant que contrôleur dans le même temps.

si vous définissez vos vues et layouts dans les fichiers XML, chargez vos ressources à partir du dossier res, et si vous évitez plus ou moins de mélanger ces choses dans votre code, alors vous êtes de toute façon suivant un modèle MVC.

la meilleure ressource que j'ai trouvé pour mettre en œuvre MVC sur Android est ce post :

j'ai suivi le même design pour l'un de mes projets, et ça a bien fonctionné. Je suis un débutant sur Android, donc je ne peux pas dire que c'est la meilleure solution.

j'ai fait une modification: j'ai instancié le modèle et le contrôleur pour chaque activité de la classe application afin qu'ils ne soient pas recréés lorsque le mode paysage-portrait change.

vous pouvez mettre en œuvre MVC dans Android, mais il n'est pas" nativement pris en charge " et prend un certain effort.

cela dit, j'ai personnellement tendance à MVP comme un modèle architectural beaucoup plus propre pour le développement Android. Et en disant MVP je veux dire ceci:

j'ai aussi posté une réponse plus détaillée ici .

après avoir joué avec les différentes approches de MVC / MVP mise en œuvre dans Android, je suis venu avec un modèle architectural raisonnable, que je ai décrit dans un ce post: MVP et MVC modèles architecturaux dans Android .

je suis d'accord avec JDPeckham, et je crois que XML seul n'est pas suffisant pour implémenter la partie UI d'une application.

cependant, si vous considérez l'activité comme faisant partie de la vue, alors la mise en œuvre MVC est assez simple. Vous pouvez remplacer Application (comme retourné par getApplication () dans Activity) et c'est ici que vous pouvez créer un contrôleur qui survit pour la durée de vie de votre application.

(Alternativement vous pouvez utiliser le modèle singleton comme suggéré par la documentation de l'Application)

création D'UI Android en utilisant des layouts, des ressources, des activités et des intentions est une mise en œuvre du modèle MVC. S'il vous plaît voir le lien suivant pour plus d'informations sur ce - http://www.cs.otago.ac.nz/cosc346/labs/COSC346-lab2.2up.pdf

miroir pour le pdf

MVC - Architecture on Android il vaut mieux suivre N'importe quel MVP à la place MVC dans android. Mais encore selon la réponse à la question cela peut être la solution

Description et lignes directrices

     Controller -
        Activity can play the role.
        Use an application class to write the
        global methods and define, and avoid
        static variables in the controller label
    Model -
        Entity like - user, Product, and Customer class.
    View -
        XML layout files.
    ViewModel -
        Class with like CartItem and owner
        models with multiple class properties
    Service -
        DataService- All the tables which have logic
        to get the data to bind the models - UserTable,
        CustomerTable
        NetworkService - Service logic binds the
        logic with network call - Login Service
Helpers -
        StringHelper, ValidationHelper static
        methods for helping format and validation code.
SharedView - fragmets or shared views from the code
        can be separated here

AppConstant -
        Use the Values folder XML files
        for constant app level

NOTE 1:

Maintenant voici le morceau de magie que vous pouvez faire. Une fois que vous avez classé le morceau de code, écrivez une classe d'interface de base comme, IEntity et IService. Déclarer des méthodes communes. Maintenant créer la classe abstraite BaseService et déclarer votre propre ensemble de méthodes et avoir la séparation du code.

NOTE 2: si votre activité présente plusieurs modèles alors plutôt que d'écrire le code/la logique dans l'activité, il est préférable de diviser les vues en fragments. Puis c'est mieux. Donc, dans l'avenir si plus de modèle est nécessaire pour apparaître dans la vue, d'en ajouter un fragment.

NOTE 3: la séparation du code est très importante. Chaque composante de l'architecture doit être indépendante et ne pas avoir de logique dépendante. Si par hasard si vous avez quelque chose de la logique dépendante, alors écrivez une classe de la logique de mapping entre les deux. Cela vous aidera dans l'avenir.

bien que ce post semble être vieux, je voudrais ajouter les deux suivants pour informer sur le développement récent dans ce domaine pour Android:

android-binding - fournissant un cadre qui enabes la liaison des widgets de vue android au modèle de données. Il aide à mettre en œuvre des modèles MVC ou MVVM dans les applications android.

roboguice - RoboGuice élimine les conjectures du développement. Injectez votre vue, ressource, Service système, ou tout autre objet, et laissez RoboGuice s'occuper des détails.

modèle MVC D'Android est (genre de) mis en œuvre avec leur Adaptateur classes. Ils remplacent un contrôleur par un "adaptateur."La description de l'adaptateur indique:

un objet adaptateur agit comme un pont entre un AdapterView et le données sous-jacentes pour ce point de vue.

je suis juste à la recherche dans ce pour une application Android qui lit à partir d'une base de données, donc je ne sais pas comment il fonctionne encore. Cependant, cela ressemble un peu à L'architecture Model-View-Delegate de Qt, qui, selon eux, est un pas en avant par rapport à un modèle MVC traditionnel. Au moins sur le PC, le modèle de Qt fonctionne assez bien.

Modèle-Vue-Contrôleur (MVC)

Description:

• quand nous avons à main de grands projets dans le développement du logiciel, MVC est généralement utilisé parce que c'est une façon universelle d'organiser le projet.
• de nouveaux développeurs peuvent s'adapter rapidement au projet
• aide dans le développement de grands projets et plate-forme croisée aussi.

le modèle MVC est essentiellement ceci:

• Modèle: éléments à afficher. Cela peut être la source de données (Ex: serveur, Raw données dans l'app)
• View: comment il est affiché. Ceci peut être le xml. Il agit donc comme un présentation du filtre. Une vue est attachée à son modèle (ou modèle partie) et obtient les données nécessaires à la présentation.
• Contrôleur: gestion des événements comme la saisie de l'utilisateur. Ce soit l'activité

caractéristique importante de MVC: nous pouvons modifier soit le modèle, soit la vue ou le contrôleur n'affectant pas encore les autres

• dire que nous changeons la couleur dans la vue, la taille de la vue ou le position de la vue. Ce faisant, il n'affectera ni le modèle ni le contrôleur
• disons que nous changeons le modèle (au lieu des données récupérées à partir du serveur fetch data from assets) cela n'affectera pas la vue et contrôleur
• disons que nous changeons le Controller (logique dans l'activité) cela n'affectera pas le modèle et la vue

je pense que l'explication simplifiée la plus utile est ici: http://www.cs.otago.ac.nz/cosc346/labs/COSC346-lab2.2up.pdf

de tout ce que j'ai vu et lu ici, la mise en œuvre de toutes ces choses rend plus difficile et ne s'intègre pas bien avec d'autres parties d'android.

ayant une activité mettre en œuvre d'autres auditeurs est déjà la norme Android way. La manière la plus inoffensive serait d'ajouter le Java Observer comme les diapositives décrivent et groupent l'onClick et d'autres types d'actions en fonctions qui sont encore dans l'activité.

la façon Android est que l'activité fait les deux. Lutter contre cela ne rend pas vraiment l'extension ou faire du codage futur plus facile.

je suis d'accord avec le 2ème post . C'est déjà en quelque sorte mis en œuvre, mais pas comme les gens sont habitués. Que ce soit dans le même dossier ou non, il y a déjà séparation. Il n'est pas nécessaire de créer une séparation supplémentaire pour la rendre compatible avec d'autres langues et OS.

fatigué du désastre MVx sur Android, j'ai récemment fait une petite bibliothèque qui fournit un flux de données unidirectionnel et est similaire au concept de MVC: https://github.com/zserge/anvil

fondamentalement, vous avez un composant (activité, fragment, et viewgroup). À l'intérieur vous définissez la structure et le style de la couche de vue. Vous définissez aussi comment les données doivent être liées aux vues. Enfin, vous pouvez lier les auditeurs au même endroit.

ensuite, une fois vos données modifiées - la méthode globale "render()" sera appelée, et vos vues seront intelligemment mises à jour avec les données les plus récentes.

voici un exemple du composant ayant tout à l'intérieur pour la compacité du code (Bien sûr le Modèle et le contrôleur peuvent être facilement séparés). Ici "count" est un model, la méthode view () est une view, et "v -> count++" est un controller qui écoute le bouton clique et met à jour le model.

public MyView extends RenderableView {
  public MyView(Context c) {
      super(c);
  }

  private int count = 0;

  public void view() {
    frameLayout(() -> {              // Define your view hierarchy
      size(FILL, WRAP);
      button(() -> {
          textColor(Color.RED);      // Define view style
          text("Clicked " + count);  // Bind data
          onClick(v -> count++);     // Bind listeners
      });
    });
  }

avec le modèle séparé et le contrôleur il ressemblerait à:

button(() -> {
   textColor(Color.RED);
   text("Clicked " + mModel.getClickCount());
   onClick(mController::onButtonClicked);
});

ici sur chaque bouton cliquez le nombre sera augmenté, puis "render ()" sera appelé, et le texte du bouton sera mis à jour.

la syntaxe devient plus agréable si vous utilisez Kotlin: http://zserge.com/blog/anvil-kotlin.html . En outre, il existe une syntaxe alternative pour Java sans lambdas.

La bibliothèque lui-même est très léger, n'a pas de dépendances, n'utilise pas de réflexion, etc.

(Disclaimer: je suis l'auteur de cette bibliothèque)

il n'y a pas d'architecture MVC implémentée, mais il existe un ensemble de bibliothèques / exemples pour implémenter une architecture MVP (model–view–presenter).

s'il vous plaît, vérifiez ces liens:

• https://github.com/sockeqwe/mosby

• https://github.com/android10/Android-CleanArchitecture

• https://github.com/antoniolg/androidmvp

Google a ajouté un exemple D'architecture Android MVP:

• https://github.com/googlesamples/android-architecture

j'ai vu que beaucoup de gens disent MVC est déjà mis en œuvre dans Android, mais ce n'est pas vrai. Android ne suit aucun MVC par défaut.

parce que Google n'aime pas imposer avec force les restrictions d'une implémentation MVC comme l'iPhone, mais ils ont laissé cette décision à l'utilisateur d'utiliser la technique MVC, parce que dans les applications petites ou simples, nous n'avons pas besoin d'utiliser MVC, mais comme l'application se complique et aura besoin de modifier son code après le développement est terminé, puis il vient un besoin du modèle MVC dans Android.

il fournit un moyen facile de modifier le code et aussi aider dans les questions indésirables. Ceux-ci viennent dans les modèles de conception simple Android. Si vous souhaitez mettre en œuvre MVC sur Android, puis suivez ce lien ci-dessous et profitez des techniques de mise en œuvre MVC dans votre projet.

http://www.therealjoshua.com/2011/11/android-architecture-part-1-intro /

selon l'explication que l'équipe de Xamarin a expliqué (sur L'iOS MVC "je sais que cela semble étrange, mais attendez une seconde"):

• Le modèle (les données ou de l'application de la logique),
• La vue (interface utilisateur), et
• le contrôleur (code derrière).

je peux dire ceci:

le modèle sur Android est simplement l'objet divisible. Le view est la mise en page XML, et le controller est le (activity + its fragment).

*C'est juste mon avis, pas à partir d'une ressource ou d'un livre.

lorsque nous appliquons MVC, MVVM , ou modèle de présentation à une application Android, ce que nous voulons vraiment est d'avoir un projet structuré clair et plus important encore plus facile pour les tests unitaires.

actuellement, sans cadre tiers, vous avez généralement beaucoup de code (comme addXXListener(), findViewById(), etc.), ce qui n'ajoute aucune valeur à l'entreprise.

de plus, vous devez exécuter des tests de L'Unité Android au lieu des tests JUnit normaux, qui prennent des années à courir et rendent les tests unitaires quelque peu impraticables. Pour ces raisons, il ya quelques années, nous avons commencé un projet open source, RoboBinding - un cadre de modèle de présentation de liaison de données pour la plate-forme Android.

RoboBinding vous aide à écrire le code UI qui est plus facile à lire, tester et maintenir. RoboBinding supprime le besoin de code inutile comme addXXListener ou ainsi , et déplace UI logic to Presentation Model, qui est un POJO et peut être testé via normal JUnit tests . RoboBinding lui-même est livré avec plus de 300 tests JUnit pour assurer sa qualité.

il était surprenant de voir qu'aucun des billets ne répondait à la question. Ils sont soit trop général, vague, incorrect ou ne traitent pas l'implémentation dans android.

dans MVC, la couche View ne sait que montrer l'interface utilisateur (UI). Si des données sont nécessaires pour cela, elles proviennent de la couche Model . Mais la vue ne demande pas directement au modèle de trouver les données, il le fait à travers le Contrôleur . Ainsi, le Contrôleur appelle la Modèle pour fournir les données nécessaires pour le Vue . Une fois les données prêtes, le contrôleur informe le View que les données sont prêtes à être acquises à partir du modèle . Maintenant, le voir peut obtenir les données du modèle .

ce flux peut être résumé comme suit:

Il est intéressant de noter que le Vue peut savoir à propos de la disponibilité des données dans le Modèle soit par Contrôleur - également connu comme le "1519470920 Passive" MVC -- ou en observant les données dans le Modèle par enregistrant des observables à elle, qui est MVC Active .

en ce qui concerne la mise en œuvre, l'une des premières choses qui vient à l'esprit est que quel composant android devrait être utilisé pour le View ? Activity ou Fragment ?

la réponse est qu'il n'importe pas et les deux peuvent être utilisés. Le View devrait être capable de présenter l'interface utilisateur (UI) sur l'appareil et répondre l'interaction de l'utilisateur avec l'INTERFACE utilisateur. Les deux Activity et Fragment fournissent les méthodes requises à cet effet.

dans l'exemple app utilisé dans cet article j'ai utilisé Activity pour le voir couche, mais Fragment peut également être utilisé.

l'application d'échantillonnage complète se trouve dans la branche" mvc "de mon github repo ici .

j'ai aussi traité avec les avantages et les inconvénients de l'architecture MVC dans android à travers un exemple ici .

pour ceux intéressés, j'ai commencé une série d'articles sur l'architecture de l'application android ici dans lequel je compare les différentes architectures, c'est-à-dire MVC, MVP, MVVM, pour le développement de l'application android à travers une application complète de travail.

Modèle-Vue-Contrôleur dans Android Vers 2011, quand Android a commencé à devenir de plus en plus populaire, les questions d'architecture sont apparus naturellement. Depuis MVC était l'un des modèles D'UI les plus populaires à cette époque, les développeurs ont essayé de l'appliquer à Android aussi.

Modèle Le Modèle représente un ensemble de classes qui décrivent la logique métier d'affaires modèle ainsi que les opérations d'accès aux données c'est à dire le modèle de données. Il définit également des règles commerciales pour les données signifie Comment les données peuvent être modifiées et manipulées.

Vue La vue représente les composantes de L'assurance-chômage. Il n'est responsable que de l'affichage des données reçues du responsable du traitement. Cela transforme également le(S) Modèle (s) en UI.

Contrôleur Le Contrôleur est responsable de processus les demandes entrantes. Il reçoit les entrées des utilisateurs via la vue, puis traite les données de l'utilisateur à l'aide de Model et renvoie les résultats à la vue. En général, il agit comme coordinateur entre le point de vue et le modèle.

en d'autres mots

Modèles: Les Fournisseurs De Contenu. Les gestionnaires de données qui sont la forme recommandée de partage de données entre les applications.

Vues: Activités. C'est la principale interface utilisateur de l'application composant. Chaque écran individuel D'une application Android est dérivé de la classe D'activité Java (android.App.Activité.) Ils sont des conteneurs pour les vues (android.vue.Vue.)

Contrôleurs: Services. Ce sont des composants d'arrière-plan qui se comportent comme des démons UNIX et des Services Windows. Ils fonctionnent invisiblement et effectuent un traitement continu sans surveillance.