แแฎแแ แแแกแฌแแแแแ แแฃ แ แแแแ แแแแแแแจแแ แแ แแแแ แแแแแก แขแแแแคแแแ USB-แแก แกแแจแฃแแแแแแ แแแแแแฃแขแแ แก แ แแแแ แช แแแกแแ แแ แแแแ แฉแแ แแแ แแแแแชแแแแ แแแแแชแแแ แแ แแแคแแ แแแชแแแก แแแแแชแแแ แคแแแจ แแ แแแแแก แแแแแงแแแแแแก แแแ แแจแ. แซแแแแแ แแแแคแแ แขแฃแแแ.
แแก แกแขแแขแแ แแแแแฃแแแแแแแ แงแแแแ แแ แแแแแกแแแแก, แ แแแแแแช แแฌแแ แแแแแก แขแแแแคแแแแแก Android 9/8/7/6: Samsung, HTC, Lenovo, LG, Sony, ZTE, Huawei, Meizu, Fly, Alcatel, Xiaomi, Nokia แแ แกแฎแแแแ. แฉแแแ แแ แแแ แ แแแกแฃแฎแแกแแแแแแแ แแฅแแแแก แฅแแแแแแแแแ.
แงแฃแ แแแฆแแแ! แกแขแแขแแแก แแแแแก แจแแแแซแแแแ แแแฃแกแแแ แแฅแแแแ แจแแแแแฎแแ แกแแแชแแแแแกแขแก.
แ แ แแ แแก MTP แ แแแแแ แแ แกแแ แฌแแแแแ USB แ แแแแแ?
Android 4.4 KitKat-แแแ แจแแกแแซแแแแแแ แแงแ USB-แแ แแแแแแจแแ แแแ แคแแแจ แแ แแแแแ. แแแแแแฃแขแแ แ แฎแแแแแแ แแแฌแงแแแแแแแแก, แ แแแแ แช แแแกแแฎแกแแแ แแแกแแก แแ แฃแแ แฃแแแแแงแแคแแ แแแแแ แฃแคแแแแแแก: แแแแฎแแแ แแแแแก แจแแแซแแ แกแฎแแ แแแฅแแแแแแแแแก แจแแกแ แฃแแแแแช.
แจแแแแแ แแแแ แแแแแก แแฎแแ แแแ แกแแแแจแ USB แ แแแแแ แจแแแชแแแแ MTP-แแ, แ แแแแแจแแช แแฎแแแแ แแแแแชแแแแ แแแแแชแแแแก แคแฃแแฅแชแแ แแแ แฉแ แแ แแแแแ แคแแ แแแขแแ แแแ แแ แแฃแจแแแแแ.
แขแแแแคแแแแก แแแแแแฃแขแแ แแแ แแแแจแแ แแก แแแงแแแแแ USB-แแก แกแแจแฃแแแแแแ
USB-แแก แกแแจแฃแแแแแแ แแแแแแฃแขแแ แแแ แแแแจแแ แแก แกแแแแ แแแแแ, แแญแแ แแแแแ. แแแแกแแแแแก แแแแแแขแแ แแแแงแแคแแแแแ โแแแแแแแแแ แแแแกแแแแกโ แแแแ แแแแแก แแแ แแแแขแ แแแก (แแฃ แแก แแ แแ แกแแแแแก):
- แแแฎแกแแแแ แแแ แแแแขแ แแแ.
- แแแแแแแ "แขแแแแคแแแแก แจแแกแแฎแแ" แแ "แแแฌแงแแแแแแแแก แจแแกแแฎแแ" แแแแงแแคแแแแแแจแ.
- "Build แแแแแ แ" แแ "MIUI แแแ แกแแ".
- แแแแญแแ แแ (แแแแฌแแแแฃแแแ) แแ แแ แแแฃแแแ, แกแแแแ แแ แแแแแแฎแแแ แจแแขแงแแแแแแแแก, แ แแ แแแฎแแแ แแแแแแแแแ แ (แฉแแแฃแแแแ แแ, แกแแแแแ แแกแแ 7-10 แแแฌแแแแฃแแแแ).
แแแก แจแแแแแ, แ แแช แแแแแแแแแ แแก แแแแงแแคแแแแแ แแแแแฉแแแแแ แแแ แแแแขแ แแแจแ, แจแแแแซแแแแ แฉแแ แแแ USB แแแแแ แแแ. แแแแแก แแกแ แฐแฅแแแ, แแกแ แ แแ แแฅแแแ แฃแแ แแแแ แฃแแแ แแแแแแขแแแแ แกแแแแแแ แ โOnโ แแแแแชแแแแ แแ แแแแแแกแขแฃแ แแ แแแ แฉแแแแแแแ.
แฒแแแแขแแแ
แแฎแแ แแฅแแแ แจแแแแซแแแแ แแแแแแแจแแ แแ แแแฌแงแแแแแแแ แแฅแแแแก แแแแแแฃแขแแ แก USB-แแก แกแแจแฃแแแแแแ แแ แแแ แฉแแแ แแฃแจแแแแแก แ แแแแแ. Android-แแก แฃแแฎแแแก แแแ แกแแแแจแ แงแแแแแแ แฎแจแแ แแ แแแแแแงแแแแแ:
- MTP - แแแแแกแแแแ แ แคแแแแแก แแแแแขแแแ แแแแแแฃแขแแ แแแแ แขแแแแคแแแแ แแ แแแ แแฅแแ.
- PTP - แคแแขแแแแแก แแแแแชแแแ, แแกแแแ แคแแแแแแแก แแแแแชแแแ, แ แแแแแแแช แแ แแ แแก แแฎแแ แแแญแแ แแแ MTP แ แแแแแจแ.
- แแฎแแแแ แแแแฃแฎแขแแ.
แแแแแแจแแ แแแ USB แแแฎแกแแแ แแแแก แ แแแแแจแ
แแฃ แแแ แแฉแแแแแ แแแแแ แคแแแแ แแก แแแแแงแแแแแแก, แแแฃแแ แฃแแแแ USB แแแฎแกแแแ แแแแก แ แแแแแก. แแแแกแแแแก แแแแญแแ แแแแแ:
- แแแแแกแขแแแแ แแแฃแแแ USB MASS STORAGE แฉแแแ แแแแแ.
แแ แแแแแแแก แแแแแงแแแแแแ แจแแแซแแแแ แแแแแแแแแก แกแแกแขแแแแก แคแแแแแแ. แแ แจแแแแฎแแแแแจแ, Android-แแก แแแแแขแแแ แแแ แแแแแฌแแแ.
Android-แแก แแแแแแฃแขแแ แแแ แแแกแแแก แกแแฎแแ แแแกแแแแแจแแ แแแแแ:
- แแแฃแจแแแ USB Mass STORAGE Enabler.
- แแแแแแญแแ แกแฃแแแ แแแแฎแแแ แแแแแก แฃแคแแแแแแ แแ แแแแแแแฎแแแ Selinux-แแก แแฃแจแแแแแก แแ แแแชแแแแก แจแแชแแแแก.
- แแฃ แแแฌแงแแแแแแแ แแฎแแ แแแญแแ แแแแ, แแแแแแแชแแแก แแแแแแ แ แแแแแฃ แแแแฎแกแแแแ.
- แแแแฌแแแแฃแแแ "USB แแแกแแแ แแแ แจแแแแฎแแแก แฉแแ แแแ".
แฒแแแแขแแแ
แแฎแแ, แ แแแแกแแช แแแแแแฃแขแแ แแแ แแ แแก แแแแแแจแแ แแแฃแแ, แขแแแแคแแแ แแ แขแแแแแขแ แแแแแฉแแแแแ แแแกแแแก แกแแฎแแ. MTP แแ PTP แ แแแแแจแ แแแกแแแแแจแแ แแแแแ, แฃแแ แแแแ แแแแแขแแแ แแแ แแแฌแงแแแแแแแ. แแแก แจแแแแแ แ แแช แแแแกแ แฃแแแแ แแแกแแแ แแแ แจแแแแฎแแแก แ แแแแแก, แแแแ แฃแแแแ แแแจแ แแ แแแแแ แแแ USB แแแกแแแ แแแ แจแแแแฎแแ.
USB แแแแแ แแแแก แ แแแแแ แแ แแก Android แแแแ แแชแแฃแแ แกแแกแขแแแแก แคแฃแแฅแชแแ, แ แแแแแแช แแแแแฃแแแแแแแ แแแแแแแชแแแแแก แแแแแแแแแ แแแแกแแแแก. แแฃแแชแ, แกแแแแแแ แฎแจแแ แแ แแก แแฃแชแแแแแแแแ แฉแแแฃแแแแ แแแ แแแแฎแแแ แแแแแแแกแแแแกแแช. แ แแแแ แช แฌแแกแ, แแ แ แแแแแแก แฉแแ แแแแก แแฃแชแแแแแแแแ แฉแแแแแ แแ แแแ แแแแแแแฃแ แ แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แแแกแขแแแแชแแแกแแก แแ แแแแแชแแแแ แกแแ แแแแ แแ แแกแแแก แจแแฅแแแแกแแก.
แแ แกแขแแขแแแจแ แแแแแแฎแแแแแ แแ แแแแก, แ แแแ แฉแแ แแแ USB แแแแแ แแแแก แ แแแแแ Android แขแแแแคแแแแ แแ แขแแแแแขแแ. แแแ แแแแ แแแแแแ แแ แแก แแแแแแ แ, แแก แแฃแจแแแแก แฃแแแขแแก แแแแแแแแ แแแ แแแฌแงแแแแแแแแแแ. แแแแ แ แแแแแแ แจแแกแแแแแแกแ แแฅแแแแ Android-แแก แซแแแแ แแแ แกแแแแแก แแฅแแแ แแแฌแงแแแแแแแแแแกแแแแก.
Android-แแ USB แแแแแ แแแแก แ แแแแแแก แฉแแ แแแแก แซแแ แแแแแ แแแแแแ
แแแ แแแ แ แแแจแ, แฉแแแ แแฆแแฌแแ แ Android-แแ USB แแแแแ แแแแก แ แแแแแแก แฉแแ แแแแก แแแแแแ แแแแก. แแก แแแแแแ แแฃแจแแแแก แงแแแแ Android แแแฌแงแแแแแแแแแ Android แแแ แกแแแ, แ แแแแ แแชแแ 4.0, 5.0, 6.0 แแ 7.0. แแฃ แแแฅแแ แแแแ แแแแ Google-แแก แแ แแแแแแแฃแ แ แแแ แกแแ, แแแจแแ แแแฅแแแแแ แงแแแแแคแแ แ, แ แแแแ แช แฅแแแแแ แแแชแแแฃแ แแแ แแแแก แกแฃแ แแแแแจแ. แแฃ แแฅแแแ แแแฅแแ แแแแกแฎแแแแแแฃแแ แญแฃแ แแ, แแแแแแแแแ, แญแฃแ แแ แแฌแแ แแแแแแแกแแแ, แแแจแแ แจแแแซแแแแ แแงแแก แแชแแ แ แแแแกแฎแแแแแแแแ. แแแแ แแ, แแแแแแแ, แงแแแแแคแแ แ แแแแฅแแแก แแแแแแ.
แแแแแฏแ No. 1. แฉแแ แแแ แแแแแแแแแ แแก แ แแแแแ.
แแกแ แ แแ, แแแแกแแแแแก, แ แแ แฉแแ แแแ USB แแแแแ แแแแก แ แแแแแ Android-แแ, แฏแแ แแญแแ แแแแแ. แแแแกแแแแแก แแแฎแกแแแแ Android-แแก แแแ แแแแขแ แแแ, แแแแแแฎแแแแ แแแแแแแ แแ แแแฎแกแแแแ แแแแงแแคแแแแแ โแขแแแแคแแแแก แจแแกแแฎแแโ (แแ แแแแงแแคแแแแแ โแขแแแแแขแแก แจแแกแแฎแแโ, แแฃ แแฅแแแ แแแฅแแ แแแแแจแแขแฃแ แ แแแแแแฃแขแแ แ แแ แแ แ แขแแแแคแแแ).
แแแแงแแคแแแแแแก "แขแแแแคแแแแก แจแแกแแฎแแ" แแแฎแกแแแก แจแแแแแ, แแฅแแแ แฃแแแ แแแแแแฎแแแแ แงแแแแ แแแ แแแแขแ แ แแแแแแแ. แแฅแแแแ แฎแแแ แกแแฎแแแฌแแแแแแ "Build Number". แแแแแแแแแ แแก แ แแแแแแก แแแกแแแฅแขแแฃแ แแแแแ, แแฅแแแ แฃแแแ แแแแฌแแแแฃแแแ แแแแแแแ แ แแแแแแฏแแ แแ แฎแแแแ, แ แแแแแจแแช แแแชแแแฃแแแ แแแคแแ แแแชแแ แแจแแแแแแก แแแแ แแก แจแแกแแฎแแ.
5-10 แกแฌแ แแคแ แแแฌแแแแฃแแแแแก แจแแแแแ แแแแแฉแแแแแ แจแแขแงแแแแแแแ, แ แแ แแฅแแแ แแแฎแแแ แแแแแแแแแ แ. แแก แแแจแแแแก, แ แแ แแแ แแแแขแ แแแจแ แแแแแฉแแแ แแแแงแแคแแแแแ โแแแแแแแแแ แแแแกแแแแกโ แแ แแฎแแ แจแแแแซแแแแ แฉแแ แแแ USB แแแแแ แแแแก แ แแแแแ.
แแฃ แแแแแแแแแ แแก แ แแแแแ แฃแแแ แฉแแ แแฃแแแ, แแแจแแ แแแฎแแแ แจแแขแงแแแแแแแแก, แ แแ "แแฅแแแ แฃแแแ แฎแแ แ แแแแแแแแแ แ" แแ แแ แแญแแ แแแแแ แแ แแคแ แแก แฉแแ แแแ, แแก แแกแแแ แแแจแแแแก, แ แแ แแแแงแแคแแแแแ "แแแแแแแแแ แแแแกแแแแก" แแฅแขแแฃแ แแ แแ แแแกแ แแแฎแกแแ แจแแกแแซแแแแแแแ.
แแแแแฏแ #2: แฉแแ แแแ USB แแแแแ แแแแก แ แแแแแ.
แแแแแแแแแ แแก แ แแแแแแก แฉแแ แแแแก แจแแแแแ, แจแแแแซแแแแ แแแแแ แซแแแแ USB แแแแแ แแแแก แ แแแแแแก แฉแแ แแแ. แแแแกแแแแแก แแแแ แฃแแแแ Android-แแก แแแ แแแแขแ แแแแก แแแแแแ แแแแแฃแจแ แแ แแแแแแแ แกแแแก แแแแแแแ. แแฎแแ, "แขแแแแคแแแแก แจแแกแแฎแแ" แแแแงแแคแแแแแแก แแแแ แแแ แฃแแแ แแแแแฉแแแแก แแแแงแแคแแแแแ "แแแแแแแแแ แแแแกแแแแก". แกแฌแแ แแ แแ แแแแงแแคแแแแแแจแแ แแแแแแแกแแแฃแแ USB แแแแแ แแแแก แ แแแแแ, แแกแ แ แแ แแแแแกแฃแคแแแ แแแฎแกแแแแ แแแ.
"แแแแแแแแแ แแแแกแแแแก" แแแแงแแคแแแแแแจแ, แแฅแแแ แฃแแแ แแแแแฎแแแแแ แแแ แแแแขแ แแแแก แแแแแ, แ แแแ แแแฎแแแแ "แแแแแ แแแแก" แแแแแจแ.
แแฅ, "แแแแแ แแแแก" แแแ แแแแขแ แแแแก แแแแแแก แแแแ แแแฌแแแจแ แแฅแแแแ แคแฃแแฅแชแแ แกแแฎแแแฌแแแแแแ "USB แแแแแ แแแ". แฉแแ แแแ แแ แแแแแ แแแแก แ แแแแแ แแแฃแจแแแแแก.
แฉแแ แแแ USB แแแแแ แแแแก แ แแแแแ Android-แแก แซแแแ แแแ แกแแแแแ
แแฃ แแฅแแแ แแแฅแแ แแแแ แแแแแก แขแแแแคแแแ แแแแ แแแแแก แฃแคแ แ แซแแแแ แแแ แกแแแ, แแแแแแแแแ, Android 2.0, แแแจแแ แแฅแแแแก แจแแแแฎแแแแแจแ USB แแแแแ แแแแก แ แแแแแ แฉแแ แแฃแแ แแฅแแแแ แกแ แฃแแแแ แแแแกแฎแแแแแแฃแแ แแแแ. Android-แแก แซแแแ แแแ แกแแแแจแ, แแแแกแแแแแก แแฅแแแ แฃแแแ แแแฎแกแแแ แแแ แแแแขแ แแแ, แแแแแแแ "แแแแแแแชแแแแแก" แแแแงแแคแแแแแแจแ แแ แจแแแแแ แแแฎแกแแแแ "แแแแแแแแ แแแแก" แแแแงแแคแแแแแ.
แแแแก แจแแแแแ, แแฅแแแ แฃแแแ แฉแแ แแแ USB แแแแแ แแแ แแ แแแแแแกแขแฃแ แแ แแแ แแแแขแ แแแแก แชแแแแแแแ แฆแแแแแแ "แแแแฎ" แแแญแแ แแ.
USB (แฃแแแแแ แกแแแฃแ แ แกแแ แแฃแแ แแแขแแแฃแกแ)- แกแแขแงแแแกแแขแงแแแ "แฃแแแแแ แกแแแฃแ แ แกแแ แแฃแแ แแแขแแแฃแกแ". แแก แแ แแก แแแแแชแแแแ แแแแแชแแแแก แกแแ แแฃแแ แแแขแแ แคแแแกแ, แ แแแแแแช แคแแ แแแ แแแแแแงแแแแแ แแแแฅแขแ แแแแแแกแ แแ แแแแแแแแแแจแ แแ แแ แช Android แแแแ แแชแแฃแแ แกแแกแขแแแแแ แแแคแฃแซแแแแฃแแ แแแแแแฃแ แ แแแฌแงแแแแแแแแแแ แแแแแแแแแแกแ. แแฃแแชแ, แงแแแแแคแแ แ แงแแแแแแแแก แกแแแแแ แแกแแ แจแแฃแคแแ แฎแแแแแ แแ แแแแแก, แจแแแซแแแแ แแแ แแแแฃแแ แแ แแแแแแแแ แฌแแ แแแแจแแแก.
แแฃแแชแ แงแแแแแคแแ แ แ แแแแแ. แแแ แแแแ, แแแแแ แแแแ แแแแแ, แ แ แขแแแแก USB แแแแแฅแขแแ แแแ แแ แกแแแแแก. แกแฃแ แฎแฃแแ แแแแแแแแ:
แแแ แชแฎแแแแแ แแแ แฏแแแแ: microUSB, miniUSB, B แขแแแแก, A แขแแแแก "แแแแ", A แขแแแแก "แแแแ".
microUSB- แแแแแฅแขแแ แแแแแแ แงแแแแแแ แแแขแแ แ, แ แแแแแแช แแแแแแงแแแแแ แแแแแแขแฃแ แฃแ แแแแฅแขแ แแแฃแ แแแฌแงแแแแแแแแแจแ, แ แแแแ แแชแแ แกแแแ แขแคแแแแแ, แขแแแแคแแแแแ, แแแแแจแแขแฃแ แ แแแแแแฃแขแแ แแแ, แแแแฅแขแ แแแฃแแ แฌแแแแแแฎแแแแแแ แแ แ.แจ. แแแแ แแ แแก แแก แงแแแแแแ แแแขแแ แแแแ แชแแแแ แแแแ แแแแแก แแแฌแงแแแแแแแแแจแ แแแกแ แแ แแแแแคแแ แแแแแแแก แแแแ, แแ แแฅแขแแแฃแแแ แแแแชแแแแแก miniUSB-แก.
miniUSB- แแแแแ แแฆแแแแขแแแ microUSB-แก, แแแแ แแ แแกแแแ แแแแแแงแแแแแ แแชแแ แ แแแแฅแขแ แแแฃแ แแแฌแงแแแแแแแแแจแ. แแฆแแก แแก แแ แแฅแขแแแฃแแแ แแ แแแแแแงแแแแแ Android-แแก แแ แแแแแ แแแฃแ แแแแแจแแขแแแกแ แแ แกแแแ แขแคแแแแแจแ, แแฃแแชแ แแแ แ แคแแ แแแ แแงแ แแแแ แชแแแแแฃแแ. แแฃแแชแ, แแก แแแฎแแแแแ แฉแแแฃแ แแแฌแงแแแแแแแแแจแ, แฃแคแ แ แแแขแแช, แแแกแ แกแแแแคแแกแ แแ แกแแแแ แขแแแแก แแแแ, แแแแแ แ แแแแแแแแ แชแแแแแแ แฉแแแแแ แแฌแแ แแแแแแแ แฃแแ แฃแแแแแ miniUSB-แก, แแแ แแแฌแงแแแแแแแแแจแ microUSB-แแก แแแงแแแแแแก แแแ แแแแฃแแ แแแ แแแแแก แจแแแแแ. แงแแแแแแ แฎแจแแ แแ แแแฎแแแแแ แแแแแ แแแจแ, แแแแแแแแแแ แแแจแ แแ แ.แจ.
B แขแแแแกโ แแแแแฅแขแแ แ, แ แแแแแแช แงแแแแแแ แฎแจแแ แแ แแแฎแแแแแ แแ แแแขแแ แแแจแ, แกแแแแแ แแแจแ แแ แแแแแแฃแขแแ แแก แกแฎแแ แแแ แแคแแ แแฃแ แแแฌแงแแแแแแแแแจแ, แ แแแแกแแช แแแแแก แแแแแแแแแ แแ แแฅแแก แแแแจแแแแแแแ.
แฒขแแแโแแแแโ (แแแแฆแแแ) โ แแแแแฅแขแแ แ, แ แแแแแแช แแแแแแขแแแแแฃแแแ แแแ แกแแแแแฃแ แแแแแแฃแขแแ แแแแ แแ แแแแฏแแ แขแแแแแขแแแแ A- แขแแแแก แแแแแฅแขแแ แแก แแแกแแแแแจแแ แแแแแ. แแ แขแแแแก แแแแแฅแขแแ แ แแกแแแ แจแแแแซแแแแ แแแฎแแ USB แแแคแแ แแแแแแก แแแแแแแแจแ แแ USB OTG แแแแแแแแจแ.
แฒขแแแโแแแแแแโ (แจแแแแ แแแแแแ) โ แจแแกแแแแแแก A-แขแแแแก แแแแฆแแแแแ แแแกแแแแแจแแ แแแแแ.
แชแแแแ แแฆแแแจแแแแก แฆแแ แกแแ USB 2.0 แกแแแชแแคแแแแชแแแก แแแคแแ แแแแแ - USB OTG (USB On The Go), แ แแแแแแช แจแแฅแแแแแแ USB แแแ แแคแแ แแฃแแ แแแฌแงแแแแแแแแแแก แแ แแแแแแแแแ แแแแแแแ แแแกแแแแแจแแ แแแแแ. แแก แแแแกแแแฃแแ แแแแ แแฎแแแ แขแแแแแข แแแแแแฃแขแแ แแแก, แกแแแ แขแคแแแแแก, แแแแฅแขแ แแแฃแ แแแแแฎแแแแแแก แแ Android-แแ แแแคแฃแซแแแแฃแ แกแฎแแ แแแฌแงแแแแแแแแแก, แ แแแแแ แแ แกแแแชแแคแแแแชแแแก แแฎแแ แแแญแแ แแ แแ แจแแกแแแแแแกแ USB OTG แแแคแแ แแแแแแก แแแแแขแแ แแ, แจแแแแซแแแแ แแแ แแแแแ แแแแแแแจแแ แแ แคแแแจ แแ แแแแแแ, แแแแแ แแแ, แแแ แ USB HDD แแ แ.แจ. แแแแแแฃแ แแแฌแงแแแแแแแแแ แจแแแแแแ.
แแกแแแ แแ แกแแแแแก แแแแแ แ แแแ แกแแแฃแแ แแแแก USB แแแแแฅแขแแ แแแ, แ แแแแแแแช แจแแฅแแแแแแ แชแแแแแฃแแ แแแแแแแแแแแก แแแแ , แแแแ แแ แแก แแ แแฅแขแแแ แแแแแแแแ แฌแแ แกแฃแแก แฉแแแแ แแ - แแแแแแแแแแจแ แแแแแ แ แแฎแ แแแ แฃแแแแแ แกแแแฃแ แ แแแแแฅแขแแ แแแแกแแแ แแ แแก แแ แแก แแแ แแแแฃแแ แแแฃแกแ.
แแฎแแ แแแแแ แแแแแ แแแแแ, แ แ แฃแแแ แแแแแแแแแ, แแฃ Android แแแฌแงแแแแแแแแก USB แแแแแแแก แกแแจแฃแแแแแแ แแแแแแฃแขแแ แแแ แแแแแแจแแ แแแแกแแก, แแแแแแฃแ แ แแแฌแงแแแแแแแ แแ แแ แแก แแแแแแแแแแแ, แแ แแแแ แแฎแแแแ แแแขแแแแแแ (แแก แฃแแแแแกแแแแแ แแแฃแแแแแแก แแแแแฅแขแแ แแก แแแแแแแแแแแ - แแแแ แแแ แแแแฌแแแแแ แแก).
แแแ แแแ แ แแแจแ, แแ แฏแแ แแแแแแแแแฌแแแ, แแ แแก แแฃ แแ แ แฉแแแ แแแแแ แแแแแจแแฃแแ "แแแ แแแแขแ แแแจแ" - "แแแแแแฃแขแแ แแแ แแแแแแจแแ แแแ" - "แแแแฎแแ". แแฃ แแแแแกแขแแแแ แแแฃแแแ, แกแชแแแแ แแแกแ แแแแฆแแแ แแ แฎแแแแฎแแ แแแกแขแแแแชแแ.
แแฃ แแก แแ แแแแแแฎแแแ แ, แฉแแแ แแชแแแแแแ แแแแแแแงแแแแ แกแฎแแ USB แแแแแแ (แฉแแแฃแ แ แแแแฃแกแขแ แแแก แกแแกแฌแแฃแแแแ แแแแกแแแฃแแ แแแแ แแแแ แแแแแแ แฌแแ แฃแแแขแแแแแแแกแแแ), แแแแแแแจแแ แแ แแแ แแแแแแฃแขแแ แแก แกแฎแแ USB แแแ แขแแแ (แ แแแแแแแแแแฃแแแ แแแแแแงแแแแ แแแ แขแแแ, แ แแแแแแแช แแแแแแ แแแแก แฃแแแแ แแฎแแ แแก. แกแแกแขแแแแก แแ แแแฃแแแก, แแฃ แฉแแแ แแกแแฃแแ แแแ แแแกแแขแแ แแแแแแฃแขแแ แแ, แ แแแแแ แแก แแแ แขแแแ แแแ แแแแแ , แแแคแแ แแแแแแก แแแแแแแแแก แแแ แแจแ, แจแแแฃแฆแแแฃแแแ แแแแแแแแขแแ), แกแแแแแแแ, แกแชแแแแ แกแฎแแ แแแแแแฃแขแแ แแก แแแแแแจแแ แแแ, แแฃ แแก แจแแกแแซแแแแแแแ. แแฃ แแแแแ แฉแแแแแแแแแแแแแ แแ แชแแ แแ แแ แแแแแแฎแแแ แแแ, แจแแแแซแแแแ แกแชแแแแ แคแแแจ แแแ แแแแก แจแแชแแแ แกแฎแแ แแแ แแแแ. แแกแแแ แแ แแ แแก แ แแแแแแแแแแฃแแ แ แแแแ แแแแแแขแ แแแแแแงแแแแแแแก แแ แแแคแแ แแแแแแก แกแแแแแแแแก แแแแแงแแแแแ - แซแแแแแ แฎแจแแ แแ แแกแแแ แแ แแแ แแ แแแแแแแก แแแแแแ.
แฏแแ แแแแแ แแแฅแแ แแ แแแแแแแแ แแฅแแแแก แแแแแแฃแขแแ แแแ USB-แแ แแแแแแจแแ แแแแกแแก? แแ แแแแแแ แแ แแ แแก, แแก แแแแแแแก. แฉแแแ แแแ แซแแแแแ แแ แแฎแกแแแ Task Killer-แก, แแฃ แแก แแแแแกแขแแแแ แแแฃแแแ, แแ แแแแแขแแแ โแกแแแฅแ แแแแแแชแแแก แแแแแแฃแขแแ แแแโ แแแแแแแแแแกแแแแก แกแแแจแ - แแ แแแแแแแชแแแ แจแแแซแแแแ แฃแแ แแแแ แแฃแแ แซแแแแก แแแฌแงแแแแแแแแก แแแแแแฃแขแแ แแแ แกแแแฅแ แแแแแแชแแ. แแกแแแ แจแแแแซแแแแ แกแชแแแแ USB แแแแแ แแแแก แฉแแ แแแ. แแก แแแแแแแขแ แแแแแแ แแแแก แแแแแฃแจแ "แแแ แแแแขแ แแแ" - "แแแแแแแชแแแแ" - "แแแแแแแแ แแแ":
แแฃ แแ แแแแแแฃแ แ แแแฌแงแแแแแแแ Samsung-แแก แแแแแแฃแ แ แแแฏแแขแแ แแ แแแแแแฃแขแแ แ แแแก แแ โแฎแแแแแกโ แแ แช Kies-แแก แแ แแ แช Odin-แแก แกแแจแฃแแแแแแ, แแแจแแ แฃแแแ แกแชแแแแ แแแแแแแแ แแแแแฆแแ Kies, แงแแแแ แซแแแแ Samsung แแ Samsung PC Studio แแ แแแแแ แ แแ แจแแแแแ แแกแแ แแแแแแกแขแแแแ แแ Kies. . แแแแแ แแฎแแแ HTC แแแฌแงแแแแแแแแแก แกแแแฃแแ แแแแจแ แแ แกแแแฃแแ HTC Sync แแ แแแ แแแแ.
USB แแแฌแงแแแแแแแแกแแแแก แแ แแแแแ แแก แฎแแแแ แแ แฉแแแ แแกแแแ แจแแแซแแแแ แแแแแแฎแแแ แแก. แแแแกแแแแแก แแแแแแแ "แแแฌแงแแแแแแแแก แแแแแฏแแ แจแ" Windows-แแก "แแแแแแจแ". แฉแแแ แแแซแแแ แแ แแแแแแฃแ แแแฌแงแแแแแแแแก - แแก แแแแแฉแแแแแ แซแแฎแแแแก แแแจแแแ. แแแแฌแแแแฃแแแ แแแกแแ แแแ แฏแแแแ แฆแแแแแแ แแ แแแ แฉแแแ "แแแแแฎแแแแ แแ แแแแแ แ" - "แแแ แฉแแแ แแ แแแแแ แแก แแแกแขแแแแชแแ แแฅแแแแ แแแแแแฃแขแแ แแแแ" - "แแแ แฉแแแ แแ แแแแแ แแแ แฃแแแ แแแแแกแขแแแแ แแแฃแแแแแ". แกแแแจแ แแแ แฉแแแ แฃแแแแแ แกแแแฃแ แ USB แแแแขแ แแแแ แ - แแแแแแแแขแฃแ แ USB แแแฌแงแแแแแแแ (แแแแฏแแ Microsoft-แแก แแ แแแแแ แแช แจแแแซแแแแ แแงแแก แจแแกแแคแแ แแกแ). แแแแก แจแแแแแ, แกแแกแขแแแ แแแขแแแแขแฃแ แแ แแแแแแกแขแแแแ แแแก แแ แฉแแฃแ แแ แแแแแ แก แแ แแแฌแงแแแแแแแแก แแแแแงแแแแแ แจแแกแแซแแแแแแแ USB แคแแแจ แแ แแแแแก แ แแแแแจแ. แแฃ แแแฃแแแแแแแแ แจแแแแฅแแแแ แจแแชแแแแ "แกแแแแแแแแก แชแแกแคแแ แ แแแ แแแแ", แแฅแแแ แฃแแแ แแแแแขแแแ แแแ แแแแแแฃแขแแ แ แฃแกแแคแ แแฎแ แ แแแแแจแ แแแฌแงแแแแแแแแก แแแแแ แแแแก แแแ แแจแ. Windows-แแก แฃแกแแคแ แแฎแ แ แแแแแจแ แฉแแขแแแ แแแแก แจแแแแแ, แแแซแแแแแ แฉแแแแ แแแแแแฃแ แ แแแฌแงแแแแแแแ Device Manager-แจแ, แแแแฌแแแแฃแแแ แแแกแแ แแแ แฏแแแแ แฆแแแแแแ แแ แแแแแฆแแ แแ แแแแแ แ. แแแแก แจแแแแแ, แจแแแแซแแแแ แกแชแแแแ แกแฎแแ แแ แแแแแ แแก แกแแกแขแแแแจแ โแฉแแแแขแแแ แแแโ USB-แกแแแ แแแแแแจแแ แแแฃแ แแแฌแงแแแแแแแแกแแแ แแฃแจแแแแแกแแแแก - แ แแก แจแแแแแแแช แแก แจแแแซแแแแ แฉแแแฃแแแแ แแ แแแแแแแแแแแก.
แแแ แแ แแแแกแ, แจแแแแซแแแแ แแแแแแกแขแแแแ แแ Android USB แแ แแแแแ แ. แแกแแแ, แแ แแแ แแแแแแก แฃแแแขแแกแแแ Android แแแฌแงแแแแแแแแก แแแ แกแแแแแฃแ แแแแแแฃแขแแ แแแ แกแแแฅแ แแแแแแชแแแกแแแแก, แ แแแแ แแชแแ HTC Sync แแ Samsung Kies, แแงแแแแแก แกแแแฃแแแ แแ แแแแแ แแแก. แแแแจแแแแแแแแแแ - แฉแแแ แแแ แฉแแแ แแแแแ แแแ แแแขแแแแ แฃแกแฃแแ แแ แแแ แแแแแ แแแแแแฃแขแแ แแแแ แแ แแแแแ แแแแก แแแงแแแแแแกแแก.
แแแแฏแแ แฅแแ แฎแแฃแ แแแ แแแแขแ แแแแ แแแแแขแแแ แแแ (แ.แฌ. wipe) แแแแแแฃแ แ แแแฌแงแแแแแแแแก แแแ แแแแขแ แแแแก แแ แแฆแแแแแแก แ แแแแแแก แแแจแแแแแแ แแแแแฎแแแ แแแแ. แแแแแขแแแ แแแ แฌแแจแแแก แแแแฎแแแ แแแแแก แแแแ แแแแแกแขแแแแ แแแฃแ แงแแแแ แแแแแแแชแแแก แแ แแฆแแแแแแก แฅแแ แฎแแฃแ แแแ แแแแขแ แแแก.
แแแแแแจแแฌแแแแแแ แแแฌแงแแแแแแแแแแก แแ แแแแแ แแแแก แกแฌแแ แแ แแแแฆแแแ แแฅแแแแ แแแ แกแแแแแฃแ แ แแแแแแฃแขแแ แแแแ, แกแแแแ แฎแแแแฎแแ แแแแแแกแขแแแแ แแแ. แแกแแแ แฎแจแแ แแ แแแแแแแ Device Manager-แจแ, แ แแแแ แช แแ แแแฌแงแแแแแแแ แแแแแ แแฃแแแ แแ แแแแแแแแก แแ แซแแแแแแก แแแแแแแแก แจแแกแแฎแแ. แฎแจแแ แแ, แแแแแ แกแแฎแแแฌแแแแแแก แแ แแแแแ แแแก แจแแฃแซแแแแ แแแแคแแแฅแขแ แแแ แกแแแแแก แจแแฃแกแแแแแแแแก แแแแ. แแแแแ, แแแแแฌแงแแ แแแแแฃแงแแแแแแแ แแแฌแงแแแแแแแแแแก แกแแแก แแแกแฃแคแแแแแแ, แ แแช แฎแจแแ แแ แจแแแซแแแแ แแงแแก แแแแ แแแแแก แแแฏแแขแแก โแฃแคแฃแแฅแชแแแแแกโ แแแแแแ, แ แแแแกแแช แแก USB-แแ แแ แแก แแแแแแจแแ แแแฃแแ. แแแ แแแ แ แแแจแ, แแแแแจแแ แงแแแแ แแแ แ USB แแแฌแงแแแแแแแ แแแแแแฃแขแแ แแแแ. แจแแฅแแแแแ แแแ แแแแก แชแแแแแ DEVMGR_SHOW_NONPRESENT_DEVICES แแแแจแแแแแแแแ 1. แแแแกแแแแแก แแแแฌแแแแฃแแแ แแแฃแกแแก แแแ แฏแแแแ แฆแแแแแแ "แฉแแแ แแแแแแฃแขแแ แ", แแแ แฉแแแ "แแแแกแแแแแ", "Advanced", แแแแฌแแแแฃแแแ "Environment Variables". แคแแแฏแแ แแจแ, แ แแแแแแช แแฎแกแแแแ, แแแแญแแ แแ แฆแแแแแก "แจแแฅแแแ" แแแแ. "แชแแแแแแก แกแแฎแแแ" แแแแจแ แจแแแงแแแแแ:
DEVMGR_SHOW_NONPRESENT_DEVICES
"แชแแแแแ แแแแจแแแแแแแ" แแแแจแ แจแแแงแแแแแ, แจแแกแแแแแแกแแ, 1. แแแแฌแแแแฃแแแ แแ แฏแแ "OK" แแแแแฃแก แแแกแแฎแฃแ แแแแ.
แแ แชแแแแแแก แจแแฅแแแแ, Device Manager แแฉแแแแแแก แกแแกแขแแแแจแ แแแแแกแขแแแแ แแแฃแ แงแแแแ แแ แแแแแ แก, แแแ แจแแ แแก แคแแ แฃแแก แแ แแแ, แแแแช แแแแกแแ แแแแแแจแแ แแแฃแแ แแแ แกแแแแแฃแ แแแแแแฃแขแแ แแแ.
แแแแแแแ "แแแฌแงแแแแแแแแก แแแแแฏแแ แจแ", แแแแแฃแก แแฃแแฅแขแจแ "แแแฎแแ" แแแ แฉแแแ "แแแแแแฃแแ แแแฌแงแแแแแแแแแแก แฉแแแแแแ". แแฎแแ แแฅแแแ แจแแแแซแแแแ แแแแฌแงแแ แแแแ แแชแแฃแแ แกแแกแขแแแแก แแแฌแแแแแ แกแฎแแแแแกแฎแแ โแแแแแแกแแแโ. แแแ แแแแ, แแแฎแกแแแแ แแแแงแแคแแแแแ "แแแกแแแก แแแฌแงแแแแแแแแแ". แแแฃแแแกแ แแกแแ, แ แแ แงแแแแ แฏแแ แแ, แ แแชแ แแฎแแ แคแแแจ แแ แแแแก แแแแแจแแ แแแ, แแแกแแแแก แแฎแแแ แแ แแแแแ แ แแแกแขแแแแ แแแฃแแแ แแ แแก แแแกแขแแแแ แแแฃแแแ แแแจแแแแช แแ, แแฃ แแแแแแแจแแ แแแ แแแแแ แคแแแจ แแ แแแแก, แแแแ แแ แกแฎแแ USB แแแ แขแก. แงแแแแ แแแแแ แแฃแแ แแแกแแฎแกแแแแ แแแแแแก แแ แแแแแ แแแแก แฃแกแแคแ แแฎแแ แแแแฆแแแ แจแแกแแซแแแแแแแ, แ แแแแแ แแแแแแฃแขแแ แแแ แแแแแแจแแ แแแแกแแก แแแแแแแก แแ แแแแแ แแแ แฎแแแแฎแแ แแแแแกแขแแแแ แแแแ. แแ แแ แแแแแ แแแก แจแแ แแก, แแกแแแ แจแแแแซแแแแ แแแแแแ แแฅแแแแ Android แแแฌแงแแแแแแแแก แแ แแแแแ แ, แจแแกแแซแแแ แแ แแกแฌแแ แแ แแแแแกแขแแแแ แแแฃแแ แแ แจแแกแแซแแแ แแ แแแ แแแขแแช แแ. แแก แฉแแแแฌแแ แแแ แแกแแแ แจแแแซแแแแ แฃแกแแคแ แแฎแแ แฌแแแจแแแแก, แ แแแแแ แแแ แจแแแซแแแแ แแ แแแแแแแแ แจแแฃแฅแแแแ - แแแแแกแแแแ แจแแแแฎแแแแแจแ, แ แแแแกแแช แฎแแแแฎแแ แแแแแแแจแแ แแแ แแ แกแแแฃแ Android แแแฌแงแแแแแแแแก, แแแกแ แแ แแแแแ แ แฎแแแแฎแแ แแแแแกแขแแแแ แแแแ แแ แแแแฎแแแ แแแแแก แแแแแฎแแแแแ แแแกแ แแแกแขแแแแชแแ. "แแแแแแฃแแ" แแแฌแงแแแแแแแแแแก แแแแงแแคแแแแแแจแ แจแแแแซแแแแ แฌแแจแแแแ แแแกแแแฃแขแฃแ แแ แงแแแแ แคแแ แฃแแ (แแแชแ แแกแคแแ แ) แแแฌแงแแแแแแแ, แ แแแแแ แแก แกแฎแแ แแ แแคแแ แแ แแฃ แแ แ แแแฌแงแแแแแแแแกแแแแก แแ แแแแแ แแก แแแงแแแแแแก แฌแแ แฃแแแขแแแแแ แแชแแแแแแแแ แแ แแกแแแ แแแแแแแแแ แแ แแ แแก แกแแญแแ แ แกแแกแขแแแแจแ. "แจแแแแฎแแแก แขแแแแแแก" แแแแงแแคแแแแแแจแ แแกแแแ แจแแแแซแแแแ แฌแแจแแแแ แงแแแแ แคแแ แฃแแ (แแแชแ แแกแคแแ แ) แฉแแแแฌแแ แ, แ แแแแแ แแก แแ แแก "แแกแ" แแแแแญแแแฃแแ แแแ แ แแแแแแจแแ แแแฃแ แคแแแจ แแ แแแแแแแ - แแแแแกแแแแ แจแแแแฎแแแแแจแ, แ แแแแกแแช แคแแแจ แแ แแแแ แแแแแ แแแแแแจแแ แแแแ, แแกแแแ แแแแแ แแแแแญแแแฃแแ แแฅแแแแ. แฃแแแแแ แกแแแฃแ แ แกแแ แแฃแแ แแแขแแแฃแกแแก แแแแขแ แแแแ แแแแก แแแแงแแคแแแแแแจแ แจแแแแซแแแแ แฌแแจแแแแ แงแแแแ แคแแ แฃแแ (แแแชแ แแกแคแแ แ) แแแฌแงแแแแแแแ. แแแแ แแชแแฃแแ แกแแกแขแแแแก แแ แแกแแญแแ แ แแ แแแแแ แแแแกแแแ แแแฌแแแแแแก แจแแแแแ, แแแแแขแแแ แแแ แแแแแแฃแขแแ แ. แแแแแขแแแ แแแแก แจแแแแแ แแแแแแจแแ แแแ แแแแ แแแแแก แแแฌแงแแแแแแแแก, แแก Windows แแแแ แแชแแฃแแ แกแแกแขแแแแก แแแแ แแฅแแแแ แแแแแแแแแแแ, แ แแแแ แช แแฎแแแ แแแฌแงแแแแแแแ แแ แแแขแแแแขแฃแ แแ แแแแแกแขแแแแ แแแแ แแ แแแแแ แแแ, แแ แจแแแแซแแแแ แฎแแแแ แแแแแแกแขแแแแ แแ แกแแญแแ แ แแ แแแแแ แแแ. แแแแแแฃแขแแ แแก แแแแแ แแ แแ แแแแแขแแแ แแแแก แจแแแแแ, แแแแคแแแฅแขแฃแ แแ แแแแแ แแแแแ แแแแแแจแแ แแแฃแแ แงแแแแ แแ แแแแแแ แฌแแ แกแฃแแจแ แฃแแแ แแแ แฉแแก.
Android แแ แแก แแแ แขแแแ แแแแแกแแงแแแแแแแ, แแแแ แแ แจแแแชแแแก แแแแ แคแแ แฃแ แคแฃแแฅแชแแแก แแแฌแแแแแ แแแแฎแแแ แแแแแแแกแแแแก. แแแแ แ แแแแแแแ แแแแแแฃแแแ แแแแแแแแแ แแก แแแ แแแแขแ แแแแก แแแแแฃแจแ. แ แแแแ แช แกแแฎแแแแแแ แฉแแแก, แแก แคแฃแแฅแชแแแแ แกแแกแแชแแชแฎแแแ แแแแจแแแแแแแแแแ แแแแแแแแแ แแแแกแแแแก, แ แแแแแแแช แแแฃแจแแแแแแ แแแแแก Android-แแ, แแแแ แแ แแแ แแกแแแ แแฅแแ แกแแ แแแแแแ แกแแจแฃแแแ แแแแฎแแแ แแแแแกแแแแก.
Android-แแก แแแแแแแแแ แแก แแ แ-แแ แแ แงแแแแแแ แชแแแแแแ แคแฃแแฅแชแแแ USB Debugging. แแฅแแแ แจแแแซแแแแ แแแแแฎแแแ แแก แแแ แแแแขแ แแแจแ แแ แแแแแขแแ แแกแแแ แฃแแแ แฉแแ แแแ แแฃ แแ แ. แแแแฎแแ, แ แแกแแแแก แแ แแก แแก แ แแแแแ แแ แแญแแ แแแแแ แแฃ แแ แ.
แ แ แแ แแก USB แแแแแ แแแ?
แแแแแแ, USB แแแแแ แแแ แกแแจแฃแแแแแแก แแซแแแแก Android แแแฌแงแแแแแแแแก แแแฃแแแแจแแ แแแก แแแแแแฃแขแแ แก, แ แแแแแแช แแฃแจแแแแก Android SDK-แแ, แ แแแ แแแแแแงแแแแก แแแคแแ แแแแแฃแแ แแแแ แแชแแแแ.
Android แแแแแแก แจแแแฃแจแแแแแแกแแก, แแฅแแแ แฃแแแ แแแแแแกแขแแแแ แแ Android Software Development Kit (SDK) แแฅแแแแก แแแแแแฃแขแแ แจแ. SDK แแแแชแแแก แแแกแขแ แฃแแแแขแแแแก แแ แแแแแแแแแก, แ แแแแแแแช แกแแกแแชแแชแฎแแแ แแแแจแแแแแแแแแแ แแแแแกแแแแ แ แแแแแแแแแ แแกแแแแก, แแแแแแแแแ, แแแแแ แแแ แแแแแก แแ แแแแแแแแแก แแแแแกแแญแ แแแแ. แแแแแแแแแแแแ SDK-แแก แแแแแ แแ แแ แซแแ แแแแแ แแแแแแแแแขแแ.
แแก แกแแจแฃแแแแแแก แแซแแแแก แแแแแแแแแ แแแก แจแแแกแ แฃแแแ แกแแแ แแ แคแฃแแฅแชแแแแ แแแแ แฎแแแแฎแแแ แแแแแ แแแแก แแแ แแจแ. แแแแแแแแแ, Android-แก แแฅแแก แฉแแจแแแแแฃแแ แแแญแแแแก แคแฃแแฅแชแแ, แแกแ แ แแ, แ แแแแกแแช แฌแแ แ แแแแแแแชแแแก, แแฅแแแ แแ แแญแแ แแแแแ แแแญแแแแก แแฎแแแ แฎแแ แฎแแก แแแคแแฅแ แแแ. แแฅแแแ แฃแแ แแแแ แแแ แแแแแ แแแแแแแแแแแจแ แจแแขแแแแ แฉแแจแแแแแฃแ แแแแแแก, แ แแชแ แแแแก แแแแแแแแ แแญแแ แแแแแ.
Android-แแ แแแแ แ แ แแแแก แแแแแแแแ แจแแแแซแแแแ แแแแแ แแแฌแงแแแแแแแแแแ. แแแแ แแ แแแแแแแแแ แแแก แแแขแ แแแ แแแแขแ แกแญแแ แแแแแ, แแแแกแแแฃแแ แแแแ แจแแชแแแแแแแก แแแขแแแฃแ แ แแฃแ แแแแแก แจแแแ แแแแแแกแแก. แแ แคแแแแแแแก แแแซแแแแ แแ แแแฌแงแแแแแแแแแแ แฎแแแแ แแแแแขแแแ แแแแ แขแแแแแแ แแฅแแแแแแ, แแแแขแแ แแกแแแ แแงแแแแแแ Android Studio-แกแ แแ Android SDK-แจแ แฉแแจแแแแแฃแ แฎแแแกแแฌแงแแแแก, แ แแแ แแก แฃแแขแแแแแแฃแแ แแงแแก.
USB แแแแแ แแแแก แฉแแ แแแ แกแแจแฃแแแแแแก แแซแแแแก แแฅแแแแก แขแแแแคแแแก แแแฃแแแแจแแ แแแก แแฅแแแแก แแแแแแฃแขแแ แก, แแกแ แ แแ แแฅแแแ แจแแแแซแแแแ แแกแแ แแแแแแ แแ แฎแแแกแแฌแงแแแแแ.
แ แแกแแแแก แแแแแแงแแแแแ USB แแแแแ แแแ?
USB แแแแแ แแแแก แแแ แแจแ, แแฅแแแ แแ แจแแแแซแแแแ แแแแแแแแแแ แแแฌแแแแแ แแ แซแแแแแแแ แแฅแแแแก แขแแแแคแแแแ USB แแแแแแแก แแแแแงแแแแแแ. USB แแแแแ แแแแก แฉแแ แแแแก แงแแแแแแ แแแแ แชแแแแแฃแแ แแแแแแ แแ แแก แแก, แ แแ แแแแแแแแแ แแแ แแแฃแจแแแแแแ แแแแแแแชแแแแก แแแแแแแ แแแฌแงแแแแแแแแแแ แขแแกแขแแ แแแแกแแแแก.
แ แแแแกแแช แแฅแแแ แฅแแแแ แแฅแแแแ แแแแก แแฎแแ แแแ แกแแแก Android Studio-แจแ แแ แแกแฃแ แ แแแกแ แแแแแชแแ, แจแแแแซแแแแ แแแแแแแแ แแ แแแ แแฅแแแแก แแแแแแจแแ แแแฃแ แแแฌแงแแแแแแแแแ แ แแแแแแแแ แแแฌแแแแฃแแแแแ. แจแแแ แแแแก แจแแแแแ, แแก แแแแฅแแแแแแแ แแ แแแฃแงแแแแแแแแ แแแแแฉแแแแแ แแฅแแแแก แแแฌแงแแแแแแแแแ. แแก แฃแคแ แ แกแฌแ แแคแแ, แแแแ แ APK แคแแแแแก แฉแแแแขแแแ แแแ แแ แฎแแแแ แแแกแขแแแแชแแ.
แแ แแแแแแแแแแ แแแ แฉแแแฃแแแแ แแ แฃแจแแแแก USB แแแแแ แแแแก แแแฆแแแแก root แฃแคแแแแแแ(แกแฃแแแ แแแแฎแแแ แแแแแก แฌแแแแแ แแ root แฌแแแแแ) แแแ แขแแแแคแแแแแแ. Root แฌแแแแแ แแแแกแฎแแแแแแแ แแแฌแงแแแแแแแแก แแแฎแแแแแ, แแแแ แแ แแแแแแแแแก แฃแแแขแแกแแแ แแแแชแแแก แแ แแแ แแแแก, แ แแแแแกแแช แแฌแแ แแแแแ แแฅแแแแ แแแกแแขแแแแแแ. แแแก แจแแแแแ แ แแช แฉแแ แแแแ USB แแแแแ แแแแก แแ แแแแแแแจแแ แแแ แแฅแแแแก แขแแแแคแแแก, แจแแแแซแแแแ แแแแแแงแแแแ root แแแกแขแ แฃแแแแขแ, แ แแแ แแแแแแแแแแ root แแแกแขแ แฃแฅแชแแแแ แแฅแแแแก แแแแแแฃแ แแแฌแงแแแแแแแแแ แจแแฎแแแแก แแแ แแจแ. แกแแแแแ ROM-แแก แแแงแแแแแ แแกแแแแก แแ แแชแแกแก แแแแชแแแก.
แแฅแแแ แแกแแแ แแแแญแแ แแแแแ USB แแแแแ แแแแก แฉแแ แแแ Android Debug Bridge (ADB) แแ แซแแแแแแแแก แแแแแกแแงแแแแแแแ. แแกแแแ แกแแจแฃแแแแแแก แแแซแแแแ แแแแแแกแขแแแแ แแ แแฅแแแแก แแแแแแฃแขแแ แจแ แแแแแแแกแแแฃแแ APK-แแแ แแฅแแแแก แขแแแแคแแแแ, แแแแแแขแแแแ แคแแแแแแ แฌแแ แแ แฃแแแ แแ แแแฎแแ แแแฌแงแแแแแแแแก แแฃแ แแแแแแ แแแแแ แแแแก แจแแชแแแแแแแกแแแแก. ADB แแ Fastboot แแ แซแแแแแแแ แแกแแแ แจแแแซแแแแ แจแแแแแฎแแก แแฅแแแแก แแแฌแงแแแแแแแแแ, แแแจแแแแช แแ, แแฃ แแฅแแแ แแ แจแแแแซแแแแ แฉแแ แแแ แแแ แแแ แแแแฃแ แแ.
Android-แแก แซแแแ แแแ แกแแแแจแ USB แแแแแ แแแ แแแแแแงแแแแแแแ แกแฎแแ แคแฃแแฅแชแแแแแกแแแแก. แแแแแแ แงแแแแแแ แแแแจแแแแแแแแแ แแงแ แกแแ แแแจแแขแแก แแแแแฆแแแ USB-แแ. แแก แแงแ แแแแแ, แกแแแแ Android-แก แฐแฅแแแแ แกแขแแแแแ แขแฃแแ แแ แซแแแแแ แแแ แแแแก แแแแแแญแแแก แแแแแกแแฆแแแแ. แแฎแแ แแฅแแแ แฃแแ แแแแ แฃแแแ แแแแญแแ แแ แแฅแแแแ แแแฌแงแแแแแแแแก แฆแแแแแแแแก แแแแแแแแชแแแก (แฉแแแฃแแแแ แแ: Power and Volume Down) แแแ แแแแก แแแแแแญแแแก แแแแแกแแฆแแแแ - แแแแ แแแแฃแฅแแ แแก แแแแแแ.
แ แแแแ แฉแแ แแแ USB แแแแแ แแแ?
แแแแแแแแ แแแ Android แแแฌแงแแแแแแแแแแ, แแฅแแแ แแแแแแ USB แแแแแ แแแแก Developer Options แแแแแฃแจแ, แ แแแแแแช แแแแแแฃแแแ แแแแฃแแแกแฎแแแแแ. แแแก แแแแกแแแแแแแ แแแฎแกแแแแ แแแ แแแแขแ แแแ แแ แแแแแแแ แฅแแแแแ แขแแแแคแแแแก แจแแกแแฎแแ. แแแแแแฎแแแแ แแแแ แแ แฅแแแแแ แแ แแแแแแฎแแแ แฉแแแแฌแแ แก build แแแแ แแ. แจแแแฎแแ แแแก แ แแแแแแฏแแ แแ แแ แแแแแแฎแแแ แจแแขแงแแแแแแแแก, แ แแแแแแช แแแขแงแแแ, แ แแ แแฎแแ แแแแแแแแแ แ แฎแแ แ.
แแแฃแแ แฃแแแแ แแแ แแแแขแ แแแก แแ แแแแแแฎแแแแ แขแแแแคแแแแก แจแแกแแฎแแ แแแแแจแ. แแฅแแแ แแแฎแแแ แแฎแแ แฉแแแแฌแแ แก, แแแแแแแแแ แแก แแคแชแแแแก. แจแแแฎแแ แแแก แแ แแแซแแแแแ USB แแแแแ แแแ แแแแแ แแแแก แกแแแแฃแ แแก แฅแแแจ. แจแแแฎแแ แกแแแแแแ แก แแแก แแแกแแแฅแขแแฃแ แแแแแ แแ แแฆแแแ แแ Android-แแก แแแคแ แแฎแแแแแ, แ แแ แแแกแแแ, แ แแก แแแแแแแก แคแฃแแฅแชแแ.
แกแฃแ แแก แแ แแก - แแฎแแ แแฅแแแ แฃแแ แแแแ แฃแแแ แแแฃแแแแจแแ แแ แแฅแแแแ แขแแแแคแแแ แแฅแแแแก แแแแแแฃแขแแ แก USB แแแแแแแก แแแแแงแแแแแแ. แ แแแแกแแช แแแแก แแแแแแแแแ, แแฅแแแแก แขแแแแคแแแแ แแแแแแฎแแแ แแแแฎแแแแแก, แ แแแแแแช แแแแแแฎแแแแ, แแกแฃแ แ แแฃ แแ แ USB แแแแแ แแแแก แฉแแ แแแ แแ แแแแแ แแขแฃแแ แแแแแแฃแขแแ แแกแแแแก. แแก แแ แแก แฃแกแแคแ แแฎแแแแแก แคแฃแแฅแชแแ, แ แแแแแแช แจแแฅแแแแแแ แแฅแแแแ แแแฌแงแแแแแแแแก แแแแแแกแฎแแแแแกแแแ แแแกแแชแแแแ.
แแ แแก แแฃ แแ แ USB แแแแแ แแแ แฃแกแแคแ แแฎแ?
แแแแ แแฃแแแ, แแฃ แฉแแ แแฃแแแ USB แแแแแ แแแ, แแฅแแแแ แขแแแแคแแแแก แแแแแแจแแ แแแ แกแแฏแแ แ แแแขแแแแแก แแแ แขแแแ แจแแแซแแแแ แแแแแแฌแแแแก แแ แแแแแแแแ. แแฃ แแแแแแก แแฅแแก แฌแแแแแ แแแ แขแแ, แแแก แจแแฃแซแแแ แแแแแแ แแก แแแคแแ แแแชแแ แแฅแแแแ แแแฌแงแแแแแแแแแแ แแ แแแแแแกแขแแแแ แแก แแแแแ แแแแแแแชแแแแ. แกแฌแแ แแ แแแแขแแ Android แแฉแแแแแแก แแแแแกแขแฃแ แแแแก แแแแฎแแแแแก, แแกแ แ แแ แแฅแแแ แแ แฃแแแ แแแฃแแแแจแแ แแแ แแแแแแฃแขแแ แก, แ แแแแแกแแช แแ แแแแแแแ. แแฃแแชแ, แฃแแญแแแแแ แแแแฎแแแ แแแแแแ แจแแแซแแแแ แแแแฆแแก แแแฌแแแแ แแกแ, แ แแ แแ แแแแแแก แแก แ แ แแ แแก.
แแแ แแ แแแแกแ, USB แแแแแ แแแแก แฉแแ แแแ แกแแจแฃแแแแแแก แแแแชแแแ แแแ แแแ แแฅแแแแ แแแฌแงแแแแแแแ, แแฃ แแก แแแแแ แแแแ. แแแแแกแแแแ แก, แแแแช แแแแแแก แแแก, แจแแฃแซแแแ แแแแแแแจแแ แแก แแฅแแแแ แแแฌแงแแแแแแแ แแแแแก แแแแแแฃแขแแ แแแ แแ แแแกแชแแก แแ แซแแแแแแแ แแแกแแ ADB-แแก แแแจแแแแแแ แแฅแแแแ PIN แแแแแก แชแแแแแก แแแ แแจแ.
แแฃ แ แแแฃแแแ แฃแแแ แแ แแงแแแแแ ADB-แก แแ แแฃแแแแแแ แแ แแแแแจแแ แแแ แแฅแแแแก Android แแแฌแงแแแแแแแแก แแฅแแแแก แแแแแแฃแขแแ แก, แแ แฃแแแ แแแขแแแแ USB แแแแแ แแแ แฉแแ แแฃแแ. แแแ แแแ แแแกแ แฉแแ แแแ แ แแแแแแแแ แแฆแแก แแแแแแแแแแแจแ, แกแแแแ แ แแแแแแ แแฃแจแแแแ, แแแแ แแ แแ แแ แแก แกแแญแแ แ แแแกแ แฉแแ แแแ, แ แแแแกแแช แแแก แ แแแฃแแแ แฃแแแ แแ แแงแแแแแ.
แ แแแแ แแแแแแแงแแแแ USB แแแแแ แแแ?
แฉแแแ แแแแแแฎแแแแ แ แแก แแแแแแแก USB แแแแแ แแแ แแ แ แแกแแแแก แจแแแแซแแแแ แแแกแ แแแแแงแแแแแ. แแแ แแแแ, แแก แคแฃแแฅแชแแ แกแแจแฃแแแแแแก แแแซแแแแ แแแแฆแแ แฌแแแแแ Android-แแก แแแคแแ แแแแแฃแ แคแฃแแฅแชแแแแแ แแแแแแฃแขแแ แแแ แแแแแแจแแ แแแแกแแก. USB แแแแแ แแแ แกแแกแแชแแชแฎแแแ แแแแจแแแแแแแแแแ แแแแแแแแแ แแแแกแแแแก, แแแแ แแ แแแแแช แจแแแชแแแก แ แแแแแแแแ แกแแกแแ แแแแแ แฎแ แแแก แแแฌแแแแแ แแแแฎแแแ แแแแแแแกแแแแก. แแแฃแฎแแแแแแ แแแแกแ, แ แแ แแแแ แฃแแแ แแงแแ แฉแแ แแแ แแก แกแแญแแ แแแแแก แจแแแแฎแแแแแจแ, แแแ แฉแแแ แแแแแ แแแ แแก, แ แแแแกแแช แแ แแงแแแแแ, แแฅแแแแ แแแฌแงแแแแแแแแก แฃแกแแคแ แแฎแแแแแก แแแแ แแแก แแแแแแ.
แฉแแ แแฃแแ แแแฅแแ แแฃ แแแแแ แแฃแแ แแแฅแแ USB แแแแแ แแแ แขแแแแคแแแแ? แฒ แแกแแแแก แแงแแแแ? แแแแแฎแแ แแ แแแแก แจแแกแแฎแแ แแแแแแขแแ แแแจแ!
แ แแแแ แช แฉแแแก, Android แแแฌแงแแแแแแแแก แแแแแแฃแขแแ แแแ แแแแแแจแแ แแแ แกแแแ แแแ แแ แแ แแก แ แแฃแแ. USB-แแ แแแแ USB แแแแแแแ แจแแแแแ แแ แแ แงแแแแแคแแ แ แฃแแแ แแฃแจแแแแแแก. แแแแ แแ แแก แงแแแแแแแแก แแ แฎแแแแ. แแแแฏแแ แกแแญแแ แแ แแแแแขแแแแแ แแแแแฏแแแ. แแแแแ แแแกแแฃแแ แแ แแแแแ แจแแแแแแแจแ.
แแแแแฌแงแแ แแแแ, แ แแ Android-แแก แกแฎแแแแแกแฎแแ แแแ แกแแแแก แแฅแแ แแแแแ แแแแกแฎแแแแแแฃแแ แแแแแ แแแฌแงแแแแแแแแก แแแแแแฃแขแแ แแแ แจแแกแแแแฎแแ แแแกแแแแแจแแ แแแแแ. แแ แแชแแ แแฅแแแแ แแแ แกแแ? แแแแแแแ แแแ แแแแขแ แแแแ, แแแซแแแแแ แแแแแฃแก แแฃแแฅแขแ "แขแแแแคแแแแก แจแแกแแฎแแ", "แขแแแแแขแแก แจแแกแแฎแแ" แแ "แแแฌแงแแแแแแแแก แจแแกแแฎแแ". แแฅแแแแ แแแฏแแขแแก แแแ แกแแ แแฅ แแ แแก แฉแแแแแแแแแ. แจแแแแแแ, แแแแแ แซแแแแ Android-แแก แแฅแแแแ แแแ แกแแแกแแแแก แแแแแแแแแ แแแกแขแ แฃแฅแชแแแแแก แแแฎแแแแแ.
Android 2.1 โ 2.3.7
- แจแแแแ แแแ แแฅแแแแ แแแฌแงแแแแแแแ แแแแแแฃแขแแ แแแ USB แแแแแแแก แแแแแงแแแแแแ
- แแแแแแแแ แกแแแแ แแแแแแฃแขแแ แ แแฆแแแแฉแแแก แแแฌแงแแแแแแแแก. แแฃ แแแแแแฃแขแแ แแ แแฆแแแแฉแแแ แแฅแแแแ แขแแแแคแแแ แแ แขแแแแแขแ, แแแแแขแแแแ แจแแแแแแ แแแแแฏแ. แฌแแแแแฆแแแแ แจแแแแฎแแแแแจแ, แแแฐแงแแแแ แแแกแขแ แฃแฅแชแแแก แจแแแแแ แแแแแฏแก
- แแแแแจแแ แแฅแแแแ แแแฌแงแแแแแแแ แแแแแแฃแขแแ แแแแ. แแแแแแแ แแแ แแแแขแ แแแ -> แแ แแแ แแแแแ -> แแแแแแแแแ แแก แแแ แแแแขแ แแแ -> USB แแแแแ แแแ. แแแแญแแ แแ แฆแแแแแก USB แแแแแ แแแแก แ แแแแแแก แแแกแแแฅแขแแฃแ แแแแแ. แจแแแแ แแแ แแฅแแแแ แแแฌแงแแแแแแแ แแแแแแฃแขแแ แแแ.
- แ แแแแกแแช แแแฌแงแแแแแแแ แแแแแชแแแแก แแแแแแฃแขแแ แก, USB แฎแแขแฃแแ แแแแแฉแแแแแ แกแขแแขแฃแกแแก แแแแจแ. แฉแแแแฌแแแ แกแขแแขแฃแกแแก แแแแ แแแแแ, แจแแแฎแแ โUSB แแแแจแแ แโ
- แแฃ แแแแแชแแแแ แแ แฉแแแแแ แแแ แแแแขแ แแแก แจแแ แแก โแแแแแแจแแ แแแ แ แแแแ แช แแแแแ แแแฌแงแแแแแแแ (MTP)โ แแ โแแแแแแจแแ แแแ แ แแแแ แช แแแแแ แ (PTP)โ, แแแ แฉแแแ แแแ แแแแ แแแ แแแแขแ.
- แแแแแแ! แแฌแแแแ แแแแ แแแแแก แฎแแขแฃแแ แฎแแแแ แแแ แแแฏแแกแคแแ แ, แฎแแแ แแแแแแฃแขแแ แแ แแฅแแแแ แแแฌแงแแแแแแแ แแแฉแแแแแแแ แ แแแแ แช แแแแแชแแแแ แกแแชแแแ (แแแฎแกแแแแ แแแกแแ แแแแแญแแแฃแแ แแกแแแแแ)
Android 4.0 โ 4.2
แ แแแแ แช แฌแแกแ, Android-แแก แแ แแแ แกแแแแจแ แแแฌแงแแแแแแแ แแแขแแแแขแฃแ แแ แแแแแชแแแแก แแแแจแแ แแก แจแแแแแ. แแฃ แแก แแ แแแฎแแ, แแแฐแงแแแแ แแ แแแแแฏแแแก:
- แจแแแแ แแแ แแฅแแแแ แแแฏแแขแ แแแแแแฃแขแแ แแแ USB-แแก แกแแจแฃแแแแแแ
- แแแ แฉแแแ แแแ แแแแขแ แแแ -> แจแแแแฎแแ -> USB แแแแจแแ แแก แแแ แแแแขแ แแแ
- แจแแแแแแแแแแแฃแแ แแ แ แแแ แแแแขแแแแ (แแแแแแจแแ แแแ แ แแแแ แช แแแแแ แแแฌแงแแแแแแแ/แ แแแแ แช แแแแแ แ), แแแ แฉแแแ แแแ แแแแ. แแแแแแ! แแแฌแงแแแแแแแ แแแแแแจแแ แแแฃแแแ แ แแแแ แช แแแฎแกแแแ แแแ
แแฎแแ แแฅแแแ แแชแแ, แ แแแแ แฉแแ แแแ USB แแแกแแ Android-แแ แแแแแกแแแแ แ แแแ แกแแแ.
แ แแแแ แแแแแกแฃแคแแแแ Android-แแก แจแแแ แแแฎแกแแแ แแแ
แขแแแแคแแแแก แแ แขแแแแแขแแก แฉแแแแขแแแ แจแแแ แแแฎแกแแแ แแแ แแ แแก แแ แแแแแแ, แ แแแแแกแแช แแแ แ แแฃ แแแแแ แแแแแกแแแแ แ แแแแฎแแแ แแแแแ แแฌแงแแแแ. แแแก แจแแแแแ, แ แแช แแฅแแแแก แแแแแแฃแขแแ แก USB-แแก แกแแจแฃแแแแแแ แแแฃแแแแจแแ แแแแแ, แแฅแแแ แแแฅแแ แแแกแ แแแแแญแ แแก แแแกแแฎแแ แฎแแแแแ แแแ. แแฅ แแแชแแแฃแแแ แฅแแแแแแแแแก แแแแแ แฉแแแแแแแแแแ, แ แแแแแแแช แจแแแแซแแแแ แแแแแฎแแ แชแแแแแ แแฅแแแแ Android แแแฌแงแแแแแแแแก แจแแแ แแแฎแกแแแ แแแแก แแแกแแกแฃแคแแแแแแแแ แแแแแแฃแขแแ แแแ แแแแแแจแแ แแแแก แแแแ.
- แแแแแแขแแแแ แแฅแแแแ แคแแขแแแแ แแ แแแแแ แแแแแแฃแขแแ แจแ. แฃแแ แแแแ แแแแแแขแแแแ แแกแแแ แแแแแแฃแขแแ แแก แกแแกแฃแ แแแ แกแแฅแแฆแแแแแจแ แแ แฌแแจแแแแ แแกแแแ แแฅแแแแ แขแแแแคแแแแแแ
- แจแแแแแฌแแแ แแฅแแแแ แฉแแแแขแแแ แแแแก แกแแฅแแฆแแแแ. แ แแแแ แช แฌแแกแ, แแฅ แแ แแแแแแ แแแแ แ แแ แแกแแญแแ แ แแแแแแฌแแ แแแ แคแแแแ. แฌแแจแแแแ แแกแแแ แแ แแแแแแขแแแแ แ แแช แแญแแ แแแแแ แแฅแแแแก แแแแแแฃแขแแ แจแ
- แแฅแแแ แแกแแแ แจแแแแซแแแแ แจแแแแแฎแแ แแแ แแแแฃแแ แแแแแชแแแแแ แแแ แแแแแ แแแแแแแชแแแแแแแ แแฅแแแแก แแแแแแฃแขแแ แจแ. แแแแแแแแแ, แจแแแแซแแแแ แแแแ แฅแแแแ แงแแแแ แแฅแแแแ SMS แแ แจแแแแแฎแแ แแกแแแ แแฅแแแแก แแแแแแฃแขแแ แจแ
แแฅแแแแ Android แแแฌแงแแแแแแแแก แแแแแแฃแขแแ แแแ, แ แแแแ แช แกแแชแแแแแ แแแแแแจแแ แแแแ, แจแแแแซแแแแ แแแ แขแแแแ แแแชแแแแแ แแแคแแ แแแชแแ แแแฌแงแแแแแแแแแก แจแแ แแก แแ แแกแแแ แแแแคแแ แขแฃแแแ แแแแกแฃแคแแแแแ แแฅแแแแ แแแฏแแขแแก แจแแแ แแแฎแกแแแ แแแ.