การสร้างประสบการณ์การใช้งานแบบเต็มหน้าจอ

เราสามารถสร้างเว็บไซต์และแอปพลิเคชันแบบเต็มหน้าจอที่สมจริงได้อย่างง่ายดาย แต่ก็มีวิธีทำ 2-3 วิธีเช่นเดียวกับสิ่งอื่นๆ บนเว็บ ซึ่งสำคัญอย่างยิ่งในปัจจุบัน เนื่องจากเบราว์เซอร์จำนวนมากขึ้นรองรับประสบการณ์การใช้งาน "เว็บแอปที่ติดตั้ง" ซึ่งเปิดแบบเต็มหน้าจอ

การทำให้แอปหรือเว็บไซต์แสดงแบบเต็มหน้าจอ

ผู้ใช้หรือนักพัฒนาแอปสามารถทำให้เว็บแอปแสดงแบบเต็มหน้าจอได้หลายวิธี

  • ขอให้เบราว์เซอร์เข้าสู่โหมดเต็มหน้าจอเพื่อตอบสนองต่อท่าทางผู้ใช้
  • ติดตั้งแอปในหน้าจอหลัก
  • หลอกตา: ซ่อนแถบที่อยู่โดยอัตโนมัติ

ขอให้เบราว์เซอร์เข้าสู่โหมดเต็มหน้าจอเพื่อตอบสนองต่อท่าทางผู้ใช้

แต่ละแพลตฟอร์มมีความแตกต่างกัน iOS Safari ไม่มี Fullscreen API แต่เรามีใน Chrome บน Android, Firefox และ IE 11+ แอปพลิเคชันส่วนใหญ่ที่คุณสร้างจะใช้ทั้ง JS API และตัวเลือก CSS ที่ข้อกำหนดแบบเต็มหน้าจอมีให้ JS API หลักที่คุณต้องคำนึงถึงเมื่อสร้างประสบการณ์การใช้งานแบบเต็มหน้าจอมีดังนี้

  • element.requestFullscreen() (ปัจจุบันมีคำนำหน้าใน Chrome, Firefox และ IE) แสดงองค์ประกอบในโหมดเต็มหน้าจอ
  • document.exitFullscreen() (ปัจจุบันมีคำนำหน้าใน Chrome, Firefox และ IE Firefox ใช้ cancelFullScreen() แทน) จะยกเลิกโหมดเต็มหน้าจอ
  • document.fullscreenElement (ปัจจุบันมีคำนำหน้าใน Chrome, Firefox และ IE) จะแสดงผลเป็น "จริง" หากองค์ประกอบใดๆ อยู่ในโหมดเต็มหน้าจอ

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

<button id="goFS">Go fullscreen</button>
<script>
  var goFS = document.getElementById('goFS');
  goFS.addEventListener(
    'click',
    function () {
      document.body.requestFullscreen();
    },
    false,
  );
</script>

ตัวอย่างข้างต้นเป็นตัวอย่างที่สร้างขึ้นมาเล็กน้อย โดยเราได้ซ่อนความซับซ้อนทั้งหมดเกี่ยวกับการใช้คำนำหน้าของผู้ให้บริการ

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

function toggleFullScreen() {
  var doc = window.document;
  var docEl = doc.documentElement;

  var requestFullScreen =
    docEl.requestFullscreen ||
    docEl.mozRequestFullScreen ||
    docEl.webkitRequestFullScreen ||
    docEl.msRequestFullscreen;
  var cancelFullScreen =
    doc.exitFullscreen ||
    doc.mozCancelFullScreen ||
    doc.webkitExitFullscreen ||
    doc.msExitFullscreen;

  if (
    !doc.fullscreenElement &&
    !doc.mozFullScreenElement &&
    !doc.webkitFullscreenElement &&
    !doc.msFullscreenElement
  ) {
    requestFullScreen.call(docEl);
  } else {
    cancelFullScreen.call(doc);
  }
}

นักพัฒนาเว็บไม่ชอบความซับซ้อน API นามธรรมระดับสูงที่ดีที่คุณใช้ได้คือโมดูล Screenfull.js ของ Sindre Sorhus ซึ่งรวม JS API และคำนำหน้าของผู้ให้บริการที่แตกต่างกันเล็กน้อย 2 รายการเข้าเป็น API ที่สอดคล้องกันรายการเดียว

เคล็ดลับเกี่ยวกับ Fullscreen API

กำลังทำให้เอกสารแสดงแบบเต็มหน้าจอ
โหมดเต็มหน้าจอในองค์ประกอบเนื้อหา
รูปที่ 1: โฆษณาแบบเต็มหน้าจอในองค์ประกอบเนื้อหา

เป็นเรื่องปกติที่จะคิดว่าคุณใช้องค์ประกอบเนื้อหาแบบเต็มหน้าจอ แต่หากคุณใช้เครื่องมือแสดงผลที่ใช้ WebKit หรือ Blink คุณจะเห็นว่าองค์ประกอบดังกล่าวมีผลแปลกๆ ในการลดความกว้างของเนื้อหาให้เหลือขนาดที่เล็กที่สุดเท่าที่จะเป็นไปได้ซึ่งจะมีเนื้อหาทั้งหมด (Mozilla Gecko ก็ใช้ได้)

เต็มหน้าจอในองค์ประกอบเอกสาร
รูปที่ 2: โหมดเต็มหน้าจอในองค์ประกอบเอกสาร

หากต้องการแก้ไขปัญหานี้ ให้ใช้องค์ประกอบเอกสารแทนองค์ประกอบเนื้อหา ดังนี้

document.documentElement.requestFullscreen();
การทำให้องค์ประกอบวิดีโอแสดงแบบเต็มหน้าจอ

การทำให้องค์ประกอบวิดีโอแสดงแบบเต็มหน้าจอจะเหมือนกับการทำให้องค์ประกอบอื่นๆ แสดงแบบเต็มหน้าจอทุกประการ คุณเรียกใช้เมธอด requestFullscreen ในองค์ประกอบวิดีโอ

<video id="videoElement"></video>
<button id="goFS">Go Fullscreen</button>
<script>
  var goFS = document.getElementById('goFS');
  goFS.addEventListener(
    'click',
    function () {
      var videoElement = document.getElementById('videoElement');
      videoElement.requestFullscreen();
    },
    false,
  );
</script>

หากองค์ประกอบ <video> ไม่ได้กำหนดแอตทริบิวต์ตัวควบคุมไว้ ผู้ใช้จะควบคุมวิดีโอไม่ได้เมื่ออยู่ในโหมดเต็มหน้าจอ วิธีที่แนะนำในการดำเนินการนี้คือการมีคอนเทนเนอร์พื้นฐานที่รวมวิดีโอและการควบคุมที่คุณต้องการให้ผู้ใช้เห็น

<div id="container">
  <video></video>
  <div>
    <button>Play</button>
    <button>Stop</button>
    <button id="goFS">Go fullscreen</button>
  </div>
</div>
<script>
  var goFS = document.getElementById('goFS');
  goFS.addEventListener(
    'click',
    function () {
      var container = document.getElementById('container');
      container.requestFullscreen();
    },
    false,
  );
</script>

ซึ่งจะช่วยให้คุณมีความยืดหยุ่นมากขึ้นเนื่องจากสามารถรวมออบเจ็กต์คอนเทนเนอร์กับตัวเลือกเทียม CSS (เช่น เพื่อซ่อนปุ่ม "goFS")

<style>
  #goFS:-webkit-full-screen #goFS {
    display: none;
  }
  #goFS:-moz-full-screen #goFS {
    display: none;
  }
  #goFS:-ms-fullscreen #goFS {
    display: none;
  }
  #goFS:fullscreen #goFS {
    display: none;
  }
</style>

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

  • ด้วยการระบุลิงก์กลับไปยังหน้าเริ่มต้น
  • โดยการจัดเตรียมกลไกในการปิดกล่องโต้ตอบหรือย้อนกลับ

การเปิดหน้าเว็บแบบเต็มหน้าจอจากหน้าจอหลัก

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

ในแพลตฟอร์มหลักๆ สำหรับอุปกรณ์เคลื่อนที่ การติดตั้งใช้งานโดยใช้เมตาแท็กหรือไฟล์ Manifest นั้นทำได้ง่ายมาก ดังนี้

iOS

ตั้งแต่เปิดตัว iPhone ผู้ใช้สามารถติดตั้งเว็บแอปในหน้าจอหลักและเปิดใช้งานเป็นเว็บแอปแบบเต็มหน้าจอได้

<meta name="apple-mobile-web-app-capable" content="yes" />

หากตั้งค่าเนื้อหาเป็น yes เว็บแอปพลิเคชันจะทำงานในโหมดเต็มหน้าจอ แต่หากตั้งค่าเป็นอย่างอื่น เว็บแอปพลิเคชันจะไม่ทำงานในโหมดเต็มหน้าจอ ลักษณะการทำงานเริ่มต้นคือการใช้ Safari เพื่อแสดงเนื้อหาเว็บ คุณสามารถระบุได้ว่าจะแสดงหน้าเว็บในโหมดเต็มหน้าจอหรือไม่โดยใช้พร็อพเพอร์ตี้ JavaScript แบบบูลีนแบบอ่านอย่างเดียว window.navigator.standalone

Apple

Chrome สำหรับแอนดรอยด์

เมื่อเร็วๆ นี้ ทีม Chrome ได้ใช้ฟีเจอร์ที่บอกให้เบราว์เซอร์เปิดหน้าเว็บแบบเต็มหน้าจอเมื่อผู้ใช้เพิ่มหน้าเว็บลงในหน้าจอหลัก ซึ่งคล้ายกับโมเดล iOS Safari

<meta name="mobile-web-app-capable" content="yes" />

คุณสามารถตั้งค่าเว็บแอปให้เพิ่มไอคอนทางลัดของแอปพลิเคชันลงในหน้าจอหลักของอุปกรณ์ และให้แอปเปิดใน "โหมดแอป" แบบเต็มหน้าจอได้โดยใช้รายการเมนู "เพิ่มลงในหน้าจอหลัก" ของ Chrome สำหรับ Android

Google Chrome

ตัวเลือกที่ดีกว่าคือการใช้ไฟล์ Manifest ของเว็บแอป

ไฟล์ Manifest ของเว็บแอป (Chrome, Opera, Firefox, Samsung)

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

  1. การแจ้งเบราว์เซอร์เกี่ยวกับไฟล์ Manifest
  2. อธิบายวิธีเปิดตัว

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

<link rel="manifest" href="/manifest.json" />

Chrome รองรับไฟล์ Manifest ตั้งแต่เวอร์ชัน 38 สำหรับ Android (ตุลาคม 2014) และช่วยให้คุณควบคุมลักษณะที่เว็บแอปจะปรากฏเมื่อติดตั้งลงในหน้าจอหลัก (ผ่านพร็อพเพอร์ตี้ short_name, name และ icons) และวิธีเปิดใช้งานเมื่อผู้ใช้คลิกไอคอนเปิดใช้งาน (ผ่าน start_url, display และ orientation)

ตัวอย่างไฟล์ Manifest แสดงอยู่ด้านล่าง แต่ไม่ได้แสดงทุกอย่างที่อยู่ในไฟล์ Manifest ได้

{
  "short_name": "Kinlan's Amaze App",
  "name": "Kinlan's Amazing Application ++",
  "icons": [
    {
      "src": "launcher-icon-4x.png",
      "sizes": "192x192",
      "type": "image/png"
    }
  ],
  "start_url": "/index.html",
  "display": "standalone",
  "orientation": "landscape"
}

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

เมื่อผู้ใช้เพิ่มเว็บไซต์หรือแอปของคุณลงในหน้าจอหลัก แสดงว่าผู้ใช้ตั้งใจที่จะใช้เว็บไซต์หรือแอปนั้นเหมือนกับแอป ซึ่งหมายความว่าคุณควรตั้งเป้าหมายที่จะนำผู้ใช้ไปยังฟังก์ชันการทำงานของแอปแทนหน้า Landing Page ของผลิตภัณฑ์ เช่น หากผู้ใช้ต้องลงชื่อเข้าใช้แอปของคุณ หน้านั้นก็เป็นหน้าที่ดีที่จะเปิดขึ้นมา

แอปยูทิลิตี

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

    "display": "standalone"
เกม

เกมส่วนใหญ่จะได้รับประโยชน์จากไฟล์ Manifest ทันที เกมส่วนใหญ่จะต้องการเปิดแบบเต็มหน้าจอและบังคับให้ใช้การวางแนวที่เฉพาะเจาะจง

หากคุณกำลังพัฒนาเกมแบบเลื่อนแนวตั้งหรือเกมอย่าง Flappy Birds คุณอาจต้องการให้เกมอยู่ในโหมดแนวตั้งเสมอ

    "display": "fullscreen",
    "orientation": "portrait"

ในทางกลับกัน หากคุณกำลังสร้างเกมปริศนาหรือเกมอย่าง X-Com คุณอาจต้องการให้เกมใช้การวางแนวแนวนอนเสมอ

    "display": "fullscreen",
    "orientation": "landscape"
เว็บไซต์ข่าว

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

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

    "display": "browser"

หากต้องการให้เว็บไซต์ข่าวมีลักษณะเหมือนแอปที่เน้นข่าวส่วนใหญ่ที่ถือว่าประสบการณ์การใช้งานเป็นแอปและนำ Chrome ที่มีลักษณะเหมือนเว็บทั้งหมดออกจาก UI คุณสามารถทำได้โดยตั้งค่าการแสดงผลเป็น standalone

    "display": "standalone"

หลอก: ซ่อนแถบที่อยู่โดยอัตโนมัติ

คุณสามารถ "จำลองโหมดเต็มหน้าจอ" ได้โดยซ่อนแถบที่อยู่โดยอัตโนมัติดังนี้

window.scrollTo(0, 1);

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

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

หลักเกณฑ์ UX

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

อย่าพึ่งพาตัวควบคุมการนำทาง

iOS ไม่มีปุ่มย้อนกลับหรือท่าทางสัมผัสเพื่อรีเฟรชในฮาร์ดแวร์ ดังนั้นคุณต้องตรวจสอบว่าผู้ใช้สามารถไปยังส่วนต่างๆ ของแอปได้โดยไม่ติดขัด

คุณสามารถตรวจหาได้ว่ากำลังทำงานในโหมดเต็มหน้าจอหรือโหมดติดตั้งหรือไม่ ได้อย่างง่ายดายในแพลตฟอร์มหลักทั้งหมด

iOS

ใน iOS คุณสามารถใช้บูลีน navigator.standalone เพื่อดูว่าผู้ใช้เปิดแอปจากหน้าจอหลักหรือไม่

if (navigator.standalone == true) {
  // My app is installed and therefore fullscreen
}

ไฟล์ Manifest ของเว็บแอป (Chrome, Opera, Samsung)

เมื่อเปิดใช้งานเป็น Installed App, Chrome จะไม่ทำงานในประสบการณ์แบบเต็มหน้าจอที่แท้จริง ดังนั้น document.fullscreenElement จะแสดงผลเป็นค่าว่างและตัวเลือก CSS จะไม่ทำงาน

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

selector:-webkit-full-screen {
  display: block; // displays the element only when in fullscreen
}

selector {
  display: none; // hides the element when not in fullscreen mode
}

หากผู้ใช้เปิดเว็บไซต์จากหน้าจอหลัก ระบบจะตั้งค่าการสืบค้นสื่อ display-mode เป็นค่าที่กำหนดไว้ในไฟล์ Manifest ของเว็บแอป ในกรณีที่เป็นโฆษณาแบบเต็มหน้าจอล้วนๆ จะเป็นดังนี้

@media (display-mode: fullscreen) {
}

หากผู้ใช้เปิดแอปพลิเคชันในโหมดสแตนด์อโลน display-mode คำค้นหาสื่อจะเป็น standalone:

@media (display-mode: standalone) {
}

Firefox

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

selector:-moz-full-screen {
  display: block; // hides the element when not in fullscreen mode
}

selector {
  display: none; // hides the element when not in fullscreen mode
}

Internet Explorer

ใน IE คลาสจำลอง CSS จะไม่มีขีดกลาง แต่จะทำงานคล้ายกับ Chrome และ Firefox

selector:-ms-fullscreen {
  display: block;
}

selector {
  display: none; // hides the element when not in fullscreen mode
}

ข้อมูลจำเพาะ

การสะกดในข้อกำหนดจะตรงกับไวยากรณ์ที่ IE ใช้

selector:fullscreen {
  display: block;
}

selector {
  display: none; // hides the element when not in fullscreen mode
}

ให้ผู้ใช้อยู่ในประสบการณ์แบบเต็มหน้าจอ

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

  • การเปลี่ยน URL โดยใช้โปรแกรม window.location = "http://example.com" จะออกจากโหมดเต็มหน้าจอ
  • ผู้ใช้ที่คลิกลิงก์ภายนอกภายในหน้าเว็บจะออกจากโหมดเต็มหน้าจอ
  • การเปลี่ยน URL ผ่าน navigator.pushState API จะทำให้ประสบการณ์การใช้งานแบบเต็มหน้าจอหยุดชะงักด้วย

คุณมี 2 ตัวเลือกหากต้องการให้ผู้ใช้ได้รับประสบการณ์การใช้งานแบบเต็มหน้าจอต่อไป ดังนี้

  1. ใช้กลไกของเว็บแอปที่ติดตั้งได้เพื่อแสดงแบบเต็มหน้าจอ
  2. จัดการ UI และสถานะแอปโดยใช้แฟรกเมนต์ #

การใช้ไวยากรณ์ # เพื่ออัปเดต URL (window.location = "#somestate") และฟังเหตุการณ์ window.onhashchange จะช่วยให้คุณใช้สแต็กประวัติของเบราว์เซอร์เพื่อจัดการการเปลี่ยนแปลงสถานะแอปพลิเคชัน อนุญาตให้ผู้ใช้ใช้ปุ่มย้อนกลับของฮาร์ดแวร์ หรือมอบประสบการณ์การใช้งานปุ่มย้อนกลับแบบเป็นโปรแกรมง่ายๆ โดยใช้ History API ดังนี้

window.history.go(-1);

ให้ผู้ใช้เลือกเวลาที่จะเข้าสู่โหมดเต็มหน้าจอ

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

อย่าขัดจังหวะการโต้ตอบแบบสัมผัสครั้งแรกและเรียกใช้ requestFullscreen()

  1. น่ารำคาญ
  2. เบราว์เซอร์อาจตัดสินใจแจ้งผู้ใช้ในอนาคตเกี่ยวกับการอนุญาตให้แอปใช้โหมดเต็มหน้าจอ

หากต้องการเปิดแอปแบบเต็มหน้าจอ ให้พิจารณาใช้ประสบการณ์การติดตั้งสำหรับแต่ละแพลตฟอร์ม

อย่าสแปมผู้ใช้ให้ติดตั้งแอปของคุณลงในหน้าจอหลัก

หากคุณวางแผนที่จะมอบประสบการณ์การใช้งานแบบเต็มหน้าจอผ่านกลไกของ Installed App โปรดคำนึงถึงผู้ใช้ด้วย

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

บทสรุป

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

ความคิดเห็น