ขอแนะนำ Cahier: ตัวอย่าง GitHub ใหม่ของ Android สำหรับประสิทธิภาพการทำงานและความคิดสร้างสรรค์บนหน้าจอขนาดใหญ่
ใช้เวลาอ่าน 11 นาที
ตอนนี้ 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 ก็เป็นตัวอย่างที่ชัดเจนของวิธีนำไปใช้อย่างมีประสิทธิภาพ
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 เพื่อสร้างเส้นวาดใหม่เมื่อโหลดโน้ต
นอกเหนือจากโมดูลหลักเหล่านี้ การอัปเดตล่าสุดยังได้ขยายความสามารถของ Ink API ดังนี้
- API เวอร์ชันทดลองใหม่สำหรับออบเจ็กต์
BrushFamilyที่กำหนดเองช่วยให้นักพัฒนาแอปสร้างประเภทแปรงที่สร้างสรรค์และไม่เหมือนใครได้ ซึ่งจะช่วยเพิ่มความเป็นไปได้ให้กับเครื่องมือต่างๆ เช่น แปรงดินสอและตัวชี้เลเซอร์
Cahier ใช้แปรงที่กำหนดเอง ซึ่งรวมถึงแปรงเพลงที่ไม่เหมือนใครซึ่งแสดงอยู่ด้านล่าง เพื่อแสดงให้เห็นถึงความเป็นไปได้ในการสร้างสรรค์ขั้นสูง
เลเซอร์สีรุ้งที่สร้างด้วยแปรงที่กำหนดเองของ Ink API
แปรงเพลงที่สร้างด้วยแปรงที่กำหนดเองของ 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 ขั้นตอน ซึ่งทั้งหมดแสดงอยู่ในตัวอย่างต่อไปนี้
- การประกาศไฟล์ Manifest: อันดับแรก แอปต้องประกาศความสามารถในการจัดการ Intent การจดโน้ต ใน AndroidManifest.xml แอป Cahier จะมี
<intent-filter>สำหรับการดำเนินการ android.intent.action.CREATE_NOTE ซึ่งจะส่งสัญญาณไปยังระบบว่าแอปเป็นตัวเลือกที่มีแนวโน้มสำหรับบทบาทการจดโน้ต - การตรวจสอบสถานะบทบาท: SettingsViewModel ใช้ RoleManager ของ Android เพื่อระบุสถานะปัจจุบัน SettingsViewModel จะตรวจสอบว่าบทบาทโน้ตพร้อมใช้งานในอุปกรณ์หรือไม่ (isRoleAvailable) และ Cahier มีบทบาทดังกล่าวอยู่หรือไม่ (isRoleHeld) สถานะนี้จะแสดงต่อ UI โดยใช้ Kotlin Flow
- การขอรับบทบาท: ในไฟล์ Settings.kt ระบบจะแสดงปุ่มแก่ผู้ใช้หากบทบาทพร้อมใช้งานแต่ยังไม่มีการถือครอง เมื่อคลิก ปุ่มจะเรียกใช้ฟังก์ชัน
requestNotesRoleใน ViewModel ฟังก์ชันนี้จะสร้าง Intent เพื่อเปิดหน้าจอการตั้งค่าแอปเริ่มต้นที่ผู้ใช้สามารถเลือก Cahier ได้ กระบวนการนี้ได้รับการจัดการโดยใช้ API rememberLauncherForActivityResult ซึ่งจะจัดการการเปิด Intent และรับผลลัพธ์ - การอัปเดต UI: หลังจากผู้ใช้กลับมาจากหน้าจอการตั้งค่า Callback ของ ActivityResultLauncher จะทริกเกอร์ฟังก์ชันใน ViewModel เพื่ออัปเดตสถานะบทบาท เพื่อให้มั่นใจว่า UI แสดงสถานะอย่างถูกต้องว่าแอปเป็นแอปเริ่มต้นหรือไม่
ดูวิธีผสานรวมบทบาทโน้ตในแอปได้ในคู่มือการสร้างแอปจดโน้ต
Cahier เปิดขึ้นในหน้าต่างแบบลอยเป็นแอปจดโน้ตเริ่มต้นในแท็บเล็ต Lenovo
ก้าวสำคัญ: Lenovo เปิดใช้บทบาทการจดบันทึก
เรายินดีที่จะประกาศความก้าวหน้าครั้งสำคัญสำหรับประสิทธิภาพการทำงานบน Android หน้าจอขนาดใหญ่ นั่นคือ Lenovo ได้เปิดใช้การรองรับบทบาทโน้ตในแท็บเล็ตที่ใช้ Android 15 ขึ้นไปแล้ว การอัปเดตนี้ช่วยให้คุณอัปเดตแอปจดโน้ตเพื่อให้ผู้ใช้ที่มีอุปกรณ์ Lenovo ที่เข้ากันได้สามารถตั้งค่าแอปเป็นแอปเริ่มต้นได้ ซึ่งจะช่วยให้เข้าถึงจากหน้าจอล็อกได้อย่างราบรื่นและปลดล็อกฟีเจอร์การจับภาพเนื้อหาระดับระบบ
ความมุ่งมั่นนี้จาก OEM ชั้นนำแสดงให้เห็นถึงความสำคัญที่เพิ่มขึ้นของบทบาทของโน้ตในการมอบประสบการณ์การใช้งานที่ผสานรวมและมีประสิทธิภาพอย่างแท้จริงบน Android
การทำงานหลายอินสแตนซ์ การทำงานหลายหน้าต่าง และหน้าต่างเดสก์ท็อป
ประสิทธิภาพการทำงานบนหน้าจอขนาดใหญ่เป็นเรื่องของการจัดการข้อมูลและเวิร์กโฟลว์อย่างมีประสิทธิภาพ ด้วยเหตุนี้ Cahier จึงสร้างขึ้นเพื่อรองรับความสามารถในการจัดการหน้าต่างขั้นสูงของ Android อย่างเต็มรูปแบบ โดยมอบพื้นที่ทำงานที่ยืดหยุ่นซึ่งปรับให้เข้ากับความต้องการของผู้ใช้ แอปนี้รองรับสิ่งต่อไปนี้
- การแสดงผลหลายหน้าต่าง: ความสามารถพื้นฐานในการทำงานร่วมกับแอปอื่นในโหมดแยกหน้าจอหรือโหมดรูปแบบอิสระ ซึ่งจำเป็นสำหรับงานต่างๆ เช่น การอ้างอิงหน้าเว็บขณะจดโน้ตใน Cahier
- อินสแตนซ์หลายรายการ: นี่คือจุดที่การทำงานหลายอย่างพร้อมกันอย่างแท้จริงจะโดดเด่นขึ้นมา Cahier ช่วยให้ผู้ใช้เปิดหน้าต่างแอปหลายหน้าต่างแยกกันได้พร้อมกัน ลองนึกภาพการเปรียบเทียบโน้ต 2 รายการที่แตกต่างกันแบบเคียงข้างกัน หรือการอ้างอิงโน้ตข้อความในหน้าต่างหนึ่งขณะทำงานกับภาพวาดในอีกหน้าต่างหนึ่ง Cahier แสดงวิธีจัดการอินสแตนซ์ที่แยกกันเหล่านี้ ซึ่งแต่ละอินสแตนซ์มีสถานะของตัวเอง ซึ่งจะเปลี่ยนแอปของคุณให้เป็นเครื่องมือที่มีประสิทธิภาพและหลากหลายแง่มุม
- หน้าต่างเดสก์ท็อป: เมื่อเชื่อมต่อกับจอแสดงผลภายนอก โหมดเดสก์ท็อปของ Android จะเปลี่ยนแท็บเล็ตหรืออุปกรณ์แบบพับได้ให้เป็นเวิร์กสเตชัน เนื่องจาก Cahier สร้างขึ้นด้วย UI ที่ปรับเปลี่ยนได้และรองรับอินสแตนซ์หลายรายการ แอปจึงทำงานได้อย่างสวยงามในสภาพแวดล้อมนี้ ผู้ใช้สามารถเปิด ปรับขนาด และจัดตำแหน่งหน้าต่าง Cahier หลายหน้าต่างได้เหมือนบนเดสก์ท็อปแบบเดิม ซึ่งช่วยให้ทำเวิร์กโฟลว์ที่ซับซ้อนซึ่งก่อนหน้านี้ไม่สามารถทำได้บนอุปกรณ์เคลื่อนที่
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) กับแบ็กเอนด์ระยะไกลที่อาจมีในอนาคตได้อย่างราบรื่น ขั้นตอนการรับส่งข้อมูลสำหรับการดำเนินการอย่างการแก้ไขโน้ตนั้นตรงไปตรงมา ดังนี้
- UI ของ Jetpack Compose จะทริกเกอร์เมธอดใน ViewModel
- ViewModel จะดึงข้อมูลโน้ตจาก NoteRepository, จัดการตรรกะ และส่งโน้ตที่อัปเดตกลับไปยังที่เก็บข้อมูล
- NoteRepository จะบันทึกการอัปเดตลงในฐานข้อมูล Room
ตัวช่วยในการป้อนข้อมูลที่ครอบคลุม
แอปต้องจัดการวิธีการป้อนข้อมูลที่หลากหลายได้อย่างไร้ที่ติจึงจะเป็นขุมพลังด้านประสิทธิภาพการทำงานที่แท้จริง Cahier สร้างขึ้นเพื่อให้เป็นไปตามหลักเกณฑ์การป้อนข้อมูลบนหน้าจอขนาดใหญ่และรองรับสิ่งต่อไปนี้
- สไตลัส: การผสานรวมกับ Ink API, การปฏิเสธฝ่ามือ, การลงทะเบียนสำหรับบทบาทการจดบันทึก, การป้อนข้อมูลด้วยสไตลัสในช่องข้อความ และโหมดใหญ่พิเศษ
- แป้นพิมพ์: รองรับแป้นพิมพ์ลัดและการกดแป้นพิมพ์ร่วมกันที่พบบ่อยที่สุด (เช่น ctrl+คลิก, meta+คลิก) และการระบุโฟกัสของแป้นพิมพ์ที่ชัดเจน
- เมาส์และแทร็กแพด: รองรับการคลิกขวาและสถานะการวางเมาส์เหนือสิ่งต่างๆ
การรองรับการโต้ตอบด้วยแป้นพิมพ์ เมาส์ และแทร็กแพดขั้นสูงเป็นจุดมุ่งเน้นหลักสำหรับการปรับปรุงเพิ่มเติม
เริ่มต้นใช้งานวันนี้เลย
เราหวังว่า Cahier จะเป็นจุดเริ่มต้นสำหรับแอปที่ยอดเยี่ยมแอปถัดไปของคุณ เราสร้างแอปนี้ขึ้นมาเพื่อเป็นแหล่งข้อมูลโอเพนซอร์สที่ครอบคลุม ซึ่งแสดงวิธีรวม UI ที่ปรับเปลี่ยนได้, API ที่มีประสิทธิภาพ เช่น Ink และบทบาทของโน้ต รวมถึงสถาปัตยกรรมที่ทันสมัยและปรับเปลี่ยนได้
พร้อมเจาะลึกแล้วหรือยัง
- สำรวจโค้ด: ไปที่ที่เก็บ GitHub เพื่อสำรวจฐานของโค้ด Cahier และดูหลักการออกแบบที่นำไปใช้จริง
- สร้างแอปของคุณเอง: ใช้ Cahier เป็นรากฐานสำหรับการจดโน้ต มาร์กอัปเอกสาร หรือแอปพลิเคชันสร้างสรรค์ของคุณเอง
- มีส่วนร่วม: เรายินดีรับฟังความคิดเห็นจากคุณ ช่วยเราปรับปรุง Cahier ให้เป็นแหล่งข้อมูลที่ดียิ่งขึ้นสำหรับชุมชนนักพัฒนาแอป Android
ดูคู่มือนักพัฒนาซอฟต์แวร์อย่างเป็นทางการ แล้วเริ่มสร้างแอปเพื่อประสิทธิภาพการทำงานและความคิดสร้างสรรค์แห่งอนาคตได้เลยวันนี้ เราจะตั้งตารอดูผลงานของคุณ
-
วิธีการในฐานะนักพัฒนาแอปและไลบรารี Android เราทุกคนต่างพยายามบรรลุเป้าหมายเดียวกัน นั่นคือแอปที่มีประสิทธิภาพซึ่งมอบประสบการณ์ของผู้ใช้ที่ราบรื่น ส่วนสำคัญของเรื่องนี้เกี่ยวข้องกับ R8 ซึ่งเป็นเครื่องมือเพิ่มประสิทธิภาพแอปของ Android R8 ช่วยปรับปรุงประสิทธิภาพของแอปโดยการนำโค้ดที่ไม่ได้ใช้ออก รวมถึงเพิ่มประสิทธิภาพและสร้างความสับสนให้กับโค้ดที่เหลือ
Breana Tate • ใช้เวลาอ่าน 6 นาที -
วิธีการยินดีต้อนรับกลับสู่ชุดบล็อกโพสต์ "สร้างแอป Android อัจฉริยะ" ซึ่งคุณจะได้นำแอป Android พื้นฐานมาเปลี่ยนให้เป็นประสบการณ์การใช้งานที่ปรับเปลี่ยนในแบบของคุณ ชาญฉลาด และทำงานแบบ Agent ในโพสต์ก่อนหน้านี้ คุณได้เรียนรู้วิธีเชื่อมต่อกับระบบอัจฉริยะโดยใช้ AppFunctions
Jolanda Verhoef • ใช้เวลาอ่าน 9 นาที -
วิธีการMedia3 1.11 พร้อมให้ใช้งานแล้ว การเปิดตัวครั้งนี้จะช่วยขับเคลื่อนแอปสื่อยอดนิยมส่วนใหญ่ใน Android โดยมาพร้อมฟีเจอร์ใหม่ๆ การแก้ไขข้อบกพร่อง และการปรับปรุงต่างๆ ในคอมโพเนนต์การเล่น การแก้ไข และ UI
Toni Heidenreich • ใช้เวลาอ่าน 3 นาที
รับข้อมูลเชิงลึกล่าสุดเกี่ยวกับการพัฒนา Android ที่ส่งไปยังกล่องจดหมายของคุณทุกสัปดาห์