รู้จักกับ Dependencies และการเรียกใช้ Library บน Android Studio

       สำหรับวันนี้ขอแนะนำให้รู้จักกับ Dependencies กัน ซึ่งคำนี้ผู้ที่หลงเข้ามาอ่านที่ใช้ Android Studio น่าจะคุ้นๆและผ่านตากันมาบ้างแล้ว จึงขอขยายความเพื่อให้เข้าใจมันยิ่งขึ้นอีกซักหน่อย

        Dependencies มีความหมายคร่าวๆว่า "การพึ่งพา" ซึ่งไม่ต้องไปแปลตรงตัวอะไรมากนัก เพียงแค่ลักษณะการทำงานของมันคล้ายๆกับความหมายของมัน แต่ถ้าจะให้อธิบายสั้นๆง่ายๆสำหรับผู้ที่หลงเข้ามาอ่านก็คงจะเป็น..

        Dependencies เอาไว้ช่วยจัดการกับ Library นั่นแหละ

        เพราะว่าบน Android Studio มี Dependencies ที่เอาไว้จัดการ Library เป็นหลัก ถ้าว่ากันตามตรง Dependencies เป็นบางอย่างที่เอาไว้จัดการกับ Library ที่เอามาใช้ในโปรเจคนั้นๆ

        โดย Dependencies ถูกแบ่งออกเป็น 3 ประเภทดังนี้

                • Module Dependencies
                • Local Dependencies
                • Remote Dependencies

        ซึ่ง Dependencies แต่ละประเภทก็จะมีวิธีเรียกใช้งานที่แตกต่างกันไป แต่ทั้งหมดนี้ก็มีเป้าหมายหลักเดียวกันคือ คอยจัดการกับ Library ที่จะนำมาใช้งาน


Module Dependencies

        บน Android Studio จะเห็นว่า Project ต่างๆนั้นถูกจับแยกออกจากกันแล้ว โปรเจคหนึ่งตัวก็จะถูกเปิดขึ้นมาเป็นหนึ่งหน้าต่าง ซึ่งต่างจาก Eclipse ADT ที่มี Project Explorer ให้เปิดหลายๆโปรเจคพร้อมๆกันได้

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

        แล้วจะเอาไลบรารีมาใช้ได้ยังไงล่ะ? 

        เพราะว่าบน Eclipse ADT จะใช้วิธีเพิ่ม Library ลงไปในโปรเจคด้วยการ Import โปรเจคของ Library ลงไปใน Workspace ก่อน แล้วกำหนดให้โปรเจคที่ต้องการเรียกไปยังโปรเจคของ Library นั้นๆอีกที

        แต่เมื่อจับแยกออกจากกันแบบนี้จึงทำให้ใช้วิธีแบบเดิมๆไม่ได้แล้ว จึงเป็นอีกหนึ่งปัญหาที่ผู้ที่หลงเข้ามาอ่านหลายๆคนนั้นติดแหง่กอยู่

        ซึ่งในความเป็นจริงแล้ว บน Android Studio ก็ยังสามารถทำให้โปรเจคมีมากกว่าหนึ่งโปรเจคก็ได้เหมือนกันนะ แต่ทว่าจะไม่ได้เรียกว่าโปรเจคอีกต่อไป จะเรียกกันว่า Module แทน

        โดยที่โมดูลมันก็เสมือน Sub-project นั่นเอง เพราะว่าในโปรเจคหนึ่งตัวนั้นจะมีโมดูลอยู่หนึ่งตัวข้างในนั้น ซึ่งก็คือ Source Code ของแอพฯนั้นๆ

        จากเดิมที่มองกันเป็น 1 โปรเจค ก็ให้มองใหม่ว่ามันคือโมดูลแทน ส่วนโปรเจคก็คือ Workspace นั่นเอง

        ดังนั้นการเปิดโปรเจคใดๆบน Android Studio ก็เสมือนการเลือก Workspace บน Eclipse ADT นั่นเอง แต่ทว่าบน Android Studio นั้นหมายถึง "แอพฯเพียง 1 ตัว" เท่านั้น

        ถึงแม้ว่า 1 โปรเจคจะมีได้แค่แอพ 1 ตัวเท่านั้น แต่มันก็สามารถประกอบไปด้วยโมดูลที่เป็นไลบรารีได้อยู่นะเออ

        จะเห็นว่าตอนนี้ในหนึ่งโปรเจคของเจ้าของบล็อกมีโมดูล 2 ตัวแล้ว ดังนั้นโครงสร้างโปรเจคตัวนี้ก็จะเป็นแบบนี้

        ในโปรเจคตัวนี้ก็จะมีโมดูลชื่อ app ที่เป็นส่วนหลักของแอพฯ และโมดูลชื่อ library ที่เป็นไลบรารีที่เจ้าของบล็อกเอาเข้ามาเรียกใช้งานในโค๊ดอีกทีหนึ่ง

        หมายเหตุ - ชื่อโมดูลนั้นตั้งเองได้ ไม่ได้กำหนดตายตัว (แต่เจ้าของบล็อกกำหนดชื่อให้ดูเข้าใจง่าย) และชื่อโมดูลนั้นไม่มีผลต่อชื่อแอพ เพราะสุดท้ายก็กำหนดใน Android Manifest อยู่ดี


        โดยที่ Dependencies ประเภทนี้จะมีคำสั่ง Gradle เพื่อกำหนดโมดูลที่จะใช้งานเป็นไลบรารีดังนี้

dependencies {
    compile project(':library')
}

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

        ใน Gradle ของโมดูล app เจ้าของบล็อกก็จะต้องกำหนดลงไปดังนี้

dependencies {
    compile project(':hellochart' )
    compile project(':bluetoothspp')
}

        เพื่อให้สามารถเรียกใช้งานไลบรารีทั้งสองตัวนี้ได้

        และนอกจากนี้ยังสามารถนำไลบรารีที่เป็น .jar หรือ .aar มาทำเป็นโมดูลได้ด้วยนะเออ

        ดังนั้น Module Dependencies จึงเป็นวิธีจัดการไลบรารีที่อยู่ในรูปของโปรเจคตัวหนึ่งที่มี Source Code อยู่ข้างในหรือ .jar/.aar ที่ทำให้อยู่ในรูปของโมดูล แล้วใช้ Gradle กำหนดที่โมดูลหลักของแอพฯว่าโมดูลตัวไหนที่เป็นไลบรารี


ขั้นตอนการเพิ่ม Library แบบ Module Dependencies

        เจ้าของบล็อกขอแบ่งเป็น 3 กรณีนะ คือกรณีที่ต้องการสร้างขึ้นใหม่เอง, กรณีที่นำไลบรารีจากที่อื่นเข้ามาไว้ในโปรเจค และกรณีที่ไลบรารีเป็นไฟล์ .jar/.aar

กรณีสร้างไลบรารีขึ้นใหม่เอง

     • เลือกไปที่ File > New Module...

        • จะมีหน้าต่าง Create New Module แสดงขึ้นมา ให้เลือกที่ Android Library แล้วกดปุ่ม Next

        • ต่อมาจะเป็นการตั้งชื่อไลบรารีและชื่อโมดูลที่จะแสดงในโปรเจค และสามารถกำหนด Package Name เพิ่มเติมได้ เมื่อกำหนดเสร็จแล้วให้กดปุ่ม Next

        • ถัดมาจะให้เลือก Activity เริ่มต้นที่ต้องการให้สร้าง แต่ทว่าไลบรารีส่วนใหญ่นั้นไม่ได้ต้องการสร้าง Activity เสียหน่อย ก็ให้เลือก Add No Activity แล้วกดปุ่ม Finish ซะ

        • เมื่อสร้างเสร็จแล้วก็จะเห็นว่ามีโมดูลของไลบรารีที่สร้างขึ้นเมื่อครู่นี้แสดงขึ้นมาให้เห็นแล้ว

        • และที่สำคัญก็คืออย่าลืมเพิ่มคำสั่งใน build.gradle ของโมดูลหลัก (ในตัวอย่างโมดูลชื่อว่า app) เพื่อให้ใช้งานไลบรารีที่สร้างขึ้นมาด้วย

กรณีใช้ไลบรารีที่มีอยู่แล้ว

        • เลือกไปที่ File > Import Module...

        • จะมีหน้าต่าง New Module แสดงขึ้นมา ที่ช่อง Source directory ให้กำหนด Directory ของไลบรารีหรือกดที่ปุ่ม ... เพื่อเลือกโฟลเดอร์ก็ได้

        • เมื่อกำหนด Directory เสร็จแล้ว ให้กำหนด Module name ด้วย แล้วกดปุ่ม Next

        • โปรแกรมจะถามถึงการ Import ดังนี้

        Replace jars with dependencies, when possible ถ้ามีไฟล์ .jar ที่เป็นไลบรารีตัวเดียวกันกับที่เลือกจะใช้ไลบรารีจาก Dependencies แทนที่ .jar

        Replace library sources with dependencies, when possible ถ้ามี Source Code ของไลบรารีดังกล่าวอยู่ในโมดูลหลักอยู่แล้ว จะใช้ไลบรารีจาก Dependencies แทนที่ Source Code

        Create Gradle-style (camelCase) module names ตั้งชื่อโมดูลโดยกำหนดชื่อด้วยวิธี camelCase
     

        ซึ่งในขั้นตอนนี้ไม่ต้องแก้ไขอะไร ให้กดปุ่ม Next

        • ในการ Import Module จะต้องมีการติดตั้ง Android Support Repository ใน Android SDK Manager ด้วย ถ้าไม่ได้ติดตั้งโปรแกรมจะมีการแจ้งให้ไปติดตั้งก่อน แต่ถ้าติดตั้งแล้วก็กดปุ่ม Finish ได้เลย (โปรแกรมบอกว่าเจ้าของบล็อกไม่ได้ลงซะงั้น ทั้งๆที่ลงไว้เรียบร้อยแล้ว)

        • ความงี่เง่าอย่างหนึ่งของ Android Studio ก็คือเมื่อทำการ Import Module ที่กำหนด Target SDK Version ไว้เป็นเวอร์ชันที่ไม่ได้ติดตั้งไว้ใน Android SDK Manager โปรแกรมจะบังคับให้ต้องติดตั้งในทันที ไม่สามารถข้ามผ่านไปแล้วค่อยไปแก้ Target SDK Version ทีหลังได้ เพราะมันจะไม่แสดงโมดูลตัวนั้นให้เห็นเลย เนื่องจาก Build Gradle ไม่ผ่าน

        เรียกได้ว่าโดนบังคับโหลดทั้งๆที่ไม่ต้องการ 

        แต่ข้อดีก็คือเมื่อกดที่ Install missing platform(s) and sync project แล้วโปรแกรมจะเลือกติดตั้ง Package ที่ขาดไปให้อัตโนมัติ ซึ่งขั้นตอนการติดตั้งคงไม่ต้องอธิบายกันแล้ว น่าจะทำเป็นกันแล้ว

        การบังคับดาวน์โหลดที่ว่านั้นรวมไปถึง Android SDK Built-tools ด้วยเช่นกัน....

        • เมื่อ Import โมดูลเสร็จแล้วให้รอ Gradle ทำการ Build ให้เสร็จก่อน ก็จะเห็นว่ามีโมดูลของไลบรารีที่เพิ่มเข้ามาแล้ว

        • และอย่าลืมไปเพิ่มคำสั่งให้ Gradle เพิ่มไลบรารีของโมดูลไลบรารีเข้าไปด้วย โดยกำหนดใน build.gradle ของโมดูลหลัก

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

กรณีที่ไลบรารีเป็นไฟล์ .jar/.aar

        • เลือกไปที่ File > New Module...

        • หน้าต่าง Create New Module จะแสดงขึ้นมา ให้เลือก Import .JAR or .AAR Package แล้วกดปุ่ม Next

        • เลือก Directory ของไฟล์ไลบรารีที่จะใช้งาน แล้วกดปุ่ม Finish

        • เพียงเท่านี้ไฟล์ไลบรารีก็จะถูกดึงเข้ามาในโปรเจคโดยทำให้อยู่ในรูปโมดูลแล้ว 

        • และที่สำคัญ อย่าลืมกำหนดให้โมดูลหลักเรียกใช้งานไลบรารีตัวนี้ใน Gradle ด้วย 

การลบ Module ออกจาก Project

        สำหรับการลบโมดูลทิ้งจะกดลบทิ้งจากหน้าต่างโปรเจคไม่ได้ ซึ่งต่างจากตอนใช้ Eclipse ADT เพราะบน Android Studio จะต้องเข้าไปลบใน Project Structure แทน 

        • โดยเลือกไปที่ File > Project Structure...

        • แล้วเลือกโมดูลจากหน้าต่าง Project Structure แล้วกดที่ปุ่มเครื่องหมายลบสีแดง 

        • โปรแกรมจะมีการถามเพื่อยืนยันว่าต้องการลบโมดูลทิ้งจริงๆ ให้กดปุ่ม Yes

        • ปิดหน้าต่าง Project Structure แล้วจะเห็นว่าโมดูลที่เลือกได้ถูกลบทิ้งไปแล้ว

        • และมาพร้อมกับ Error บน Gradle ด้วยเช่นกัน เพราะว่าต้องลบคำสั่งของโมดูลไลบรารีใน Gradle ออกเอง (โปรแกรมไม่ได้ลบออกให้อัตโนมัติ)

        • ลบคำสั่งของไลบรารีออกแล้วลอง Build Gradle ใหม่ ก็เป็นอันเสร็จการลบโมดูลออกจากโปรเจค

        เพิ่มเติม - การลบโมดูลบน Android Studio ไม่ได้เป็นการลบไฟล์ที่อยู่บนเครื่อง ดังนั้นจะยังคงมีไฟล์ในโฟลเดอร์ของโปรเจคอยู่ 

        สามารถทดสอบได้ด้วยการเปลี่ยนรูปแบบการแสดงไฟล์โปรเจคในหน้าต่าง Project ให้เปลี่ยนจาก Android เป็นแบบ Project แทน เพื่อแสดงไฟล์และโฟลเดอร์ทั้งหมดในโปรเจค

        ที่หน้านี้จะสามารถเลือกลบไฟล์ได้ และไฟล์ก็จะถูกลบออกจากเครื่องถาวร โดยมีหน้าต่างถามเพื่อยืนยันเวลาที่ลบไฟล์ใดๆด้วย

Local Dependencies

        Dependencies ประเภทนี้เข้าใจได้ง่ายมากๆ เพราะมันคือ Dependencies ที่จัดการกับไลบรารีที่อยู่ในรูปของไฟล์สำเร็จแล้วนั่นเอง อะไรนะ? นึกไม่ออก? ก็อย่างเช่นไฟล์ .jar ไงล่ะ!!

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

        โดยที่ Dependencies ประเภทนี้จะมีคำสั่ง Gradle เพื่อกำหนดโมดูลที่จะใช้งานเป็นไลบรารีดังนี้

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
}

ขั้นตอนการเพิ่ม Library แบบ Local Dependencies

        วิธีนั้นเหมือนกับบน Eclipse ADT เลย นั่นก็คือยัดไฟล์ไว้ในโฟลเดอร์ที่ชื่อว่า libs ที่อยู่ในโปรเจค แต่ใน Android Studio ก็จะเป็นการยัดไว้ในโฟลเดอร์ libs ที่อยู่ในโมดูลหลักแทน

        อะไรนะ? หาโฟลเดอร์ libs ไม่เจอ?

        • ให้เปลี่ยนรูปแบบการแสดงผลของหน้าต่าง Project ก่อน โดยเปลี่ยนจากแบบ Android เป็น Project

        • ให้ Expand โฟลเดอร์ app (โมดูลหลักนั่นเอง) แล้วจะเห็นโฟลเดอร์ libs อยู่ในนี้แล้ว

        • ให้เอาไฟล์ .jar ไว้ในโฟลเดอร์นี้ จะก๊อปแปะหรือลากใส่โฟลเดอร์นี้ก็ได้

        • เมื่อเพิ่มไฟล์เข้ามาแล้ว ให้ทำการ Build Gradle ใหม่ก่อนแล้วจึงจะเรียกใช้ไลบรารีได้ และสำหรับ build.gradle ไม่ต้องกำหนดอะไรเพิ่มเติม เนื่องจากโปรแกรมกำหนดไว้ให้ตั้งแต่ตอนสร้างโปรเจคแล้ว

        ส่วนการลบไลบรารีทิ้งก็แค่กดลบไฟล์ที่อยู่ในโฟลเดอร์ libs ทิ้งก็เป็นอันเสร็จ

Remote Dependencies

        สำหรับ Dependencies ประเภทนี้เรียกได้ว่าเป็นฟีเจอร์บน Android Studio ที่จะช่วยให้ชีวิตนักพัฒนานั้นง่ายขึ้นอย่างมาก 

        ลองนึกภาพการถึงการเขียนแอพฯจริงๆจังๆซัก 1 ตัว (แอพฯที่เป็นเรื่องเป็นราว) ย่อมมีการเรียกใช้ไลบรารีต่างๆนานาเข้ามาช่วยเพื่อให้งานเสร็จได้ไวขึ้นอยู่แล้ว แต่ทว่าไลบรารีบางตัวก็เรียกใช้ไลบรารีตัวอื่นอีกที จึงเกิดปัญหาว่า 

        ต้องไปไล่หาโหลดไลบรารีนั้นๆมาให้ครบ

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

        ดังนั้น Remote Dependencies จึงเป็นพระเอกที่ขี่ม้าขาวมาช่วยจัดการกับเหล่าร้ายนี้ให้หมดลง โดยที่นักพัฒนาไม่จำเป็นต้องไปนั่งไล่หาดาวน์โหลดไลบรารีเพื่อใช้งานเอง โดยมี Maven Central เป็นตัวสำคัญที่เป็นคลังรวมไลบรารีไว้ 

        นักพัฒนาก็แค่กำหนดใน Gradle ด้วยรูปแบบที่ Maven กำหนดไว้ เพื่อระบุว่าต้องการดึงไลบรารีตัวไหนมาใช้งาน 

        ยกตัวอย่างเช่น เจ้าของบล็อกอยากจะใช้ไลบรารีที่ชื่อว่า FadingActionBar 

        แต่เจ้าของบล็อกไม่จำเป็นต้องเข้าไปดาวน์โหลดไฟล์เพื่อมา Import เอง เพียงแค่กำหนดใน build.gradle ของ Module ที่จะเรียกใช้งานไลบรารีตัวนี้

dependencies {
    compile 'com.github.manuelpeinado.fadingactionbar:fadingactionbar:3.1.2'
}

        เพียงเท่านี้โปรแกรมก็จะไปดึงไฟล์ไลบรารีและไฟล์ที่เกี่ยวข้องจาก Maven Central Repositories มาลงไว้ในเครื่องของเจ้าของบล็อกแล้วเพิ่มเข้าไปในโปรเจคให้ทันที ดังนั้นสิ่งที่เจ้าของบล็อกก็จะมีแค่

        • เพิ่มคำสั่งใน build.gradle
        • ทำการ Build Gradle แล้วนั่งรอจนเสร็จ
        • เรียกใช้งานไลบรารีได้เลย

        โอ้ว~! ชีวิตง่ายขึ้นเยอะเลย~♪

        โดยที่รูปแบบของ Maven จะมีลักษณะดังนี้

                <Group>:<Name>:<Version>

        จากตัวอย่างของไลบรารี FadingActionBar ก็จะแบ่งได้ดังนี้

                Group : com.github.manuelpeinado
                Name : fadingactionbar
                Version : 3.1.2

        โดยค่าตรงนี้ไม่จำเป็นต้องหาเอง เพราะไลบรารีที่เก็บไฟล์ไว้ที่ Maven Central Repositories จะมีบอกไว้ใน Readme ของไลบรารีให้แล้ว แต่ถ้าอยากรู้ว่าไลบรารีนั้นๆมีอยู่ใน Maven Central Repositories หรือไม่ ก็สามารถค้นหาได้จาก The Central Repositories โดยเอา Group หรือ Name ไปค้นหาก็ได้

        ส่วนการใช้งานแต่ละไลบรารีก็ไปหาดูที่เว็ปของไลบรารีนั้นๆนะ (แต่ส่วนมากจะมีอยู่ใน GitHub ด้วย)


        จึงสรุปได้ว่า Remote Dependencies เป็นประเภทที่มีไว้จัดการกับไลบรารีที่อยู่บน Maven Central ที่ต้องเชื่อมต่ออินเตอร์เน็ตเพื่อดาวน์โหลดมาใช้งาน และยังสามารถใช้กับอย่างอื่นนอกจาก Maven Central ได้อีกด้วยนะเออ อย่างเช่น jCenter และถ้าอยากเอาไลบรารีขึ้นไปไว้บนนั้นบ้าง ก็สามารถดูขั้นตอนได้ที่ วิธีการนำ Android Library ที่เขียนขึ้น jcenter และ Maven Central ผ่าน Android Studio ให้คนอื่นนำไปใช้งาน

ขั้นตอนการเพิ่ม Library แบบ Remote Dependencies

        ก็อธิบายไปแล้วเมื่อกี้ไง!!

จัดการกับ Dependencies ผ่าน Project Structure

        นอกเหนือจากการจัดการกับ Dependencies ที่ Gradle โดยตรงแล้ว ยังสามารถจัดการผ่าน Project Structure ได้อีกด้วย จะได้ไม่ต้องพิมพ์คำสั่งใน Gradle ให้ผิดๆถูกๆ

        โดยเลือกไปที่ File > Project Structure...

        ที่หน้าต่าง Project Structure ให้เลือกไปที่โมดูลหลักแล้วเลือกที่ Dependencies

        ให้กดที่ปุ่มรูปบวกสีเขียวที่อยู่ตรงขวามือของหน้าต่างแล้วจะมีให้เลือกว่าต้องการเพิ่ม Dependencies แบบไหน

        Library dependencies คือ Remote Dependencies
        File dependencies คือ Local Dependencies
        Module dependencies ก็ตามนี้น่ะแหละ

        สำหรับ Library dependencies จะมีข้อดีตรงที่สามารถใส่ชื่อ Package ของ Dependencies ที่ต้องการดึงจาก Maven Central ได้เลย

        ส่วน File dependencies จะเป็นการเลือกไฟล์ .jar/.aar ที่อยู่ในโมดูล ดังนั้นจะไฟล์ไลบรารีเข้ามาไว้ในโฟลเดอร์ libs เสียก่อน

        และ Module Dependencies เป็นการเลือกโมดูลของไลบรารี ดังนั้นจะต้องทำให้ไลบรารีเป็นโมดูลในโปรเจคนี้เสียก่อนถึงจะมีให้เลือก

        โดยการกำหนดค่า Dependencies ใน Project Structure นี้ โปรแกรมจะจัดกับการคำสั่งใน Gradle ให้เองโดยที่ผู้ที่หลงเข้ามาอ่านไม่จำเป็นต้องไปแก้ไขเอง

สรุปจบท้าย

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