HTML5-Techniken zur Optimierung der Leistung auf Mobilgeräten

Wesley Hales
Wesley Hales

Einführung

Ladekreisel, abgehackte Seitenübergänge und regelmäßige Verzögerungen bei Tippereignissen sind nur einige der Probleme, die im heutigen mobilen Web auftreten. Entwickler versuchen, so nah wie möglich an die native Leistung heranzukommen, werden aber oft durch Hacks, Resets und starre Frameworks behindert.

In diesem Artikel werden die Mindestanforderungen für die Erstellung einer mobilen HTML5-Web-App erläutert. Dabei geht es vor allem darum, die versteckten Komplexitäten aufzudecken, die heutige mobile Frameworks zu verbergen versuchen. Sie sehen einen minimalistischen Ansatz (mit grundlegenden HTML5-APIs) und grundlegende Konzepte, die Sie in die Lage versetzen, Ihr eigenes Framework zu schreiben oder zu dem von Ihnen derzeit verwendeten Framework beizutragen.

Hardwarebeschleunigung

Normalerweise verarbeiten GPUs detaillierte 3D-Modelle oder CAD-Diagramme. In diesem Fall möchten wir jedoch, dass unsere einfachen Zeichnungen (Divs, Hintergründe, Text mit Schlagschatten, Bilder usw.) flüssig dargestellt und über die GPU flüssig animiert werden. Leider überlassen die meisten Frontend-Entwickler diesen Animationsprozess einem Drittanbieter-Framework, ohne sich um die Semantik zu kümmern. Aber sollten diese Kernfunktionen von CSS3 maskiert werden? Hier sind ein paar Gründe, warum es wichtig ist, sich um diese Dinge zu kümmern:

  1. Arbeitsspeicherzuweisung und Rechenaufwand: Wenn Sie jedes Element im DOM nur für die Hardwarebeschleunigung zusammensetzen, wird die nächste Person, die an Ihrem Code arbeitet, Sie möglicherweise jagen und schwer verletzen.

  2. Stromverbrauch – Wenn die Hardware aktiv wird, wird natürlich auch der Akku beansprucht. Bei der Entwicklung für Mobilgeräte müssen Entwickler beim Schreiben von mobilen Web-Apps die vielfältigen Einschränkungen der Geräte berücksichtigen. Dies wird noch wichtiger, wenn Browserhersteller den Zugriff auf immer mehr Gerätehardware ermöglichen.

  3. Konflikte – Ich habe fehlerhaftes Verhalten festgestellt, wenn ich die Hardwarebeschleunigung auf Teile der Seite angewendet habe, die bereits beschleunigt waren. Es ist also sehr wichtig, zu wissen, ob sich die Beschleunigung überschneidet.

Damit die Nutzerinteraktion reibungslos und so nah wie möglich an der nativen Interaktion ist, müssen wir den Browser für uns arbeiten lassen. Idealerweise sollte die CPU des Mobilgeräts die anfängliche Animation einrichten und die GPU dann nur für das Compositing verschiedener Ebenen während des Animationsprozesses verantwortlich sein. Das ist die Aufgabe von translate3d, scale3d und translateZ. Sie geben den animierten Elementen eine eigene Ebene, sodass das Gerät alles zusammen flüssig rendern kann. Weitere Informationen zum beschleunigten Compositing und zur Funktionsweise von WebKit finden Sie im Blog von Ariya Hidayat.

Seitenübergänge

Sehen wir uns drei der gängigsten Ansätze für Nutzerinteraktionen bei der Entwicklung einer mobilen Web-App an: Wisch-, Umblätter- und Rotationseffekte.

Sie können sich diesen Code hier in Aktion ansehen: http://slidfast.appspot.com/slide-flip-rotate.html. Hinweis: Diese Demo wurde für Mobilgeräte entwickelt. Starten Sie also einen Emulator, verwenden Sie Ihr Smartphone oder Tablet oder verkleinern Sie Ihr Browserfenster auf etwa 1.024 Pixel oder weniger.

Zuerst sehen wir uns die Übergänge „Schieben“, „Umdrehen“ und „Drehen“ an und wie sie beschleunigt werden. Beachten Sie, dass jede Animation nur drei oder vier Zeilen CSS und JavaScript benötigt.

Fließend

Der häufigste der drei Übergangsansätze, der gleitende Seitenübergang, ahmt das native Verhalten mobiler Anwendungen nach. Der Folienübergang wird aufgerufen, um einen neuen Inhaltsbereich in den Darstellungsbereich zu bringen.

Für den Schiebeeffekt deklarieren wir zuerst das Markup:

<div id="home-page" class="page">
  <h1>Home Page</h1>
</div>

<div id="products-page" class="page stage-right">
  <h1>Products Page</h1>
</div>

<div id="about-page" class="page stage-left">
  <h1>About Page</h1>
</div>

Beachten Sie, dass wir hier das Konzept des Staging von Seiten links oder rechts haben. Es könnte im Grunde jede Richtung sein, aber diese ist am häufigsten.

Wir haben jetzt Animationen und Hardwarebeschleunigung mit nur wenigen Zeilen CSS. Die eigentliche Animation erfolgt, wenn wir die Klassen der div-Elemente auf der Seite austauschen.

.page {
  position: absolute;
  width: 100%;
  height: 100%;
  /*activate the GPU for compositing each page */
  -webkit-transform: translate3d(0, 0, 0);
}

translate3d(0,0,0) wird als „Silver Bullet“-Ansatz bezeichnet.

Wenn der Nutzer auf ein Navigationselement klickt, wird das folgende JavaScript ausgeführt, um die Klassen zu tauschen. Es werden keine Frameworks von Drittanbietern verwendet, sondern nur JavaScript. ;)

function getElement(id) {
  return document.getElementById(id);
}

function slideTo(id) {
  //1.) the page we are bringing into focus dictates how
  // the current page will exit. So let's see what classes
  // our incoming page is using. We know it will have stage[right|left|etc...]
  var classes = getElement(id).className.split(' ');

  //2.) decide if the incoming page is assigned to right or left
  // (-1 if no match)
  var stageType = classes.indexOf('stage-left');

  //3.) on initial page load focusPage is null, so we need
  // to set the default page which we're currently seeing.
  if (FOCUS_PAGE == null) {
    // use home page
    FOCUS_PAGE = getElement('home-page');
  }

  //4.) decide how this focused page should exit.
  if (stageType > 0) {
    FOCUS_PAGE.className = 'page transition stage-right';
  } else {
    FOCUS_PAGE.className = 'page transition stage-left';
  }

  //5. refresh/set the global variable
  FOCUS_PAGE = getElement(id);

  //6. Bring in the new page.
  FOCUS_PAGE.className = 'page transition stage-center';
}

stage-left oder stage-right wird zu stage-center und die Seite wird in den mittleren Darstellungsbereich verschoben. Wir verlassen uns vollständig auf CSS3, um die schwere Arbeit zu erledigen.

.stage-left {
  left: -480px;
}

.stage-right {
  left: 480px;
}

.stage-center {
  top: 0;
  left: 0;
}

Als Nächstes sehen wir uns das CSS an, das für die Erkennung und Ausrichtung von Mobilgeräten zuständig ist. Wir könnten jedes Gerät und jede Auflösung berücksichtigen (siehe Auflösung von Medienabfragen). In dieser Demo habe ich nur ein paar einfache Beispiele verwendet, um die meisten Hoch- und Querformate auf Mobilgeräten abzudecken. Das ist auch nützlich, um die Hardwarebeschleunigung pro Gerät anzuwenden. Da die Desktopversion von WebKit beispielsweise alle transformierten Elemente beschleunigt (unabhängig davon, ob es sich um 2D oder 3D handelt), ist es sinnvoll, eine Medienabfrage zu erstellen und die Beschleunigung auf dieser Ebene auszuschließen. Beachten Sie, dass Tricks zur Hardwarebeschleunigung unter Android Froyo 2.2+ keine Geschwindigkeitsverbesserung bringen. Die gesamte Komposition erfolgt innerhalb der Software.

/* iOS/android phone landscape screen width*/
@media screen and (max-device-width: 480px) and (orientation:landscape) {
  .stage-left {
    left: -480px;
  }

  .stage-right {
    left: 480px;
  }

  .page {
    width: 480px;
  }
}

Spiegeln

Auf Mobilgeräten wird das Umblättern durch Wischen auf der Seite ausgeführt. Hier verwenden wir einfaches JavaScript, um dieses Ereignis auf iOS- und Android-Geräten (WebKit-basiert) zu verarbeiten.

Sehen Sie sich die Funktion unter http://slidfast.appspot.com/slide-flip-rotate.html in Aktion an.

Wenn Sie mit Touch-Events und Übergängen arbeiten, müssen Sie zuerst die aktuelle Position des Elements ermitteln. Weitere Informationen zu WebKitCSSMatrix finden Sie in diesem Dokument.

function pageMove(event) {
  // get position after transform
  var curTransform = new WebKitCSSMatrix(window.getComputedStyle(page).webkitTransform);
  var pagePosition = curTransform.m41;
}

Da wir für das Umblättern einen CSS3-Ease-Out-Übergang verwenden, funktioniert das übliche element.offsetLeft nicht.

Als Nächstes möchten wir herausfinden, in welche Richtung der Nutzer blättert, und einen Schwellenwert für ein Ereignis (Seitennavigation) festlegen.

if (pagePosition >= 0) {
 //moving current page to the right
 //so means we're flipping backwards
   if ((pagePosition > pageFlipThreshold) || (swipeTime < swipeThreshold)) {
     //user wants to go backward
     slideDirection = 'right';
   } else {
     slideDirection = null;
   }
} else {
  //current page is sliding to the left
  if ((swipeTime < swipeThreshold) || (pagePosition < pageFlipThreshold)) {
    //user wants to go forward
    slideDirection = 'left';
  } else {
    slideDirection = null;
  }
}

Außerdem wird die swipeTime in Millisekunden gemessen. So kann das Navigationsereignis ausgelöst werden, wenn der Nutzer schnell über den Bildschirm wischt, um eine Seite umzublättern.

Um die Seite zu positionieren und die Animationen so aussehen zu lassen, als würden sie nativ ausgeführt, während ein Finger den Bildschirm berührt, verwenden wir nach jedem Ereignis CSS3-Übergänge.

function positionPage(end) {
  page.style.webkitTransform = 'translate3d('+ currentPos + 'px, 0, 0)';
  if (end) {
    page.style.WebkitTransition = 'all .4s ease-out';
    //page.style.WebkitTransition = 'all .4s cubic-bezier(0,.58,.58,1)'
  } else {
    page.style.WebkitTransition = 'all .2s ease-out';
  }
  page.style.WebkitUserSelect = 'none';
}

Ich habe versucht, mit „cubic-bezier“ zu experimentieren, um die Übergänge so natürlich wie möglich zu gestalten, aber „ease-out“ hat den Zweck erfüllt.

Damit die Navigation funktioniert, müssen wir die zuvor definierten slideTo()-Methoden aufrufen, die wir in der letzten Demo verwendet haben.

track.ontouchend = function(event) {
  pageMove(event);
  if (slideDirection == 'left') {
    slideTo('products-page');
  } else if (slideDirection == 'right') {
    slideTo('home-page');
  }
}

Drehen

Sehen wir uns als Nächstes die Rotationsanimation an, die in dieser Demo verwendet wird. Sie können die Seite, die Sie gerade ansehen, jederzeit um 180 Grad drehen, um die Rückseite zu sehen. Tippen Sie dazu auf die Menüoption „Kontakt“. Auch hierfür sind nur ein paar Zeilen CSS und etwas JavaScript erforderlich, um eine Übergangsklasse onclick zuzuweisen. HINWEIS: Der Übergang „Drehen“ wird in den meisten Android-Versionen nicht korrekt gerendert, da die Funktion „3D-CSS-Transformation“ fehlt. Anstatt das Umdrehen zu ignorieren, lässt Android die Seite jedoch durch Drehen statt Umdrehen „wegradeln“. Wir empfehlen, diesen Übergang nur sparsam zu verwenden, bis die Unterstützung verbessert wird.

Das Markup (Grundkonzept von Vorder- und Rückseite):

<div id="front" class="normal">
...
</div>
<div id="back" class="flipped">
    <div id="contact-page" class="page">
        <h1>Contact Page</h1>
    </div>
</div>

Das JavaScript:

function flip(id) {
  // get a handle on the flippable region
  var front = getElement('front');
  var back = getElement('back');

  // again, just a simple way to see what the state is
  var classes = front.className.split(' ');
  var flipped = classes.indexOf('flipped');

  if (flipped >= 0) {
    // already flipped, so return to original
    front.className = 'normal';
    back.className = 'flipped';
    FLIPPED = false;
  } else {
    // do the flip
    front.className = 'flipped';
    back.className = 'normal';
    FLIPPED = true;
  }
}

Das CSS:

/*----------------------------flip transition */
#back,
#front {
  position: absolute;
  width: 100%;
  height: 100%;
  -webkit-backface-visibility: hidden;
  -webkit-transition-duration: .5s;
  -webkit-transform-style: preserve-3d;
}

.normal {
  -webkit-transform: rotateY(0deg);
}

.flipped {
  -webkit-user-select: element;
  -webkit-transform: rotateY(180deg);
}

Fehlerbehebung bei der Hardwarebeschleunigung

Nachdem wir die grundlegenden Übergänge behandelt haben, sehen wir uns nun an, wie sie funktionieren und zusammengesetzt werden.

Um diese magische Debugging-Sitzung zu starten, öffnen wir ein paar Browser und die IDE Ihrer Wahl. Starten Sie Safari zuerst über die Befehlszeile, um einige Umgebungsvariablen für die Fehlerbehebung zu verwenden. Ich verwende einen Mac. Die Befehle können sich je nach Betriebssystem unterscheiden. Öffnen Sie das Terminal und geben Sie Folgendes ein:

  • $> export CA_COLOR_OPAQUE=1
  • $> export CA_LOG_MEMORY_USAGE=1
  • $> /Applications/Safari.app/Contents/MacOS/Safari

Dadurch wird Safari mit einigen Debugging-Hilfen gestartet. CA_COLOR_OPAQUE zeigt uns, welche Elemente tatsächlich zusammengesetzt oder beschleunigt werden. CA_LOG_MEMORY_USAGE zeigt, wie viel Arbeitsspeicher verwendet wird, wenn Zeichenvorgänge an den Backing Store gesendet werden. So sehen Sie genau, wie stark das Mobilgerät beansprucht wird, und erhalten möglicherweise Hinweise darauf, wie sich die GPU-Nutzung auf den Akku des Zielgeräts auswirkt.

Starten wir nun Chrome, um uns die Informationen zu den Bildern pro Sekunde (FPS) anzusehen:

  1. Öffnen Sie den Google Chrome-Webbrowser.
  2. Geben Sie in die URL-Leiste about:flags ein.
  3. Scrollen Sie nach unten und klicken Sie bei „FPS Counter“ auf „Aktivieren“.

Wenn Sie diese Seite in Ihrer optimierten Chrome-Version aufrufen, sehen Sie links oben den roten FPS-Zähler.

Chrome FPS

Daran erkennen wir, dass die Hardwarebeschleunigung aktiviert ist. Außerdem erhalten wir so einen Eindruck davon, wie die Animation ausgeführt wird und ob es Lecks gibt (kontinuierlich laufende Animationen, die gestoppt werden sollten).

Eine weitere Möglichkeit, die Hardwarebeschleunigung zu visualisieren, besteht darin, dieselbe Seite in Safari zu öffnen (mit den oben genannten Umgebungsvariablen). Jedes beschleunigte DOM-Element hat einen roten Farbton. So sehen wir genau, was auf welcher Ebene zusammengesetzt wird. Die weiße Navigation ist nicht rot, da sie nicht beschleunigt wird.

Zusammengesetzter Kontakt

Eine ähnliche Einstellung für Chrome ist auch unter about:flags „Composited render layer borders“ verfügbar.

Eine weitere gute Möglichkeit, die zusammengesetzten Ebenen zu sehen, ist die WebKit-Demo mit fallenden Blättern, während dieser Modus angewendet wird.

omposited Leaves

Um die Leistung der Grafikhardware unserer Anwendung wirklich zu verstehen, sehen wir uns an, wie der Arbeitsspeicher genutzt wird. Hier sehen wir, dass wir 1,38 MB an Zeichenanweisungen an die CoreAnimation-Zwischenspeicher unter macOS senden. Die Core Animation-Speicherpuffer werden zwischen OpenGL ES und der GPU geteilt, um die endgültigen Pixel zu erstellen, die Sie auf dem Bildschirm sehen.

Coreanimation 1

Wenn wir die Größe des Browserfensters ändern oder es maximieren, wird auch der Arbeitsspeicher erweitert.

Coreanimation 2

So erhalten Sie eine Vorstellung davon, wie der Arbeitsspeicher auf Ihrem Mobilgerät genutzt wird, wenn Sie die Größe des Browsers auf die richtigen Abmessungen anpassen. Wenn Sie für iPhone-Umgebungen debuggen oder testen, ändern Sie die Größe auf 480 × 320 Pixel. Wir wissen jetzt genau, wie die Hardwarebeschleunigung funktioniert und was für das Debugging erforderlich ist. Es ist eine Sache, darüber zu lesen, aber die GPU-Arbeitsspeicherpuffer visuell in Aktion zu sehen, macht die Sache wirklich anschaulich.

Hinter den Kulissen: Abrufen und Caching

Jetzt ist es an der Zeit, das Caching von Seiten und Ressourcen auf die nächste Stufe zu heben. Ähnlich wie bei JQuery Mobile und ähnlichen Frameworks werden wir unsere Seiten mit gleichzeitigen AJAX-Aufrufen Prefetch und im Cache speichern.

Sehen wir uns einige der wichtigsten Probleme im mobilen Web an und warum wir sie beheben müssen:

  • Abrufen: Durch das Prefetch unserer Seiten können Nutzer die App offline verwenden und müssen nicht zwischen Navigationsaktionen warten. Natürlich möchten wir die Bandbreite des Geräts nicht drosseln, wenn es online geht. Daher sollten wir diese Funktion nur sparsam einsetzen.
  • Caching: Als Nächstes möchten wir einen gleichzeitigen oder asynchronen Ansatz beim Abrufen und Zwischenspeichern dieser Seiten verwenden. Außerdem müssen wir localStorage verwenden (da es von vielen Geräten unterstützt wird), was leider nicht asynchron ist.
  • AJAX und Parsen der Antwort: Die Verwendung von innerHTML() zum Einfügen der AJAX-Antwort in das DOM ist gefährlich (und unzuverlässig?). Stattdessen verwenden wir einen zuverlässigen Mechanismus für das Einfügen von AJAX-Antworten und die Verarbeitung gleichzeitiger Aufrufe. Wir nutzen auch einige neue Funktionen von HTML5, um die xhr.responseText zu parsen.

Aufbauend auf dem Code aus der Demo „Slide, Flip, and Rotate“ fügen wir zuerst einige sekundäre Seiten hinzu und verlinken sie. Wir parsen dann die Links und erstellen Übergänge im laufenden Betrieb.

iPhone Home

Hier finden Sie die Demo zu „Abrufen und im Cache speichern“.

Wie Sie sehen, verwenden wir hier semantisches Markup. Nur ein Link zu einer anderen Seite. Die untergeordnete Seite hat dieselbe Knoten-/Klassenstruktur wie die übergeordnete Seite. Wir könnten noch einen Schritt weiter gehen und das data-*-Attribut für „page“-Knoten usw. verwenden. Und hier ist die Detailseite (untergeordnetes Element) in einer separaten HTML-Datei (/demo2/home-detail.html), die beim Laden der App geladen, im Cache gespeichert und für den Übergang eingerichtet wird.

<div id="home-page" class="page">
  <h1>Home Page</h1>
  <a href="demo2/home-detail.html" class="fetch">Find out more about the home page!</a>
</div>

Sehen wir uns jetzt das JavaScript an. Der Einfachheit halber lasse ich alle Hilfsprogramme oder Optimierungen aus dem Code weg. Wir durchlaufen hier nur ein bestimmtes Array von DOM-Knoten, um Links zum Abrufen und Speichern im Cache zu finden. Hinweis: In dieser Demo wird die Methode fetchAndCache() beim Seitenaufbau aufgerufen. Im nächsten Abschnitt überarbeiten wir sie, wenn wir die Netzwerkverbindung erkennen und festlegen, wann sie aufgerufen werden soll.

var fetchAndCache = function() {
  // iterate through all nodes in this DOM to find all mobile pages we care about
  var pages = document.getElementsByClassName('page');

  for (var i = 0; i < pages.length; i++) {
    // find all links
    var pageLinks = pages[i].getElementsByTagName('a');

    for (var j = 0; j < pageLinks.length; j++) {
      var link = pageLinks[j];

      if (link.hasAttribute('href') &amp;&amp;
      //'#' in the href tells us that this page is already loaded in the DOM - and
      // that it links to a mobile transition/page
         !(/[\#]/g).test(link.href) &amp;&amp;
        //check for an explicit class name setting to fetch this link
        (link.className.indexOf('fetch') >= 0))  {
         //fetch each url concurrently
         var ai = new ajax(link,function(text,url){
              //insert the new mobile page into the DOM
             insertPages(text,url);
         });
         ai.doGet();
      }
    }
  }
};

Wir sorgen für eine ordnungsgemäße asynchrone Nachbearbeitung, indem wir das „AJAX“-Objekt verwenden. Eine ausführlichere Erklärung zur Verwendung von localStorage in einem AJAX-Aufruf finden Sie unter Working Off the Grid with HTML5 Offline. In diesem Beispiel sehen Sie die grundlegende Verwendung des Cachings bei jeder Anfrage und die Bereitstellung der im Cache gespeicherten Objekte, wenn der Server eine andere Antwort als eine erfolgreiche (200) zurückgibt.

function processRequest () {
  if (req.readyState == 4) {
    if (req.status == 200) {
      if (supports_local_storage()) {
        localStorage[url] = req.responseText;
      }
      if (callback) callback(req.responseText,url);
    } else {
      // There is an error of some kind, use our cached copy (if available).
      if (!!localStorage[url]) {
        // We have some data cached, return that to the callback.
        callback(localStorage[url],url);
        return;
      }
    }
  }
}

Da localStorage UTF-16 für die Zeichencodierung verwendet, wird jedes einzelne Byte als 2 Byte gespeichert.Dadurch sinkt das Speicherlimit von 5 MB auf insgesamt 2, 6 MB. Der Grund für das Abrufen und Caching dieser Seiten/dieses Markups außerhalb des Anwendungs-Cache-Bereichs wird im nächsten Abschnitt erläutert.

Dank der jüngsten Fortschritte beim iframe-Element mit HTML5 haben wir jetzt eine einfache und effektive Möglichkeit, die responseText zu parsen, die wir von unserem AJAX-Aufruf zurückerhalten. Es gibt viele JavaScript-Parser mit 3.000 Zeilen und reguläre Ausdrücke, die Script-Tags und so weiter entfernen. Aber warum lassen Sie den Browser nicht das tun, was er am besten kann? In diesem Beispiel schreiben wir die responseText in einen temporären ausgeblendeten iFrame. Wir verwenden das HTML5-Attribut „sandbox“, das Skripts deaktiviert und viele Sicherheitsfunktionen bietet…

Aus der Spezifikation: Wenn das Sandbox-Attribut angegeben ist, werden zusätzliche Einschränkungen für alle Inhalte aktiviert, die vom iFrame gehostet werden. Der Wert muss ein ungeordneter Satz eindeutiger, durch Leerzeichen getrennter Tokens sein, bei denen die Groß-/Kleinschreibung nicht berücksichtigt wird. Die zulässigen Werte sind allow-forms, allow-same-origin, allow-scripts und allow-top-navigation. Wenn das Attribut festgelegt ist, wird der Inhalt so behandelt, als stamme er von einem eindeutigen Ursprung. Formulare und Skripts sind deaktiviert, Links können nicht auf andere Browserkontexte verweisen und Plug-ins sind deaktiviert.

var insertPages = function(text, originalLink) {
  var frame = getFrame();
  //write the ajax response text to the frame and let
  //the browser do the work
  frame.write(text);

  //now we have a DOM to work with
  var incomingPages = frame.getElementsByClassName('page');

  var pageCount = incomingPages.length;
  for (var i = 0; i < pageCount; i++) {
    //the new page will always be at index 0 because
    //the last one just got popped off the stack with appendChild (below)
    var newPage = incomingPages[0];

    //stage the new pages to the left by default
    newPage.className = 'page stage-left';

    //find out where to insert
    var location = newPage.parentNode.id == 'back' ? 'back' : 'front';

    try {
      // mobile safari will not allow nodes to be transferred from one DOM to another so
      // we must use adoptNode()
      document.getElementById(location).appendChild(document.adoptNode(newPage));
    } catch(e) {
      // todo graceful degradation?
    }
  }
};

Safari weigert sich zu Recht, einen Knoten implizit von einem Dokument in ein anderes zu verschieben. Wenn der neue untergeordnete Knoten in einem anderen Dokument erstellt wurde, wird ein Fehler ausgegeben. Hier verwenden wir also adoptNode und alles ist in Ordnung.

Warum also iFrame? Warum nicht einfach innerHTML verwenden? Obwohl innerHTML jetzt Teil der HTML5-Spezifikation ist, ist es gefährlich, die Antwort eines Servers (bösartig oder gutartig) in einen ungeprüften Bereich einzufügen. Während ich diesen Artikel schrieb, konnte ich niemanden finden, der etwas anderes als innerHTML verwendet. Ich weiß, dass JQuery es im Kern verwendet, mit einem Fallback auf „append“ nur bei Ausnahmen. Und JQuery Mobile verwendet es ebenfalls. Ich habe jedoch keine umfassenden Tests dazu durchgeführt, ob innerHTML zufällig nicht mehr funktioniert. Es wäre aber sehr interessant, alle Plattformen zu sehen, die davon betroffen sind. Es wäre auch interessant zu sehen, welcher Ansatz leistungsfähiger ist… Ich habe von beiden Seiten Behauptungen dazu gehört.

Erkennung, Verarbeitung und Profilerstellung von Netzwerktypen

Da wir jetzt die Möglichkeit haben, unsere Web-App zu puffern (oder einen vorausschauenden Cache zu verwenden), müssen wir die richtigen Funktionen zur Verbindungserkennung bereitstellen, um unsere App intelligenter zu machen. An dieser Stelle wird die Entwicklung mobiler Apps extrem empfindlich gegenüber Online-/Offline-Modi und Verbindungsgeschwindigkeit. Hier kommt die Network Information API ins Spiel. Jedes Mal, wenn ich diese Funktion in einer Präsentation zeige, hebt jemand im Publikum die Hand und fragt: „Wofür würde ich das verwenden?“ Hier ist also eine Möglichkeit, eine extrem intelligente mobile Web-App einzurichten.

Zuerst ein Szenario, das auf der Hand liegt: Wenn Sie im Hochgeschwindigkeitszug mit einem Mobilgerät im Web surfen, kann es sein, dass die Verbindung immer wieder abbricht und dass die Übertragungsgeschwindigkeit je nach Region variiert. So ist in manchen städtischen Gebieten vielleicht HSPA oder 3G verfügbar, während in abgelegenen Gebieten nur langsamere 2G-Technologien unterstützt werden. Der folgende Code deckt die meisten Verbindungsszenarien ab.

Der folgende Code bietet:

  • Offlinezugriff über applicationCache.
  • Erkennt, ob ein Lesezeichen gesetzt wurde und ob der Nutzer offline ist.
  • Erkennt, wenn von offline zu online und umgekehrt gewechselt wird.
  • Erkennt langsame Verbindungen und ruft Inhalte basierend auf dem Netzwerktyp ab.

Auch für diese Funktionen ist nur sehr wenig Code erforderlich. Zuerst erkennen wir unsere Ereignisse und Ladeszenarien:

window.addEventListener('load', function(e) {
 if (navigator.onLine) {
  // new page load
  processOnline();
 } else {
   // the app is probably already cached and (maybe) bookmarked...
   processOffline();
 }
}, false);

window.addEventListener("offline", function(e) {
  // we just lost our connection and entered offline mode, disable eternal link
  processOffline(e.type);
}, false);

window.addEventListener("online", function(e) {
  // just came back online, enable links
  processOnline(e.type);
}, false);

In den EventListeners oben müssen wir unserem Code mitteilen, ob er von einem Ereignis oder einer tatsächlichen Seitenanfrage oder -aktualisierung aufgerufen wird. Der Hauptgrund dafür ist, dass das onload-Ereignis im Body nicht ausgelöst wird, wenn zwischen dem Online- und dem Offlinemodus gewechselt wird.

Als Nächstes folgt eine einfache Prüfung auf ein ononline- oder onload-Ereignis. Dieser Code setzt deaktivierte Links zurück, wenn vom Offline- in den Onlinemodus gewechselt wird. Wenn diese App komplexer wäre, könnten Sie Logik einfügen, die das Abrufen von Inhalten fortsetzt oder die UX für zeitweise Verbindungen verarbeitet.

function processOnline(eventType) {

  setupApp();
  checkAppCache();

  // reset our once disabled offline links
  if (eventType) {
    for (var i = 0; i < disabledLinks.length; i++) {
      disabledLinks[i].onclick = null;
    }
  }
}

Dasselbe gilt für processOffline(). Hier würden Sie Ihre App für den Offlinemodus anpassen und versuchen, alle Transaktionen wiederherzustellen, die im Hintergrund ausgeführt wurden. Der folgende Code sucht alle externen Links und deaktiviert sie. So bleiben die Nutzer für immer in unserer Offline-App gefangen. Muhahaha!

function processOffline() {
  setupApp();

  // disable external links until we come back - setting the bounds of app
  disabledLinks = getUnconvertedLinks(document);

  // helper for onlcick below
  var onclickHelper = function(e) {
    return function(f) {
      alert('This app is currently offline and cannot access the hotness');return false;
    }
  };

  for (var i = 0; i < disabledLinks.length; i++) {
    if (disabledLinks[i].onclick == null) {
      //alert user we're not online
      disabledLinks[i].onclick = onclickHelper(disabledLinks[i].href);

    }
  }
}

Kommen wir nun zu den interessanten Dingen. Da unsere App jetzt weiß, in welchem Verbindungsstatus sie sich befindet, können wir auch den Verbindungstyp prüfen, wenn sie online ist, und die App entsprechend anpassen. In den Kommentaren zu den einzelnen Verbindungen habe ich die typischen Download- und Latenzwerte für nordamerikanische Anbieter aufgeführt.

function setupApp(){
  // create a custom object if navigator.connection isn't available
  var connection = navigator.connection || {'type':'0'};
  if (connection.type == 2 || connection.type == 1) {
      //wifi/ethernet
      //Coffee Wifi latency: ~75ms-200ms
      //Home Wifi latency: ~25-35ms
      //Coffee Wifi DL speed: ~550kbps-650kbps
      //Home Wifi DL speed: ~1000kbps-2000kbps
      fetchAndCache(true);
  } else if (connection.type == 3) {
  //edge
      //ATT Edge latency: ~400-600ms
      //ATT Edge DL speed: ~2-10kbps
      fetchAndCache(false);
  } else if (connection.type == 2) {
      //3g
      //ATT 3G latency: ~400ms
      //Verizon 3G latency: ~150-250ms
      //ATT 3G DL speed: ~60-100kbps
      //Verizon 3G DL speed: ~20-70kbps
      fetchAndCache(false);
  } else {
  //unknown
      fetchAndCache(true);
  }
}

Wir könnten zahlreiche Anpassungen an unserem fetchAndCache-Prozess vornehmen, aber hier habe ich nur angegeben, dass die Ressourcen für eine bestimmte Verbindung asynchron (true) oder synchron (false) abgerufen werden sollen.

Zeitachse für Edge-Anfragen (synchron)

Edge-Synchronisierung

Zeitachse für asynchrone WIFI-Anfragen

WLAN-Asynchron

So kann die Nutzererfahrung zumindest in gewissem Maße an langsame oder schnelle Verbindungen angepasst werden. Dies ist keineswegs eine endgültige Lösung. Eine weitere Aufgabe wäre, ein Lade-Modal einzublenden, wenn ein Link angeklickt wird (bei langsamen Verbindungen), während die App die Seite dieses Links im Hintergrund abruft. Der wichtigste Punkt hierbei ist, die Latenzen zu reduzieren und gleichzeitig die vollen Möglichkeiten der Verbindung des Nutzers mit den neuesten und besten Funktionen von HTML5 zu nutzen. Demo zur Netzwerkerkennung ansehen

Fazit

Die Entwicklung von mobilen HTML5-Apps steht erst am Anfang. Sie sehen jetzt die sehr einfachen und grundlegenden Grundlagen eines mobilen „Frameworks“, das ausschließlich auf HTML5 und den unterstützenden Technologien basiert. Ich denke, es ist wichtig, dass Entwickler mit diesen Funktionen arbeiten und sie im Kern ansprechen, ohne dass sie von einem Wrapper maskiert werden.