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

1. บทนำ

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

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

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

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

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

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

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

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

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

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

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

2. การเริ่มต้นใช้งาน

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

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

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

ในไฟล์ Gradle ระดับโปรเจ็กต์ (build.gradle) ให้เพิ่มกฎเพื่อรวมปลั๊กอิน Gradle ของบริการของ Google ตรวจสอบว่าคุณมีที่เก็บ 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):

apply plugin: ‘com.android.application'

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

apply plugin: ‘com.google.gms.google-services' // Google Services plugin

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 ลงในแอปด้วย โดยเพิ่มโค้ดต่อไปนี้ในส่วนการขึ้นต่อกัน

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 โดยเลือกไฟล์ > ซิงค์โปรเจ็กต์กับไฟล์ 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. ตั้งค่าพารามิเตอร์เริ่มต้นในแอป

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

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

การควบคุมปริมาณ

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

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

ช่วงเวลาการดึงข้อมูลขั้นต่ำเริ่มต้นสำหรับ Remote Config คือ 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. คลิก "เปิด" ในเวอร์ชัน Java หรือ Kotlin

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

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

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

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

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

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

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

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

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

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

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