คุณสามารถใช้GoogleApiClient
("ไคลเอ็นต์ Google API")
เข้าถึง Google APIs ที่ให้ไว้ในไลบรารีบริการ Google Play
(เช่น Google Sign-In, เกม และไดรฟ์) ไคลเอ็นต์ Google API จะมี
จุดแรกเข้าทั่วไปไปยังบริการ Google Play และจัดการเครือข่าย
การเชื่อมต่อระหว่างอุปกรณ์ของผู้ใช้กับบริการแต่ละอย่างของ Google
อย่างไรก็ตาม อินเทอร์เฟซรุ่นใหม่ของ GoogleApi
และการใช้งานง่ายกว่า
และเป็นวิธีที่แนะนำในการเข้าถึง API ของบริการ Google Play
โปรดดูการเข้าถึง Google API
คู่มือนี้แสดงวิธีทำสิ่งต่อไปนี้
- จัดการการเชื่อมต่อกับบริการ Google Play โดยอัตโนมัติ
- เรียกใช้ API แบบพร้อมกันและไม่พร้อมกันไปยังบริการ Google Play บริการใดก็ได้
- จัดการการเชื่อมต่อกับบริการ Google Play ด้วยตนเองในกรณีที่เกิดขึ้นไม่บ่อยนัก ตามความจำเป็น ดูข้อมูลเพิ่มเติมได้ที่การเชื่อมต่อที่จัดการด้วยตนเอง
![](https://developers.google.cn/static/android/images/GoogleApiClient_2x.png?authuser=7&hl=th)
ในการเริ่มต้นใช้งาน คุณต้องติดตั้งไลบรารีบริการ Google Play (เวอร์ชัน 15 ขึ้นไป) ก่อน สำหรับ Android SDK หากยังไม่ได้ดำเนินการ ให้ทำตามวิธีการใน ตั้งค่า SDK บริการ Google Play
เริ่มการเชื่อมต่อที่มีการจัดการโดยอัตโนมัติ
หลังจากลิงก์โปรเจ็กต์กับไลบรารีบริการ Google Play แล้ว ให้สร้างอินสแตนซ์
GoogleApiClient
โดยใช้
GoogleApiClient.Builder
API ในกิจกรรม
onCreate()
GoogleApiClient.Builder
ซึ่งมีเมธอดที่ช่วยให้คุณสามารถระบุ Google APIs ที่ต้องการใช้ และ
ขอบเขตของ OAuth 2.0 นี่คือตัวอย่างโค้ดที่สร้าง
อินสแตนซ์ของ GoogleApiClient
ที่เชื่อมต่อกับบริการ Google ไดรฟ์
GoogleApiClient mGoogleApiClient = new GoogleApiClient.Builder(this) .enableAutoManage(this /* FragmentActivity */, this /* OnConnectionFailedListener */) .addApi(Drive.API) .addScope(Drive.SCOPE_FILE) .build();
คุณสามารถเพิ่ม API หลายรายการและหลายขอบเขตได้เหมือนกัน
GoogleApiClient
โดยการเพิ่มการโทรเพิ่มเติมไปที่ addApi()
และ addScope()
สำคัญ: หากคุณกำลังเพิ่ม Wearable
API ร่วมกับ API อื่นๆ ลงใน
GoogleApiClient
คุณอาจพบข้อผิดพลาดในการเชื่อมต่อไคลเอ็นต์ในอุปกรณ์ที่
ไม่ได้ติดตั้งแอป Wear OS ไว้ ถึง
เพื่อหลีกเลี่ยงข้อผิดพลาดในการเชื่อมต่อ เรียกใช้เมธอด addApiIfAvailable()
แล้วส่ง
Wearable
API เพื่อให้ลูกค้าจัดการกับสิ่งที่ขาดไปได้อย่างราบรื่น
API ดูข้อมูลเพิ่มเติมได้ที่เข้าถึง Wearable API
หากต้องการเริ่มการเชื่อมต่อที่มีการจัดการโดยอัตโนมัติ คุณต้องระบุ
การใช้งานสำหรับOnConnectionFailedListener
เพื่อรับข้อผิดพลาดในการเชื่อมต่อที่แก้ไขไม่ได้ เมื่อคุณจัดการโดยอัตโนมัติ
อินสแตนซ์ GoogleApiClient
พยายามเชื่อมต่อกับ Google APIs อินสแตนซ์จะ
เพื่อพยายามแก้ไขการเชื่อมต่อที่ไม่สำเร็จ (ตัวอย่างเช่น หาก
จำเป็นต้องอัปเดตบริการ Google Play) หากเกิดข้อผิดพลาดที่ไม่สามารถ
คุณจะได้รับโทรศัพท์ไปยัง
onConnectionFailed()
คุณยังระบุการติดตั้งใช้งานที่ไม่บังคับสําหรับอินเทอร์เฟซ ConnectionCallbacks
ได้ด้วย หากแอปจําเป็นต้องใช้
การเชื่อมต่อที่มีการจัดการโดยอัตโนมัติถูกสร้างขึ้นหรือถูกระงับ ตัวอย่างเช่น หาก
แอปของคุณทำการร้องขอเพื่อเขียนข้อมูลไปยัง Google API ซึ่งควรเรียกใช้
หลังจากที่เรียกใช้เมธอด onConnected()
แล้วเท่านั้น
ต่อไปนี้เป็นตัวอย่างกิจกรรมที่ใช้อินเทอร์เฟซ Callback และเพิ่ม ลงในไคลเอ็นต์ Google API
import com.google.android.gms.common.api.GoogleApiClient; import com.google.android.gms.common.api.GoogleApiClient.OnConnectionFailedListener; import gms.drive.*; import android.support.v4.app.FragmentActivity; public class MyActivity extends FragmentActivity implements OnConnectionFailedListener { private GoogleApiClient mGoogleApiClient; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); // Create a GoogleApiClient instance mGoogleApiClient = new GoogleApiClient.Builder(this) .enableAutoManage(this /* FragmentActivity */, this /* OnConnectionFailedListener */) .addApi(Drive.API) .addScope(Drive.SCOPE_FILE) .build(); // ... } @Override public void onConnectionFailed(ConnectionResult result) { // An unresolvable error has occurred and a connection to Google APIs // could not be established. Display an error message, or handle // the failure silently // ... } }
อินสแตนซ์ GoogleApiClient
จะเชื่อมต่อโดยอัตโนมัติหลังจากกิจกรรม
โทรหา onStart()
และยกเลิกการเชื่อมต่อหลังจากโทร onStop()
แอปของคุณเริ่มทำให้
อ่านคำขอไปยัง Google API หลังจากการสร้าง GoogleApiClient
โดยไม่มี
กำลังรอให้การเชื่อมต่อเสร็จสมบูรณ์
สื่อสารกับบริการของ Google
หลังจากเชื่อมต่อแล้ว ไคลเอ็นต์จะอ่านและเขียนการเรียกโดยใช้ API เฉพาะบริการสำหรับ
ที่แอปของคุณได้รับอนุญาต ตามที่ระบุโดย API และขอบเขตที่คุณเพิ่ม
GoogleApiClient
หมายเหตุ: ก่อนที่จะโทรหาบริการบางอย่างของ Google คุณอาจต้องลงทะเบียน ใน Google Developer Console หากต้องการทราบวิธีการ โปรดดูที่ คู่มือเริ่มต้นใช้งานสำหรับ API ที่คุณใช้งานอยู่ เช่น Google ไดรฟ์ หรือ Google Sign-In
เมื่อคุณส่งคำขออ่านหรือเขียนโดยใช้ GoogleApiClient
ไคลเอ็นต์ API จะส่งกลับออบเจ็กต์ PendingResult
ที่แสดงถึงคำขอ
กรณีนี้จะเกิดขึ้นทันที ก่อนที่ระบบจะส่งคำขอไปยังบริการของ Google ที่แอปของคุณเรียกใช้
ตัวอย่างเช่น นี่คือคำขออ่านไฟล์จาก Google ไดรฟ์ที่ระบุ
ออบเจ็กต์ PendingResult
:
Query query = new Query.Builder() .addFilter(Filters.eq(SearchableField.TITLE, filename)); PendingResult<DriveApi.MetadataBufferResult> result = Drive.DriveApi.query(mGoogleApiClient, query);
หลังจากที่แอปมีออบเจ็กต์ PendingResult
แล้ว
จากนั้นแอปของคุณสามารถระบุได้ว่าจะให้การจัดการคำขอเป็นการโทรแบบไม่พร้อมกันหรือการโทรพร้อมกัน
เคล็ดลับ: แอปของคุณสามารถจัดคิวคำขออ่านได้ในขณะที่ไม่ได้เชื่อมต่อกับบริการ Google Play สำหรับ
เช่น แอปจะเรียกใช้เมธอดเพื่ออ่านไฟล์จาก Google ไดรฟ์ได้ ไม่ว่าอินสแตนซ์ GoogleApiClient
จะเชื่อมต่ออยู่หรือไม่ก็ตาม หลังจากสร้างการเชื่อมต่อแล้ว ระบบจะดำเนินการกับคำขออ่านที่จัดคิวไว้ คำขอการเขียนจะทำให้เกิดข้อผิดพลาดหากเรียกใช้แอป
บริการ Google Play เขียนเมธอดขณะที่ไคลเอ็นต์ Google API ไม่ได้เชื่อมต่อ
การใช้การโทรแบบไม่พร้อมกัน
หากต้องการทำให้คำขอไม่พร้อมกัน ให้เรียกใช้
setResultCallback()
ใน PendingResult
และระบุ
การนำ
อินเทอร์เฟซ ResultCallback
สำหรับ
ตัวอย่างเช่น ต่อไปนี้คือคำขอที่ดำเนินการแบบไม่พร้อมกัน
private void loadFile(String filename) { // Create a query for a specific filename in Drive. Query query = new Query.Builder() .addFilter(Filters.eq(SearchableField.TITLE, filename)) .build(); // Invoke the query asynchronously with a callback method Drive.DriveApi.query(mGoogleApiClient, query) .setResultCallback(new ResultCallback<DriveApi.MetadataBufferResult>() { @Override public void onResult(DriveApi.MetadataBufferResult result) { // Success! Handle the query result. // ... } }); }
เมื่อแอปได้รับออบเจ็กต์ Result
ใน
Callback ของ onResult()
มีการส่งเป็นอินสแตนซ์ของคลาสย่อยที่เหมาะสม ตามที่ระบุโดย API ที่คุณใช้
เช่น
DriveApi.MetadataBufferResult
การใช้การโทรพร้อมกัน
ถ้าคุณต้องการให้โค้ดของคุณทำงานตามลำดับที่กำหนดไว้อย่างเคร่งครัด อาจเป็นเพราะผลลัพธ์ของ
ต้องมีการเรียกเป็นอาร์กิวเมนต์ของอีกรายการหนึ่ง คุณสามารถทำให้คำขอของคุณพร้อมกันได้โดยการเรียกใช้
await()
ใน
PendingResult
การดำเนินการนี้จะบล็อกชุดข้อความ
และแสดงผลออบเจ็กต์ Result
เมื่อ
คำขอเสร็จสมบูรณ์ ออบเจ็กต์นี้นำส่งเป็นอินสแตนซ์ของคลาสย่อยที่เหมาะสมตามที่ระบุโดย
เช่น API ที่คุณใช้งานอยู่
DriveApi.MetadataBufferResult
เนื่องจากโทรหา await()
บล็อกเทรดจนกว่าผลลัพธ์จะมาถึง แอปของคุณไม่ควรส่งคำขอแบบพร้อมกันไปยัง Google APIs ใน
ชุดข้อความ UI แอปของคุณสามารถสร้างชุดข้อความใหม่โดยใช้ออบเจ็กต์ AsyncTask
และใช้ชุดข้อความนั้นเพื่อสร้างคำขอแบบซิงโครนัส
ตัวอย่างต่อไปนี้แสดงวิธีส่งคำขอไฟล์ไปยัง Google ไดรฟ์เป็นการเรียกพร้อมกัน
private void loadFile(String filename) { new GetFileTask().execute(filename); } private class GetFileTask extends AsyncTask{ protected void doInBackground(String filename) { Query query = new Query.Builder() .addFilter(Filters.eq(SearchableField.TITLE, filename)) .build(); // Invoke the query synchronously DriveApi.MetadataBufferResult result = Drive.DriveApi.query(mGoogleApiClient, query).await(); // Continue doing other stuff synchronously // ... } }
เข้าถึง API ที่สวมใส่ได้
Wearable API มีช่องทางการสื่อสารสำหรับแอปที่ทำงานในอุปกรณ์พกพาและอุปกรณ์ที่สวมใส่ได้ API ประกอบด้วยชุดออบเจ็กต์ข้อมูลที่ระบบส่งและซิงค์ข้อมูลได้ และ Listener ที่แจ้งแอปของคุณเกี่ยวกับเหตุการณ์สำคัญโดยใช้ชั้นข้อมูล Wearable API พร้อมใช้งานในอุปกรณ์ที่ใช้ Android 4.3 (API ระดับ 18) ขึ้นไปเมื่อ เชื่อมต่ออุปกรณ์ที่สวมใส่ได้และมีแอปที่ใช้ร่วมกันกับ Wear OS ติดตั้งอยู่ในอุปกรณ์
การใช้ Wearable API แบบสแตนด์อโลน
หากแอปของคุณใช้ Wearable API ซึ่งไม่ใช่ API อื่นๆ ของ Google ให้เพิ่ม API นี้โดย
ที่เรียกใช้เมธอด addApi()
ตัวอย่างต่อไปนี้จะแสดงวิธีเพิ่มส่วน
Wearable API ไปยังอินสแตนซ์ GoogleApiClient
GoogleApiClient mGoogleApiClient = new GoogleApiClient.Builder(this) .enableAutoManage(this /* FragmentActivity */, this /* OnConnectionFailedListener */) .addApi(Wearable.API) .build();
ในกรณีที่ Wearable API ไม่พร้อมใช้งาน จะส่งคำขอเชื่อมต่อ
รวมถึง Wearable API ล้มเหลวโดยมีแอตทริบิวต์
API_UNAVAILABLE
รหัสข้อผิดพลาด
ตัวอย่างต่อไปนี้แสดงวิธีตรวจสอบว่า Wearable API พร้อมใช้งานหรือไม่
// Connection failed listener method for a client that only // requests access to the Wearable API @Override public void onConnectionFailed(ConnectionResult result) { if (result.getErrorCode() == ConnectionResult.API_UNAVAILABLE) { // The Wearable API is unavailable } // ... }
การใช้ Wearable API กับ Google API อื่นๆ
หากแอปของคุณใช้ Wearable API นอกเหนือจาก API อื่นๆ ของ Google ให้เรียกใช้เมธอด
addApiIfAvailable()
และส่งใน Wearable API เพื่อตรวจสอบว่าใช้งานได้หรือไม่ คุณใช้การตรวจสอบนี้เพื่อช่วยให้แอปจัดการกับกรณีที่ API ไม่พร้อมใช้งานได้อย่างราบรื่น
ตัวอย่างต่อไปนี้แสดงวิธีเข้าถึง Wearable API รวมถึง API ไดรฟ์:
// Create a GoogleApiClient instance mGoogleApiClient = new GoogleApiClient.Builder(this) .enableAutoManage(this /* FragmentActivity */, this /* OnConnectionFailedListener */) .addApi(Drive.API) .addApiIfAvailable(Wearable.API) .addScope(Drive.SCOPE_FILE) .build();
ในตัวอย่างด้านบน GoogleApiClient
สามารถเชื่อมต่อกับ
Google ไดรฟ์โดยไม่เชื่อมต่อกับ Wearable API หากไม่พร้อมใช้งาน หลัง
คุณเชื่อมต่อ GoogleApiClient
อินสแตนซ์ ให้ตรวจสอบว่า Wearable API พร้อมใช้งานก่อนเรียก API โดยทำดังนี้
boolean wearAvailable = mGoogleApiClient.hasConnectedApi(Wearable.API);
การละเว้นความล้มเหลวในการเชื่อมต่อ API
หากคุณโทรหา addApi()
และ GoogleApiClient
ดำเนินการต่อไปนี้ไม่ได้
เชื่อมต่อกับ API นั้นได้สำเร็จ การดำเนินการเชื่อมต่อทั้งหมดสำหรับไคลเอ็นต์นั้นล้มเหลว และ
เรียกใช้ Callback onConnectionFailed()
คุณสามารถลงทะเบียนความล้มเหลวในการเชื่อมต่อ API ที่จะถูกละเว้นได้โดยใช้
addApiIfAvailable()
ในกรณีที่เพิ่ม API ด้วย
addApiIfAvailable()
เชื่อมต่อไม่สำเร็จเนื่องจากเกิดข้อผิดพลาดที่กู้คืนไม่ได้
(เช่น API_UNAVAILABLE
สำหรับ Wear)
ที่ API ถูกตัดออกจาก GoogleApiClient
ของคุณ และไคลเอ็นต์จะไปที่
เชื่อมต่อกับ API อื่นๆ อย่างไรก็ตาม หากการเชื่อมต่อ API ล้มเหลวโดยมีข้อผิดพลาดที่กู้คืนได้ (เช่น
ความตั้งใจในการแก้ปัญหาความยินยอม OAuth) ดำเนินการเชื่อมต่อไคลเอ็นต์ไม่สำเร็จ วันและเวลา
ใช้การเชื่อมต่อที่มีการจัดการโดยอัตโนมัติ GoogleApiClient
จะพยายาม
เพื่อแก้ไขข้อผิดพลาดดังกล่าวเมื่อเป็นไปได้ เมื่อใช้การเชื่อมต่อที่มีการจัดการด้วยตนเอง
ConnectionResult
ที่มีความตั้งใจในการแก้ปัญหา
ที่ส่งไปยังหมายเลขติดต่อกลับของ onConnectionFailed()
API
ระบบจะเพิกเฉยต่อความล้มเหลวในการเชื่อมต่อเฉพาะในกรณีที่ไม่มีวิธีการแก้ไขสำหรับความล้มเหลวดังกล่าว
และเพิ่ม API แล้ว
ด้วย addApiIfAvailable()
ดูวิธีใช้การเชื่อมต่อด้วยตนเองไม่สำเร็จ
โปรดดูที่ส่วนจัดการความล้มเหลวในการเชื่อมต่อ
เนื่องจาก API ที่เพิ่มด้วย
addApiIfAvailable()
อาจไม่แสดงอยู่ในการเชื่อมต่อ
GoogleApiClient
คุณควรป้องกันการเรียกไปยัง API เหล่านี้โดยเพิ่มการตรวจสอบ
ด้วย hasConnectedApi()
เพื่อหาว่าเพราะเหตุใด
API บางรายการล้มเหลวในการเชื่อมต่อเมื่อการดำเนินการเชื่อมต่อทั้งหมดสำหรับไคลเอ็นต์สำเร็จ โทร
getConnectionResult()
และรับรหัสข้อผิดพลาดจาก
ออบเจ็กต์ ConnectionResult
ในกรณีที่ไคลเอ็นต์ของคุณเรียกใช้ API เมื่อไม่ได้ใช้
แต่การติดต่อนั้นล้มเหลวโดยมี
API_NOT_AVAILABLE
รหัสสถานะ
หาก API ที่คุณจะเพิ่มผ่าน addApiIfAvailable()
จำเป็นต้องใช้หรือ
ขอบเขตเพิ่มเติม ให้เพิ่มขอบเขตเหล่านั้นเป็นพารามิเตอร์ใน
แทนการใช้เมธอด addApiIfAvailable()
addScope()
ระบบอาจไม่ขอขอบเขตที่เพิ่มโดยใช้แนวทางนี้หาก API
เชื่อมต่อไม่สำเร็จก่อนที่จะขอความยินยอม OAuth ในขณะที่เพิ่มขอบเขตด้วย
มีการขอ addScope()
เสมอ
การเชื่อมต่อที่จัดการด้วยตนเอง
เนื้อหาส่วนใหญ่ของคู่มือนี้จะแสดงวิธีใช้
enableAutoManage
เพื่อเริ่มต้น
ให้กับการเชื่อมต่อที่มีการจัดการโดยอัตโนมัติ พร้อมกับแก้ไขข้อผิดพลาดโดยอัตโนมัติ ในอีกเกือบ
ทั้งหมด วิธีนี้เป็นวิธีที่ดีที่สุดและง่ายที่สุดในการเชื่อมต่อกับ Google APIs จาก
แอปสำหรับ Android แต่ก็มีบางกรณีที่คุณอาจต้องใช้
การเชื่อมต่อที่มีการจัดการด้วยตนเองกับ Google APIs ในแอปของคุณ
- เพื่อเข้าถึง Google API นอกเหนือจากกิจกรรม หรือยังคงควบคุม API ได้ การเชื่อมต่อ
- เพื่อปรับแต่งการจัดการและแก้ปัญหาข้อผิดพลาดในการเชื่อมต่อ
ส่วนนี้จะแสดงตัวอย่าง Use Case เหล่านี้และขั้นสูงอื่นๆ
เริ่มการเชื่อมต่อที่มีการจัดการด้วยตนเอง
หากต้องการเริ่มการเชื่อมต่อที่มีการจัดการด้วยตนเองกับ GoogleApiClient
คุณต้องดำเนินการต่อไปนี้
ระบุการใช้งานสำหรับอินเทอร์เฟซ Callback
ConnectionCallbacks
และ OnConnectionFailedListener
อินเทอร์เฟซเหล่านี้จะได้รับ Callback เพื่อตอบสนองต่อการอะซิงโครนัส
connect()
เมื่อเมธอด
การเชื่อมต่อกับบริการ Google Play สำเร็จ ไม่สำเร็จ หรือถูกระงับ
mGoogleApiClient = new GoogleApiClient.Builder(this) .addApi(Drive.API) .addScope(Drive.SCOPE_FILE) .addConnectionCallbacks(this) .addOnConnectionFailedListener(this) .build()
เมื่อจัดการการเชื่อมต่อด้วยตนเอง คุณจะต้องเรียกใช้
connect()
และ
disconnect()
ณ จุดที่เหมาะสมในวงจรของแอป ในกิจกรรม
บริบทที่แนวทางปฏิบัติแนะนำคือการเรียกใช้ connect()
ใน onStart()
ของกิจกรรม
และ disconnect()
ในเมธอด onStop()
ของกิจกรรม
connect()
และ
เมธอด disconnect()
จะถูกเรียกโดยอัตโนมัติเมื่อใช้การเชื่อมต่อที่มีการจัดการโดยอัตโนมัติ
หากคุณใช้ GoogleApiClient
เพื่อเชื่อมต่อกับ API ที่ต้องใช้
เช่น Google ไดรฟ์
หรือ Google Play Games
การเชื่อมต่อครั้งแรกของคุณจะไม่สำเร็จและแอปจะได้รับสายเรียกเข้า
ถึง onConnectionFailed()
ด้วย SIGN_IN_REQUIRED
เนื่องจากไม่ได้ระบุบัญชีผู้ใช้
จัดการความล้มเหลวในการเชื่อมต่อ
เมื่อแอปรับสายไปที่onConnectionFailed()
Callback คุณควรโทรหา hasResolution()
ใน ConnectionResult
ที่ระบุไว้
ออบเจ็กต์ หากผลลัพธ์แสดงเป็น "จริง" แอปสามารถขอให้ผู้ใช้ดำเนินการแก้ไขข้อผิดพลาดในทันทีโดย
กำลังโทรหา startResolutionForResult()
ในออบเจ็กต์ ConnectionResult
เมธอด startResolutionForResult()
จะทำงานเหมือนกับ startActivityForResult()
ในสถานการณ์นี้
และเปิดกิจกรรมที่เหมาะสมกับบริบทที่ช่วยให้ผู้ใช้แก้ไขข้อผิดพลาดได้ (เช่น กิจกรรมที่ช่วยให้ผู้ใช้ดำเนินการ
เลือกบัญชี)
หากเป็น hasResolution()
แสดงค่าเท็จ แอปของคุณควรเรียกใช้
GoogleApiAvailability.getErrorDialog()
,
การส่งรหัสข้อผิดพลาดไปยังเมธอดนี้ ซึ่งจะแสดง
Dialog
ให้บริการโดย Google Play
บริการที่เหมาะสมสำหรับข้อผิดพลาด กล่องโต้ตอบอาจมีเพียงข้อความอธิบาย
หรืออาจระบุการดำเนินการเพื่อเปิดกิจกรรมที่แก้ไขข้อผิดพลาดได้
(เช่น เมื่อผู้ใช้ต้องติดตั้งบริการ Google Play เวอร์ชันใหม่)
ตัวอย่างเช่น
ตอนนี้เมธอด Callback onConnectionFailed()
ควรมีลักษณะดังนี้
public class MyActivity extends Activity implements ConnectionCallbacks, OnConnectionFailedListener { // Request code to use when launching the resolution activity private static final int REQUEST_RESOLVE_ERROR = 1001; // Unique tag for the error dialog fragment private static final String DIALOG_ERROR = "dialog_error"; // Bool to track whether the app is already resolving an error private boolean mResolvingError = false; // ... @Override public void onConnectionFailed(ConnectionResult result) { if (mResolvingError) { // Already attempting to resolve an error. return; } else if (result.hasResolution()) { try { mResolvingError = true; result.startResolutionForResult(this, REQUEST_RESOLVE_ERROR); } catch (SendIntentException e) { // There was an error with the resolution intent. Try again. mGoogleApiClient.connect(); } } else { // Show dialog using GoogleApiAvailability.getErrorDialog() showErrorDialog(result.getErrorCode()); mResolvingError = true; } } // The rest of this code is all about building the error dialog /* Creates a dialog for an error message */ private void showErrorDialog(int errorCode) { // Create a fragment for the error dialog ErrorDialogFragment dialogFragment = new ErrorDialogFragment(); // Pass the error that should be displayed Bundle args = new Bundle(); args.putInt(DIALOG_ERROR, errorCode); dialogFragment.setArguments(args); dialogFragment.show(getSupportFragmentManager(), "errordialog"); } /* Called from ErrorDialogFragment when the dialog is dismissed. */ public void onDialogDismissed() { mResolvingError = false; } /* A fragment to display an error dialog */ public static class ErrorDialogFragment extends DialogFragment { public ErrorDialogFragment() { } @Override public Dialog onCreateDialog(Bundle savedInstanceState) { // Get the error code and retrieve the appropriate dialog int errorCode = this.getArguments().getInt(DIALOG_ERROR); return GoogleApiAvailability.getInstance().getErrorDialog( this.getActivity(), errorCode, REQUEST_RESOLVE_ERROR); } @Override public void onDismiss(DialogInterface dialog) { ((MyActivity) getActivity()).onDialogDismissed(); } } }
หลังจากที่ผู้ใช้ดำเนินการเสร็จสิ้นตามกล่องโต้ตอบที่ระบุโดย
startResolutionForResult()
หรือปิดข้อความที่ระบุโดย GoogleApiAvailability.getErrorDialog()
กิจกรรมของคุณจะได้รับ
onActivityResult()
Callback พร้อม
RESULT_OK
รหัสผลลัพธ์
จากนั้นแอปของคุณจะเรียก
connect()
อีกครั้ง
เช่น
@Override protected void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == REQUEST_RESOLVE_ERROR) { mResolvingError = false; if (resultCode == RESULT_OK) { // Make sure the app is not already connected or attempting to connect if (!mGoogleApiClient.isConnecting() && !mGoogleApiClient.isConnected()) { mGoogleApiClient.connect(); } } } }
ในโค้ดข้างต้น คุณอาจสังเกตเห็นบูลีน mResolvingError
ซึ่งจะติดตามผลของ
สถานะแอปขณะที่ผู้ใช้กำลังแก้ไขข้อผิดพลาดเพื่อหลีกเลี่ยงการพยายามแก้ไขสิ่งเดิมซ้ำๆ
ตัวอย่างเช่น ในขณะที่กล่องโต้ตอบเครื่องมือเลือกบัญชีแสดงขึ้นเพื่อช่วยผู้ใช้ในการแก้ไข
SIGN_IN_REQUIRED
ผู้ใช้อาจหมุนหน้าจอ วิธีนี้จะสร้างกิจกรรมของคุณอีกครั้งและทําให้
onStart()
เป็นเมธอด
อีกครั้ง ซึ่งจากนั้นจะเรียก
connect()
อีกครั้ง ช่วงเวลานี้
ทำให้การเรียกอีก
startResolutionForResult()
ซึ่งจะสร้างกล่องโต้ตอบเครื่องมือเลือกบัญชีขึ้นหน้ากล่องโต้ตอบที่มีอยู่
บูลีนนี้ตามวัตถุประสงค์ที่ตั้งใจไว้ก็ต่อเมื่อบูลีนคงอยู่ในอินสแตนซ์กิจกรรมเท่านั้น ส่วนถัดไปอธิบายวิธีรักษาสถานะการจัดการข้อผิดพลาดของแอป แม้ว่าผู้ใช้จะมีการดำเนินการอื่นๆ ก็ตาม หรือเหตุการณ์ที่เกิดขึ้นในอุปกรณ์
คงสถานะไว้ขณะแก้ไขข้อผิดพลาด
เพื่อหลีกเลี่ยงการเรียกใช้โค้ดใน
onConnectionFailed()
ขณะที่การพยายามแก้ไขข้อผิดพลาดครั้งก่อนอยู่ระหว่างดำเนินการ คุณจะต้องเก็บบูลีนไว้
ติดตามว่าแอปของคุณพยายามแก้ไขข้อผิดพลาดแล้วหรือไม่
ดังที่แสดงในตัวอย่างโค้ดด้านบน แอปของคุณควรตั้งค่าบูลีนเป็น true
ทุกครั้งที่เรียกใช้
startResolutionForResult()
หรือแสดงกล่องโต้ตอบจาก
GoogleApiAvailability.getErrorDialog()
จากนั้นเมื่อแอปได้รับ
RESULT_OK
ในช่วง
onActivityResult()
Callback ตั้งค่าบูลีนเป็น false
เพื่อติดตามบูลีนเมื่อรีสตาร์ทกิจกรรม (เช่น เมื่อผู้ใช้หมุนหน้าจอ)
บันทึกบูลีนในข้อมูลอินสแตนซ์ที่บันทึกไว้ของกิจกรรมโดยใช้
onSaveInstanceState()
:
private static final String STATE_RESOLVING_ERROR = "resolving_error"; @Override protected void onSaveInstanceState(Bundle outState) { super.onSaveInstanceState(outState); outState.putBoolean(STATE_RESOLVING_ERROR, mResolvingError); }
จากนั้นกู้คืนสถานะที่บันทึกไว้ในระหว่าง
onCreate()
:
@Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); // ... mResolvingError = savedInstanceState != null && savedInstanceState.getBoolean(STATE_RESOLVING_ERROR, false); }
ตอนนี้คุณก็พร้อมที่จะเรียกใช้แอปอย่างปลอดภัยและเชื่อมต่อกับบริการ Google Play ด้วยตนเองแล้ว