เทคนิค HTML5 สำหรับการเพิ่มประสิทธิภาพการทำงานบนมือถือ

บทนำ

การรีเฟรชที่หมุนวน การเปลี่ยนหน้าเว็บที่ขาดๆ หายๆ และความล่าช้าเป็นระยะๆ ในเหตุการณ์การแตะเป็นเพียงปัญหาเล็กน้อยที่น่าปวดหัวในสภาพแวดล้อมเว็บบนมือถือในปัจจุบัน นักพัฒนาแอปพยายามทำให้แอปมีประสิทธิภาพใกล้เคียงกับแอปที่มาพร้อมเครื่องมากที่สุด แต่ก็มักจะถูกขัดขวางโดยการแฮ็ก การรีเซ็ต และเฟรมเวิร์กที่เข้มงวด

ในบทความนี้ เราจะพูดถึงข้อกำหนดขั้นต่ำสุดในการสร้างเว็บแอป HTML5 บนอุปกรณ์เคลื่อนที่ ประเด็นหลักคือการเปิดเผยความซับซ้อนที่ซ่อนอยู่ซึ่งเฟรมเวิร์กบนอุปกรณ์เคลื่อนที่ในปัจจุบันพยายามซ่อนไว้ คุณจะได้เห็นแนวทางแบบมินิมอล (โดยใช้ HTML5 API หลัก) และพื้นฐานเบื้องต้นที่จะช่วยให้คุณเขียนเฟรมเวิร์กของตัวเองหรือมีส่วนร่วมในเฟรมเวิร์กที่ใช้อยู่ในปัจจุบันได้

การเร่งฮาร์ดแวร์

โดยปกติแล้ว GPU จะจัดการการสร้างโมเดล 3 มิติหรือแผนภาพ CAD โดยละเอียด แต่ในกรณีนี้ เราต้องการให้ภาพวาดพื้นฐาน (div, พื้นหลัง, ข้อความที่มีเงาตกกระทบ, รูปภาพ ฯลฯ) ปรากฏอย่างราบรื่นและเคลื่อนไหวอย่างราบรื่นผ่าน GPU สิ่งที่น่าเสียดายคือ นักพัฒนาฟรอนท์เอนด์ส่วนใหญ่ส่งกระบวนการสร้างภาพเคลื่อนไหวนี้ไปยังเฟรมเวิร์กของบุคคลที่สามโดยไม่คำนึงถึงความหมาย แต่ฟีเจอร์ CSS3 หลักเหล่านี้ควรถูกปิดบังหรือไม่ เรามาดูเหตุผลบางประการที่ทำให้การใส่ใจเรื่องนี้เป็นสิ่งสำคัญกัน

  1. การจัดสรรหน่วยความจำและภาระการประมวลผล — หากคุณทำการจัดองค์ประกอบทุกองค์ประกอบใน DOM เพียงเพื่อการเร่งฮาร์ดแวร์ บุคคลถัดไปที่ทำงานกับโค้ดของคุณอาจไล่ตามคุณและตีคุณอย่างรุนแรง

  2. การใช้พลังงาน — แน่นอนว่าเมื่อฮาร์ดแวร์ทำงาน แบตเตอรี่ก็ทำงานด้วย เมื่อพัฒนาแอปสำหรับอุปกรณ์เคลื่อนที่ นักพัฒนาแอปจำเป็นต้องพิจารณาข้อจำกัดต่างๆ ของอุปกรณ์ขณะเขียนเว็บแอปบนมือถือ ซึ่งจะยิ่งแพร่หลายมากขึ้นเมื่อผู้ผลิตเบราว์เซอร์เริ่มเปิดให้เข้าถึงฮาร์ดแวร์ของอุปกรณ์ได้มากขึ้นเรื่อยๆ

  3. ความขัดแย้ง — ฉันพบปัญหาการทำงานผิดปกติเมื่อใช้การเร่งฮาร์ดแวร์กับส่วนต่างๆ ของหน้าที่เร่งความเร็วอยู่แล้ว ดังนั้นการทราบว่าคุณมีการเร่งความเร็วที่ทับซ้อนกันหรือไม่จึงเป็นเรื่องที่สำคัญมาก

เราต้องทำให้เบราว์เซอร์ทำงานให้เรา เพื่อให้การโต้ตอบของผู้ใช้เป็นไปอย่างราบรื่นและใกล้เคียงกับแอปที่มาพร้อมเครื่องมากที่สุด ตามหลักการแล้ว เราต้องการให้ 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) ที่ดี

  1. เปิดเว็บเบราว์เซอร์ Google Chrome
  2. พิมพ์ about:flags ในแถบ URL
  3. เลื่อนลงไป 2-3 รายการ แล้วคลิก "เปิดใช้" สำหรับตัวนับ FPS

หากดูหน้านี้ใน Chrome เวอร์ชันที่ปรับปรุงแล้ว คุณจะเห็นตัวนับ FPS สีแดงที่มุมซ้ายบน

Chrome FPS

ซึ่งวิธีนี้จะช่วยให้เราทราบว่าการเร่งฮาร์ดแวร์เปิดอยู่ นอกจากนี้ยังช่วยให้เราทราบว่าภาพเคลื่อนไหวทำงานอย่างไร และมีปัญหาการรั่วไหล (ภาพเคลื่อนไหวที่ทำงานต่อเนื่องซึ่งควรหยุด) หรือไม่

อีกวิธีหนึ่งในการแสดงภาพการเร่งฮาร์ดแวร์คือการเปิดหน้าเดียวกันใน Safari (โดยใช้ตัวแปรสภาพแวดล้อมที่กล่าวถึงข้างต้น) องค์ประกอบ DOM ที่เร่งความเร็วทุกรายการจะมีสีแดงอ่อนๆ ซึ่งจะแสดงให้เราเห็นว่ามีการจัดองค์ประกอบอะไรบ้างตามเลเยอร์ โปรดสังเกตว่าการนำทางสีขาวไม่ใช่สีแดงเนื่องจากไม่ได้เร่งความเร็ว

รายชื่อติดต่อแบบผสม

การตั้งค่าที่คล้ายกันสำหรับ Chrome ยังมีอยู่ใน about:flags "Composited render layer borders"

อีกวิธีที่ยอดเยี่ยมในการดูเลเยอร์ที่ประกอบกันคือการดูเดโมใบไม้ร่วงของ WebKit ขณะที่ใช้โหมดนี้

ใบไม้แบบผสม

สุดท้าย เพื่อให้เข้าใจประสิทธิภาพฮาร์ดแวร์กราฟิกของแอปพลิเคชันอย่างแท้จริง เรามาดูวิธีใช้หน่วยความจำกัน ในที่นี้ เราจะเห็นว่าเรากำลังพุชคำสั่งการวาดขนาด 1.38 MB ไปยังบัฟเฟอร์ CoreAnimation ใน Mac OS บัฟเฟอร์หน่วยความจำ Core Animation จะแชร์ระหว่าง OpenGL ES และ GPU เพื่อสร้างพิกเซลสุดท้ายที่คุณเห็นบนหน้าจอ

Coreanimation 1

เมื่อเราปรับขนาดหรือขยายหน้าต่างเบราว์เซอร์ให้ใหญ่สุด เราจะเห็นว่าหน่วยความจำก็ขยายตามไปด้วย

Coreanimation 2

ซึ่งจะช่วยให้คุณทราบว่ามีการใช้หน่วยความจำในอุปกรณ์เคลื่อนที่อย่างไรก็ต่อเมื่อคุณปรับขนาดเบราว์เซอร์ให้มีขนาดที่ถูกต้อง หากคุณกำลังแก้ไขข้อบกพร่องหรือทดสอบสำหรับสภาพแวดล้อม iPhone ให้ปรับขนาดเป็น 480 x 320 พิกเซล ตอนนี้เราเข้าใจวิธีการทำงานของการเร่งฮาร์ดแวร์และสิ่งที่ต้องใช้ในการแก้ไขข้อบกพร่องอย่างถ่องแท้แล้ว การอ่านข้อมูลเกี่ยวกับเรื่องนี้ก็เป็นเรื่องหนึ่ง แต่การได้เห็นบัฟเฟอร์หน่วยความจำ GPU ทำงานแบบเป็นภาพจริงๆ ช่วยให้เข้าใจสิ่งต่างๆ ได้ดีขึ้นมาก

เบื้องหลัง: การดึงข้อมูลและการแคช

ตอนนี้ถึงเวลาแล้วที่จะยกระดับการแคชหน้าเว็บและทรัพยากรไปอีกขั้น เราจะดึงข้อมูลล่วงหน้าและแคชหน้าเว็บด้วยการเรียก AJAX พร้อมกัน ซึ่งคล้ายกับแนวทางที่ JQuery Mobile และเฟรมเวิร์กที่คล้ายกันใช้

มาดูปัญหาหลักๆ ของเว็บบนมือถือและสาเหตุที่เราต้องดำเนินการดังนี้

  • การดึงข้อมูล: การดึงข้อมูลหน้าเว็บล่วงหน้าช่วยให้ผู้ใช้ใช้งานแอปแบบออฟไลน์ได้ และยังช่วยให้ไม่ต้องรอระหว่างการไปยังส่วนต่างๆ แน่นอนว่าเราไม่ต้องการให้แบนด์วิดท์ของอุปกรณ์ติดขัดเมื่ออุปกรณ์ออนไลน์ ดังนั้นเราจึงต้องใช้ฟีเจอร์นี้อย่างประหยัด
  • การแคช: ต่อไป เราต้องการแนวทางแบบพร้อมกันหรือแบบอะซิงโครนัสเมื่อดึงข้อมูลและแคชหน้าเว็บเหล่านี้ นอกจากนี้ เรายังต้องใช้ localStorage (เนื่องจากอุปกรณ์ต่างๆ รองรับเป็นอย่างดี) ซึ่งน่าเสียดายที่ไม่ใช่แบบอะซิงโครนัส
  • AJAX และการแยกวิเคราะห์การตอบกลับ: การใช้ innerHTML() เพื่อแทรกการตอบกลับ AJAX ลงใน DOM เป็นอันตราย (และไม่น่าเชื่อถือ) แต่เราใช้กลไกที่เชื่อถือได้สำหรับการแทรกการตอบกลับ AJAX และการจัดการการเรียกพร้อมกัน นอกจากนี้ เรายังใช้ประโยชน์จากฟีเจอร์ใหม่ๆ ของ HTML5 เพื่อแยกวิเคราะห์ xhr.responseText ด้วย

เราจะเริ่มด้วยการเพิ่มหน้าสำรองและลิงก์ไปยังหน้าเหล่านั้น โดยต่อยอดจากโค้ดในเดโมการเลื่อน พลิก และหมุน จากนั้นเราจะแยกวิเคราะห์ลิงก์และสร้างการเปลี่ยนผ่านได้ทันที

หน้าแรกของ iPhone

ดูการสาธิตการดึงข้อมูลและการแคชที่นี่

คุณจะเห็นว่าเราใช้ประโยชน์จากมาร์กอัปเชิงความหมายที่นี่ เป็นเพียงลิงก์ไปยังหน้าอื่น หน้าย่อยจะมีโครงสร้างโหนด/คลาสเหมือนกับหน้าหลัก เราสามารถดำเนินการขั้นต่อไปและใช้แอตทริบิวต์ 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') &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();
      }
    }
  }
};

เราตรวจสอบว่ามีการประมวลผลหลังการประมวลผลแบบอะซิงโครนัสอย่างเหมาะสมผ่านการใช้ออบเจ็กต์ "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 (แบบซิงโครนัส)

Edge Sync

ไทม์ไลน์คำขอ Wi-Fi (แบบอะซิงโครนัส)

Wi-Fi Async

ซึ่งจะช่วยให้สามารถปรับประสบการณ์ของผู้ใช้ตามการเชื่อมต่อที่ช้าหรือเร็วได้ นี่ไม่ใช่โซลูชันที่สมบูรณ์แบบ สิ่งที่ต้องทำอีกอย่างคือแสดงโมดัลการโหลดเมื่อมีการคลิกลิงก์ (ในการเชื่อมต่อที่ช้า) ขณะที่แอปอาจยังคงดึงข้อมูลหน้าของลิงก์นั้นในเบื้องหลัง ประเด็นสำคัญคือการลดเวลาในการตอบสนองไปพร้อมกับการใช้ประโยชน์จากการเชื่อมต่อของผู้ใช้อย่างเต็มที่ด้วย HTML5 เวอร์ชันล่าสุดและดีที่สุด ดูเดโมการตรวจจับเครือข่ายได้ที่นี่

บทสรุป

การเดินทางบนเส้นทางของแอป HTML5 บนอุปกรณ์เคลื่อนที่เพิ่งเริ่มต้นขึ้นเท่านั้น ตอนนี้คุณจะเห็นรากฐานที่เรียบง่ายและพื้นฐานของ "เฟรมเวิร์ก" บนอุปกรณ์เคลื่อนที่ซึ่งสร้างขึ้นโดยใช้ HTML5 และเทคโนโลยีที่รองรับเท่านั้น ผมคิดว่าสิ่งสำคัญสำหรับนักพัฒนาแอปคือการทำงานและจัดการกับฟีเจอร์เหล่านี้ที่แกนหลัก ไม่ใช่การปิดบังด้วย Wrapper