การผสานรวมการกำหนดค่าระยะไกลใน Android Codelab

1. บทนำ

อัปเดตล่าสุด 09-03-2021

การกำหนดค่าระยะไกลของ Firebase คืออะไร

การกำหนดค่าระยะไกลของ Firebase เป็นบริการระบบคลาวด์ที่ช่วยให้คุณเปลี่ยนลักษณะการทำงานและรูปลักษณ์ของแอปได้โดยที่ผู้ใช้ไม่ต้องดาวน์โหลดแอปอัปเดตแอปโดยไม่มีค่าใช้จ่าย เมื่อใช้การกำหนดค่าระยะไกล คุณจะสร้างค่าเริ่มต้นในแอปที่ควบคุมลักษณะการทำงานและรูปลักษณ์ของแอป จากนั้นคุณสามารถใช้คอนโซล Firebase หรือ API แบ็กเอนด์ของการกำหนดค่าระยะไกลเพื่อลบล้างค่าเริ่มต้นในแอปสำหรับผู้ใช้แอปทั้งหมดหรือสำหรับกลุ่มฐานผู้ใช้ของคุณ แอปของคุณจะควบคุมเมื่อมีการนำอัปเดตไปใช้ และจะตรวจสอบการอัปเดตได้บ่อยครั้ง และนำการอัปเดตไปใช้โดยมีผลกระทบต่อประสิทธิภาพเพียงเล็กน้อย

หลักการทำงาน

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

เมธอด get ของไลบรารีของไคลเอ็นต์การกำหนดค่าระยะไกลมีจุดเข้าใช้งานจุดเดียวสำหรับค่าพารามิเตอร์ แอปของคุณจะได้รับค่าฝั่งเซิร์ฟเวอร์โดยใช้ตรรกะเดียวกับที่ใช้ในการรับค่าเริ่มต้นในแอป คุณจึงเพิ่มความสามารถของการกำหนดค่าระยะไกลลงในแอปได้โดยไม่ต้องเขียนโค้ดมากมาย

หากต้องการลบล้างค่าเริ่มต้นในแอป ให้ใช้คอนโซล Firebase หรือ API แบ็กเอนด์ของการกำหนดค่าระยะไกลเพื่อสร้างพารามิเตอร์ที่มีชื่อเดียวกันกับพารามิเตอร์ที่ใช้ในแอป สําหรับพารามิเตอร์แต่ละรายการ คุณสามารถกำหนดค่าเริ่มต้นฝั่งเซิร์ฟเวอร์เพื่อลบล้างค่าเริ่มต้นในแอป และยังสร้างค่าแบบมีเงื่อนไขเพื่อลบล้างค่าเริ่มต้นในแอปสําหรับอินสแตนซ์แอปที่เป็นไปตามเงื่อนไขบางอย่างได้ด้วย กราฟิกนี้จะแสดงลำดับความสำคัญของค่าพารามิเตอร์ในแบ็กเอนด์การกำหนดค่าระยะไกลและในแอป

สิ่งที่คุณจะได้เรียนรู้

• วิธีใช้งานการกำหนดค่าระยะไกลของ Firebase
• วิธีใช้การกำหนดค่าระยะไกลของ Firebase เพื่อเปลี่ยนค่าโดยไม่ต้องอัปเดตแอป

สิ่งที่คุณต้องมี

• Android Studio เวอร์ชันล่าสุด
• บัญชี Firebase
• (แนะนำ แต่ไม่บังคับ) อุปกรณ์ Android ทางกายภาพที่จะใช้เรียกใช้แอป
• ความรู้พื้นฐานเกี่ยวกับ Java หรือ Kotlin

2. การตั้งค่า

(ไม่บังคับ) ดาวน์โหลดโค้ดตัวอย่าง

คุณจะสร้างแอปทดสอบใน Codelab นี้ แต่หากต้องการดูและเรียกใช้แอปตัวอย่างที่มีอยู่ คุณก็ดาวน์โหลดโค้ดตัวอย่างการเริ่มต้นอย่างรวดเร็วได้

คลิกปุ่มต่อไปนี้เพื่อดาวน์โหลดโค้ดทั้งหมดสำหรับ Codelab นี้:

ดาวน์โหลดซอร์สโค้ด

แตกไฟล์ ZIP ที่ดาวน์โหลด การดำเนินการนี้จะคลายแพ็กโฟลเดอร์รูทที่ชื่อ quickstart-android-master

...หรือโคลนที่เก็บ GitHub จากบรรทัดคำสั่ง

$ git clone https://github.com/firebase/quickstart-android.git

ที่เก็บมีหลายโฟลเดอร์ เราจะใช้โฟลเดอร์ config

(ไม่บังคับ) นำเข้าโค้ดตัวอย่าง

เปิด Android Studio แล้วเลือก "นำเข้าโปรเจ็กต์" ในหน้าจอต้อนรับ จากนั้นเปิดโฟลเดอร์ที่ดาวน์โหลดแล้วเลือกโฟลเดอร์ config แล้วคลิก "เปิด"

สร้างโปรเจ็กต์ Android ใหม่

1. ใน Android Studio ให้เริ่มโปรเจ็กต์ใหม่
2. เลือกกิจกรรมพื้นฐาน
3. ในส่วน "กำหนดค่าโปรเจ็กต์ของคุณ" หน้าจอ:
4. ตั้งชื่อโปรเจ็กต์ ระบบจะสร้างชื่อแพ็กเกจและตำแหน่งบันทึกโดยอัตโนมัติ
5. ภาษา: Java
6. SDK ขั้นต่ำ 16

3. เพิ่ม Firebase และ Firebase Analytics ลงในโปรเจ็กต์ Android

สร้างโปรเจ็กต์ Firebase

คุณต้องสร้างโปรเจ็กต์ Firebase เพื่อเชื่อมต่อกับแอป iOS ก่อนจึงจะเพิ่ม Firebase ลงในแอป Android ได้ ไปที่ทำความเข้าใจโปรเจ็กต์ Firebase เพื่อดูข้อมูลเพิ่มเติมเกี่ยวกับโปรเจ็กต์ Firebase

1. ในคอนโซล Firebase ให้คลิกเพิ่มโปรเจ็กต์ จากนั้นเลือกหรือป้อนชื่อโปรเจ็กต์

หากมีโปรเจ็กต์ Google Cloud Platform (GCP) อยู่แล้ว คุณสามารถเลือกโปรเจ็กต์จากเมนูแบบเลื่อนลงเพื่อเพิ่มทรัพยากร Firebase ไปยังโปรเจ็กต์นั้นได้

2. (ไม่บังคับ) หากสร้างโปรเจ็กต์ใหม่ คุณจะแก้ไขรหัสโปรเจ็กต์ได้

Firebase จะกำหนดรหัสที่ไม่ซ้ำกันให้กับโปรเจ็กต์ Firebase โดยอัตโนมัติ ไปที่ "ทำความเข้าใจโปรเจ็กต์ Firebase" เพื่อดูวิธีที่ Firebase ใช้รหัสโปรเจ็กต์

หมายเหตุ: หลังจากที่ Firebase จัดสรรทรัพยากรสำหรับโปรเจ็กต์ Firebase แล้ว คุณจะเปลี่ยนรหัสโปรเจ็กต์ไม่ได้ หากต้องการใช้ตัวระบุที่เจาะจง คุณต้องแก้ไขรหัสโปรเจ็กต์ในขั้นตอนการตั้งค่านี้

3. คลิกต่อไป
4. ตั้งค่า Google Analytics สําหรับโปรเจ็กต์ ซึ่งจะช่วยให้คุณได้รับประสบการณ์ที่ดีที่สุดโดยใช้ผลิตภัณฑ์ Firebase ต่อไปนี้

• Firebase Crashlytics
• Firebase Predictions
• Firebase Cloud Messaging
• การรับส่งข้อความในแอป Firebase
• การกำหนดค่าระยะไกลของ Firebase
• Firebase A/B Testing

เมื่อได้รับข้อความแจ้ง ให้เลือกใช้บัญชี Google Analytics ที่มีอยู่หรือสร้างบัญชีใหม่ หากเลือกสร้างบัญชีใหม่ ให้เลือกตำแหน่งการรายงานของ Analytics จากนั้นยอมรับการตั้งค่าการแชร์ข้อมูลและข้อกำหนดของ Google Analytics สำหรับโปรเจ็กต์

5. คลิกสร้างโปรเจ็กต์ (หรือเพิ่ม Firebase หากใช้โปรเจ็กต์ GCP ที่มีอยู่)

Firebase จะจัดสรรทรัพยากรสำหรับโปรเจ็กต์ Firebase โดยอัตโนมัติ เมื่อขั้นตอนเสร็จสมบูรณ์ ระบบจะนำคุณไปยังหน้าภาพรวมสำหรับโปรเจ็กต์ Firebase ในคอนโซล Firebase

ลงทะเบียนแอปกับ Firebase

หลังจากมีโปรเจ็กต์ Firebase แล้ว คุณจะเพิ่มแอป Android ลงในโปรเจ็กต์นั้นได้

ไปที่ทำความเข้าใจโปรเจ็กต์ Firebase เพื่อดูข้อมูลเพิ่มเติมเกี่ยวกับแนวทางปฏิบัติที่ดีที่สุดและข้อควรพิจารณาสำหรับการเพิ่มแอปในโปรเจ็กต์ Firebase รวมถึงวิธีจัดการตัวแปรบิลด์หลายรายการ

1. ไปที่คอนโซล Firebase
2. ที่ด้านบนของหน้าภาพรวมโปรเจ็กต์ ให้คลิกไอคอน Android เพื่อเปิดเวิร์กโฟลว์การตั้งค่า หากคุณเพิ่มแอปลงในโปรเจ็กต์ Firebase แล้ว ให้คลิก "เพิ่มแอป" เพื่อแสดงตัวเลือกแพลตฟอร์ม
3. ป้อนชื่อแพ็กเกจของแอปในช่องชื่อแพ็กเกจ Android
4. (ไม่บังคับ) ป้อนชื่อเล่นแอป
5. เว้นช่อง SHA-1 ว่างไว้เนื่องจากไม่จำเป็นสำหรับ SHA-1 สำหรับโปรเจ็กต์นี้
6. คลิกลงทะเบียนแอป

เพิ่มไฟล์การกำหนดค่า Firebase

จากนั้น ระบบจะแจ้งให้คุณดาวน์โหลดไฟล์การกำหนดค่าที่มีข้อมูลเมตา Firebase ทั้งหมดที่จำเป็นสำหรับแอป คลิกดาวน์โหลด google-services.json เพื่อรับไฟล์การกำหนดค่า Android ของ Firebase (google-services.json)

ในไฟล์ Gradle ระดับโปรเจ็กต์ (build.gradle) ให้เพิ่มกฎเพื่อรวมปลั๊กอิน Google Services Gradle ตรวจสอบว่าคุณมีที่เก็บ Maven ของ Google ด้วย

Build.gradle ระดับโปรเจ็กต์ (<project>/build.gradle):

buildscript {

  repositories {
    // Check that you have the following line (if not, add it):
    google()  // Google's Maven repository
  }

  dependencies {
    // ...

    // Add the following line:
    classpath 'com.google.gms:google-services:4.3.5'  // Google Services plugin
  }
}

allprojects {
  // ...

  repositories {
    // Check that you have the following line (if not, add it):
    google()  // Google's Maven repository
    // ...
  }
}

ในไฟล์ Gradle ของโมดูล (ระดับแอป) (โดยทั่วไปจะเป็น app/build.gradle) ให้ใช้ปลั๊กอิน Gradle บริการของ Google ดังนี้

Build.gradle ระดับแอป (<project>/<app-module>/build.gradle):

ใช้ปลั๊กอิน: "com.android.application"

// เพิ่มบรรทัดต่อไปนี้

applyปลั๊กอิน: "com.google.gms.google-services" // ปลั๊กอินบริการของ Google

android {

// ...

}

เพิ่ม Firebase SDK ลงในแอป Android

สำหรับการกำหนดค่าระยะไกล ต้องใช้ Google Analytics ในการกำหนดเป้าหมายแบบมีเงื่อนไขของอินสแตนซ์แอปไปยังพร็อพเพอร์ตี้ผู้ใช้และกลุ่มเป้าหมาย ตรวจสอบว่าเปิดใช้ Google Analytics ในโปรเจ็กต์แล้ว

(ซึ่งทำแล้วในโค้ดการเริ่มต้นอย่างรวดเร็วตัวอย่าง)

ใช้ Firebase Android BoM เพื่อประกาศทรัพยากร Dependency สำหรับไลบรารีการกำหนดค่าระยะไกลสำหรับ Android ในไฟล์ Gradle ของโมดูล (ระดับแอป) (โดยทั่วไปจะเป็น app/build.gradle) การใช้ Firebase Android BoM จะทำให้แอปใช้ไลบรารี Firebase Android เวอร์ชันที่เข้ากันได้เสมอ

นอกจากนี้ ในการตั้งค่า Analytics คุณยังต้องเพิ่ม Firebase SDK สำหรับ Google Analytics ลงในแอปด้วย ในส่วนทรัพยากร Dependency ให้เพิ่มโค้ดต่อไปนี้

app/build.gradle

dependencies {
    // Import the BoM for the Firebase platform
    implementation platform('com.google.firebase:firebase-bom:26.6.0')

    // Declare the dependencies for the Remote Config and Analytics libraries
    // When using the BoM, you don't specify versions in Firebase library dependencies
    implementation 'com.google.firebase:firebase-config'
    implementation 'com.google.firebase:firebase-analytics'
}

ซิงค์โปรเจ็กต์กับไฟล์ Gradle

หากต้องการตรวจสอบว่าทรัพยากร Dependency ทั้งหมดพร้อมใช้งานกับแอป ให้ซิงค์โปรเจ็กต์กับไฟล์ Gradle โดยเลือก File > ซิงค์โปรเจ็กต์กับไฟล์ Gradle

4. ตรวจสอบคอมโพเนนต์หลักของการกำหนดค่าระยะไกล

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

1. รับออบเจ็กต์ Singleton สำหรับการกำหนดค่าระยะไกล

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

MainActivity.java

mFirebaseRemoteConfig = FirebaseRemoteConfig.getInstance();
FirebaseRemoteConfigSettings configSettings = new FirebaseRemoteConfigSettings.Builder()
        .setMinimumFetchIntervalInSeconds(3600)
        .build();
mFirebaseRemoteConfig.setConfigSettingsAsync(configSettings);

ออบเจ็กต์ Singleton ใช้ในการจัดเก็บค่าพารามิเตอร์เริ่มต้นในแอป ดึงข้อมูลค่าพารามิเตอร์ที่อัปเดตจากแบ็กเอนด์ และควบคุมเมื่อค่าที่ดึงข้อมูลพร้อมใช้งานสำหรับแอป

ระหว่างการพัฒนา ขอแนะนำให้กำหนดช่วงเวลาการดึงข้อมูลขั้นต่ำค่อนข้างต่ำ โปรดดูข้อมูลเพิ่มเติมที่การควบคุม

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

2. ตั้งค่าพารามิเตอร์เริ่มต้นในแอป

คุณสามารถตั้งค่าพารามิเตอร์เริ่มต้นในแอปในออบเจ็กต์การกำหนดค่าระยะไกล เพื่อให้แอปทำงานตามที่ต้องการก่อนที่จะเชื่อมต่อกับแบ็กเอนด์การกำหนดค่าระยะไกล และเพื่อให้ค่าเริ่มต้นสามารถใช้ได้หากไม่ได้ตั้งค่าไว้ในแบ็กเอนด์

คุณกำหนดชุดของชื่อพารามิเตอร์และค่าพารามิเตอร์เริ่มต้นได้โดยใช้ออบเจ็กต์แมป หรือไฟล์ทรัพยากร XML ที่จัดเก็บไว้ในโฟลเดอร์ res/xml ของแอป แอปตัวอย่างการเริ่มต้นการกำหนดค่าระยะไกลอย่างรวดเร็วจะใช้ไฟล์ XML เพื่อกำหนดชื่อและค่าพารามิเตอร์เริ่มต้น วิธีสร้างไฟล์ XML ของคุณเองมีดังนี้

1. สร้างโฟลเดอร์ xml ในโฟลเดอร์ res

2. คลิกขวาที่โฟลเดอร์ xml ที่สร้างใหม่และสร้างไฟล์

3. ตั้งค่าเริ่มต้น ในส่วนถัดไป ให้ลองเปลี่ยนค่าเริ่มต้นในไฟล์ XML การเริ่มต้นใช้งานการกำหนดค่าระยะไกลอย่างรวดเร็ว
4. เพิ่มค่าเหล่านี้ลงในออบเจ็กต์การกำหนดค่าระยะไกลโดยใช้ setDefaultsAsync(int) ดังที่แสดงด้านล่างนี้

MainActivity.java

mFirebaseRemoteConfig.setDefaultsAsync(R.xml.remote_config_defaults);

3. รับค่าพารามิเตอร์เพื่อใช้ในแอป

ตอนนี้คุณสามารถรับค่าพารามิเตอร์จากออบเจ็กต์การกำหนดค่าระยะไกลได้แล้ว หากคุณตั้งค่าในแบ็กเอนด์ ให้ดึงข้อมูลแล้วเปิดใช้งานค่าเหล่านั้น ค่าเหล่านั้นจะพร้อมใช้งานในแอป ไม่เช่นนั้น ระบบจะกำหนดค่าพารามิเตอร์ในแอปโดยใช้ setDefaultsAsync(int) ในการรับค่าเหล่านี้ ให้เรียกใช้เมธอดด้านล่างซึ่งจับคู่กับประเภทข้อมูลที่แอปคาดหวัง โดยระบุคีย์พารามิเตอร์เป็นอาร์กิวเมนต์

• getBoolean()
• getDouble()
• getLong()
• getString()

4. ดึงข้อมูลและเปิดใช้งานค่า

1. หากต้องการดึงค่าพารามิเตอร์จากแบ็กเอนด์การกำหนดค่าระยะไกล ให้เรียกใช้เมธอด fetch() ค่าที่คุณกำหนดในแบ็กเอนด์จะถูกดึงข้อมูลและเก็บไว้ในออบเจ็กต์การกำหนดค่าระยะไกล
2. หากต้องการให้ค่าพารามิเตอร์ที่ดึงมาใช้ได้กับแอป ให้เรียกใช้เมธอด activate() สำหรับกรณีที่คุณต้องการดึงข้อมูลและเปิดใช้งานค่าในการเรียกใช้ครั้งเดียว คุณสามารถใช้คำขอFetchAndActivate() เพื่อดึงค่าจากแบ็กเอนด์การกำหนดค่าระยะไกล และทำให้ค่านั้นพร้อมใช้งานในแอป โดยทำดังนี้

MainActivity.java

mFirebaseRemoteConfig.fetchAndActivate()
        .addOnCompleteListener(this, new OnCompleteListener<Boolean>() {
            @Override
            public void onComplete(@NonNull Task<Boolean> task) {
                if (task.isSuccessful()) {
                    boolean updated = task.getResult();
                    Log.d(TAG, "Config params updated: " + updated);
                    Toast.makeText(MainActivity.this, "Fetch and activate succeeded",
                            Toast.LENGTH_SHORT).show();

                } else {
                    Toast.makeText(MainActivity.this, "Fetch failed",
                            Toast.LENGTH_SHORT).show();
                }
                displayWelcomeMessage();
            }
        });

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

หมายเหตุ: หากแอปสร้างด้วย Gradle ไม่ได้ คุณต้องเพิ่มทรัพยากรสตริง google_app_id ที่ถูกต้องลงในแอปด้วยตนเองเพื่อให้การกำหนดค่าระยะไกลเริ่มต้นได้ ปกติแล้วปลั๊กอิน Gradle ของ google-services จะเพิ่มค่านี้โดยอัตโนมัติ แต่คุณสามารถหาค่าที่เหมาะสมได้ในไฟล์ google-services.json ที่คุณดาวน์โหลดจากคอนโซล Firebase สำหรับข้อมูลเพิ่มเติมเกี่ยวกับการรับค่า google_app_id จากไฟล์ google-services.json โปรดดูการประมวลผลไฟล์ JSON

การควบคุม

หากแอปดึงข้อมูลหลายครั้งเกินไปในช่วงเวลาสั้นๆ ระบบจะควบคุมการเรียกเพื่อดึงข้อมูลและ SDK จะแสดงผลFirebaseRemoteConfigFetchThrottledException ก่อน SDK เวอร์ชัน 17.0.0 ขีดจำกัดคือคำขอดึงข้อมูล 5 รายการในช่วงเวลา 60 นาที (เวอร์ชันใหม่จะมีขีดจำกัดที่เข้มงวดกว่า)

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

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

1. พารามิเตอร์ใน fetch(long)
2. พารามิเตอร์ใน FirebaseRemoteConfigSettings.setMinimumFetchIntervalInSeconds(long)
3. ค่าเริ่มต้นคือ 12 ชั่วโมง

หากต้องการกำหนดช่วงเวลาการดึงข้อมูลขั้นต่ำเป็นค่าที่กำหนดเอง ให้ใช้ FirebaseRemoteConfigSettings.Builder.setMinimumFetchIntervalInSeconds(long)

โปรดทราบว่าการตั้งค่านี้ควรใช้สำหรับการพัฒนาเท่านั้น ไม่ใช่สำหรับแอปที่ทำงานในเวอร์ชันที่ใช้งานจริง หากคุณเพิ่งทดสอบแอปกับทีมพัฒนาที่มีสมาชิก 10 คน ไม่น่าจะถึงขีดจำกัดโควต้าฝั่งบริการรายชั่วโมง แต่หากคุณพุชแอปไปยังผู้ใช้ทดสอบหลายพันรายโดยมีช่วงเวลาการดึงข้อมูลขั้นต่ำต่ำมาก แอปของคุณก็น่าจะถึงโควต้านี้

5. เปลี่ยนลักษณะการทำงานของแอปด้วยการกำหนดค่าระยะไกล

เปลี่ยนพารามิเตอร์เริ่มต้นในแอป

เปิด res/xml/remote_config_defaults.xml และเปลี่ยนค่าเริ่มต้นเป็นอย่างอื่น

res/xml/remote_config_defaults.xml

<?xml version="1.0" encoding="utf-8"?>
<!-- START xml_defaults -->
<defaultsMap>
    <entry>
        <key>loading_phrase</key>
        <value>Fetching config...</value>
    </entry>
    <entry>
        <key>welcome_message_caps</key>
        <value>false</value>
    </entry>
    <entry>
        <key>welcome_message</key>
        <value>Welcome to my awesome app!</value>
    </entry>
</defaultsMap>
    <!-- END xml_defaults -->

ยืนยันการเปลี่ยนแปลงมูลค่าเริ่มต้นในแอป

1. เรียกใช้โปรเจ็กต์ในโปรแกรมจำลองหรือใช้อุปกรณ์ทดสอบเพื่อยืนยันลักษณะการทำงาน
2. คลิก Open ในเวอร์ชัน Java หรือ Kotlin

3. ตรวจสอบข้อความต้อนรับในมุมมองหลัก

ตั้งค่าค่าพารามิเตอร์ในแบ็กเอนด์การกำหนดค่าระยะไกล

ตอนนี้มาทดสอบการส่งค่าผ่านการกำหนดค่าระยะไกลกัน เมื่อใช้คอนโซล Firebase หรือ API แบ็กเอนด์ของการกำหนดค่าระยะไกล คุณสามารถสร้างค่าเริ่มต้นฝั่งเซิร์ฟเวอร์ที่ลบล้างค่าในแอปตามตรรกะแบบมีเงื่อนไขหรือการกำหนดเป้าหมายผู้ใช้ที่คุณต้องการ ส่วนนี้จะอธิบายขั้นตอนในการสร้างค่าเหล่านี้ในคอนโซล Firebase

1. เปิดคอนโซล Firebase เปิดโปรเจ็กต์
2. เลือกการกำหนดค่าระยะไกลจากเมนูด้านซ้ายมือในส่วน Engage เพื่อดูแดชบอร์ดการกำหนดค่าระยะไกล
3. ในส่วนเพิ่มพารามิเตอร์ ให้ป้อน Parameter key. ใต้ Default value เพิ่มข้อความตามต้องการ จากนั้นคลิก "เพิ่มพารามิเตอร์" สำหรับ Codelab นี้ เราจะใช้คีย์พารามิเตอร์ในไฟล์ res/xml/remote_config_defaults.xml โปรดดูรายละเอียดในตารางด้านล่าง

คีย์พารามิเตอร์	ค่าเริ่มต้น (remote_config_defaults.xml)	คำอธิบาย
loading_phrase	กำลังดึงข้อมูลการกำหนดค่า...	String; แสดงเมื่อดึงข้อมูลค่าของการกำหนดค่าระยะไกล
welcome_message_caps	เท็จ	บูลีน หากเป็น "จริง" เปลี่ยน Welcome_message เป็นตัวพิมพ์ใหญ่ทั้งหมด
welcome_message	ยินดีต้อนรับสู่แอปสุดเจ๋งของฉัน	String; ข้อความต้อนรับ

ภาพหน้าจอตัวอย่าง

4. เมื่อคุณเพิ่มพารามิเตอร์เสร็จแล้ว ให้คลิก "เผยแพร่การเปลี่ยนแปลง"
5. เรียกใช้แอปของคุณในโปรแกรมจําลองหรืออุปกรณ์อีกครั้ง และคลิก "ดึงข้อมูลต้อนรับจากระยะไกล" ในครั้งนี้

6. ข้อความต้อนรับควรได้รับการอัปเดตตามพารามิเตอร์และค่าการกำหนดค่าระยะไกล

6. ขอแสดงความยินดี

ขอแสดงความยินดี คุณใช้การกำหนดค่าระยะไกลเพื่อเปลี่ยนข้อความต้อนรับเรียบร้อยแล้ว การใช้การกำหนดค่าระยะไกลเพื่อเปลี่ยนและปรับแต่งแอปทำได้หลายวิธี โปรดดูแหล่งข้อมูลเพิ่มเติมด้านล่าง

• เริ่มต้นใช้งานการกำหนดค่าระยะไกลของ Firebase
• ฉันจะใช้การกำหนดค่าระยะไกลทำอะไรได้บ้าง
• API การกำหนดค่าระยะไกลของ Firebase
• สร้างการทดสอบการกำหนดค่าระยะไกลของ Firebase ด้วยการทดสอบ A/B