บทนำ
การรีเฟรชที่หมุนวน การเปลี่ยนหน้าเว็บที่ขาดๆ หายๆ และความล่าช้าเป็นระยะๆ ในเหตุการณ์การแตะเป็นเพียงปัญหาเล็กน้อยที่น่าปวดหัวในสภาพแวดล้อมเว็บบนมือถือในปัจจุบัน นักพัฒนาแอปพยายามทำให้แอปมีประสิทธิภาพใกล้เคียงกับแอปที่มาพร้อมเครื่องมากที่สุด แต่ก็มักจะถูกขัดขวางโดยการแฮ็ก การรีเซ็ต และเฟรมเวิร์กที่เข้มงวด
ในบทความนี้ เราจะพูดถึงข้อกำหนดขั้นต่ำสุดในการสร้างเว็บแอป HTML5 บนอุปกรณ์เคลื่อนที่ ประเด็นหลักคือการเปิดเผยความซับซ้อนที่ซ่อนอยู่ซึ่งเฟรมเวิร์กบนอุปกรณ์เคลื่อนที่ในปัจจุบันพยายามซ่อนไว้ คุณจะได้เห็นแนวทางแบบมินิมอล (โดยใช้ HTML5 API หลัก) และพื้นฐานเบื้องต้นที่จะช่วยให้คุณเขียนเฟรมเวิร์กของตัวเองหรือมีส่วนร่วมในเฟรมเวิร์กที่ใช้อยู่ในปัจจุบันได้
การเร่งฮาร์ดแวร์
โดยปกติแล้ว GPU จะจัดการการสร้างโมเดล 3 มิติหรือแผนภาพ CAD โดยละเอียด แต่ในกรณีนี้ เราต้องการให้ภาพวาดพื้นฐาน (div, พื้นหลัง, ข้อความที่มีเงาตกกระทบ, รูปภาพ ฯลฯ) ปรากฏอย่างราบรื่นและเคลื่อนไหวอย่างราบรื่นผ่าน GPU สิ่งที่น่าเสียดายคือ นักพัฒนาฟรอนท์เอนด์ส่วนใหญ่ส่งกระบวนการสร้างภาพเคลื่อนไหวนี้ไปยังเฟรมเวิร์กของบุคคลที่สามโดยไม่คำนึงถึงความหมาย แต่ฟีเจอร์ CSS3 หลักเหล่านี้ควรถูกปิดบังหรือไม่ เรามาดูเหตุผลบางประการที่ทำให้การใส่ใจเรื่องนี้เป็นสิ่งสำคัญกัน
การจัดสรรหน่วยความจำและภาระการประมวลผล — หากคุณทำการจัดองค์ประกอบทุกองค์ประกอบใน DOM เพียงเพื่อการเร่งฮาร์ดแวร์ บุคคลถัดไปที่ทำงานกับโค้ดของคุณอาจไล่ตามคุณและตีคุณอย่างรุนแรง
การใช้พลังงาน — แน่นอนว่าเมื่อฮาร์ดแวร์ทำงาน แบตเตอรี่ก็ทำงานด้วย เมื่อพัฒนาแอปสำหรับอุปกรณ์เคลื่อนที่ นักพัฒนาแอปจำเป็นต้องพิจารณาข้อจำกัดต่างๆ ของอุปกรณ์ขณะเขียนเว็บแอปบนมือถือ ซึ่งจะยิ่งแพร่หลายมากขึ้นเมื่อผู้ผลิตเบราว์เซอร์เริ่มเปิดให้เข้าถึงฮาร์ดแวร์ของอุปกรณ์ได้มากขึ้นเรื่อยๆ
ความขัดแย้ง — ฉันพบปัญหาการทำงานผิดปกติเมื่อใช้การเร่งฮาร์ดแวร์กับส่วนต่างๆ ของหน้าที่เร่งความเร็วอยู่แล้ว ดังนั้นการทราบว่าคุณมีการเร่งความเร็วที่ทับซ้อนกันหรือไม่จึงเป็นเรื่องที่สำคัญมาก
เราต้องทำให้เบราว์เซอร์ทำงานให้เรา เพื่อให้การโต้ตอบของผู้ใช้เป็นไปอย่างราบรื่นและใกล้เคียงกับแอปที่มาพร้อมเครื่องมากที่สุด ตามหลักการแล้ว เราต้องการให้ CPU ของอุปกรณ์เคลื่อนที่ตั้งค่าภาพเคลื่อนไหวเริ่มต้น จากนั้นให้ GPU รับผิดชอบเฉพาะการจัดองค์ประกอบเลเยอร์ต่างๆ ในระหว่างกระบวนการสร้างภาพเคลื่อนไหว ซึ่งเป็นสิ่งที่ translate3d, scale3d และ translateZ ทำ โดยจะให้องค์ประกอบที่เคลื่อนไหวมีเลเยอร์ของตัวเอง ซึ่งจะช่วยให้อุปกรณ์แสดงผลทุกอย่างร่วมกันได้อย่างราบรื่น หากต้องการดูข้อมูลเพิ่มเติมเกี่ยวกับการจัดองค์ประกอบแบบเร่งและการทำงานของ WebKit Ariya Hidayat มีข้อมูลดีๆ มากมายในบล็อกของเขา
การเปลี่ยนหน้าเว็บ
มาดูแนวทางการโต้ตอบของผู้ใช้ที่พบบ่อยที่สุด 3 แนวทางเมื่อพัฒนาเว็บแอปบนมือถือ ได้แก่ เอฟเฟกต์การเลื่อน การพลิก และการหมุน
คุณดูโค้ดนี้ที่ทำงานอยู่ได้ที่ http://slidfast.appspot.com/slide-flip-rotate.html (หมายเหตุ: การสาธิตนี้สร้างขึ้นสำหรับอุปกรณ์เคลื่อนที่ ดังนั้นให้เปิดโปรแกรมจำลอง ใช้โทรศัพท์หรือแท็บเล็ต หรือลดขนาดหน้าต่างเบราว์เซอร์ให้เหลือประมาณ 1024 พิกเซลหรือน้อยกว่า)
ก่อนอื่น เราจะแยกส่วนการเปลี่ยนสไลด์ การพลิก และการหมุน รวมถึงวิธีเร่งความเร็วของการเปลี่ยนภาพเหล่านี้ สังเกตว่าภาพเคลื่อนไหวแต่ละภาพใช้ CSS และ JavaScript เพียง 3 หรือ 4 บรรทัดเท่านั้น
การเลื่อน
การเปลี่ยนหน้าแบบเลื่อนเป็นวิธีที่พบบ่อยที่สุดใน 3 วิธีนี้ โดยจะเลียนแบบความรู้สึกของการใช้แอปพลิเคชันบนอุปกรณ์เคลื่อนที่ ระบบจะเรียกใช้การเปลี่ยนสไลด์เพื่อนำพื้นที่เนื้อหาใหม่เข้ามาในวิวพอร์ต
สำหรับเอฟเฟกต์สไลด์ ก่อนอื่นเราจะประกาศมาร์กอัปดังนี้
<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 ที่จัดการการตรวจจับและการวางแนวของอุปกรณ์เคลื่อนที่ เราสามารถจัดการกับอุปกรณ์ทุกเครื่องและความละเอียดทุกแบบได้ (ดูความละเอียดของ Media Query) เราใช้ตัวอย่างง่ายๆ เพียงไม่กี่ตัวอย่างในการสาธิตนี้เพื่อให้ครอบคลุมมุมมองแนวตั้งและแนวนอนส่วนใหญ่บนอุปกรณ์เคลื่อนที่ ซึ่งยังมีประโยชน์สำหรับการใช้การเร่งฮาร์ดแวร์ต่ออุปกรณ์ด้วย ตัวอย่างเช่น เนื่องจาก WebKit เวอร์ชันเดสก์ท็อปจะเร่งองค์ประกอบที่เปลี่ยนรูปแบบทั้งหมด (ไม่ว่าจะเป็น 2 มิติหรือ 3 มิติ) จึงควรสร้างการสืบค้นสื่อและยกเว้นการเร่งในระดับนั้น โปรดทราบว่าเคล็ดลับการเร่งฮาร์ดแวร์ไม่ได้ช่วยเพิ่มความเร็วใน 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 3 มิติ แต่ 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);
}
การแก้ไขข้อบกพร่องการเร่งฮาร์ดแวร์
เมื่อเราได้พูดถึงการเปลี่ยนฉากพื้นฐานไปแล้ว มาดูกลไกการทำงานและการจัดองค์ประกอบของการเปลี่ยนฉากกัน
หากต้องการให้เซสชันการแก้ไขข้อบกพร่องอันน่าทึ่งนี้เกิดขึ้น ให้เปิดเบราว์เซอร์ 2-3 รายการและ IDE ที่คุณเลือก ก่อนอื่น ให้เริ่ม Safari จากบรรทัดคำสั่งเพื่อใช้ตัวแปรสภาพแวดล้อมการแก้ไขข้อบกพร่องบางอย่าง เราใช้ Mac ดังนั้นคำสั่งอาจแตกต่างกันไปตามระบบปฏิบัติการของคุณ เปิดเทอร์มินัลและพิมพ์ข้อความต่อไปนี้
- $> export CA_COLOR_OPAQUE=1
- $> export CA_LOG_MEMORY_USAGE=1
- $> /Applications/Safari.app/Contents/MacOS/Safari
ซึ่งจะเริ่ม Safari ด้วยตัวช่วยแก้ไขข้อบกพร่อง 2-3 รายการ CA_COLOR_OPAQUE จะแสดงให้เราเห็นว่าองค์ประกอบใดที่ได้รับการจัดองค์ประกอบหรือเร่งความเร็วอย่างแท้จริง CA_LOG_MEMORY_USAGE แสดงให้เราเห็นว่าเราใช้หน่วยความจำไปเท่าใดเมื่อส่งการดำเนินการวาดไปยังที่เก็บข้อมูลสำรอง ซึ่งจะบอกให้คุณทราบอย่างชัดเจนว่าคุณกำลังสร้างภาระให้กับอุปกรณ์เคลื่อนที่มากเพียงใด และอาจให้คำแนะนำเกี่ยวกับวิธีที่การใช้งาน GPU อาจทำให้แบตเตอรี่ของอุปกรณ์เป้าหมายหมดเร็วขึ้น
ตอนนี้ให้เปิด Chrome เพื่อดูข้อมูลเฟรมต่อวินาที (FPS) ที่ดี
- เปิดเว็บเบราว์เซอร์ Google Chrome
- พิมพ์ about:flags ในแถบ URL
- เลื่อนลงไป 2-3 รายการ แล้วคลิก "เปิดใช้" สำหรับตัวนับ FPS
หากดูหน้านี้ใน Chrome เวอร์ชันที่ปรับปรุงแล้ว คุณจะเห็นตัวนับ FPS สีแดงที่มุมซ้ายบน
ซึ่งวิธีนี้จะช่วยให้เราทราบว่าการเร่งฮาร์ดแวร์เปิดอยู่ นอกจากนี้ยังช่วยให้เราทราบว่าภาพเคลื่อนไหวทำงานอย่างไร และมีปัญหาการรั่วไหล (ภาพเคลื่อนไหวที่ทำงานต่อเนื่องซึ่งควรหยุด) หรือไม่
อีกวิธีหนึ่งในการแสดงภาพการเร่งฮาร์ดแวร์คือการเปิดหน้าเดียวกันใน Safari (โดยใช้ตัวแปรสภาพแวดล้อมที่กล่าวถึงข้างต้น) องค์ประกอบ DOM ที่เร่งความเร็วทุกรายการจะมีสีแดงอ่อนๆ ซึ่งจะแสดงให้เราเห็นว่ามีการจัดองค์ประกอบอะไรบ้างตามเลเยอร์ โปรดสังเกตว่าการนำทางสีขาวไม่ใช่สีแดงเนื่องจากไม่ได้เร่งความเร็ว
การตั้งค่าที่คล้ายกันสำหรับ Chrome ยังมีอยู่ใน about:flags "Composited render layer borders"
อีกวิธีที่ยอดเยี่ยมในการดูเลเยอร์ที่ประกอบกันคือการดูเดโมใบไม้ร่วงของ WebKit ขณะที่ใช้โหมดนี้
สุดท้าย เพื่อให้เข้าใจประสิทธิภาพฮาร์ดแวร์กราฟิกของแอปพลิเคชันอย่างแท้จริง เรามาดูวิธีใช้หน่วยความจำกัน ในที่นี้ เราจะเห็นว่าเรากำลังพุชคำสั่งการวาดขนาด 1.38 MB ไปยังบัฟเฟอร์ CoreAnimation ใน Mac OS บัฟเฟอร์หน่วยความจำ Core Animation จะแชร์ระหว่าง OpenGL ES และ GPU เพื่อสร้างพิกเซลสุดท้ายที่คุณเห็นบนหน้าจอ
เมื่อเราปรับขนาดหรือขยายหน้าต่างเบราว์เซอร์ให้ใหญ่สุด เราจะเห็นว่าหน่วยความจำก็ขยายตามไปด้วย
ซึ่งจะช่วยให้คุณทราบว่ามีการใช้หน่วยความจำในอุปกรณ์เคลื่อนที่อย่างไรก็ต่อเมื่อคุณปรับขนาดเบราว์เซอร์ให้มีขนาดที่ถูกต้อง หากคุณกำลังแก้ไขข้อบกพร่องหรือทดสอบสำหรับสภาพแวดล้อม iPhone ให้ปรับขนาดเป็น 480 x 320 พิกเซล ตอนนี้เราเข้าใจวิธีการทำงานของการเร่งฮาร์ดแวร์และสิ่งที่ต้องใช้ในการแก้ไขข้อบกพร่องอย่างถ่องแท้แล้ว การอ่านข้อมูลเกี่ยวกับเรื่องนี้ก็เป็นเรื่องหนึ่ง แต่การได้เห็นบัฟเฟอร์หน่วยความจำ GPU ทำงานแบบเป็นภาพจริงๆ ช่วยให้เข้าใจสิ่งต่างๆ ได้ดีขึ้นมาก
เบื้องหลัง: การดึงข้อมูลและการแคช
ตอนนี้ถึงเวลาแล้วที่จะยกระดับการแคชหน้าเว็บและทรัพยากรไปอีกขั้น เราจะดึงข้อมูลล่วงหน้าและแคชหน้าเว็บด้วยการเรียก AJAX พร้อมกัน ซึ่งคล้ายกับแนวทางที่ JQuery Mobile และเฟรมเวิร์กที่คล้ายกันใช้
มาดูปัญหาหลักๆ ของเว็บบนมือถือและสาเหตุที่เราต้องดำเนินการดังนี้
- การดึงข้อมูล: การดึงข้อมูลหน้าเว็บล่วงหน้าช่วยให้ผู้ใช้ใช้งานแอปแบบออฟไลน์ได้ และยังช่วยให้ไม่ต้องรอระหว่างการไปยังส่วนต่างๆ แน่นอนว่าเราไม่ต้องการให้แบนด์วิดท์ของอุปกรณ์ติดขัดเมื่ออุปกรณ์ออนไลน์ ดังนั้นเราจึงต้องใช้ฟีเจอร์นี้อย่างประหยัด
- การแคช: ต่อไป เราต้องการแนวทางแบบพร้อมกันหรือแบบอะซิงโครนัสเมื่อดึงข้อมูลและแคชหน้าเว็บเหล่านี้ นอกจากนี้ เรายังต้องใช้ 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 เพื่อขุดลิงก์เพื่อดึงข้อมูลและแคช
หมายเหตุ - สำหรับการสาธิตนี้ ระบบจะเรียกใช้เมธอด 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" ดูคำอธิบายขั้นสูงเพิ่มเติมเกี่ยวกับการใช้ localStorage ภายในการเรียก AJAX ได้ในการทำงานแบบออฟไลน์ด้วย HTML5 Offline ในตัวอย่างนี้ คุณจะเห็นการใช้งานพื้นฐานของการแคชในแต่ละคำขอและการจัดเตรียมออบเจ็กต์ที่แคชไว้เมื่อเซิร์ฟเวอร์แสดงผลลัพธ์ใดๆ นอกเหนือจากการตอบกลับที่สำเร็จ (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 ไบต์ ซึ่งทำให้ขีดจำกัดพื้นที่เก็บข้อมูลของเราลดลงจาก 5 MB เหลือทั้งหมด 2.6 MB เหตุผลทั้งหมดในการดึงข้อมูลและแคชหน้าเว็บ/มาร์กอัปเหล่านี้ไว้นอกขอบเขตแคชของแอปพลิเคชันจะเปิดเผยในส่วนถัดไป
ความก้าวหน้าล่าสุดในองค์ประกอบ iframe ที่มี HTML5 ทำให้เรามีวิธีที่ง่ายและมีประสิทธิภาพในการแยกวิเคราะห์ responseText ที่เราได้รับกลับมาจากการเรียก AJAX มีโปรแกรมแยกวิเคราะห์ JavaScript และนิพจน์ทั่วไปจำนวนมากที่มีความยาว 3,000 บรรทัดซึ่งจะนำแท็กสคริปต์และอื่นๆ ออก แต่ทำไมไม่ปล่อยให้เบราว์เซอร์ทำสิ่งที่ทำได้ดีที่สุดล่ะ ในตัวอย่างนี้ เราจะเขียน responseText ลงใน iframe ที่ซ่อนอยู่ชั่วคราว เราใช้แอตทริบิวต์ "แซนด์บ็อกซ์" ของ HTML5 ซึ่งปิดใช้สคริปต์และมีฟีเจอร์ความปลอดภัยมากมาย…
จากข้อกำหนด: แอตทริบิวต์แซนด์บ็อกซ์เมื่อระบุจะเปิดใช้ชุดข้อจำกัดเพิ่มเติมในเนื้อหาที่โฮสต์โดย 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 ใช้ฟังก์ชันนี้เป็นหลัก โดยมีฟังก์ชันสำรองแบบต่อท้ายในกรณีที่มีข้อยกเว้นเท่านั้น และ JQuery Mobile ก็ใช้ด้วยเช่นกัน อย่างไรก็ตาม ฉันยังไม่ได้ทำการทดสอบอย่างหนักหน่วงเกี่ยวกับ innerHTML "หยุดทำงานแบบสุ่ม" แต่น่าสนใจมากที่จะได้เห็นแพลตฟอร์มทั้งหมดที่ได้รับผลกระทบจากเรื่องนี้ นอกจากนี้ยังน่าสนใจที่จะดูว่าแนวทางใดมีประสิทธิภาพมากกว่ากัน… ฉันได้ยินคำกล่าวอ้างจากทั้ง 2 ฝ่ายเกี่ยวกับเรื่องนี้ด้วย
การตรวจจับ การจัดการ และการทำโปรไฟล์ประเภทเครือข่าย
เมื่อเรามีความสามารถในการบัฟเฟอร์ (หรือแคชแบบคาดการณ์) เว็บแอปแล้ว เราต้องจัดเตรียมฟีเจอร์การตรวจจับการเชื่อมต่อที่เหมาะสมซึ่งจะทำให้แอปของเราฉลาดขึ้น นี่คือจุดที่การพัฒนาแอปบนอุปกรณ์เคลื่อนที่มีความไวต่อโหมดออนไลน์/ออฟไลน์และความเร็วในการเชื่อมต่ออย่างมาก 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 โค้ดนี้จะรีเซ็ตลิงก์ที่ปิดใช้เมื่อเปลี่ยนจากออฟไลน์เป็นออนไลน์ แต่หากแอปนี้มีความซับซ้อนมากขึ้น คุณอาจแทรกตรรกะที่จะดึงเนื้อหาต่อหรือจัดการ UX สำหรับการเชื่อมต่อที่ไม่ต่อเนื่อง
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 ได้หลายวิธี แต่สิ่งที่เราทำที่นี่คือการบอกให้ดึงข้อมูลทรัพยากรแบบอะซิงโครนัส (จริง) หรือแบบซิงโครนัส (เท็จ) สำหรับการเชื่อมต่อหนึ่งๆ
ไทม์ไลน์คำขอ Edge (แบบซิงโครนัส)
ไทม์ไลน์คำขอ Wi-Fi (แบบอะซิงโครนัส)
ซึ่งจะช่วยให้สามารถปรับประสบการณ์ของผู้ใช้ตามการเชื่อมต่อที่ช้าหรือเร็วได้ นี่ไม่ใช่โซลูชันที่สมบูรณ์แบบ สิ่งที่ต้องทำอีกอย่างคือแสดงโมดัลการโหลดเมื่อมีการคลิกลิงก์ (ในการเชื่อมต่อที่ช้า) ขณะที่แอปอาจยังคงดึงข้อมูลหน้าของลิงก์นั้นในเบื้องหลัง ประเด็นสำคัญคือการลดเวลาในการตอบสนองไปพร้อมกับการใช้ประโยชน์จากการเชื่อมต่อของผู้ใช้อย่างเต็มที่ด้วย HTML5 เวอร์ชันล่าสุดและดีที่สุด ดูเดโมการตรวจจับเครือข่ายได้ที่นี่
บทสรุป
การเดินทางบนเส้นทางของแอป HTML5 บนอุปกรณ์เคลื่อนที่เพิ่งเริ่มต้นขึ้นเท่านั้น ตอนนี้คุณจะเห็นรากฐานที่เรียบง่ายและพื้นฐานของ "เฟรมเวิร์ก" บนอุปกรณ์เคลื่อนที่ซึ่งสร้างขึ้นโดยใช้ HTML5 และเทคโนโลยีที่รองรับเท่านั้น ผมคิดว่าสิ่งสำคัญสำหรับนักพัฒนาแอปคือการทำงานและจัดการกับฟีเจอร์เหล่านี้ที่แกนหลัก ไม่ใช่การปิดบังด้วย Wrapper