หน้านี้ได้รับการแปลโดย Cloud Translation API

เริ่มต้นใช้งานการกำหนดค่าระยะไกลของ Firebase

คุณสามารถใช้การกำหนดค่าระยะไกลของ Firebase เพื่อกำหนดพารามิเตอร์ในแอปและอัปเดต ค่านั้นในระบบคลาวด์ ซึ่งทำให้คุณปรับแต่งรูปลักษณ์และลักษณะการทำงานของ แอปของคุณโดยไม่เผยแพร่การอัปเดตแอป คู่มือนี้จะแนะนําขั้นตอนในการเริ่มต้นใช้งานและ โค้ดตัวอย่าง ซึ่งทั้งหมดสามารถโคลนหรือดาวน์โหลดได้จาก firebase/quickstart-androidในที่เก็บ GitHub

ขั้นตอนที่ 1: เพิ่ม Firebase และ SDK การกำหนดค่าระยะไกลลงในแอป

หากคุณยังไม่ได้ดำเนินการ เพิ่ม Firebase ลงในโปรเจ็กต์ Android
สำหรับการกำหนดค่าระยะไกล คุณต้องใช้ Google Analytics สำหรับ การกำหนดเป้าหมายแบบมีเงื่อนไขของอินสแตนซ์แอป สำหรับพร็อพเพอร์ตี้ผู้ใช้และกลุ่มเป้าหมาย โปรดตรวจสอบว่า คุณจะเปิดใช้ Google Analytics ในโปรเจ็กต์ได้
ในไฟล์ Gradle ของโมดูล (ระดับแอป) (ปกติ <project>/<app-module>/build.gradle.kts หรือ <project>/<app-module>/build.gradle) เพิ่มทรัพยากร Dependency สำหรับไลบรารีการกำหนดค่าระยะไกลสำหรับ Android เราขอแนะนำให้ใช้ BoM ของ Firebase Android เพื่อควบคุมการกำหนดเวอร์ชันไลบรารี

นอกจากนี้ คุณยังต้องเพิ่ม Firebase SDK ในฐานะส่วนหนึ่งของการตั้งค่า Analytics Google Analytics ไปยังแอปของคุณ
```
dependencies {
    // Import the BoM for the Firebase platform
    implementation(platform("com.google.firebase:firebase-bom:33.1.2"))

    // Add 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")
}
```
การใช้ Firebase Android BoM แอปจะใช้ไลบรารี Firebase Android เวอร์ชันที่เข้ากันได้เสมอ
(ทางเลือก) เพิ่มทรัพยากร Dependency ของไลบรารี Firebase โดยไม่ต้องใช้ BoM

หากเลือกไม่ใช้ Firebase BoM คุณต้องระบุเวอร์ชันไลบรารี Firebase แต่ละเวอร์ชัน ในบรรทัดทรัพยากร Dependency

โปรดทราบว่าหากคุณใช้ไลบรารี Firebase หลายรายการในแอป เราขอแนะนำอย่างยิ่ง ขอแนะนำให้ใช้ BoM ในการจัดการเวอร์ชันไลบรารี เพื่อดูแลให้ทุกเวอร์ชัน ที่เข้ากันได้
```
dependencies {
    // Add the dependencies for the Remote Config and Analytics libraries
    // When NOT using the BoM, you must specify versions in Firebase library dependencies
    implementation("com.google.firebase:firebase-config:22.0.0")
    implementation("com.google.firebase:firebase-analytics:22.0.2")
}
```
หากกำลังมองหาโมดูลไลบรารีสำหรับ Kotlin โดยเฉพาะ จะเริ่มต้นใน ตุลาคม 2023 (Firebase BoM 32.5.0) ทั้งนักพัฒนาซอฟต์แวร์ Kotlin และ Java สามารถ ขึ้นอยู่กับโมดูลไลบรารีหลัก (ดูรายละเอียดได้ที่ คําถามที่พบบ่อยเกี่ยวกับโครงการริเริ่มนี้)

ขั้นตอนที่ 2: รับออบเจ็กต์ Singleton สำหรับการกำหนดค่าระยะไกล

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

Kotlin+KTX

val remoteConfig: FirebaseRemoteConfig = Firebase.remoteConfig
val configSettings = remoteConfigSettings {
    minimumFetchIntervalInSeconds = 3600
}
remoteConfig.setConfigSettingsAsync(configSettings)MainActivity.kt

Java

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

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

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

ขั้นตอนที่ 3: ตั้งค่าพารามิเตอร์เริ่มต้นในแอป

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

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

หากคุณกำหนดค่าพารามิเตอร์แบ็กเอนด์ของการกำหนดค่าระยะไกลแล้ว คุณสามารถดาวน์โหลดไฟล์ XML ที่สร้างขึ้น ซึ่งมีค่าเริ่มต้นทั้งหมดและ บันทึกลงในไดเรกทอรี res/xml ของแอป:
REST
```
curl --compressed -D headers -H "Authorization: Bearer token" -X GET https://firebaseremoteconfig.googleapis.com/v1/projects/my-project-id/remoteConfig:downloadDefaults?format=XML -o remote_config_defaults.xml
```
คอนโซล Firebase
1. ในพารามิเตอร์ เปิดเมนู และ เลือกดาวน์โหลดค่าเริ่มต้น
2. เมื่อมีข้อความแจ้ง ให้เปิดใช้ .xml สำหรับ Android แล้วคลิก ดาวน์โหลดไฟล์
เพิ่มค่าเหล่านี้ลงในออบเจ็กต์การกำหนดค่าระยะไกลโดยใช้ setDefaultsAsync(int), ดังต่อไปนี้
Kotlin+KTX
```
remoteConfig.setDefaultsAsync(R.xml.remote_config_defaults)
```
Java
```
mFirebaseRemoteConfig.setDefaultsAsync(R.xml.remote_config_defaults);
```

ขั้นตอนที่ 4: รับค่าพารามิเตอร์เพื่อใช้ในแอป

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

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

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

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

ขั้นตอนที่ 6: ดึงข้อมูลและเปิดใช้งานค่า

หากต้องการดึงค่าพารามิเตอร์จากแบ็กเอนด์การกำหนดค่าระยะไกล ให้เรียกเมธอด fetch() ระบบจะดึงข้อมูลค่าใดก็ตามที่คุณกำหนดในแบ็กเอนด์ และจัดเก็บไว้ในออบเจ็กต์การกำหนดค่าระยะไกล

หากต้องการให้ค่าพารามิเตอร์ที่ดึงข้อมูลไว้ใช้กับแอปได้ ให้เรียกใช้เมธอด activate()

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

Kotlin+KTX

remoteConfig.fetchAndActivate()
    .addOnCompleteListener(this) { task ->
        if (task.isSuccessful) {
            val updated = task.result
            Log.d(TAG, "Config params updated: $updated")
            Toast.makeText(
                this,
                "Fetch and activate succeeded",
                Toast.LENGTH_SHORT,
            ).show()
        } else {
            Toast.makeText(
                this,
                "Fetch failed",
                Toast.LENGTH_SHORT,
            ).show()
        }
        displayWelcomeMessage()
    }

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

ขั้นตอนที่ 7: ฟังข้อมูลอัปเดตแบบเรียลไทม์

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

Firebase SDK สำหรับ Android เวอร์ชัน 21.3.0 ขึ้นไป (Firebase BoM) รองรับการอัปเดตแบบเรียลไทม์ v31.2.4 ขึ้นไป)

สำคัญ: การกำหนดค่าระยะไกลแบบเรียลไทม์ยังต้องใช้ การกำหนดค่าระยะไกลของ Firebase Realtime API ซึ่งควรเปิดใช้ให้คุณอยู่แล้ว หากต้องการยืนยัน ให้เปิด Google Cloud Console เลือกโปรเจ็กต์ แล้วเปิดหน้า API และบริการ API ควร จะปรากฏเป็นเปิดใช้งาน ถ้าไม่มี API หรือไม่ได้เปิดใช้ ให้คลิกเปิดใช้ API และ บริการ ให้ค้นหา Realtime API ของการกำหนดค่าระยะไกลของ Firebase เปิดใช้ได้เลย

ในแอป ให้ใช้ addOnConfigUpdateListener() เพื่อเริ่มฟังข้อมูลอัปเดต และดึงข้อมูลค่าพารามิเตอร์ใหม่โดยอัตโนมัติ ใช้ onUpdate() Callback เพื่อเปิดใช้การกำหนดค่าที่อัปเดตแล้ว

Kotlin+KTX

remoteConfig.addOnConfigUpdateListener(object : ConfigUpdateListener {
    override fun onUpdate(configUpdate : ConfigUpdate) {
       Log.d(TAG, "Updated keys: " + configUpdate.updatedKeys);

       if (configUpdate.updatedKeys.contains("welcome_message")) {
           remoteConfig.activate().addOnCompleteListener {
               displayWelcomeMessage()
           }
       }
    }

    override fun onError(error : FirebaseRemoteConfigException) {
        Log.w(TAG, "Config update error with code: " + error.code, error)
    }
})

Java

mFirebaseRemoteConfig.addOnConfigUpdateListener(new ConfigUpdateListener() {
    @Override
    public void onUpdate(ConfigUpdate configUpdate) {
        Log.d(TAG, "Updated keys: " + configUpdate.getUpdatedKeys());

        mFirebaseRemoteConfig.activate().addOnCompleteListener(new OnCompleteListener() {
            @Override
            public void onComplete(@NonNull Task task) {
                displayWelcomeMessage();
            }
        });
    }

    @Override
    public void onError(FirebaseRemoteConfigException error) {
        Log.w(TAG, "Config update error with code: " + error.getCode(), error);
    }
});

ครั้งต่อไปที่คุณเผยแพร่การกำหนดค่าระยะไกลเวอร์ชันใหม่ อุปกรณ์ ที่กำลังใช้งานแอปของคุณอยู่และรอรับการเปลี่ยนแปลงอยู่การเรียกฟังก์ชัน ConfigUpdateListener.

การควบคุม

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

เคล็ดลับ: เริ่มตั้งแต่ Android SDK v21.3.0 ขึ้นไป (Firebase BoM v31.3.0 ขึ้นไป) คุณสามารถใช้แบบเรียลไทม์ กำหนดค่าระยะไกลเพื่อดึงค่าพารามิเตอร์ที่อัปเดตแล้วโดยอัตโนมัติจาก แบ็กเอนด์การกำหนดค่าระยะไกลทันทีที่เผยแพร่ โดยข้ามการกำหนดขั้นต่ำใดๆ การตั้งค่าช่วงเวลาการดึงข้อมูล ดูข้อมูลเพิ่มเติมได้ที่ฟัง เพื่อดูการอัปเดตแบบเรียลไทม์

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

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

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

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

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

ขั้นตอนถัดไป

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