מבוא
רענון מתמשך, מעברים קטועים בין דפים ועיכובים תקופתיים באירועי הקשה הם רק חלק מהבעיות בסביבות האינטרנט לנייד כיום. מפתחים מנסים להגיע כמה שיותר קרוב לאפליקציות נייטיב, אבל לעיתים קרובות הם נתקלים בבעיות בגלל פריצות, איפוסים ומסגרות נוקשות.
במאמר הזה נדון בדרישות המינימליות ליצירת אפליקציית אינטרנט לנייד ב-HTML5. המטרה העיקרית היא לחשוף את המורכבות הנסתרת שמסגרות העבודה לנייד של היום מנסות להסתיר. נציג גישה מינימליסטית (באמצעות ממשקי API בסיסיים של HTML5) ועקרונות בסיסיים שיאפשרו לכם לכתוב מסגרת משלכם או לתרום למסגרת שבה אתם משתמשים כרגע.
שיפור המהירות באמצעות חומרה
בדרך כלל, מעבדים גרפיים מטפלים במודלים מפורטים בתלת-ממד או בתרשימי CAD, אבל במקרה הזה, אנחנו רוצים שהשרטוטים הפרימיטיביים שלנו (רכיבי div, רקעים, טקסט עם צלליות, תמונות וכו') יופיעו בצורה חלקה ויונפשו בצורה חלקה באמצעות המעבד הגרפי. למרבה הצער, רוב מפתחי ה-Front-end מעבירים את תהליך האנימציה הזה למסגרת של צד שלישי בלי להתייחס לסמנטיקה, אבל האם צריך להסתיר את תכונות הליבה האלה של CSS3? הנה כמה סיבות למה חשוב לשים לב לדברים האלה:
הקצאת זיכרון ונטל חישובי – אם תבצעו קומפוזיציה של כל רכיב ב-DOM רק בשביל שיפור המהירות באמצעות חומרה, האדם הבא שיעבוד על הקוד שלכם עלול לרדוף אחריכם ולהכות אתכם קשות.
צריכת חשמל – ברור שכשהחומרה מתחילה לפעול, גם הסוללה מתחילה לפעול. כשמפתחים אפליקציות אינטרנט לנייד, המפתחים צריכים להביא בחשבון את מגוון המגבלות של המכשירים. התופעה הזו תהיה נפוצה עוד יותר כשמפתחי דפדפנים יתחילו לאפשר גישה ליותר ויותר חומרה של מכשירים.
התנגשויות – נתקלתי בהתנהגות לא תקינה כשהפעלתי שיפור מהירות באמצעות חומרה בחלקים של הדף שכבר עברו שיפור מהירות. לכן חשוב מאוד לדעת אם יש לכם חפיפה בהאצה.
כדי שהאינטראקציה של המשתמש תהיה חלקה וקרובה ככל האפשר לאפליקציה מקורית, אנחנו צריכים לגרום לדפדפן לעבוד בשבילנו. באופן אידיאלי, אנחנו רוצים שה-CPU של המכשיר הנייד יגדיר את האנימציה הראשונית, ואז ה-GPU יהיה אחראי רק על הרכבת שכבות שונות במהלך תהליך האנימציה. זה מה ש-translate3d, scale3d ו-translateZ עושים – הם נותנים לאלמנטים המונפשים שכבה משלהם, וכך מאפשרים למכשיר לעבד את הכול ביחד בצורה חלקה. כדי לקבל מידע נוסף על קומפוזיציה מואצת ועל אופן הפעולה של WebKit, כדאי לקרוא את הבלוג של אריה הידאיאט, שכולל הרבה מידע שימושי.
מעברים בין דפים
בואו נבחן שלוש מהגישות הנפוצות ביותר לאינטראקציה של משתמשים כשמפתחים אפליקציית אינטרנט לנייד: אפקטים של החלקה, היפוך וסיבוב.
אתם יכולים לראות את הקוד הזה בפעולה כאן http://slidfast.appspot.com/slide-flip-rotate.html (הערה: ההדגמה הזו מיועדת למכשיר נייד, אז הפעילו אמולטור, השתמשו בטלפון או בטאבלט, או הקטינו את חלון הדפדפן ל-~1024px או פחות).
קודם ננתח את המעברים של החלקה, היפוך וסיבוב, ונראה איך הם מואצים. שימו לב שכל אנימציה דורשת רק שלוש או ארבע שורות של CSS ו-JavaScript.
הזזה
הגישה הנפוצה ביותר מבין שלוש הגישות למעברים, מעברי דפים בהחלקה מחקים את התחושה המקורית של אפליקציות לנייד. המעבר בין השקפים מופעל כדי להציג אזור תוכן חדש באזור התצוגה.
כדי להוסיף את אפקט ההחלקה, קודם צריך להצהיר על תגי העיצוב:
<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>
שימו לב שיש לנו את הקונספט הזה של דפי ביניים משמאל או מימין. הוא יכול להיות בכל כיוון, אבל זה הכיוון הכי נפוץ.
עכשיו יש לנו אנימציה וגם שיפור מהירות באמצעות חומרה, עם כמה שורות CSS בלבד. האנימציה עצמה מתרחשת כשאנחנו מחליפים מחלקות ברכיבי ה-div של הדף.
.page {
position: absolute;
width: 100%;
height: 100%;
/*activate the GPU for compositing each page */
-webkit-transform: translate3d(0, 0, 0);
}
translate3d(0,0,0) ידועה בתור גישת "כדור הכסף".
כשהמשתמש לוחץ על רכיב ניווט, אנחנו מפעילים את ה-JavaScript הבא כדי להחליף את המחלקות. לא נעשה שימוש במסגרות של צד שלישי, זה 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 או stage-right הופך ל-stage-center ומאלץ את הדף להחליק אל אזור התצוגה המרכזי. אנחנו מסתמכים לחלוטין על CSS3 כדי לבצע את העבודה הקשה.
.stage-left {
left: -480px;
}
.stage-right {
left: 480px;
}
.stage-center {
top: 0;
left: 0;
}
עכשיו נסתכל על ה-CSS שמטפל בזיהוי ובכיוון של המכשיר הנייד. אנחנו יכולים להתייחס לכל מכשיר ולכל רזולוציה (ראו רזולוציה של שאילתת מדיה). השתמשתי רק בכמה דוגמאות פשוטות בהדגמה הזו כדי לכסות את רוב התצוגות לאורך ולרוחב במכשירים ניידים. ההגדרה הזו שימושית גם להחלת שיפור מהירות באמצעות חומרה בכל מכשיר. לדוגמה, מכיוון שהגרסה למחשב של WebKit מאיצה את כל הרכיבים שעברו טרנספורמציה (לא משנה אם הם דו-ממדיים או תלת-ממדיים), כדאי ליצור שאילתת מדיה ולהחריג את ההאצה ברמה הזו. חשוב לדעת: טריקים לשיפור מהירות באמצעות חומרה לא משפרים את המהירות ב-Android Froyo 2.2 ואילך. כל הקומפוזיציה מתבצעת בתוכנה.
/* 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;
}
}
היפוך
במכשירים ניידים, דפדוף הוא בעצם החלקה של הדף. כאן אנחנו משתמשים בקוד JavaScript פשוט כדי לטפל באירוע הזה במכשירי iOS ו-Android (מבוססי WebKit).
אפשר לראות את זה בפעולה בכתובת http://slidfast.appspot.com/slide-flip-rotate.html.
כשעובדים עם אירועי מגע ומעברים, הדבר הראשון שצריך לעשות הוא לקבל נקודת אחיזה במיקום הנוכחי של הרכיב. מידע נוסף על WebKitCSSMatrix זמין במסמך הזה.
function pageMove(event) {
// get position after transform
var curTransform = new WebKitCSSMatrix(window.getComputedStyle(page).webkitTransform);
var pagePosition = curTransform.m41;
}
מכיוון שאנחנו משתמשים במעבר CSS3 מסוג ease-out לדפדוף, ה-element.offsetLeft הרגיל לא יעבוד.
עכשיו אנחנו רוצים להבין לאיזה כיוון המשתמש מדפדף ולהגדיר סף להתרחשות של אירוע (ניווט בדפים).
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;
}
}
אפשר גם לראות שאנחנו מודדים את swipeTime גם באלפיות השנייה. כך אירוע הניווט יופעל אם המשתמש יחליק במהירות על המסך כדי להעביר דף.
כדי למקם את הדף ולגרום לאנימציות להיראות טבעיות בזמן שהאצבע נוגעת במסך, אנחנו משתמשים במעברי CSS3 אחרי כל הפעלה של אירוע.
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';
}
ניסיתי לשחק עם cubic-bezier כדי לתת את התחושה הכי טבעית למעברים, אבל ease-out עשה את העבודה.
לבסוף, כדי שהניווט יתבצע, אנחנו צריכים לקרוא לשיטות slideTo() שהגדרנו קודם והשתמשנו בהן בהדגמה האחרונה.
track.ontouchend = function(event) {
pageMove(event);
if (slideDirection == 'left') {
slideTo('products-page');
} else if (slideDirection == 'right') {
slideTo('home-page');
}
}
סיבוב
עכשיו נסתכל על אנימציית הסיבוב שבה משתמשים בהדגמה הזו. בכל שלב, אתם יכולים לסובב את הדף שמוצג ב-180 מעלות כדי לחשוף את הצד השני. כדי לעשות את זה, לוחצים על האפשרות "איש קשר" בתפריט. שוב, צריך רק כמה שורות של CSS וקצת JavaScript כדי להקצות מחלקת מעבר onclick.
הערה: מעבר הסיבוב לא מוצג בצורה נכונה ברוב הגרסאות של Android כי אין להן יכולות טרנספורמציה של CSS תלת-ממדי. לצערנו, במקום להתעלם מההיפוך, Android גורמת לדף "להתגלגל" על ידי סיבוב במקום היפוך. מומלץ להשתמש במעבר הזה כמה שפחות עד שהתמיכה תשתפר.
תגי העיצוב (הקונספט הבסיסי של החלק הקדמי והחלק האחורי):
<div id="front" class="normal">
...
</div>
<div id="back" class="flipped">
<div id="contact-page" class="page">
<h1>Contact Page</h1>
</div>
</div>
קוד ה-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;
}
}
ה-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);
}
ניפוי באגים בשיפור המהירות באמצעות חומרה
עכשיו, אחרי שסקרנו את המעברים הבסיסיים, בואו נראה איך הם פועלים ואיך הם מורכבים.
כדי להפעיל את הסשן הקסום הזה של ניפוי באגים, נפעיל כמה דפדפנים ואת ה-IDE שבחרתם. קודם כל, מפעילים את Safari משורת הפקודה כדי להשתמש במשתני סביבה מסוימים לניפוי באגים. אני משתמש ב-Mac, אז יכול להיות שהפקודות יהיו שונות בהתאם למערכת ההפעלה שלך. פותחים את הטרמינל ומקלידים את הפקודה הבאה:
- $> export CA_COLOR_OPAQUE=1
- $> export CA_LOG_MEMORY_USAGE=1
- $> /Applications/Safari.app/Contents/MacOS/Safari
הפעולה הזו מפעילה את Safari עם כמה כלי עזר לניפוי באגים. האפשרות CA_COLOR_OPAQUE מראה לנו אילו רכיבים באמת מורכבים או מואצים. הערך CA_LOG_MEMORY_USAGE מראה לנו כמה זיכרון אנחנו משתמשים כשאנחנו שולחים את פעולות הציור שלנו למאגר הגיבוי. כך אפשר לדעת בדיוק כמה עומס מופעל על המכשיר הנייד, ולקבל רמזים לגבי האופן שבו השימוש ב-GPU עלול לרוקן את הסוללה של מכשיר היעד.
עכשיו נפעיל את Chrome כדי לראות מידע על קצב הפריימים (FPS):
- פותחים את דפדפן האינטרנט Google Chrome.
- בסרגל הכתובות, מקלידים about:flags.
- גוללים למטה כמה פריטים ולוחצים על "הפעלה" של מונה FPS.
אם תפתחו את הדף הזה בגרסה המשופרת של Chrome, תראו את מונה ה-FPS בצבע אדום בפינה הימנית העליונה.
כך אנחנו יודעים שהתכונה "שיפור מהירות באמצעות חומרה" מופעלת. הוא גם נותן לנו מושג איך האנימציה פועלת ואם יש זליגות (אנימציות שפועלות ברציפות וצריך לעצור אותן).
דרך נוספת לראות את שיפור המהירות באמצעות חומרה היא לפתוח את אותו דף ב-Safari (עם משתני הסביבה שציינתי למעלה). כל רכיב DOM מואץ מקבל גוון אדום. כך אנחנו יכולים לראות בדיוק מה מורכב בכל שכבה. שימו לב שהניווט הלבן לא אדום כי הוא לא מואץ.
הגדרה דומה ל-Chrome זמינה גם ב-about:flags "Composited render layer borders".
דרך מצוינת נוספת לראות את השכבות המורכבות היא להציג את הדגמת העלים הנושרים של WebKit כשהמוד הזה מופעל.
ולבסוף, כדי להבין באמת את ביצועי חומרת הגרפיקה של האפליקציה, בואו נסתכל על צריכת הזיכרון. כאן אנחנו רואים שאנחנו דוחפים 1.38MB של הוראות ציור למאגרי הנתונים הזמניים של CoreAnimation ב-Mac OS. מאגרי הזיכרון של Core Animation משותפים בין OpenGL ES לבין ה-GPU כדי ליצור את הפיקסלים הסופיים שמוצגים במסך.
כשאנחנו משנים את הגודל של חלון הדפדפן או מגדילים אותו, אנחנו רואים שגם הזיכרון מתרחב.
כך תוכלו לקבל מושג לגבי צריכת הזיכרון במכשיר הנייד, רק אם תשנו את גודל הדפדפן למידות הנכונות. אם אתם מנפים באגים או בודקים סביבות של אייפון, שנו את הגודל ל-480px על 320px. עכשיו אנחנו מבינים בדיוק איך פועל שיפור המהירות באמצעות חומרה ומה נדרש כדי לנפות באגים. זה דבר אחד לקרוא על זה, אבל לראות בפועל את מאגרי הזיכרון של ה-GPU פועלים באופן חזותי באמת נותן פרספקטיבה.
מאחורי הקלעים: אחזור ושמירה במטמון
עכשיו הגיע הזמן לקחת את השמירה במטמון של הדפים והמשאבים שלנו צעד אחד קדימה. בדומה לגישה שבה משתמשים ב-JQuery Mobile ובמסגרות דומות, אנחנו הולכים לאחזר מראש את הדפים שלנו ולשמור אותם במטמון באמצעות קריאות AJAX בו-זמניות.
בואו נתייחס לכמה בעיות מרכזיות באינטרנט לנייד ולסיבות שבגללן אנחנו צריכים לעשות את זה:
- אחזור: אחזור מראש של הדפים שלנו מאפשר למשתמשים להעביר את האפליקציה למצב אופליין, וגם מונע המתנה בין פעולות הניווט. כמובן שאנחנו לא רוצים להעמיס על רוחב הפס של המכשיר כשהוא מתחבר לאינטרנט, אז אנחנו צריכים להשתמש בתכונה הזו בזהירות.
- שמירה במטמון: בשלב הבא, אנחנו רוצים גישה בו-זמנית או אסינכרונית בזמן האחזור והשמירה במטמון של הדפים האלה. אנחנו צריכים גם להשתמש ב-localStorage (כי הוא נתמך היטב במכשירים), שלצערנו הוא לא אסינכרוני.
- AJAX וניתוח התגובה: שימוש ב-innerHTML() כדי להוסיף את תגובת ה-AJAX ל-DOM הוא מסוכן (ולא אמין?). במקום זאת, אנחנו משתמשים במנגנון אמין להוספת תגובות AJAX ולטיפול בשיחות בו-זמניות. אנחנו גם משתמשים בכמה תכונות חדשות של HTML5 כדי לנתח את
xhr.responseText.
בהתבסס על הקוד מההדגמה של החלקה, היפוך וסיבוב, נתחיל בהוספת כמה דפים משניים וקישור אליהם. לאחר מכן ננתח את הקישורים וניצור מעברים באופן מיידי.
כאן אפשר לצפות בהדגמה של אחזור ושמירה במטמון.
כמו שאפשר לראות, אנחנו משתמשים כאן בתגי עיצוב סמנטיים. רק קישור לדף אחר. דף הצאצא פועל לפי אותו מבנה צומת/מחלקה כמו דף ההורה. אנחנו יכולים לקחת את זה צעד אחד קדימה ולהשתמש במאפיין data-* עבור צומתי "דף" וכו'. והנה דף הפרטים (צאצא) שנמצא בקובץ HTML נפרד (/demo2/home-detail.html) שייטען, יישמר במטמון ויוגדר למעבר בטעינת האפליקציה.
<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>
עכשיו נסתכל על ה-JavaScript. כדי לפשט את הדברים, לא כללתי בקוד פונקציות עזר או אופטימיזציות. כל מה שאנחנו עושים כאן הוא לעבור בלולאה על מערך מסוים של צומתי DOM כדי לחלץ קישורים לאחזור ולשמירה במטמון.
הערה: בהדגמה הזו, ה-method fetchAndCache() מופעלת כשהדף נטען. אנחנו נשנה אותו בקטע הבא, כשנזהה את החיבור לרשת ונקבע מתי צריך לקרוא לו.
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') &&
//'#' 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) &&
//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();
}
}
}
};
כדי להבטיח עיבוד אסינכרוני תקין לאחר השליחה, אנחנו משתמשים באובייקט AJAX. במאמר Working Off the Grid with HTML5 Offline יש הסבר מתקדם יותר על השימוש ב-localStorage בקריאת AJAX. בדוגמה הזו מוצג שימוש בסיסי בשמירה במטמון בכל בקשה, והצגת האובייקטים שנשמרו במטמון כשהשרת מחזיר תגובה שהיא לא תגובת הצלחה (200).
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;
}
}
}
}
לצערנו, מכיוון ש-localStorage משתמש ב-UTF-16 לקידוד תווים, כל בייט בודד מאוחסן כ-2 בייטים, מה שמקטין את מגבלת האחסון מ-5MB ל-2.6MB בסך הכול. הסיבה לאחזור ולשמירה במטמון של הדפים או תגי העיצוב האלה מחוץ להיקף של מטמון האפליקציה מוסברת בסעיף הבא.
ההתקדמות שחלה לאחרונה ברכיב iframe ב-HTML5 מאפשרת לנו לנתח בצורה פשוטה ויעילה את ה-responseText שאנחנו מקבלים בחזרה מהקריאה ל-AJAX. יש הרבה מנתחי JavaScript וביטויים רגולריים באורך 3,000 שורות שמסירים תגי סקריפט וכו'. אבל למה לא לתת לדפדפן לעשות את מה שהוא עושה הכי טוב? בדוגמה הזו, נכתוב את ה-responseText ב-iframe מוסתר זמני. אנחנו משתמשים במאפיין sandbox של HTML5, שמשבית סקריפטים ומציע הרבה תכונות אבטחה…
מתוך המפרט: המאפיין sandbox, כשהוא מצוין, מפעיל קבוצה של הגבלות נוספות על כל תוכן שמתארח ב-iframe. הערך שלו חייב להיות קבוצה לא מסודרת של אסימונים ייחודיים שמופרדים ברווחים, שהם ASCII לא תלוי-רישיות. הערכים המותרים הם allow-forms, allow-same-origin, allow-scripts ו-allow-top-navigation. כשהמאפיין מוגדר, המערכת מתייחסת לתוכן כאילו הוא מגיע ממקור ייחודי, טפסים וסקריפטים מושבתים, קישורים לא יכולים לטרגט הקשרים אחרים של גלישה ופלאגינים מושבתים.
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 מסרב בצדק להעביר צומת באופן משתמע ממסמך אחד לאחר. אם צומת הצאצא החדש נוצר במסמך אחר, תופיע שגיאה. אז כאן אנחנו משתמשים ב-adoptNode והכול בסדר.
אז למה iframe? למה לא להשתמש פשוט ב-innerHTML? למרות ש-innerHTML הוא עכשיו חלק מהמפרט של HTML5, הוספת התגובה משרת (טוב או רע) לאזור לא מסומן היא נוהג מסוכן. בזמן כתיבת המאמר הזה, לא הצלחתי למצוא אף אחד שמשתמש במשהו אחר מלבד innerHTML. אני יודע ש-JQuery משתמשת בזה כברירת מחדל, עם חלופה של append רק במקרה של חריגה. וגם JQuery Mobile משתמשת בו. עם זאת, לא ביצעתי בדיקות מעמיקות לגבי "הפסקת הפעולה באופן אקראי" של innerHTML, אבל יהיה מעניין מאוד לראות את כל הפלטפורמות שמושפעות מכך. יהיה מעניין גם לראות איזו גישה מניבה ביצועים טובים יותר… שמעתי טענות משני הצדדים גם בנושא הזה.
זיהוי, טיפול ויצירת פרופילים של סוג הרשת
עכשיו, כשיש לנו את היכולת לאגור (או לשמור במטמון חזוי) את אפליקציית האינטרנט שלנו, אנחנו צריכים לספק את תכונות זיהוי החיבור המתאימות שהופכות את האפליקציה שלנו לחכמה יותר. בשלב הזה, פיתוח האפליקציה לנייד הופך לרגיש מאוד למצבי אונליין/אופליין ולמהירות החיבור. מזינים את The Network Information API. בכל פעם שאני מציג את התכונה הזו במצגת, מישהו בקהל מרים את היד ושואל "למה זה ישמש אותי?". אז הנה דרך אפשרית להגדיר אפליקציית אינטרנט לנייד חכמה במיוחד.
תרחיש משעמם ומוכר… כשגולשים באינטרנט ממכשיר נייד ברכבת מהירה, הרשת עשויה להתנתק ברגעים שונים, ואזורים גיאוגרפיים שונים עשויים לתמוך במהירויות שידור שונות (למשל, HSPA או 3G עשויים להיות זמינים באזורים עירוניים מסוימים, אבל אזורים מרוחקים עשויים לתמוך בטכנולוגיות 2G איטיות בהרבה). הקוד הבא מתייחס לרוב תרחישי החיבור.
הקוד הבא מספק:
- גישה אופליין דרך
applicationCache. - זיהוי אם הדף נוסף לסימניות וזמין אופליין.
- מזהה מעבר ממצב אופליין למצב אונליין ולהפך.
- מזהה חיבורים איטיים ומאחזר תוכן על סמך סוג הרשת.
שוב, כל התכונות האלה דורשות מעט מאוד קוד. קודם אנחנו מזהים את האירועים ואת תרחישי הטעינה:
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);
ב-EventListeners שלמעלה, אנחנו צריכים להגדיר בקוד אם הוא נקרא מאירוע או מבקשה או רענון של דף בפועל. הסיבה העיקרית היא שהאירוע onload של הגוף לא יופעל במעבר בין מצב אונליין למצב אופליין.
בשלב הבא, יש לנו בדיקה פשוטה של אירוע ononline או onload. הקוד הזה מאפס קישורים מושבתים כשעוברים ממצב אופליין למצב אונליין, אבל אם האפליקציה הזו הייתה מתוחכמת יותר, אפשר היה להוסיף לוגיקה שתחדש את אחזור התוכן או תטפל בממשק המשתמש בחיבורים לסירוגין.
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;
}
}
}
אותו דבר לגבי processOffline(). כאן אתם יכולים להפעיל את האפליקציה במצב אופליין ולנסות לשחזר את כל העסקאות שהתרחשו מאחורי הקלעים. הקוד הבא מוצא את כל הקישורים החיצוניים שלנו ומשבית אותם – כך המשתמשים נלכדים באפליקציה שלנו במצב אופליין לנצח, מוהאהאהא!
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);
}
}
}
אוקיי, אז בואו נתחיל עם הדברים הטובים. עכשיו, כשהאפליקציה יודעת מה מצב החיבור שלה, אנחנו יכולים גם לבדוק את סוג החיבור כשהיא אונליין ולבצע התאמות בהתאם. הוספתי בתגובות לכל חיבור את מהירויות ההורדה והזמנים הרגילים של ספקים בצפון אמריקה.
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);
}
}
יש הרבה התאמות שאפשר לבצע בתהליך fetchAndCache, אבל כל מה שעשיתי כאן היה להורות לו לאחזר את המשאבים באופן אסינכרוני (true) או סינכרוני (false) לחיבור נתון.
ציר הזמן של בקשות Edge (סינכרוניות)
ציר הזמן של בקשות Wi-Fi (אסינכרוניות)
כך אפשר להתאים את חוויית המשתמש, לפחות במידה מסוימת, לחיבורים איטיים או מהירים. זה לא פתרון קסם. משימה נוספת היא להציג מודל טעינה כשלוחצים על קישור (בחיבורים איטיים) בזמן שהאפליקציה עדיין מאחזרת את הדף של הקישור הזה ברקע. המטרה העיקרית היא לצמצם את זמני האחזור, ובמקביל לנצל את מלוא היכולות של החיבור של המשתמש באמצעות הגרסה העדכנית והטובה ביותר של HTML5. כאן אפשר לצפות בהדגמה של זיהוי הרשת.
סיכום
המסע בדרך של אפליקציות HTML5 לנייד רק מתחיל. עכשיו אתם רואים את היסודות הפשוטים והבסיסיים של "מסגרת" לנייד, שמבוססת רק על HTML5 ועל הטכנולוגיות שתומכות בה. אני חושב שחשוב שהמפתחים יעבדו עם התכונות האלה ויתייחסו אליהן ברמת הליבה, ולא יסתירו אותן באמצעות מעטפת.