Cet article décrit la partie de la connaissance du développement Android, en lecture de cet article, vous récolterez ce qui suit:

1.DisplayManagerService début

rôle 2.DisplayManagerService

héritage 3.DisplayManagerService

constructeur 4.DisplayManagerService

Procédé 5.DisplayManagerService de onStart

Procédé 6.DisplayManagerService de onBootPhase

avant-propos

Appelé ici le chemin de classe de code, impliquant les codes suivants, s'il vous plaît se référer aux répertoires suivants.

les cadres de Base \ services \ java \ com \ applications \ serveur \ base \ SystemServer.javaframeworks \ services de noyau \ java \ com \ applications \ server \ affichage \ DisplayManagerService.java

1.DisplayManagerService début

DisplayManagerService est SystemServer

StartService startBootstrapServices initiée par la phase de démarrage, le code est le suivant:

public final class SystemServer { ... startBootstrapServices private void () { ... // gestionnaire d'affichage est nécessaire pour fournir des mesures d'affichage avant gestionnaire de paquets // démarre. traceBeginAndSlog ( "StartDisplayManager") ;. // 1 début DisplayManagerService mDisplayManagerService = mSystemServiceManager.startService (DisplayManagerService.class); traceEnd (); ... } ... }

rôle 2.DisplayManagerService

DisplayManagerService utilisé pour gérer le cycle de vie de l'écran, qui détermine la manière dont l'appareil de commande connecté à l 'affichage physique affiche la logique, et lorsque le changement d'état, la notification est envoyée au système et d'applications, et analogues.

Est une collection de composants DisplayManagerService DisplayAdapter dépend, qui est l'affichage du système, le dispositif d'affichage a été recueilli et a trouvé pour fournir l'effet physique de l'adaptateur.

Il y a deux façons d'adaptateurs pour une utilisation

A, prévoir un adaptateur pour le dispositif d'affichage local.

En second lieu, la simulation fournit aux développeurs avec l'adaptateur d'affichage.

DisplayAdapter DisplayManagerService avec une relation de couplage faible. DisplayAdapter communication asynchrone est mis en uvre par l'enregistrement DisplayAdapter.Listener de classe DisplayManagerService.

Il y a deux raisons de le faire

A, encapsule habilement ces deux classes de fonctions,

DisplayAdapter: Appareil de traitement d'affichage respectif

DisplayManagerService: poignée état d'affichage global.

En second lieu, éliminer la possibilité de découverte de dispositif d'affichage asynchrone conduit à une impasse

Synchronisation (genlock)

Parce que le gestionnaire d'affichage est accessible par plusieurs threads, verrouillage de synchronisation de sorte qu'il devient un peu compliqué. Surtout quand le gestionnaire de fenêtres (gestionnaire de fenêtres) appelle le gestionnaire d'affichage (gestionnaire d'affichage) tout en maintenant le dessin des affaires, les gestionnaires de fenêtres attendent à appliquer immédiatement et le changement. Malheureusement, le gestionnaire d'affichage (gestionnaire d'affichage) ne peut pas tout faire de manière asynchrone.

Pour résoudre ce problème, montrant tout le gestionnaire d'objets doit tenir le même verrou. Nous avons appelé ce verrou de synchronisation de verrouillage unique.

héritage 3.DisplayManagerService

l'héritage DisplayManagerService SystemService, initié par SystemServer.

DisplayManagerService class public final étend SystemService { ... }

Service SystemService est le système de classe de base, les utilisations de classe pertinentes pour réécrire le cycle de vie des méthodes suivantes (constructeur, onStart (), onBootPhase (int)), et toutes les méthodes du cycle de vie peut être le principal appel de cycle de fil du serveur du système continental.

constructeur

Elle est appelée lorsque l'initialisation du système SystemService.

Procédé onStart ()

Les services fonctionnent le temps est appelé, et ce besoin de temps pour annoncer Interface Binder

publishBinderService (String, IBinder)

Parfois, en même temps, il a annoncé un nombre total d'appels de processus de système de publishLocalService de services locaux.

onBootPhase (int) Méthode

Dans la phase de démarrage, il sera appelé plusieurs fois, jusqu'à ce que PHASE_BOOT_COMPLETED

DisplayManagerService méthode suivante est utilisée conformément à ce processus.

constructeur 4.DisplayManagerService

Code constructeur DisplayManagerService est la suivante:

 DisplayManagerService publique (contexte de contexte) {ce (contexte, nouvelle Injector ()); } @VisibleForTesting DisplayManagerService (contexte de contexte, injecteur Injector) {super (contexte); mInjector = injecteur; mContext = contexte // mHandler utilisé pour envoyer un affichage de message mHandler = new DisplayManagerHandler (DisplayThread.get () getLooper ().); mUiHandler = UiThread.getHandler (); mDisplayAdapterListener = new DisplayAdapterListener (); mSingleDisplayDemoMode = SystemProperties.getBoolean ( "persist.demo.singledisplay", false); mDefaultDisplayDefaultColorMode = mContext.getResources (). getInteger ( com.android.internal.R.integer.config_defaultDisplayDefaultColorMode); PowerManager pm = (PowerManager) mContext.getSystemService (Context.POWER_SERVICE); mGlobalDisplayBrightness = pm.getDefaultScreenBrightnessSetting (); }

Procédé 5.DisplayManagerService de onStart

principale charge onStart données persistantes (appareil d'affichage principalement large supérieur), transmet un message de MSG_REGISTER_DEFAULT_DISPLAY_ADAPTERS annoncé Binder, le service local et autres. Procédé onStart () est la suivante:

 @Override onStart public void () {// Nous avons besoin de pré-charger le magasin de données persistantes afin qu'il soit prêt avant l'affichage par défaut // adaptateur est en place pour que nous avons la configuration de. On peut charger paresseusement, mais depuis // nous allons devoir le lire dans la suite on peut aussi bien le faire ici plutôt qu'après // nous avons attendu l'affichage s'enregistrer avec nous. synchronisé (mSyncRoot) {// 1. charge des données locales persistantes mPersistentDataStore.loadIfNeeded (); loadStableDisplayValuesLocked (); } // 2. Le message envoyé MSG_REGISTER_DEFAULT_DISPLAY_ADAPTERS mHandler.sendEmptyMessage (MSG_REGISTER_DEFAULT_DISPLAY_ADAPTERS); // 3. Binder a annoncé, le service local publishBinderService (Context.DISPLAY_SERVICE, nouveau BinderService (), vrai / * allowIsolated * /); publishLocalService (DisplayManagerInternal.class, nouveau LocalService ()); publishLocalService (DisplayTransformManager.class, nouveau DisplayTransformManager ()); }

Charger des données locales persistantes

 loadIfNeeded private void () {if (! mLoaded) { charger (); mLoaded = true; } } Private void charge () { clearState (); InputStream final est; try { est = mAtomicFile.openRead (); } Catch (FileNotFoundException ex) {return; } analyseur XmlPullParser; try { analyseur = Xml.newPullParser (); parser.setInput (nouveau BufferedInputStream (est), StandardCharsets.UTF_8.name ()); LoadFromXML (parser); } Catch (IOException | XmlPullParserException ex) { Slog.w (TAG, "Echec de la charge gestionnaire d'entrée TV persistante stocker des données." Ex); clearState (); } Enfin { IoUtils.closeQuietly (est); } }

2.MSG_REGISTER_DEFAULT_DISPLAY_ADAPTERS Procédé de traitement d'un message est le suivant:

 DisplayManagerHandler privé de classe finale étend Handler {DisplayManagerHandler public (Looper looper) {super (looper, null, true / * * async /); } @Override handleMessage public void (message msg) {switch (msg.what) {case MSG_REGISTER_DEFAULT_DISPLAY_ADAPTERS: // un adaptateur d'affichage par défaut enregistré. registerDefaultDisplayAdapters (); MSG_REGISTER_ADDITIONAL_DISPLAY_ADAPTERS de cas, la rupture: registerAdditionalDisplayAdapters (); break; ... }

Procédé de a.registerDefaultDisplayAdapters est la suivante:

principale fonction registerDefaultDisplayAdapters est d'ajouter un dispositif d'affichage enregistré à l'adaptateur de mDisplayAdapters.

 registerDefaultDisplayAdapters private void () {// enregistrer des adaptateurs d'affichage par défaut. synchronisée (mSyncRoot) {// b. Le principal de carte d'affichage, le verrouillage de l'adaptateur registre local registerDisplayAdapterLocked (nouveau LocalDisplayAdapter ( mSyncRoot, mContext, mHandler, mDisplayAdapterListener)); ... }

b. Le principal adaptateur d'affichage, le verrouillage de l'adaptateur registerDisplayAdapterLocked enregistrement local

 private void registerDisplayAdapterLocked (adaptateur DisplayAdapter) { mDisplayAdapters.add (adaptateur); adapter.registerLocked (); }

LocalDisplayAdapter hérité DisplayAdapter, principalement à fournir un adaptateur de dispositif d'affichage local.

LocalDisplayAdapter de classe finale étend DisplayAdapter { ... // Appelé avec serrure SyncRoot tenue. LocalDisplayAdapter publique (DisplayManagerService.SyncRoot SyncRoot, contexte Contexte, gestionnaire gestionnaire, auditeur Listener) {super (SyncRoot, contexte, gestionnaire, auditeur, TAG); } // appel adapter.registerLocked () registerDisplayAdapterLocked; @Override registerLocked public void () {super.registerLocked (); // 1. Appareil d'affichage de temps créer des écouteurs remplaçables à chaud mHotplugReceiver = new HotplugDisplayEventReceiver (getHandler () getLooper (.)); for (int builtInDisplayId: BUILT_IN_DISPLAY_IDS_TO_SCAN). {// 2 relié au dispositif d'affichage tryConnectDisplayLocked (builtInDisplayId); } } ... }

1. Création d'un appareil d'affichage d'écoute de temps à chaud, une partie du code de la manière suivante:

 HotplugDisplayEventReceiver privé de classe finale étend DisplayEventReceiver {HotplugDisplayEventReceiver publique (Looper looper) {super (looper, VSYNC_SOURCE_APP); } @Override onHotplug public void (longues timestampNanos, int builtInDisplayId, boolean connecté) {synchronisé (getSyncRoot ()) {if (relié) {// relié au dispositif d'affichage tryConnectDisplayLocked (builtInDisplayId); } Else { tryDisconnectDisplayLocked (builtInDisplayId); } } } }

2. L'appareil d'affichage est connecté, une partie du code de la manière suivante:

 private void tryConnectDisplayLocked (int builtInDisplayId) { IBinder displayToken = SurfaceControl.getBuiltInDisplay (builtInDisplayId); if (! DisplayToken = null) { SurfaceControl.PhysicalDisplayInfo configs = SurfaceControl.getDisplayConfigs (displayToken); int activeConfig = SurfaceControl.getActiveConfig (displayToken); int activeColorMode = SurfaceControl.getActiveColorMode (displayToken); int colorModes = SurfaceControl.getDisplayColorModes (displayToken); Dispositif LocalDisplayDevice = mDevices.get (builtInDisplayId); if (périphérique == null) {// affichage a été ajouté. Dispositif = new LocalDisplayDevice (displayToken, builtInDisplayId, configs, activeConfig, colorModes, activeColorMode); mDevices.put (builtInDisplayId, dispositif); sendDisplayDeviceEventLocked (dispositif, DISPLAY_DEVICE_EVENT_ADDED); } else if (device.updatePhysicalDisplayInfoLocked (configs, activeConfig, colorModes, activeColorMode)) {// Propriétés d'affichage ont changé. sendDisplayDeviceEventLocked (dispositif, DISPLAY_DEVICE_EVENT_CHANGED); } } Else {// L'affichage est plus disponible. Ignorer la tentative de l'ajouter. // Si elle a été connecté, mais a déjà été déconnecté, nous aurons un // événement de déconnexion qui l'enlever de mDevices. } }

Puis interfaces publishBinderService ouvertes à d'autres services et application

 / ** * Publier le service afin qu'il soit accessible à d'autres services et applications. * / final protégé publishBinderService vide (String name, service IBinder, booléen allowIsolated) { ServiceManager.addService (nom, service, allowIsolated); }

Ensuite, les processus du système divulgués publishLocalService Interface

 / ** * Publier le service il est donc accessible uniquement au processus du système. * / protégé finale < T >  vide publishLocalService (classe < T >  le type, le service T) { LocalServices.addService (type, service); }

6.DisplayManagerService de onBootPhase (phase int) Méthode

 @Override onBootPhase public void (phase int) {if (phase == PHASE_WAIT_FOR_DEFAULT_DISPLAY) {synchronisé (mSyncRoot) {long timeout = SystemClock.uptimeMillis () + MInjector. (), Tandis que (mLogicalDisplays.get (Display.DEFAULT_DISPLAY) == null || mVirtualDisplayAdapter == NULL) {long retard = timeout - SystemClock.uptimeMillis (); if (retard < = 0) {throw new RuntimeException ( "Délai d'attente en attente pour l'affichage par défaut" + "Pour initialiser. DefaultDisplay =" + MLogicalDisplays.get (Display.DEFAULT_DISPLAY) + "MVirtualDisplayAdapter =" + mVirtualDisplayAdapter); } Si (debug) { Slog.d (TAG, "waitForDefaultDisplay: attente, délai d'attente =" + retard); } Try { mSyncRoot.wait (retard); } Catch (InterruptedException ex) { } } } } }

Jusqu'à présent, le présent a pris fin, si le mauvais endroit, vos suggestions et corrections. En même temps nous réjouissons de votre attention, je vous remercie de la lecture, je vous remercie!

Cela crée un apprentissage des vidéos Android Mind Mapping et architecture, mind map informations plus détaillées et préoccupations + réponse privée lettre, accès libre « Andrews Data »!