วิธีการ

ขอแนะนำ Cahier: ตัวอย่าง GitHub ใหม่ของ Android สำหรับประสิทธิภาพการทำงานและความคิดสร้างสรรค์บนหน้าจอขนาดใหญ่

ใช้เวลาอ่าน 11 นาที
ดูโปรไฟล์ของ Chris Assigbe
Chris Assigbe วิศวกรนักพัฒนาซอฟต์แวร์สัมพันธ์

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

แอป Google เช่น Google เอกสาร, Pixel สตูดิโอ, Google Photos, Chrome PDF, YouTube Effect Maker และฟีเจอร์เฉพาะใน Android เช่น วงเพื่อค้นหาล้วนใช้ API เวอร์ชันล่าสุด 

เพื่อเป็นการเฉลิมฉลองความสำเร็จนี้ เรายินดีที่จะประกาศเปิดตัว Cahier ซึ่งเป็นตัวอย่างแอปจดโน้ตที่ครอบคลุมซึ่งได้รับการเพิ่มประสิทธิภาพสำหรับอุปกรณ์ Android ทุกขนาด โดยเฉพาะแท็บเล็ตและโทรศัพท์แบบพับได้

Cahier คืออะไร

Cahier ("สมุดบันทึก" ในภาษาฝรั่งเศส) เป็นแอปตัวอย่างที่ออกแบบมาเพื่อสาธิตวิธีสร้างแอปพลิเคชันที่ช่วยให้ผู้ใช้บันทึกและจัดระเบียบความคิดของตนเองได้โดยการรวมข้อความ ภาพวาด และรูปภาพ 

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

ฟีเจอร์หลักที่แสดงในตัวอย่างมีดังนี้

  • การสร้างโน้ตอเนกประสงค์: แสดงวิธีใช้ระบบการสร้างคอนเทนต์ที่ยืดหยุ่นซึ่งรองรับหลายรูปแบบภายในโน้ตเดียว ซึ่งรวมถึงข้อความ ภาพวาดอิสระ และไฟล์แนบรูปภาพ
  • เครื่องมือวาดภาพที่สร้างสรรค์: มอบประสบการณ์การวาดภาพที่มีประสิทธิภาพสูงและเวลาในการตอบสนองต่ำโดยใช้ Ink API ตัวอย่างนี้แสดงตัวอย่างที่ใช้งานได้จริงของการผสานรวมแปรงต่างๆ ตัวเลือกสี ฟังก์ชันเลิกทำ/ทำซ้ำ และเครื่องมือยางลบ
  • การผสานรวมเนื้อหาที่ลื่นไหลด้วยการลากและวาง: แสดงวิธีจัดการทั้งเนื้อหาขาเข้าและขาออกโดยใช้การลากและวาง ซึ่งรวมถึงการยอมรับรูปภาพที่วางจากแอปอื่นๆ และอนุญาตให้ผู้ใช้ลากเนื้อหาออกจากแอปเพื่อการแชร์ที่ราบรื่น
  • การจัดระเบียบโน้ต: ทำเครื่องหมายโน้ตเป็นรายการโปรดเพื่อให้เข้าถึงได้อย่างรวดเร็ว กรองมุมมองเพื่อจัดระเบียบ
  • สถาปัตยกรรมที่เน้นการทำงานแบบออฟไลน์:  สร้างขึ้นด้วยสถาปัตยกรรมที่เน้นการทำงานแบบออฟไลน์โดยใช้ Room เพื่อให้มั่นใจว่าข้อมูลทั้งหมดจะได้รับการบันทึกไว้ในเครื่องและแอปจะยังคงทำงานได้อย่างเต็มรูปแบบโดยไม่ต้องมีการเชื่อมต่ออินเทอร์เน็ต
  • การรองรับหลายหน้าต่างและอินสแตนซ์หลายรายการที่มีประสิทธิภาพ: แสดงวิธีรองรับอินสแตนซ์หลายรายการ ซึ่งช่วยให้เปิดแอปในหลายหน้าต่างได้เพื่อให้ผู้ใช้ทำงานกับโน้ตต่างๆ พร้อมกันได้ ซึ่งจะช่วยเพิ่มประสิทธิภาพการทำงานและความคิดสร้างสรรค์บนหน้าจอขนาดใหญ่
  • UI ที่ปรับเปลี่ยนได้สำหรับทุกหน้าจอ: อินเทอร์เฟซผู้ใช้จะปรับให้เข้ากับขนาดและการวางแนวหน้าจอต่างๆ ได้อย่างราบรื่นโดยใช้ ListDetailPaneScaffold และ NavigationSuiteScaffold เพื่อมอบประสบการณ์การใช้งานที่เพิ่มประสิทธิภาพในโทรศัพท์ แท็บเล็ต และอุปกรณ์แบบพับได้
  • การผสานรวมระบบอย่างลึกซึ้ง: แสดงคำแนะนำเกี่ยวกับวิธีทำให้แอปของคุณเป็นแอปจดโน้ตเริ่มต้นใน Android 14 ขึ้นไปโดยตอบสนองต่อ Intent ของ Notes ทั่วทั้งระบบ ซึ่งช่วยให้จับเนื้อหาได้อย่างรวดเร็วจากจุดแรกเข้าต่างๆ ของระบบ

สร้างมาเพื่อประสิทธิภาพการทำงานและความคิดสร้างสรรค์บนหน้าจอขนาดใหญ่

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

รากฐานของความสามารถในการปรับตัว

Cahier สร้างขึ้นมาให้ปรับเปลี่ยนได้ตั้งแต่ต้น ตัวอย่างนี้ใช้ไลบรารี material3-adaptive โดยเฉพาะ ListDetailPaneScaffold และ NavigationSuiteScaffold เพื่อปรับเลย์เอาต์ของแอปให้เข้ากับขนาดและการวางแนวหน้าจอต่างๆ ได้อย่างราบรื่น ซึ่งเป็นองค์ประกอบสำคัญสำหรับแอป Android สมัยใหม่ และ Cahier ก็เป็นตัวอย่างที่ชัดเจนของวิธีนำไปใช้อย่างมีประสิทธิภาพ

Cahier adaptive UI built with Material 3 Adaptive library..gif

UI แบบปรับอัตโนมัติของ Cahier ที่สร้างด้วยไลบรารีแบบปรับอัตโนมัติของ Material 3

การแสดง API และการผสานรวมที่สำคัญ

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

เจาะลึก API ที่สำคัญ

มาเจาะลึก API หลัก 2 รายการที่ Cahier ผสานรวมเพื่อมอบประสบการณ์การจดโน้ตระดับพรีเมียมกัน

การสร้างประสบการณ์การเขียนด้วยหมึกอย่างเป็นธรรมชาติด้วย Ink API

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

Ink API มีสถาปัตยกรรมแบบโมดูลาร์ คุณจึงปรับแต่งให้เหมาะกับสแต็กและความต้องการเฉพาะของแอปได้ โมดูล API ประกอบด้วย

  • โมดูลการเขียน (Compose - views): จัดการอินพุตการเขียนแบบเรียลไทม์เพื่อสร้างลายเส้นที่ลื่นไหลโดยมีเวลาในการตอบสนองต่ำที่สุดเท่าที่อุปกรณ์จะทำได้
    • ใน DrawingSurface Cahier ใช้ Composable InProgressStrokes ที่เปิดตัวใหม่เพื่อจัดการการป้อนข้อมูลด้วยสไตลัสหรือการป้อนข้อมูลด้วยการสัมผัสแบบเรียลไทม์ โมดูลนี้มีหน้าที่บันทึกเหตุการณ์ของตัวชี้และแสดงผลเส้นหมึกแบบเปียกโดยมีเวลาในการตอบสนองต่ำที่สุดเท่าที่จะเป็นไปได้
  • โมดูลลายเส้น: แสดงถึงการป้อนข้อมูลด้วยหมึกและการแสดงภาพ  ผู้ใช้วาดเส้นเสร็จแล้ว Callback onStrokesFinished จะส่งออบเจ็กต์ Stroke ที่เสร็จสมบูรณ์/แห้งแล้วไปยังแอป ออบเจ็กต์ที่เปลี่ยนแปลงไม่ได้นี้แสดงถึงเส้นหมึกที่เสร็จสมบูรณ์ จากนั้นจะได้รับการจัดการใน DrawingCanvasViewModel
  • โมดูลการแสดงผล: แสดงลายเส้นหมึกอย่างมีประสิทธิภาพ ซึ่งช่วยให้สามารถรวมเข้ากับ Jetpack Compose หรือมุมมอง Android ได้
    • หากต้องการแสดงทั้งเส้นที่มีอยู่และเส้นที่แห้งใหม่ Cahier จะใช้ CanvasStrokeRenderer ใน DrawingSurface สำหรับการวาดที่ใช้งานอยู่ และใน DrawingDetailPanePreview สำหรับแสดงตัวอย่างแบบคงที่ของโน้ต โมดูลนี้จะวาดออบเจ็กต์เส้นลงบนผืนผ้าใบได้อย่างมีประสิทธิภาพ
  • โมดูลแปรง (Compose - views): มีวิธีประกาศเพื่อกำหนดรูปแบบภาพของเส้นวาด การอัปเดตล่าสุด (ตั้งแต่รุ่น alpha03) มีแปรงเส้นประใหม่ ซึ่งมีประโยชน์อย่างยิ่งสำหรับฟีเจอร์ต่างๆ เช่น การเลือกด้วยบ่วงบาศ DrawingCanvasViewModel จะเก็บสถานะของ currentBrush ไว้ กล่องเครื่องมือใน DrawingCanvas ช่วยให้ผู้ใช้เลือกกลุ่มแปรงต่างๆ (เช่น StockBrushes.pressurePen() หรือ StockBrushes.highlighter()) และเปลี่ยนสีได้ ViewModel จะอัปเดตออบเจ็กต์ Brush ซึ่งคอมโพสิเบิล InProgressStrokes จะใช้สำหรับเส้นใหม่
  • โมดูลเรขาคณิต (Compose - views): รองรับการจัดการและวิเคราะห์เส้นสำหรับฟีเจอร์ต่างๆ เช่น การลบและการเลือก
    • เครื่องมือยางลบภายในกล่องเครื่องมือและฟังก์ชันการทำงานใน DrawingCanvasViewModel จะอาศัยโมดูลเรขาคณิต เมื่อยางลบทำงาน ระบบจะสร้าง MutableParallelogram รอบเส้นทางท่าทางสัมผัสของผู้ใช้ จากนั้นยางลบจะตรวจสอบจุดตัดระหว่างรูปร่างและกรอบล้อมรอบของเส้นที่มีอยู่เพื่อระบุเส้นที่จะลบ ทำให้ยางลบใช้งานง่ายและแม่นยำ
  • โมดูลพื้นที่เก็บข้อมูล: มีความสามารถในการแปลงข้อมูลหมึกเป็นอนุกรมและแปลงอนุกรมเป็นข้อมูลอย่างมีประสิทธิภาพ ซึ่งช่วยประหยัดพื้นที่ดิสก์และขนาดเครือข่ายได้อย่างมาก Cahier จะเก็บออบเจ็กต์ Stroke ไว้ในฐานข้อมูล Room เพื่อบันทึกภาพวาด ใน Converters ตัวอย่างจะใช้ฟังก์ชัน encode ของโมดูลพื้นที่เก็บข้อมูลเพื่อจัดเรียง StrokeInputBatch (ข้อมูลจุดดิบ) เป็น ByteArray ระบบจะบันทึกอาร์เรย์ไบต์พร้อมกับพร็อพเพอร์ตี้แปรงเป็นสตริง JSON ระบบจะใช้ฟังก์ชัน decode เพื่อสร้างเส้นวาดใหม่เมื่อโหลดโน้ต
orion.png

นอกเหนือจากโมดูลหลักเหล่านี้ การอัปเดตล่าสุดยังได้ขยายความสามารถของ Ink API ดังนี้

  • API เวอร์ชันทดลองใหม่สำหรับออบเจ็กต์ BrushFamily ที่กำหนดเองช่วยให้นักพัฒนาแอปสร้างประเภทแปรงที่สร้างสรรค์และไม่เหมือนใครได้ ซึ่งจะช่วยเพิ่มความเป็นไปได้ให้กับเครื่องมือต่างๆ เช่น แปรงดินสอและตัวชี้เลเซอร์

Cahier ใช้แปรงที่กำหนดเอง ซึ่งรวมถึงแปรงเพลงที่ไม่เหมือนใครซึ่งแสดงอยู่ด้านล่าง เพื่อแสดงให้เห็นถึงความเป็นไปได้ในการสร้างสรรค์ขั้นสูง

Rainbow laser created with Ink API's custom brushes..gif

เลเซอร์สีรุ้งที่สร้างด้วยแปรงที่กำหนดเองของ Ink API

notes.png

แปรงเพลงที่สร้างด้วยแปรงที่กำหนดเองของ Ink API

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

Ink API มีข้อดีหลายประการที่ทำให้เป็นตัวเลือกที่เหมาะสำหรับแอปเพื่อการทำงานและความคิดสร้างสรรค์มากกว่าการติดตั้งใช้งานที่กำหนดเอง ดังนี้

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

Ink API ได้รับการนำไปใช้ในแอป Google หลายแอปแล้ว ซึ่งรวมถึงการทำมาร์กอัปในเอกสารและฟีเจอร์วงเพื่อค้นหา ตลอดจนแอปพาร์ทเนอร์ เช่น Orion Notes และ PDF Scanner

"Ink API เป็นตัวเลือกแรกของเราสำหรับฟีเจอร์วงเพื่อค้นหา (CtS) การใช้เอกสารประกอบที่ครอบคลุมและการผสานรวม Ink API เป็นเรื่องง่ายมาก ทำให้เราสร้างต้นแบบที่ใช้งานได้เป็นครั้งแรกได้ภายในเวลาเพียง 1 สัปดาห์ การรองรับพื้นผิวแปรงและภาพเคลื่อนไหวที่กำหนดเองของ Ink ช่วยให้เราปรับแต่งการออกแบบเส้นพู่กันได้อย่างรวดเร็ว" - Jordan Komoda วิศวกรซอฟต์แวร์ของ Google

การเป็นแอปโน้ตเริ่มต้นที่มีบทบาทโน้ต

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

การใช้งานใน Cahier

การใช้บทบาทโน้ตมีขั้นตอนสำคัญ 2-3 ขั้นตอน ซึ่งทั้งหมดแสดงอยู่ในตัวอย่างต่อไปนี้

  1. การประกาศไฟล์ Manifest: อันดับแรก แอปต้องประกาศความสามารถในการจัดการ Intent การจดโน้ต ใน AndroidManifest.xml แอป Cahier จะมี <intent-filter> สำหรับการดำเนินการ android.intent.action.CREATE_NOTE ซึ่งจะส่งสัญญาณไปยังระบบว่าแอปเป็นตัวเลือกที่มีแนวโน้มสำหรับบทบาทการจดโน้ต
  2. การตรวจสอบสถานะบทบาท: SettingsViewModel ใช้ RoleManager ของ Android เพื่อระบุสถานะปัจจุบัน SettingsViewModel จะตรวจสอบว่าบทบาทโน้ตพร้อมใช้งานในอุปกรณ์หรือไม่ (isRoleAvailable) และ Cahier มีบทบาทดังกล่าวอยู่หรือไม่ (isRoleHeld) สถานะนี้จะแสดงต่อ UI โดยใช้ Kotlin Flow
  3. การขอรับบทบาท: ในไฟล์ Settings.kt ระบบจะแสดงปุ่มแก่ผู้ใช้หากบทบาทพร้อมใช้งานแต่ยังไม่มีการถือครอง เมื่อคลิก ปุ่มจะเรียกใช้ฟังก์ชัน requestNotesRole ใน ViewModel ฟังก์ชันนี้จะสร้าง Intent เพื่อเปิดหน้าจอการตั้งค่าแอปเริ่มต้นที่ผู้ใช้สามารถเลือก Cahier ได้ กระบวนการนี้ได้รับการจัดการโดยใช้ API rememberLauncherForActivityResult ซึ่งจะจัดการการเปิด Intent และรับผลลัพธ์
  4. การอัปเดต UI: หลังจากผู้ใช้กลับมาจากหน้าจอการตั้งค่า Callback ของ ActivityResultLauncher จะทริกเกอร์ฟังก์ชันใน ViewModel เพื่ออัปเดตสถานะบทบาท เพื่อให้มั่นใจว่า UI แสดงสถานะอย่างถูกต้องว่าแอปเป็นแอปเริ่มต้นหรือไม่

ดูวิธีผสานรวมบทบาทโน้ตในแอปได้ในคู่มือการสร้างแอปจดโน้ต

helloworld.png

Cahier เปิดขึ้นในหน้าต่างแบบลอยเป็นแอปจดโน้ตเริ่มต้นในแท็บเล็ต Lenovo

ก้าวสำคัญ: Lenovo เปิดใช้บทบาทการจดบันทึก

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

ความมุ่งมั่นนี้จาก OEM ชั้นนำแสดงให้เห็นถึงความสำคัญที่เพิ่มขึ้นของบทบาทของโน้ตในการมอบประสบการณ์การใช้งานที่ผสานรวมและมีประสิทธิภาพอย่างแท้จริงบน Android 

การทำงานหลายอินสแตนซ์ การทำงานหลายหน้าต่าง และหน้าต่างเดสก์ท็อป

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

  • การแสดงผลหลายหน้าต่าง: ความสามารถพื้นฐานในการทำงานร่วมกับแอปอื่นในโหมดแยกหน้าจอหรือโหมดรูปแบบอิสระ ซึ่งจำเป็นสำหรับงานต่างๆ เช่น การอ้างอิงหน้าเว็บขณะจดโน้ตใน Cahier
  • อินสแตนซ์หลายรายการ: นี่คือจุดที่การทำงานหลายอย่างพร้อมกันอย่างแท้จริงจะโดดเด่นขึ้นมา Cahier ช่วยให้ผู้ใช้เปิดหน้าต่างแอปหลายหน้าต่างแยกกันได้พร้อมกัน ลองนึกภาพการเปรียบเทียบโน้ต 2 รายการที่แตกต่างกันแบบเคียงข้างกัน หรือการอ้างอิงโน้ตข้อความในหน้าต่างหนึ่งขณะทำงานกับภาพวาดในอีกหน้าต่างหนึ่ง Cahier แสดงวิธีจัดการอินสแตนซ์ที่แยกกันเหล่านี้ ซึ่งแต่ละอินสแตนซ์มีสถานะของตัวเอง ซึ่งจะเปลี่ยนแอปของคุณให้เป็นเครื่องมือที่มีประสิทธิภาพและหลากหลายแง่มุม
  • หน้าต่างเดสก์ท็อป: เมื่อเชื่อมต่อกับจอแสดงผลภายนอก โหมดเดสก์ท็อปของ Android จะเปลี่ยนแท็บเล็ตหรืออุปกรณ์แบบพับได้ให้เป็นเวิร์กสเตชัน เนื่องจาก Cahier สร้างขึ้นด้วย UI ที่ปรับเปลี่ยนได้และรองรับอินสแตนซ์หลายรายการ แอปจึงทำงานได้อย่างสวยงามในสภาพแวดล้อมนี้ ผู้ใช้สามารถเปิด ปรับขนาด และจัดตำแหน่งหน้าต่าง Cahier หลายหน้าต่างได้เหมือนบนเดสก์ท็อปแบบเดิม ซึ่งช่วยให้ทำเวิร์กโฟลว์ที่ซับซ้อนซึ่งก่อนหน้านี้ไม่สามารถทำได้บนอุปกรณ์เคลื่อนที่
cahier-desktop-windowing.webp

Cahier ทำงานในโหมดหน้าต่างเดสก์ท็อปบน Pixel Tablet

ต่อไปนี้คือวิธีที่เราใช้ฟีเจอร์เหล่านี้ใน Cahier

หากต้องการเปิดใช้หลายอินสแตนซ์ ก่อนอื่นเราต้องส่งสัญญาณไปยังระบบว่าแอปรองรับการเปิดหลายครั้งโดยเพิ่มพร็อพเพอร์ตี้ PROPERTY_SUPPORTS_MULTI_INSTANCE_SYSTEM_UI ลงในการประกาศของ MainActivity ใน AndroidManifest ดังนี้

<activity

    android:name="com.example.cahier.MainActivity"

    android:exported="true"

    android:label="@string/app_name"

    android:theme="@style/Theme.MyApplication"

    android:showWhenLocked="true"

    android:turnScreenOn="true"

    android:resizeableActivity="true"

    android:launchMode="singleInstancePerTask">


    <property

        android:name="android.window.PROPERTY_SUPPORTS_MULTI_INSTANCE_SYSTEM_UI"

        android:value="true"/>

    ...

</activity>

ถัดไป เราได้ใช้ตรรกะเพื่อเปิดอินสแตนซ์ใหม่ของแอป ใน CahierHomeScreen.kt เมื่อผู้ใช้เลือกเปิดโน้ตในหน้าต่างใหม่ เราจะสร้าง Intent ใหม่ที่มี Flag เฉพาะซึ่งจะบอกระบบถึงวิธีจัดการกับการเปิดกิจกรรมใหม่ การใช้ FLAG_ACTIVITY_NEW_TASK, FLAG_ACTIVITY_MULTIPLE_TASK และ FLAG_ACTIVITY_LAUNCH_ADJACENT ร่วมกันจะช่วยให้โน้ตเปิดขึ้นในหน้าต่างใหม่ที่แยกต่างหากควบคู่ไปกับหน้าต่างที่มีอยู่

fun openNewWindow(activity: Activity?, note: Note) {

    val intent = Intent(activity, MainActivity::class.java)

    intent.putExtra(AppArgs.NOTE_TYPE_KEY, note.type)

    intent.putExtra(AppArgs.NOTE_ID_KEY, note.id)

    intent.flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_MULTIPLE_TASK or

        Intent.FLAG_ACTIVITY_LAUNCH_ADJACENT


    activity?.startActivity(intent)

}

หากต้องการรองรับโหมดหลายหน้าต่าง เราจำเป็นต้องส่งสัญญาณไปยังระบบว่าแอปรองรับการปรับขนาดโดยการตั้งค่าองค์ประกอบ <activity> หรือ <application> ของไฟล์ Manifest

<activity

    android:name="com.example.cahier.MainActivity"

    android:resizeableActivity="true"

    ...>

</activity>

UI ที่สร้างขึ้นด้วยไลบรารีแบบปรับเปลี่ยนได้ของ Material 3 ช่วยให้ปรับเปลี่ยนได้อย่างราบรื่นในสถานการณ์แบบหลายหน้าต่าง เช่น โหมดแยกหน้าจอของ Android 

เราได้เพิ่มการรองรับการลากและวางเพื่อปรับปรุงประสบการณ์ของผู้ใช้ ดูวิธีที่เรานำแนวคิดนี้ไปใช้ใน Cahier ได้ที่ด้านล่าง

ลากและวาง

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

  • นำเข้าได้ง่ายๆ: ผู้ใช้สามารถลากรูปภาพจากแอปพลิเคชันอื่นๆ เช่น เว็บเบราว์เซอร์ แกลเลอรีรูปภาพ หรือโปรแกรมจัดการไฟล์ แล้ววางลงใน Canvas ของโน้ตได้โดยตรง ด้วยเหตุนี้ Cahier จึงใช้ตัวปรับแต่ง dragAndDropTarget เพื่อกำหนดโซนวาง ตรวจสอบเนื้อหาที่เข้ากันได้ (เช่น image/*) และประมวลผล URI ขาเข้า
  • แชร์ได้ง่ายๆ: เนื้อหาใน Cahier แชร์ได้ง่ายเหมือนเนื้อหาจากแอปอื่นๆ ผู้ใช้สามารถกดรูปภาพภายในโน้ตข้อความค้างไว้ หรือกดทั้งผืนผ้าใบของโน้ตภาพวาดและองค์ประกอบรูปภาพค้างไว้ แล้วลากไปยังแอปพลิเคชันอื่นได้

ข้อมูลเจาะลึกทางเทคนิค: การลากจากแคนวาสการวาดภาพ

การใช้ท่าทางสัมผัสการลากบน Canvas สำหรับวาดภาพถือเป็นความท้าทายที่ไม่เหมือนใคร ใน DrawingSurface คอมโพสิเบิลที่จัดการอินพุตการวาดแบบสด (InProgressStrokes ของ Ink API) และ Box ที่ตรวจจับท่าทางสัมผัสแบบกดค้างเพื่อเริ่มการลากเป็นคอมโพสิเบิลที่อยู่ระดับเดียวกัน

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

เพื่อแก้ปัญหานี้ เราได้สร้าง pointerInputWithSiblingFallthrough Modifier ที่กำหนดเอง และวาง Box โดยใช้ Modifier นั้นก่อน InProgressStrokes ในโค้ด Composable ยูทิลิตีนี้เป็น Wrapper แบบบางที่ครอบระบบ pointerInput มาตรฐาน แต่มีการเปลี่ยนแปลงที่สำคัญอย่างหนึ่งคือจะลบล้างฟังก์ชัน sharePointerInputWithSiblings() เพื่อแสดงผล true ซึ่งจะบอกเฟรมเวิร์ก Compose ให้อนุญาตให้เหตุการณ์ตัวชี้ส่งผ่านไปยัง Composable ที่อยู่ระดับเดียวกัน แม้ว่าจะใช้ไปแล้วก็ตาม

internal fun Modifier.pointerInputWithSiblingFallthrough(

    pointerInputEventHandler: PointerInputEventHandler

) = this then PointerInputSiblingFallthroughElement(pointerInputEventHandler)


private class PointerInputSiblingFallthroughModifierNode(

    pointerInputEventHandler: PointerInputEventHandler

) : PointerInputModifierNode, DelegatingNode() {


    var pointerInputEventHandler: PointerInputEventHandler

        get() = delegateNode.pointerInputEventHandler

        set(value) {

            delegateNode.pointerInputEventHandler = value

        }


    val delegateNode = delegate(

        SuspendingPointerInputModifierNode(pointerInputEventHandler)

    )


    override fun onPointerEvent(

        pointerEvent: PointerEvent,

        pass: PointerEventPass,

        bounds: IntSize

    ) {

        delegateNode.onPointerEvent(pointerEvent, pass, bounds)

    }


    override fun onCancelPointerInput() {

        delegateNode.onCancelPointerInput()

    }


    override fun sharePointerInputWithSiblings() = true

}


private data class PointerInputSiblingFallthroughElement(

    val pointerInputEventHandler: PointerInputEventHandler

) : ModifierNodeElement<PointerInputSiblingFallthroughModifierNode>() {


    override fun create() = PointerInputSiblingFallthroughModifierNode(pointerInputEventHandler)


    override fun update(node: PointerInputSiblingFallthroughModifierNode) {

        node.pointerInputEventHandler = pointerInputEventHandler

    }


    override fun InspectorInfo.inspectableProperties() {

        name = "pointerInputWithSiblingFallthrough"

        properties["pointerInputEventHandler"] = pointerInputEventHandler

    }

}

วิธีใช้ใน DrawingSurface มีดังนี้

Box(

    modifier = Modifier

        .fillMaxSize()

        // Our custom modifier enables this gesture to coexist with the drawing input.

        .pointerInputWithSiblingFallthrough {

            detectDragGesturesAfterLongPress(

                onDragStart = { onStartDrag() },

                onDrag = { _, _ -> /* consume drag events */ },

                onDragEnd = { /* No action needed */ }

            )

        }

) 

// The Ink API's composable for live drawing sits here as a sibling.

InProgressStrokes(...)

เมื่อใช้ฟีเจอร์นี้ ระบบจะตรวจจับทั้งลายเส้นการวาดและท่าทางสัมผัสแบบกดค้างแล้วลากพร้อมกันได้อย่างถูกต้อง เมื่อเริ่มลาก เราจะสร้าง URI ที่แชร์ได้ content:// ด้วย FileProvider และส่ง URI ไปยังเฟรมเวิร์กการลากและวางของระบบโดยใช้ view.startDragAndDrop() โซลูชันนี้ช่วยให้ผู้ใช้ได้รับประสบการณ์การใช้งานที่มีประสิทธิภาพและใช้งานง่าย ซึ่งแสดงให้เห็นวิธีเอาชนะความขัดแย้งของท่าทางสัมผัสที่ซับซ้อนใน UI แบบเลเยอร์

สร้างด้วยสถาปัตยกรรมสมัยใหม่

นอกเหนือจาก API ที่เฉพาะเจาะจงแล้ว Cahier ยังสาธิตรูปแบบสถาปัตยกรรมที่สำคัญสำหรับการสร้างแอปพลิเคชันแบบปรับเปลี่ยนได้ที่มีคุณภาพสูง

เลเยอร์การนำเสนอ: Jetpack Compose และความสามารถในการปรับเปลี่ยน

เลเยอร์การนำเสนอสร้างขึ้นด้วย Jetpack Compose ทั้งหมด ดังที่กล่าวไว้ Cahier ใช้ไลบรารี material3-adaptive เพื่อให้ UI ปรับเปลี่ยนได้ การจัดการสถานะเป็นไปตามรูปแบบ Unidirectional Data Flow (UDF) ที่เข้มงวด โดยใช้อินสแตนซ์ ViewModel เป็นคอนเทนเนอร์ข้อมูลที่เก็บข้อมูลโน้ตและสถานะ UI

ชั้นข้อมูล: ที่เก็บและ Room

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

  1. UI ของ Jetpack Compose จะทริกเกอร์เมธอดใน ViewModel
  2. ViewModel จะดึงข้อมูลโน้ตจาก NoteRepository, จัดการตรรกะ และส่งโน้ตที่อัปเดตกลับไปยังที่เก็บข้อมูล
  3. NoteRepository จะบันทึกการอัปเดตลงในฐานข้อมูล Room

ตัวช่วยในการป้อนข้อมูลที่ครอบคลุม

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

  • สไตลัส: การผสานรวมกับ Ink API, การปฏิเสธฝ่ามือ, การลงทะเบียนสำหรับบทบาทการจดบันทึก, การป้อนข้อมูลด้วยสไตลัสในช่องข้อความ และโหมดใหญ่พิเศษ
  • แป้นพิมพ์: รองรับแป้นพิมพ์ลัดและการกดแป้นพิมพ์ร่วมกันที่พบบ่อยที่สุด (เช่น ctrl+คลิก, meta+คลิก) และการระบุโฟกัสของแป้นพิมพ์ที่ชัดเจน
  • เมาส์และแทร็กแพด: รองรับการคลิกขวาและสถานะการวางเมาส์เหนือสิ่งต่างๆ

การรองรับการโต้ตอบด้วยแป้นพิมพ์ เมาส์ และแทร็กแพดขั้นสูงเป็นจุดมุ่งเน้นหลักสำหรับการปรับปรุงเพิ่มเติม 

เริ่มต้นใช้งานวันนี้เลย

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

พร้อมเจาะลึกแล้วหรือยัง

  • สำรวจโค้ด: ไปที่ที่เก็บ GitHub เพื่อสำรวจฐานของโค้ด Cahier และดูหลักการออกแบบที่นำไปใช้จริง
  • สร้างแอปของคุณเอง: ใช้ Cahier เป็นรากฐานสำหรับการจดโน้ต มาร์กอัปเอกสาร หรือแอปพลิเคชันสร้างสรรค์ของคุณเอง
  • มีส่วนร่วม: เรายินดีรับฟังความคิดเห็นจากคุณ ช่วยเราปรับปรุง Cahier ให้เป็นแหล่งข้อมูลที่ดียิ่งขึ้นสำหรับชุมชนนักพัฒนาแอป Android

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

เขียนโดย
อ่านต่อ