Google is committed to advancing racial equity for Black communities. See how.
หน้านี้ได้รับการแปลโดย Cloud Translation API
Switch to English

โอนย้ายแอพ Android ของคุณไปที่ Firebase

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

คู่มือนี้จะอธิบายวิธีรวมบริการเฉพาะเข้ากับแอพของคุณ สำหรับคำแนะนำในการตั้งค่า Firebase พื้นฐานดูคู่มือการ ตั้งค่า Android

Google Analytics

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

ดู เอกสาร Google Analytics เพื่อเรียนรู้เพิ่มเติม

กลยุทธ์การย้ายถิ่นที่แนะนำ

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

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

เปรียบเทียบรหัส

วิเคราะห์คำแยกวิเคราะห์

 // Start collecting data
ParseAnalytics.trackAppOpenedInBackground(getIntent());

Map<String, String> dimensions = new HashMap<String, String>();
// Define ranges to bucket data points into meaningful segments
dimensions.put("priceRange", "1000-1500");
// Did the user filter the query?
dimensions.put("source", "craigslist");
// Do searches happen more often on weekdays or weekends?
dimensions.put("dayType", "weekday");

// Send the dimensions to Parse along with the 'search' event
ParseAnalytics.trackEvent("search", dimensions);
 

Google Analytics

 // Obtain the FirebaseAnalytics instance and start collecting data
mFirebaseAnalytics = FirebaseAnalytics.getInstance(this);

Bundle params = new Bundle();
// Define ranges to bucket data points into meaningful segments
params.putString("priceRange", "1000-1500");
// Did the user filter the query?
params.putString("source", "craigslist");
// Do searches happen more often on weekdays or weekends?
params.putString("dayType", "weekday");

// Send the event
mFirebaseAnalytics.logEvent("search", params);
 

ฐานข้อมูลเรียลไทม์ Firebase

ฐานข้อมูล Firebase Realtime เป็นฐานข้อมูลบนคลาวด์ NoSQL ข้อมูลถูกจัดเก็บเป็น JSON และซิงโครไนซ์แบบเรียลไทม์กับไคลเอนต์ที่เชื่อมต่อทุกเครื่อง

ดู เอกสารฐานข้อมูล Firebase เรียลไทม์ เพื่อเรียนรู้เพิ่มเติม

ความแตกต่างกับการแยกวิเคราะห์ข้อมูล

วัตถุ

ใน Parse คุณเก็บ ParseObject หรือ subclass ของมันที่มีคู่ค่าคีย์ของข้อมูลที่เข้ากันได้กับ JSON ข้อมูลเป็นแบบแผนซึ่งหมายความว่าคุณไม่จำเป็นต้องระบุคีย์ที่มีอยู่ในแต่ละ ParseObject

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

ต่อไปนี้เป็นตัวอย่างของวิธีที่คุณอาจบันทึกคะแนนสูงสำหรับเกม

การแยกวิเคราะห์
 @ParseClassName("GameScore")
public class GameScore {
        public GameScore() {}
        public GameScore(Long score, String playerName, Boolean cheatMode) {
            setScore(score);
            setPlayerName(playerName);
            setCheatMode(cheatMode);
        }

        public void setScore(Long score) {
            set("score", score);
        }

        public Long getScore() {
            return getLong("score");
        }

        public void setPlayerName(String playerName) {
            set("playerName", playerName);
        }

        public String getPlayerName() {
            return getString("playerName");
        }

        public void setCheatMode(Boolean cheatMode) {
            return set("cheatMode", cheatMode);
        }

        public Boolean getCheatMode() {
            return getBoolean("cheatMode");
        }
}

// Must call Parse.registerSubclass(GameScore.class) in Application.onCreate
GameScore gameScore = new GameScore(1337, "Sean Plott", false);
gameScore.saveInBackground();
 
Firebase
 // Assuming we defined the GameScore class as:
public class GameScore {
        private Long score;
        private String playerName;
        private Boolean cheatMode;

        public GameScore() {}
        public GameScore(Long score, String playerName, Boolean cheatMode) {
            this.score = score;
            this.playerName = playerName;
            this.cheatMode = cheatMode;
        }

        public Long getScore() {
            return score;
        }

        public String getPlayerName() {
            return playerName;
        }

        public Boolean getCheatMode() {
            return cheatMode;
        }
}

// We would save it to our list of high scores as follows:
DatabaseReference mFirebaseRef = FirebaseDatabase.getInstance().getReference();
GameScore score = new GameScore(1337, "Sean Plott", false);
mFirebaseRef.child("scores").push().setValue(score);
 
สำหรับรายละเอียดเพิ่มเติมให้ อ่าน คู่มือการ อ่านและเขียนข้อมูลบน Android

ความสัมพันธ์ระหว่างข้อมูล

ParseObject สามารถมีความสัมพันธ์กับ ParseObject อื่น: วัตถุใด ๆ สามารถใช้วัตถุอื่นเป็นค่า

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

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

การแยกวิเคราะห์
 // Create the author
ParseObject myAuthor = new ParseObject("Author");
myAuthor.put("name", "Grace Hopper");
myAuthor.put("birthDate", "December 9, 1906");
myAuthor.put("nickname", "Amazing Grace");

// Create the post
ParseObject myPost = new ParseObject("Post");
myPost.put("title", "Announcing COBOL, a New Programming Language");

// Add a relation between the Post and the Author
myPost.put("parent", myAuthor);

// This will save both myAuthor and myPost
myPost.saveInBackground();
 
Firebase
 DatabaseReference firebaseRef = FirebaseDatabase.getInstance().getReference();
// Create the author
Map<String, String> myAuthor = new HashMap<String, String>();
myAuthor.put("name", "Grace Hopper");
myAuthor.put("birthDate", "December 9, 1906");
myAuthor.put("nickname", "Amazing Grace");

// Save the author
String myAuthorKey = "ghopper";
firebaseRef.child('authors').child(myAuthorKey).setValue(myAuthor);

// Create the post
Map<String, String> post = new HashMap<String, String>();
post.put("author", myAuthorKey);
post.put("title", "Announcing COBOL, a New Programming Language");
firebaseRef.child('posts').push().setValue(post);
 

โครงร่างข้อมูลต่อไปนี้เป็นผลลัพธ์

{
  // Info about the authors
  "authors": {
    "ghopper": {
      "name": "Grace Hopper",
      "date_of_birth": "December 9, 1906",
      "nickname": "Amazing Grace"
    },
    ...
  },
  // Info about the posts: the "author" fields contains the key for the author
  "posts": {
    "-JRHTHaIs-jNPLXOQivY": {
      "author": "ghopper",
      "title": "Announcing COBOL, a New Programming Language"
    }
    ...
  }
}
สำหรับรายละเอียดเพิ่มเติมให้ตรวจสอบคำแนะนำ โครงสร้างฐานข้อมูล ของคุณ

กำลังอ่านข้อมูล

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

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

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

การแยกวิเคราะห์
 ParseQuery<ParseObject> query = ParseQuery.getQuery("GameScore");
query.whereEqualTo("playerName", "Dan Stemkoski");
query.findInBackground(new FindCallback<ParseObject>() {
    public void done(List<ParseObject> scoreList, ParseException e) {
        if (e == null) {
            for (ParseObject score: scoreList) {
                Log.d("score", "Retrieved: " + Long.toString(score.getLong("score")));
            }
        } else {
            Log.d("score", "Error: " + e.getMessage());
        }
    }
});
 
Firebase
 DatabaseReference mFirebaseRef = FirebaseDatabase.getInstance().getReference();
Query mQueryRef = mFirebaseRef.child("scores").orderByChild("playerName").equalTo("Dan Stemkoski");

// This type of listener is not one time, and you need to cancel it to stop
// receiving updates.
mQueryRef.addChildEventListener(new ChildEventListener() {
    @Override
    public void onChildAdded(DataSnapshot snapshot, String previousChild) {
        // This will fire for each matching child node.
        GameScore score = snapshot.getValue(GameScore.class);
        Log.d("score", "Retrieved: " + Long.toString(score.getScore());
    }
});
 
สำหรับรายละเอียดเพิ่มเติมเกี่ยวกับประเภทของผู้ฟังเหตุการณ์ที่มีอยู่และวิธีการสั่งซื้อและกรองข้อมูลให้ดูที่คู่มือการ อ่านและเขียนข้อมูลบน Android

กลยุทธ์การย้ายถิ่นที่แนะนำ

คิดใหม่ข้อมูลของคุณ

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

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

โอนย้ายข้อมูลของคุณ

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

ซิงค์พื้นหลัง

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

  • แปลง Parse Data ที่มีอยู่ของคุณเป็นโครงสร้าง Firebase ใหม่แล้วเขียนลงในฐานข้อมูล Firebase Realtime
  • ฟังก์ชั่นเขียนรหัสคลาวด์ที่ใช้ Firebase REST API เพื่อเขียนไปยังการเปลี่ยนแปลงฐานข้อมูลเรียลไทม์ Firebase ที่เกิดขึ้นในการแยกวิเคราะห์ข้อมูลโดยลูกค้าเก่า
  • เขียนและปรับใช้โค้ดที่รับฟังการเปลี่ยนแปลงบน Firebase และซิงค์กับฐานข้อมูล Parse

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

เขียนซ้ำ

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

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

การพิสูจน์ตัวตน Firebase

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

ดู เอกสารรับรองความถูกต้อง Firebase เพื่อเรียนรู้เพิ่มเติม

ความแตกต่างกับการแยกวิเคราะห์รับรองความถูกต้อง

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

FirebaseUser มีชุดของคุณสมบัติพื้นฐานคงที่ - ID เฉพาะ, ที่อยู่อีเมลหลัก, ชื่อและ URL รูปถ่าย - เก็บไว้ในฐานข้อมูลผู้ใช้ของโครงการแยกต่างหาก ผู้ใช้สามารถอัพเดตคุณสมบัติเหล่านั้นได้ คุณไม่สามารถเพิ่มคุณสมบัติอื่นไปยังวัตถุ FirebaseUser โดยตรง คุณสามารถจัดเก็บคุณสมบัติเพิ่มเติมในฐานข้อมูล Firebase Realtime ของคุณแทน

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

การแยกวิเคราะห์
 ParseUser user = new ParseUser();
user.setUsername("my name");
user.setPassword("my pass");
user.setEmail("email@example.com");

// other fields can be set just like with ParseObject
user.put("phone", "650-253-0000");

user.signUpInBackground(new SignUpCallback() {
    public void done(ParseException e) {
        if (e == null) {
            // Hooray! Let them use the app now.
        } else {
            // Sign up didn't succeed. Look at the ParseException
            // to figure out what went wrong
        }
    }
});
 
Firebase
 FirebaseAuth mAuth = FirebaseAuth.getInstance();

mAuth.createUserWithEmailAndPassword("email@example.com", "my pass")
    .continueWithTask(new Continuation<AuthResult, Task<Void>> {
        @Override
        public Task<Void> then(Task<AuthResult> task) {
            if (task.isSuccessful()) {
                FirebaseUser user = task.getResult().getUser();
                DatabaseReference firebaseRef = FirebaseDatabase.getInstance().getReference();
                return firebaseRef.child("users").child(user.getUid()).child("phone").setValue("650-253-0000");
            } else {
                // User creation didn't succeed. Look at the task exception
                // to figure out what went wrong
                Log.w(TAG, "signInWithEmail", task.getException());
            }
        }
    });
 

กลยุทธ์การย้ายถิ่นที่แนะนำ

โอนย้ายบัญชี

หากต้องการโอนย้ายบัญชีผู้ใช้จากการแยกวิเคราะห์เป็น Firebase ให้ส่งออกฐานข้อมูลผู้ใช้ของคุณไปยังไฟล์ JSON หรือ CSV จากนั้นนำเข้าไฟล์ไปยังโครงการ Firebase ของคุณโดยใช้คำสั่ง auth:import ของ Firebase CLI

ขั้นแรกให้ส่งออกฐานข้อมูลผู้ใช้ของคุณจากคอนโซลการแยกวิเคราะห์หรือฐานข้อมูลที่โฮสต์ด้วยตนเอง ตัวอย่างเช่นไฟล์ JSON ที่เอ็กซ์พอร์ตจากคอนโซล Parse อาจมีลักษณะดังต่อไปนี้:

{ // Username/password user
  "bcryptPassword": "$2a$10$OBp2hxB7TaYZgKyTiY48luawlTuYAU6BqzxJfpHoJMdZmjaF4HFh6",
  "email": "user@example.com",
  "username": "testuser",
  "objectId": "abcde1234",
  ...
},
{ // Facebook user
  "authData": {
    "facebook": {
      "access_token": "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
      "expiration_date": "2017-01-02T03:04:05.006Z",
      "id": "1000000000"
    }
  },
  "username": "wXyZ987654321StUv",
  "objectId": "fghij5678",
  ...
}

จากนั้นแปลงไฟล์ที่ส่งออกเป็นรูปแบบที่จำเป็นโดย Firebase CLI ใช้ objectId ของผู้ใช้งานวิเคราะห์คำของคุณเป็น localId ของผู้ใช้ Firebase ของคุณ นอกจากนี้ base64 เข้ารหัสค่า bcryptPassword จาก Parse และใช้ในฟิลด์ passwordHash ตัวอย่างเช่น:

{
  "users": [
    {
      "localId": "abcde1234",  // Parse objectId
      "email": "user@example.com",
      "displayName": "testuser",
      "passwordHash": "JDJhJDEwJE9CcDJoeEI3VGFZWmdLeVRpWTQ4bHVhd2xUdVlBVTZCcXp4SmZwSG9KTWRabWphRjRIRmg2",
    },
    {
      "localId": "fghij5678",  // Parse objectId
      "displayName": "wXyZ987654321StUv",
      "providerUserInfo": [
        {
          "providerId": "facebook.com",
          "rawId": "1000000000",  // Facebook ID
        }
      ]
    }
  ]
}

สุดท้ายนำเข้าไฟล์ที่แปลงแล้วด้วย Firebase CLI โดยระบุ bcrypt เป็นอัลกอริทึมแฮช:

firebase auth:import account_file.json --hash-algo=BCRYPT

โอนย้ายข้อมูลผู้ใช้

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

Firebase Cloud Messaging

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

ดูเอกสาร Firebase Cloud Messaging เพื่อเรียนรู้เพิ่มเติม

ความแตกต่างด้วยการแจงผลักแจง

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

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

กลยุทธ์การย้ายถิ่นที่แนะนำ

การย้ายโทเค็นอุปกรณ์

ในช่วงเวลาของการเขียน Parse Android SDK ใช้โทเค็นการลงทะเบียน FCM รุ่นเก่ากว่าซึ่งไม่สามารถใช้งานร่วมกับคุณสมบัติที่มีให้โดยผู้แต่ง Notifications

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

การย้ายช่องไปยังหัวข้อ FCM

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

 <service android:name="com.parse.PushService" />
<receiver android:name="com.parse.ParsePushBroadcastReceiver"
  android:exported="false">
<intent-filter>
<action android:name="com.parse.push.intent.RECEIVE" />
<action android:name="com.parse.push.intent.DELETE" />
<action android:name="com.parse.push.intent.OPEN" />
</intent-filter>
</receiver>
<receiver android:name="com.parse.GcmBroadcastReceiver"
  android:permission="com.google.android.c2dm.permission.SEND">
<intent-filter>
<action android:name="com.google.android.c2dm.intent.RECEIVE" />
<action android:name="com.google.android.c2dm.intent.REGISTRATION" />

<!--
IMPORTANT: Change "com.parse.starter" to match your app's package name.
-->
<category android:name="com.parse.starter" />
</intent-filter>
</receiver>

<!--
IMPORTANT: Change "YOUR_SENDER_ID" to your GCM Sender Id.
-->
<meta-data android:name="com.parse.push.gcm_sender_id"
  android:value="id:YOUR_SENDER_ID" />;
 

ตัวอย่างเช่นหากผู้ใช้ของคุณสมัครเป็นสมาชิกหัวข้อ "ไจแอนต์" คุณจะทำสิ่งที่ชอบ:

 ParsePush.unsubscribeInBackground("Giants", new SaveCallback() {
    @Override
    public void done(ParseException e) {
        if (e == null) {
            FirebaseMessaging.getInstance().subscribeToTopic("Giants");
        } else {
            // Something went wrong unsubscribing
        }
    }
});
 

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

ดู เอกสารหัวข้อ FCM เพื่อเรียนรู้เพิ่มเติม

Firebase Remote Config

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

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

หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับ Firebase Remote Config ดูการ แนะนำ Remote Config

ความแตกต่างกับการกำหนดค่าแยกวิเคราะห์

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

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

กลยุทธ์การย้ายถิ่นที่แนะนำ

คุณสามารถย้ายไปที่ Firebase Remote Config ได้โดยการคัดลอกคู่คีย์ / ค่าของ Parse config ของคุณไปยังคอนโซล Firebase จากนั้นปรับใช้แอปเวอร์ชันใหม่ที่ใช้ Firebase Remote Config

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

เปรียบเทียบรหัส

การแยกวิเคราะห์

 ParseConfig.getInBackground(new ConfigCallback() {
    @Override
    public void done(ParseConfig config, ParseException e) {
        if (e == null) {
            Log.d("TAG", "Yay! Config was fetched from the server.");
        } else {
            Log.e("TAG", "Failed to fetch. Using Cached Config.");
            config = ParseConfig.getCurrentConfig();
        }

        // Get the message from config or fallback to default value
        String welcomeMessage = config.getString("welcomeMessage", "Welcome!");
    }
});
 

Firebase

 mFirebaseRemoteConfig = FirebaseRemoteConfig.getInstance();
// Set defaults from an XML resource file stored in res/xml
mFirebaseRemoteConfig.setDefaults(R.xml.remote_config_defaults);

mFirebaseRemoteConfig.fetch()
    .addOnSuccessListener(new OnSuccessListener<Void>() {
        @Override
        public void onSuccess(Void aVoid) {
            Log.d("TAG", "Yay! Config was fetched from the server.");
            // Once the config is successfully fetched it must be activated before newly fetched
            // values are returned.
            mFirebaseRemoteConfig.activateFetched();
        }
    })
    .addOnFailureListener(new OnFailureListener() {
        @Override
        public void onFailure(@NonNull Exception exception) {
            Log.e("TAG", "Failed to fetch. Using last fetched or default.");
        }
    })

// ...

// When this is called, the value of the latest fetched and activated config is returned;
// if there's none, the default value is returned.
String welcomeMessage = mFirebaseRemoteConfig.getString("welcomeMessage");