ในบทความนี้ เราจะสำรวจวิธีที่คุณสามารถใช้ ADB เพื่อรับการควบคุมที่ละเอียดเมื่อคุณติดตั้ง ทดสอบ วินิจฉัย และจัดการอุปกรณ์และอีมูเลเตอร์ตั้งแต่หนึ่งเครื่องขึ้นไป
ในช่วงสองสามปีแรกของฉันในฐานะนักพัฒนาซอฟต์แวร์ โดยส่วนใหญ่ทำงานกับ Android SDK ฉันไม่รู้ว่า Android Debug Bridge (ADB/adb) คืออะไร ทำอะไร หรือควรใช้เมื่อใด
น่าขบขัน ไม่ใช่เป้าหมายทางอาชีพบางอย่างที่กระตุ้นให้ฉันเรียนรู้เกี่ยวกับเรื่องนี้ในตอนแรก ค่อนข้างเป็นการวนรอบการบูตของฉัน Nexus 6 ซึ่งฉันต้องการฟื้นคืนชีพ สำหรับปัญหาดังกล่าว Android Studio และ Gradle นั้นมีประโยชน์พอๆ กับถุงชาแบบกันน้ำ
ฉันยังอยากจะพูดถึงว่าบทความนี้เขียนขึ้นโดยคำนึงถึงบุคคลสองประเภท :
- ผู้ที่คุ้นเคยกับ CLI, Shell, Processes และ Client-Server Model
- ผู้ที่ไม่คุ้นเคยกับ CLI, Shell, Processes และ Client-Server Model
สำหรับผู้ที่อยู่ในหมวดหมู่แรก คุณอาจต้องการข้ามส่วนชื่อ:"วิธีการทำงานกับ ADB ."
สำหรับผู้ที่อยู่ในประเภทที่สอง ฉันจะถือว่าคุณเป็นเหมือนฉันในฐานะนักพัฒนาระดับจูเนียร์ และรู้เรื่อง CLI, Shells และ ADB น้อยมาก ส่วนแรกเป็นการแนะนำและอภิธานศัพท์แบบง่ายๆ สำหรับคำศัพท์และแนวคิดพื้นฐาน ซึ่งอธิบายด้วยวิธีที่ง่ายที่สุดที่ฉันสามารถจัดการได้
เบื้องต้น
ในที่นี้ เราจะเรียนรู้เกี่ยวกับบางหัวข้อที่สำคัญหากคุณต้องการเข้าใจว่า ADB ทำงานอย่างไรและใช้งานอย่างไร
พวกคุณบางคนอาจเคยกลัวที่จะเรียนรู้เครื่องมือบรรทัดคำสั่งในอดีตโดยการเยาะเย้ยผู้ที่ชื่นชอบ Vim หรือผู้ดูแลระบบ Unix ที่มีวิจารณญาณ อย่างที่คุณเห็น ฉันยอมรับโดยเสรีว่า CLI ไม่เหมาะสำหรับวิธีการทำงานของสมอง ฉันจึงคิดว่าคุณอาจชอบความคิดเห็นของฉันในเรื่องนี้
บรรทัดคำสั่ง
พูดง่ายๆ คือ บรรทัดคำสั่งคืออินเทอร์เฟซ (วิธีการส่ง/รับข้อมูล) ไปยังคอมพิวเตอร์ที่ ใช้เฉพาะบรรทัดข้อความ .
สิ่งสำคัญคือต้องเข้าใจว่าอินเทอร์เฟซบรรทัดคำสั่ง (CLI) ไม่ใช่โปรแกรม แต่บางโปรแกรมจะมี CLI (และอาจมีอินเทอร์เฟซอื่นๆ เช่น GUI ด้วย)
ถึงจุดหนึ่ง คุณอาจพิมพ์บางอย่างลงในพรอมต์คำสั่งของ Windows (หรือ MS-DOS ถ้าคุณเป็นเด็กยุค 90 อย่างฉัน) Mac Terminal หรือบางอย่างเช่น GNOME Terminal ที่พบได้ทั่วไปในลีนุกซ์รุ่นต่างๆ สิ่งเหล่านี้ใช้เป็นหลักผ่าน CLI
ประโยชน์และข้อเสียของการใช้ CLI นั้นขึ้นอยู่กับแต่ละบุคคลที่ใช้ CLI เป็นหลัก และปัญหาประเภทใดที่พวกเขาพยายามจะแก้ไข โดยส่วนตัวแล้วฉันไม่ชอบใช้ CLI เว้นแต่เป็นสิ่งที่ฉันทำเกือบทุกวัน .
สมองของฉันไม่เหมาะสำหรับการจดจำคำสั่งข้อความชวเลขที่คลุมเครือ (ฉันมีปัญหาในการเรียนรู้ที่จะอ่านตั้งแต่ยังเป็นเด็กด้วยเหตุผลเดียวกัน) ดังนั้นฉันต้องพึ่งพาหน่วยความจำโดยปริยายซ้ำๆ (หน่วยความจำของกล้ามเนื้อ) และแผ่นโกง
สำหรับผู้ที่เต็มใจสละเวลาแม้ว่าจะเป็นเรื่องยาก (เช่นฉัน) หรือผู้ที่จำได้ดีจริงๆ คุณจะได้เรียนรู้ที่จะชื่นชมว่าคุณมีประสิทธิภาพมากขึ้นเพียงใด ภายใน CLI เทียบกับ GUI .
การดำเนินการหลายอย่างสามารถทำได้โดยใช้เวลาเพียงเสี้ยววินาทีในการชี้และคลิกผ่านเมนูและหน้าจอต่างๆ นอกจากนี้ยังสามารถเขียนสคริปต์ ซึ่งเป็นไฟล์ที่มีชุดคำสั่งข้อความ ซึ่งสามารถเพิ่มประสิทธิภาพของคุณให้ดียิ่งขึ้นไปอีก
วิธีใช้เชลล์ ABD
ฉันจะต้องถือว่าคุณคุ้นเคยกับคำว่าระบบปฏิบัติการ (OS) ซึ่งรวมถึง Android, iOS, Windows, Mac, Linux และระบบอื่น ๆ ที่คล้าย Unix
เหตุใดคำนี้จึงเกี่ยวข้องกับ ADB เพื่อให้คำอธิบายที่จัดลำดับความสำคัญของความชัดเจนมากกว่าความแม่นยำ ระบบปฏิบัติการ Android นั้นใช้ Linux และ Linux นั้นใช้ Unix
ด้วยเหตุนี้ เราจึงสามารถใช้ ADB เพื่อรับ Unix Shell สำหรับอุปกรณ์หรือโปรแกรมจำลองที่เรากำลังทำงานด้วย ซึ่งช่วยให้เรามีความยืดหยุ่น ความสามารถ และควบคุมอุปกรณ์หรือโปรแกรมจำลองได้อย่างมากโดยการโต้ตอบกับเชลล์ของอุปกรณ์โดยตรง
เชลล์เป็นคำศัพท์ทั่วไปสำหรับโปรแกรมที่คุณใช้โต้ตอบกับระบบปฏิบัติการ เช่นเดียวกับเปลือกเต่าให้การป้องกันและการเข้าถึงเต่า (และเป็นชั้นนอกสุด) เปลือกของระบบปฏิบัติการทั้งปกป้องและให้การเข้าถึงการทำงานภายในของระบบปฏิบัติการ โดยส่วนตัวแล้ว ฉันค่อนข้างแปลกใจที่รู้ว่า "เชลล์" ไม่ใช่ตัวย่อที่ลึกลับ
อย่ารู้สึกว่าจำเป็นต้องคิดคำนี้มากเกินไป หากคุณกำลังอ่านข้อความนี้บนคอมพิวเตอร์บางประเภท คุณใช้เชลล์เพื่อช่วยให้คุณมาที่นี่
เชลล์สามารถจัดเตรียม CLI หรือ GUI อย่างใดอย่างหนึ่งหรือทั้งสองอย่าง ไม่ว่าในกรณีใด คุณจะใช้มันเพื่อสร้าง/อัปเดต/ลบ/ย้ายไฟล์ เริ่มโปรแกรมอื่น และเข้าถึงบริการต่างๆ ของ OS ที่มีให้ผ่านเชลล์
วิธีใช้ไคลเอ็นต์ ABD และเซิร์ฟเวอร์ ABD
อีกครั้ง ให้เราเริ่มต้นด้วยคำอธิบายที่ไม่แน่ชัดเล็กน้อย ซึ่งหวังว่าจะเข้าใจได้ง่ายขึ้น ฉันจะแก้ไขคำจำกัดความนี้ในไม่ช้า
ไคลเอนต์และเซิร์ฟเวอร์เป็นทั้งคอมพิวเตอร์ เหตุผลที่เราสร้างความแตกต่างในลักษณะนี้ขึ้นอยู่กับบทบาท .ของพวกเขา . ตัวอย่างเช่น คอมพิวเตอร์ของคุณ (ไม่ว่าจะเป็นเดสก์ท็อป แล็ปท็อป โทรศัพท์ หรืออะไรก็ตาม) เป็นไคลเอนต์ของเซิร์ฟเวอร์ freeCodeCamp ซึ่งให้บริการ คุณหน้า HTML นี้
โดยทั่วไป ลูกค้าคือ สิ่งที่ใช้อย่างอื่น ในขณะที่เซิร์ฟเวอร์เป็น สิ่งที่กำลังใช้งานอยู่ . อย่าคิดมากเกินไปกับคำนี้ เนื่องจาก Client-Server Model สามารถอธิบายสิ่งต่างๆ มากมายทั้งในและนอกการประมวลผลได้
เมื่อฉันบอกว่าไคลเอนต์และเซิร์ฟเวอร์เป็นทั้ง "คอมพิวเตอร์" นั่นไม่เป็นความจริงในบริบทที่เราจะใช้คำศัพท์เหล่านี้ในภายหลัง
ในฐานะโปรแกรมเมอร์และวิศวกร โดยปกติแล้ว เราควรคิดว่าไคลเอนต์และเซิร์ฟเวอร์เป็นกระบวนการ (กระบวนการเป็นเพียงโปรแกรมที่ทำงานอยู่ ).
ซึ่งหมายความว่าแม้ว่ากระบวนการของไคลเอ็นต์และกระบวนการของเซิร์ฟเวอร์มักจะทำงานบนคอมพิวเตอร์ที่แยกจากกัน แต่ก็จะดีเช่นกันหากทำงานบนคอมพิวเตอร์เครื่องเดียวกัน
พวกเขาจะครอบครองตำแหน่งที่แตกต่างกันในพื้นที่หน่วยความจำของคอมพิวเตอร์ดังกล่าว ดังนั้นความแตกต่างเพียงอย่างเดียวคือพวกเขาจะสื่อสารโดยใช้ IPC (การสื่อสารระหว่างกระบวนการ) เมื่อเทียบกับการส่งข้อความถึงกันผ่านการเชื่อมต่อเครือข่าย
ตามที่เราจะเห็นในไม่ช้า ADB ใช้ประโยชน์จากกระบวนการเซิร์ฟเวอร์ ซึ่งช่วยให้นักพัฒนาหลายคน (ไคลเอนต์หลายราย) สามารถจัดการอุปกรณ์ Android และ/หรืออีมูเลเตอร์หลายเครื่องได้
ในการตั้งค่าระดับองค์กร กระบวนการเซิร์ฟเวอร์นี้น่าจะอยู่บนคอมพิวเตอร์ระยะไกล (สื่อสารผ่านการเชื่อมต่อเครือข่าย) แต่เราจะตั้งค่าเซิร์ฟเวอร์ที่อยู่ภายในเครื่องสำหรับลูกค้าของเรา การทำเช่นนั้นจะง่ายกว่าที่คุณคิดมาก
ภูต ABD คืออะไร
ในกรณีที่คุณข้ามไปข้างหน้า ฉันได้อธิบายไปแล้วว่ากระบวนการเป็นเพียงโปรแกรมที่ทำงานอยู่ Daemon เป็นกระบวนการที่ทำงานอยู่เบื้องหลัง กล่าวคือ ผู้ใช้ไม่ได้โต้ตอบกับมันโดยตรง
ตัวอย่างเช่น หากคุณเปิดเว็บเบราว์เซอร์ งานจริงของการจัดการการเชื่อมต่อเครือข่ายที่จำเป็นในการเชื่อมต่ออินเทอร์เน็ตจะดำเนินการโดยบางอย่างเช่น NetworkManager Daemon (ซึ่งต่างจากกระบวนการของเบราว์เซอร์เอง)
อุปกรณ์ Android แต่ละเครื่อง (ทางกายภาพหรือจำลอง) หากมีการกำหนดค่าอย่างถูกต้อง จะมี ADB Daemon (adbd) ซึ่งดำเนินการคำสั่งที่กำหนดโดยกระบวนการเซิร์ฟเวอร์
กล่าวโดยสรุป เมื่อลูกค้าของเราออกคำสั่งไปยังเซิร์ฟเวอร์ เซิร์ฟเวอร์จะส่งต่อคำสั่งนั้นไปยัง ADBD ซึ่งจะรันคำสั่งบนอุปกรณ์
วิธีใช้ ADB สำหรับการพัฒนา Android
สำหรับส่วนที่เหลือของบทความนี้ เราจะสำรวจหัวข้อต่อไปนี้:
- ไดรเวอร์และการกำหนดค่าที่จำเป็นในการใช้ ADB ในระบบของคุณ
- การใช้ ADB กับอุปกรณ์จริงและอีมูเลเตอร์
- คำสั่งพื้นฐานโดยใช้ CLI ของ ADB
- ภาพรวมการใช้งานที่ซับซ้อนยิ่งขึ้นโดยใช้ Shell ของอุปกรณ์ Android ผ่าน ADB
ก่อนดำเนินการต่อ คุณจะต้องสร้างเครื่องมือ CLI ที่คุณจะใช้เพื่อโต้ตอบกับ ADB บน Windows ฉันชอบใช้ PowerShell แต่พรอมต์คำสั่งก็ใช้ได้เช่นกัน สำหรับ Linux และ Mac เทอร์มินัลเริ่มต้นควรใช้งานได้
ใช้อะไรก็ได้ที่ทำให้เสร็จได้
บทความนี้มีคำอธิบายโดยละเอียดเกี่ยวกับกระบวนการทั้งหมด แต่ฉันได้เตรียมวิดีโอแนะนำที่ครอบคลุมไว้อย่างรวบรัดที่นี่:
วิธีทำความเข้าใจตัวอย่าง CLI
บทความนี้ประกอบด้วยคำสั่งมากมายที่จะป้อนลงในเครื่องมือ CLI ที่คุณต้องการ ส่วนใดๆ ของคำสั่งที่กำหนดซึ่งเปลี่ยนแปลงตามสถานการณ์จะถูกเขียนไว้ในวงเล็บเหลี่ยม
อย่าใส่วงเล็บเหลี่ยมในคำสั่ง CLI ที่คุณเขียน
ตัวอย่างเช่น ถ้าฉันเขียน...:
adb pair <ip-address>:<port>
...คุณจะแทนที่วงเล็บมุมและชื่อสำหรับค่าจริง เช่น:
adb pair 192.168.0.1:5554
ไดรเวอร์และการกำหนดค่า ABD
ประการแรก ตรวจสอบให้แน่ใจว่าคุณมี Android SDK Platform-Tools เวอร์ชันล่าสุด (หรืออย่างน้อยเป็นเวอร์ชันล่าสุด) หากคุณไม่ได้ใช้ Android Studio (AS) ด้วยเหตุผลบางประการ ให้คลิกที่ลิงก์นั้นและดาวน์โหลดแพ็คเกจแบบสแตนด์อโลนสำหรับระบบปฏิบัติการของคุณ
หากคุณมี Android Studio คุณสามารถดาวน์โหลดหรืออัปเดตแพ็คเกจนี้โดยใช้ SDK Manager
โดยทั่วไปจะมีไอคอนแถบเครื่องมือใน AS เพื่อเปิดตัวจัดการ SDK แต่พวกเขาต้องการเปลี่ยนสิ่งที่ดูเหมือนโปรแกรมแก้ไขด่วนทุกรายการ
หากคุณไม่พบมัน ให้ไปที่ ไฟล์ -> การตั้งค่า และในแถบค้นหา ให้พิมพ์ “SDK” และค้นหารายการเมนู “Android SDK”
ขั้นตอนต่อไปจะเปลี่ยนไปตามตัวแปรจำนวนหนึ่ง ตามที่กล่าวไว้ใน เบื้องต้น ส่วน ADB ใช้ Client-Server Model ซึ่งช่วยให้มีความยืดหยุ่นมากในการใช้เครื่องมือ
เพื่อให้เฉพาะเจาะจงมากขึ้น คุณอาจมี:
- ลูกค้าหลายรายโต้ตอบกับเซิร์ฟเวอร์ระยะไกล
- เซิร์ฟเวอร์ที่อยู่ในเครื่อง (คอมพิวเตอร์เครื่องเดียวกัน) ไปยังไคลเอ็นต์หนึ่งเครื่อง
- อุปกรณ์ทางกายภาพและอีมูเลเตอร์ที่หลากหลายเชื่อมต่อกับเซิร์ฟเวอร์เดียวกัน
การกำหนดค่าขั้นสูงกับไคลเอนต์หลายตัวและอุปกรณ์จำนวนมากเป็นไปได้ด้วย ADB แต่อยู่นอกขอบเขตของบทความนี้
หนึ่งเซิร์ฟเวอร์สามารถจัดการอีมูเลเตอร์ได้สูงสุด 16 ตัวและอุปกรณ์จริงมากเท่าที่คุณต้องการ (ภายในเหตุผล) โดยไม่ต้องมีการกำหนดค่าขั้นสูง
สำหรับส่วนที่เหลือของบทความนี้ ส่วนใหญ่ที่เราจะใช้งานคืออุปกรณ์จริงหนึ่งตัวและตัวจำลองหนึ่งตัวสำหรับกระบวนการเซิร์ฟเวอร์ ADB เดียว
วิธีกำหนดค่าโปรแกรมจำลอง ABD
เป็นไปได้มากว่าคุณไม่จำเป็นต้องทำการกำหนดค่าใดๆ เพิ่มเติม แต่เป็นไปได้ที่คุณอาจต้องเปิดใช้งานตัวเลือกสำหรับนักพัฒนา บนอีมูเลเตอร์ของคุณ คุณจะรู้ในไม่ช้าว่ามันทำงานอย่างถูกต้องเมื่อเราไปถึงคำสั่ง ADB สองสามคำสั่งแรกของเรา
หากคุณต้องการเปิดใช้งานคุณลักษณะนี้บนอีมูเลเตอร์ คุณจะต้องศึกษาวิธีการเปิดใช้งานสำหรับ Android เวอร์ชันเฉพาะของคุณ
การแก้ไขจุดบกพร่อง USB – วิธีกำหนดค่าอุปกรณ์จริง
หากคุณไม่ได้วางแผนที่จะใช้อุปกรณ์ Android จริง คุณสามารถข้ามส่วนนี้ได้ อย่างไรก็ตาม เป็นที่น่าสังเกตว่าคุณอาจต้องเปิดใช้งานตัวเลือกสำหรับนักพัฒนาซอฟต์แวร์
ในการดำเนินการต่อ คุณจะต้องกำหนดค่าการแก้ไขจุดบกพร่อง USB หรือการแก้ไขจุดบกพร่อง WiFi บนอุปกรณ์ Android และเครื่องพัฒนาของคุณ
ไม่ว่าในกรณีใด ให้เริ่มต้นด้วยการเปิดใช้งานตัวเลือกสำหรับนักพัฒนา บนอุปกรณ์ของคุณ คุณจะต้องค้นคว้าวิธีดำเนินการดังกล่าวสำหรับ Android เวอร์ชันเฉพาะของคุณ
แก้จุดบกพร่อง USB
ตรวจสอบให้แน่ใจว่าคุณได้เปิดใช้งานการดีบัก USB บนอุปกรณ์ Android ผ่านตัวเลือกสำหรับนักพัฒนา ลิงก์ที่ฉันแชร์ด้านบนจะอธิบายกระบวนการนั้น ซึ่งมีแนวโน้มที่จะเปลี่ยนแปลงบ้างในระบบปฏิบัติการ Android เวอร์ชันต่างๆ
ก่อนดำเนินการต่อ ผู้ใช้ Windows จะต้องดาวน์โหลดไดรเวอร์ USB ผู้ใช้ Ubuntu ยังต้องการขั้นตอนพิเศษบางอย่าง สำหรับ Mac และ Chrome OS คุณควรไปต่อ
เมื่อเปิดใช้งานการแก้ไขข้อบกพร่อง USB ผ่านตัวเลือกสำหรับนักพัฒนาแล้ว ให้เชื่อมต่ออุปกรณ์ Android ของคุณผ่านสาย USB
การดีบัก WiFi
หากคุณมีอุปกรณ์ทางกายภาพหลายตัวหรือสาย USB ขาด คุณอาจต้องการเลือกใช้ WiFi Debugging
อีกครั้ง ไปที่ตัวเลือกนักพัฒนาบนอุปกรณ์ Android ของคุณและเปิดใช้งานการดีบักแบบไร้สาย ควรแจ้งให้คุณทราบเกี่ยวกับการอนุญาตการดีบักบนเครือข่ายที่อุปกรณ์เชื่อมต่ออยู่ ซึ่งคุณควรอนุญาต (สมมติว่าเป็นเครือข่ายที่เหมาะสม)
ถึงเวลาเริ่มทำงานกับ CLI ของคุณแล้ว . ขั้นแรก คุณจะต้องค้นหาไดเร็กทอรีเครื่องมือแพลตฟอร์ม (หรือโฟลเดอร์ - สิ่งเดียวกัน) ภายในไดเร็กทอรีการติดตั้ง Android SDK ของคุณ
สมมติว่าคุณติดตั้ง Android Studio วิธีที่รวดเร็วในการค้นหาผ่านแอปคือไปที่ไฟล์ -> การตั้งค่าอีกครั้ง จากนั้นพิมพ์ “SDK” ในแถบค้นหา เมนู “Android SDK” จะแสดงตำแหน่งที่คุณติดตั้ง SDK ซึ่งจะเป็นไดเร็กทอรีที่ควรมีเครื่องมือแพลตฟอร์ม
ในตัวอย่างด้านล่าง ฉันคัดลอกเส้นทางไปยังไดเรกทอรี Android SDK ของฉัน แล้วเปิดอินสแตนซ์ของ Windows PowerShell ฉันพิมพ์คำสั่งต่อไปนี้:
เปลี่ยนไดเรกทอรี:
cd <path-to-SDK-directory>แสดงรายการไฟล์และไดเรกทอรี:
ls
ต่อไปฉันพิมพ์ cd platform-tools เพื่อนำทางไปยังไดเร็กทอรีนั้น โปรดทราบว่าขั้นตอนต่อไปนี้ถือว่าคุณกำลังใช้อุปกรณ์ที่ใช้ Android OS 11 หรือสูงกว่า
หากคุณกำลังใช้งานอุปกรณ์ที่ใช้ Android 10 หรือต่ำกว่า ดูคำแนะนำโดยละเอียดสำหรับสถานการณ์นั้นได้ที่นี่
เมื่อคุณอยู่ในไดเร็กทอรี platform-tools คุณก็พร้อมที่จะจับคู่อุปกรณ์ Android กับเครื่องพัฒนาโดยใช้ขั้นตอนต่อไปนี้:
1. ภายในเมนูย่อยการดีบักไร้สายในการตั้งค่า -> ระบบ -> ตัวเลือกสำหรับนักพัฒนา ให้เลือก จับคู่อุปกรณ์กับรหัสการจับคู่ .
2. ภายในเครื่องมือ CLI ของคุณซึ่งควรตั้งค่าเป็นไดเร็กทอรีเครื่องมือแพลตฟอร์ม ให้ป้อนคำสั่งต่อไปนี้:
adb pair <IP address>:<Port>
โดยที่ทั้งที่อยู่ IP และพอร์ตมาจากกล่องโต้ตอบบนอุปกรณ์ Android ของคุณ ซึ่งปรากฏขึ้นหลังจากเลือกจับคู่อุปกรณ์กับรหัสการจับคู่ (ไม่รวมวงเล็บเหลี่ยม)
หมายเหตุ:คุณอาจต้องต่อสายไปยัง adb ด้วยสัญลักษณ์หรือคำสั่งอื่นๆ โดยขึ้นอยู่กับเครื่องมือ CLI ที่คุณใช้ ระบบปฏิบัติการ และการควบคุมการเข้าถึง ตัวอย่างเช่น ฉันต้องพิมพ์ .\adb pair
3. สมมติว่าทุกอย่างเป็นไปด้วยดีกับ CLI ของคุณ คุณจะได้รับแจ้งให้ป้อนรหัสการจับคู่ซึ่งปรากฏอยู่ในกล่องโต้ตอบเดียวกันบนอุปกรณ์ Android ซึ่งให้ที่อยู่ IP และหมายเลขพอร์ตแก่คุณ
4. หลังจากป้อนรหัสการจับคู่ คุณจะรู้ว่าการดำเนินการนี้สำเร็จหากคุณได้รับข้อความที่ระบุว่า:
Successfully paired to <IP Address>:<Port> [guid=<Some GUID>]
5. หากคุณใช้ Windows หรือ Linux คุณจะต้องเรียกใช้คำสั่งต่อไปนี้โดยใช้ที่อยู่ IP &พอร์ต ซึ่งมองเห็นได้จากภายในเมนูการตั้งค่าการดีบักไร้สาย (ไม่ใช่กล่องโต้ตอบที่ปรากฏขึ้นหลังจากเลือกจับคู่อุปกรณ์ด้วยรหัสการจับคู่) :
adb connect <IP Address>:<Port>
หลังจากนั้นคุณควรได้รับการแจ้งเตือนทางโทรศัพท์เพื่อระบุว่าคุณเชื่อมต่อแล้ว
วิธีใช้ ADB:คำสั่ง
สมมติว่าคุณสามารถกำหนดค่าอุปกรณ์ Android และเครื่องพัฒนาของคุณได้อย่างเหมาะสม ตอนนี้คุณสามารถใช้เครื่องมือ ADB ได้แล้ว
ก่อนดำเนินการต่อ ให้ไปที่ไดเร็กทอรีที่มี adb โดยใช้เครื่องมือ CLI (เว้นแต่คุณจะทำตามขั้นตอนในส่วนก่อนหน้าสำหรับการตั้งค่าการดีบัก WiFi)
มิฉะนั้น ให้ดำเนินการตอนนี้ หรือดูคำแนะนำในการค้นหาโฟลเดอร์นั้นในส่วนนั้น
วิธีดูว่าอุปกรณ์ใดเชื่อมต่อกับเซิร์ฟเวอร์อยู่
ตอนนี้คุณสามารถเริ่มต้นเซิร์ฟเวอร์ adb ได้โดยเรียกใช้คำสั่งใดก็ได้บน ADB ยกเว้น adb kill-server . ไม่ว่ากระบวนการของเซิร์ฟเวอร์ของคุณกำลังทำงานอยู่หรือไม่ ให้พิมพ์คำสั่งต่อไปนี้:
adb devices
ในภาพหน้าจอด้านบน ตอนแรกฉันเรียกว่า adb devices เมื่อโทรศัพท์ Android ของฉันเชื่อมต่อกับเซิร์ฟเวอร์ หลังจากฆ่าเซิร์ฟเวอร์ผ่าน adb kill-server คำสั่ง ฉันเรียกอุปกรณ์ที่รีสตาร์ทเซิร์ฟเวอร์อีกครั้ง
อีกครั้ง หากเซิร์ฟเวอร์ ADB ไม่ได้ทำงานอยู่ การเรียกคำสั่ง ADB มากหรือน้อยจะเป็นการเริ่มสำรองเซิร์ฟเวอร์ (ยกเว้น adb kill-server , แน่นอน). มี adb start-server . ที่ชัดเจน คำสั่ง แต่ในทางปฏิบัติฉันไม่เคยจำเป็นต้องใช้มัน
เนื่องจากเซิร์ฟเวอร์ถูกรีเซ็ต อุปกรณ์จึงไม่ส่งคืนรายการใดๆ ดังนั้นก่อนจะย้ายไปตัวอย่างต่อไป ฉันต้องใช้ adb pair . อีกครั้ง และ adb connect (ถ้าบน Windows หรือ Linux) คำสั่งที่อธิบายไว้ในส่วนก่อนหน้า
ตอนนี้ฉันได้เปิดเครื่องจำลองโดยใช้ PowerShell และโปรแกรมจำลองซึ่งอยู่ในไดเรกทอรีย่อยของเครื่องมือแพลตฟอร์มที่เรียกว่า "โปรแกรมจำลอง"
คุณสามารถใช้ AVD Manager หรือ Android Studio เพื่อเริ่มโปรแกรมจำลองเพื่อทำตามตัวอย่างได้หากต้องการ
หากคุณมีอุปกรณ์ที่เชื่อมต่ออยู่หลายเครื่อง ตัวเลือกที่มีประโยชน์สำหรับ adb devices คำสั่งคือ -l ซึ่งให้ข้อมูลเพิ่มเติมเกี่ยวกับอุปกรณ์แก่คุณ
ด้านล่างนี้ คุณจะเห็นหลายรายการที่อ้างถึงอุปกรณ์ Android จริงของฉัน รวมถึงโปรแกรมจำลองที่แนบกับพอร์ตเฉพาะ:
วิธีการส่งคำสั่งไปยังอุปกรณ์เฉพาะ
เพื่อหลีกเลี่ยงไม่ให้โทรศัพท์ของฉันพังโดยไม่ได้ตั้งใจ ฉันต้องการส่งคำสั่งไปยังโปรแกรมจำลองแทน ในการดำเนินการนี้ ฉันต้องเติม -s . ไว้ข้างหน้า ตามด้วยหมายเลขประจำเครื่องของอุปกรณ์เป้าหมาย ก่อนพิมพ์คำสั่ง
หมายเลขซีเรียลคืออักขระชุดแรกที่อธิบายอุปกรณ์ที่เชื่อมต่อหลังจากใช้คำสั่งอุปกรณ์
ตัวอย่างเช่น หมายเลขซีเรียลของอีมูเลเตอร์ในกรณีนี้เป็นเพียงอีมูเลเตอร์คำตามด้วยพอร์ตที่อีมูเลเตอร์เชื่อมต่ออยู่ในปัจจุบัน
ลูกศรสีแดงอีกอันชี้ไปที่หมายเลขประจำเครื่องของโทรศัพท์ของฉัน (ถูกปิดกั้นด้วยเหตุผลที่ชัดเจน)
โดยปกติ หากคุณมีอุปกรณ์เชื่อมต่อเพียงเครื่องเดียว (ไม่ว่าจะเป็นอุปกรณ์ประเภทใด) คุณไม่จำเป็นต้องใช้ -s ตัวเลือก
ติดตั้ง APK (แอป) บนอุปกรณ์
ตอนนี้ฉันกำลังจะติดตั้ง APK ทดสอบบนอีมูเลเตอร์ที่ทำงานอยู่โดยใช้ adb install สั่งการ.
โดยพื้นฐานแล้วจะเทียบเท่ากับการมี Android Studio และ Gradle ติดตั้ง APK สำหรับการดีบัก อย่างที่คุณเห็น APK ทดสอบต้องใช้ -t ตัวเลือกหลังคำสั่งติดตั้ง:
adb -s <device-serial-number> install -t <path-to-APK>
หมายเหตุ:ระบบปฏิบัติการ Android กำหนดให้ต้องมีการลงชื่อ APK ใดๆ ก่อนจึงจะสามารถติดตั้งได้ (แม้ว่าจะเป็นเพียง APK ทดสอบ/ดีบักก็ตาม)
ทางออกหนึ่งคือการสร้างและเรียกใช้แอปที่จะติดตั้งใน Android Studio ซึ่งจะลงนามด้วยใบรับรองการดีบักที่สร้างขึ้น มีหลายวิธีในการลงนาม APK ดังกล่าว ซึ่งคุณสามารถสำรวจได้โดยไปที่ลิงก์นี้
ADB สามารถทำอะไรได้อีกบ้าง
ก่อนที่เราจะมาดูการใช้งานขั้นสูงของ ADB เราขอแนะนำให้คุณลองใช้ adb --help สั่งการ. ตามปกติสำหรับโปรแกรมที่ใช้ CLI ส่วนใหญ่ คำสั่ง help จะพิมพ์เอกสารที่อธิบายคำสั่งและตัวเลือกต่างๆ ของเครื่องมือ
ฉันยินดีที่จะบอกว่าเอกสารสำหรับ ADB นั้นค่อนข้างอ่านง่ายและมีประโยชน์ ซึ่งไม่ใช่กรณีในโปรแกรม CLI เสมอไป
เคล็ดลับการใช้ ADB ขั้นสูง
คงจะเป็นการเสียเวลาสำหรับเราทั้งคู่ที่จะครอบคลุมทุกการใช้งานและคำสั่งของ ADB ในบทความนี้
ในกรณีที่มีความสับสน การใช้ ADB เพื่อติดตั้ง APK และทำหลายสิ่งหลายอย่างที่ Android Studio และ Gradle ทำเพื่อคุณไม่ใช่สิ่งที่ฉันอยากจะแนะนำ (เว้นแต่คุณจะมีเหตุผลที่ดีที่จะทำเช่นนั้น)
จากที่กล่าวมา มีหลายสิ่งที่ ADB สามารถทำได้ซึ่งยากหรือไม่สามารถทำได้หากไม่มี
ในส่วนเบื้องต้น ฉันได้กล่าวถึงว่าสามารถใช้ ADB เพื่อเชื่อมต่อกับเชลล์ของอุปกรณ์ได้ เพื่อจบบทความนี้ เราจะมาดูวิธีการใช้คำสั่งเชลล์และตำแหน่งที่จะหาข้อมูลเพิ่มเติมเกี่ยวกับคำสั่งเหล่านี้
หากคุณไม่รู้ว่าเชลล์คืออะไร คุณอาจข้ามส่วนด้านบนที่ฉันอธิบายไป
วิธีใช้เชลล์ ABD
การส่งคำสั่งไปยังเชลล์ของอุปกรณ์โดยใช้ ADB นั้นค่อนข้างง่าย จำไว้ว่าหากคุณเชื่อมต่ออุปกรณ์หลายเครื่อง ให้ทำตามด้วย -s <device-serial-number> เพื่อสั่งการคำสั่งไปยังอุปกรณ์เฉพาะ
ในการสร้างคำสั่งเชลล์เดียว เราต้องใช้ adb shell คำสั่ง (แปลกใจมากใช่มั้ย) ตามด้วยคำสั่งจริงที่เราต้องการสร้างบนเชลล์ของอุปกรณ์:
adb shell ls
เอาท์พุต:
ดังที่ได้กล่าวไว้ก่อนหน้านี้ว่า ls คำสั่งแสดงรายการไฟล์และไดเร็กทอรีที่ไดเร็กทอรีปัจจุบันของ CLI นี่เป็นไดเรกทอรีรากของอุปกรณ์ Android จนกว่าเราจะย้ายไปที่อื่น
หากคุณวางแผนที่จะสร้างคำสั่งจำนวนมากผ่าน Shell คุณยังสามารถเริ่มเซสชัน Shell แบบโต้ตอบได้ สามารถทำได้โดยใช้คำสั่งง่ายๆ:
adb shell
ขณะอยู่ในเซสชัน Shell แบบโต้ตอบ คุณสามารถพิมพ์คำสั่ง Shell ได้โดยตรงโดยไม่ต้องใช้ adb shell <command> .
โปรดทราบว่าเมื่อคุณต้องการออกจากเซสชัน Shell แบบโต้ตอบ คุณสามารถทำได้โดยพิมพ์ exit หรือกด Ctrl + D
มีคำสั่งและยูทิลิตี้ต่างๆ มากมายที่คุณสามารถใช้งานผ่านเชลล์ได้ ตัวจัดการกิจกรรม (am ) ของอุปกรณ์ Android อาจมีประโยชน์อย่างยิ่งสำหรับการทดสอบส่วนประกอบต่างๆ (กิจกรรม บริการ เครื่องรับส่งสัญญาณ เป็นต้น) ของแอป Android ภายใต้สถานการณ์ที่แตกต่างกัน
สมมติว่าเราต้องการเริ่มต้นโดยตรงในกิจกรรมเฉพาะ แต่กิจกรรมนี้ไม่ได้ถูกกำหนดให้เป็นกิจกรรมตัวเรียกใช้งานในรายการ
คุณจะต้องเพิ่ม android:exported=”true” แอตทริบิวต์ของแต่ละ <activity/> รายการในรายการที่คุณต้องการเปิดใช้งาน (สมมติว่าไม่ใช่กิจกรรมตัวเรียกใช้งานอยู่แล้ว)
หลังจากนั้น คุณสามารถใช้คำสั่งต่อไปนี้เพื่อไปยังคำสั่งนั้นได้โดยตรง:
am start -n <app-package-id>/<activity-name>
โปรดทราบว่า <activity-name> ต้องรวมแพ็คเกจใดก็ตามที่สัมพันธ์กับ package-id ที่อยู่ในนั้น ดูผลลัพธ์ด้านล่างสำหรับตัวอย่างการเริ่มกิจกรรมซึ่งอยู่ในหลายแพ็คเกจ
อ่านเพิ่มเติม
เป้าหมายของฉันในบทความนี้คือการพยายามอย่างเต็มที่เพื่อแนะนำ อธิบาย และแนะนำคุณตลอดการใช้งาน ABD ด้วยคำพูดของฉันเอง (เท่าที่จะเป็นไปได้)
ณ จุดนี้ฉันจะต้องเริ่มสร้างตัวอย่างที่ประดิษฐ์ขึ้นเองหรือคัดลอกเอกสารทั้งหมดซึ่งไม่ใช่สิ่งที่ฉันสนใจจะทำ
แต่ฉันอยากแนะนำให้คุณไปที่เอกสารประกอบ และดูสิ่งเจ๋งๆ บางอย่างที่คุณสามารถทำได้โดยใช้เครื่องมือต่างๆ เช่น ตัวจัดการกิจกรรม ตัวจัดการแพ็คเกจ ตัวจัดการนโยบาย และอื่นๆ
คุณสามารถติดต่อกับฉันทางโซเชียลมีเดียได้ที่นี่:
https://www.instagram.com/rkay301/
https://www.facebook.com/wiseassblog/
https://twitter.com/wiseass301
https://wiseassblog.com/
