เชื่อมโยง Idp

หลังจากเข้าสู่ระบบ ผู้ใช้จะต้องสามารถแสดงสถานะการเชื่อมโยงของ PlayerID ที่ใช้งานอยู่ในขณะนี้และได้รับความสามารถในการเชื่อมโยงกับ IdP อื่น ๆ (ผู้ให้บริการ ID ซึ่งจะเรียกว่า IdP ต่อไป)

โปรดกำหนดค่าผู้ใช้ให้แสดงสถานะการรวม IdP ในเมนูการตั้งค่าเกมและอนุญาตให้มีการรวม IdP และการตัดการเชื่อมต่อ

ตรวจสอบข้อมูลสถานะการรวม IdP¶

คุณสามารถตรวจสอบรายชื่อ IdP ที่เชื่อมโยงกับ PlayerID ที่เข้าสู่ระบบในปัจจุบันได้โดยใช้ AuthV4 คลาส's getPlayerInfo() วิธีการ กรุณากำหนดค่า UI เพื่อแสดงว่า IdP ใดเชื่อมโยงในหน้าจอการตั้งค่าในเกมและเปิดเผย ข้อความที่กระตุ้นการรวม IdP。

ในหน้าจอการตั้งค่าในเกม จะต้องแสดง PlayerID ของผู้ใช้พร้อมกับข้อมูลการรวม IdP PlayerID ควรระบุว่าเป็น CS Code และควรเปิดเผยค่าของ PlayerID ของผู้ใช้ที่เข้าสู่ระบบอยู่ในขณะนี้

• หน้าจอตัวอย่างสำหรับตรวจสอบ IdP ที่เชื่อมโยงกับ PlayerID ที่เข้าสู่ระบบในปัจจุบัน
• หน้าจอตัวอย่างสำหรับกระตุ้นการเชื่อมโยงบัญชี

ต่อไปนี้จะตรวจสอบรายการ IdP ที่มีอยู่ในแอปปัจจุบันผ่านทาง providerTypeList ที่ส่งกลับจาก setup() และจากนั้นใช้โค้ดตัวอย่างด้านล่างเพื่อตรวจสอบรายการ IdP ที่เชื่อมโยงกับ PlayerID และแสดงสถานะการเชื่อมโยง

AuthV4.PlayerInfo playerInfo = AuthV4.getPlayerInfo();    

        foreach (AuthV4.ProviderInfo providerInfo in playerInfo.providerInfoData) {    
            // Synced-Provider data    
    }

#include "HiveAuthV4.h"

TOptional<FHivePlayerInfo> PlayerInfo = FHiveAuthV4::GetPlayerInfo();
if (PlayerInfo.IsSet())
{
        const FHivePlayerInfo& PlayerInfoData = PlayerInfo.GetValue();
        for (const auto& ProviderInfo : PlayerInfoData.ProviderInfoData)
        {
                // Check IdP integration status
        }
}

// Request the sync status of Hive SDK AuthV4    
        for( auto providerInfo : AuthV4::getPlayerInfo().providerInfoData ) {    
            cout<<"ProviderType : "<<ProviderInfo::stringProviderType(providerInfo.second.providerType)<<endl;    
            cout<<"ProviderUserId : "<<providerInfo.second.providerUserId<<endl;    
    }

//Search the verified user data    
    AuthV4.PlayerInfo playerInfo = AuthV4.getPlayerInfo();

HIVEPlayerInfo *playerInfo = [HIVEAuthV4 getPlayerInfo];    

        for (NSString *providerTypeStr in [playerInfo.providerInfoData allKeys]) {    
            // Synced Provider data    
            HIVEProviderInfo *providerInfo = playerInfo.providerInfoData[providerTypeStr];    
    }

import HIVEService
// Search the verified user data
let playerInfo = AuthV4Interface.getPlayerInfo()

วลีเพื่อแนะนำการซิงค์ IdP¶

IdP Sync¶

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

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

สำหรับการรวม IdP ให้เรียกใช้วิธีการ connect () พร้อมกับ ProviderType ที่คุณต้องการทำงานด้วยเป็นพารามิเตอร์ ต่อไปนี้คือตัวอย่างโค้ดในการดำเนินการซิงค์ IdP

// Hive SDK AuthV4 Request to sync with IdP    
        AuthV4.Helper.connect (providerType, delegate (ResultAPI result, AuthV4.PlayerInfo playerInfo) {    
            switch(result.code) {    
            case ResultAPI.Code.Success:    
                // Success to sync IdP    
                break;    
            case ResultAPI.Code.AuthV4ConflictPlayer:    
                // Account conflict    
                break;    
            default:    
                // Exceptional case    
                break;    
            }    
    });

#include "HiveAuthV4.h"

EHiveProviderType ProviderType = EHiveProviderType::HIVE;
FHiveAuthV4::Helper::Connect(ProviderType, FHiveAuthV4HelperDelegate::CreateLambda([this](const FHiveResultAPI& Result, const TOptional<FHivePlayerInfo>& PlayerInfo) {
        switch (Result.Code) {
                case FHiveResultAPI::ECode::Success:
                        // สำเร็จในการซิงค์ IdP
                        break;
                case FHiveResultAPI::ECode::AuthV4ConflictPlayer:
                        // ข้อขัดแย้งของบัญชี
                        break;
                default:
                        // กรณีพิเศษ
                        break;
        }
}));

// Hive SDK AuthV4 Request to sync with IdP    
        AuthV4::Helper::connect(ProviderInfo::providerTypeFromString(providerType), [=](ResultAPI const & result, std::shared_ptr playerInfo) {    
                switch (result.code) {    
                case ResultAPI::Success:    
                    // Success to sync IdP    
                    break;    
                case ResultAPI::AuthV4ConflictPlayer:    
                    // Account conflict    
                    break;    
                default:    
                    // Exceptional case    
                    break;    
                }    
    });

// Hive SDK AuthV4 Request to sync with IdP    
        AuthV4.Helper.connect(ProviderType providerType, new AuthV4.Helper.AuthV4HelperListener() {    
            @Override    
            public void onAuthV4Helper(ResultAPI result, AuthV4.PlayerInfo playerInfo) {    
                switch(result.code) {    
                    case Success:    
                        // Success to sync IdP    
                        break;    
                    case AuthV4ConflictPlayer:    
                        // Account conflict    
                        break;    
                    default:    
                        // Exceptional case    
                        break;    
                }    
            }    
    });

// Hive SDK AuthV4 Request to sync with IdP    
        [[HIVEAuthV4 helper] connect:providerType handler:^(HIVEResultAPI *result, HIVEPlayerInfo *playerInfo) {    
            switch(result.code) {    
            case kSuccess:    
                // สำเร็จในการซิงค์ IdP    
                break;    
            case kAuthV4ConflictPlayer:    
                // ข้อขัดแย้งของบัญชี    
                break;    
            default:    
                // กรณีพิเศษ    
                break;    
            }    
    }];

import HIVEService
// Hive SDK AuthV4 Request to sync with IdP  

let providerType: ProviderType = .Guest
AuthV4Interface.connect(providerType) { result, conflictPlayer in
    if result.isSuccess() { .. }
}

การจัดการความขัดแย้งของบัญชีกับ IdP Sync¶

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

• CurrentPlayer: ผู้เล่นของบัญชีที่ผู้ใช้กำลังเข้าสู่ระบบอยู่ (บัญชีผู้เยี่ยมชม หรือ บัญชี IdP)
• ConflictPlayer: ผู้เล่นที่มีอยู่แล้วในบัญชี IdP ที่ผู้ใช้ต้องการเชื่อมโยง

เมื่อบันทึกการเล่นเกมของ ConflictPlayer มีอยู่ในเซิร์ฟเวอร์เกม¶

ในกรณีนี้ เมื่อเกิดความขัดแย้งของบัญชี ข้อมูลการเล่นของ ConflictPlayer จะถูกแจ้งให้ผู้ใช้ทราบและ UI สำหรับการเลือก ConflictPlayer จะถูกเปิดเผย เพื่อใช้ UI ที่จัดเตรียมโดย Hive SDK ให้กำหนดค่าข้อมูล ConflictPlayer ให้เหมาะสมกับเกมและเรียกใช้วิธีการ showConflict() โดยใช้ข้อมูล ConflictPlayer เป็นพารามิเตอร์ เมื่อเรียกใช้ คุณสามารถเปลี่ยนไปยัง ConflictPlayer หรือเลือกยกเลิกเพื่อเล่นเกมต่อกับ CurrentPlayer ในตัวอย่างภาพ UI ด้านล่าง การคลิกปุ่มตรวจสอบจะเปลี่ยนไปยัง ConflictPlayer และการคลิกปุ่ม X จะทำให้เกมดำเนินต่อไปกับ CurrentPlayer

เมื่อบันทึกการเล่นเกมของ ConflictPlayer ไม่มีอยู่ในเซิร์ฟเวอร์เกม¶

บางครั้ง จะมีเพียงตัวระบุผู้เล่น (PlayerId) ของ ConflictPlayer เท่านั้น แต่ไม่มีบันทึกการเล่นจริงบนเซิร์ฟเวอร์เกม ในกรณีนี้ ให้เรียกใช้ resolveConflict(CB) เพื่อเลือก PlayerID ของ CurrentPlayer และดำเนินเกมต่อไป แสดง UI ต่อไปนี้เมื่อเกิดความขัดแย้งของบัญชี

• เมื่อ CurrentPlayer เป็นบัญชีผู้เยี่ยมชมและ ConflictPlayer เป็นบัญชี IdP

  • ปุ่ม "ยืนยัน" จะถูกแสดง และเมื่อผู้ใช้คลิกมัน CurrentPlayer จะยังคงล็อกอินอยู่

• เมื่อ CurrentPlayer เป็นบัญชี IdP 1 (ตัวอย่าง: Facebook) และ ConflictPlayer เป็นบัญชี IdP 2 (ตัวอย่าง: Google Play)

  • ยกเลิก: คงสถานะการเข้าสู่ระบบกับ CurrentPlayer ปัจจุบันของบัญชี Facebook ของคุณ
  • ยืนยัน: เปลี่ยนผู้เล่นเป็น ConflictPlayer ของบัญชี Google Play

เมื่อ ConflictPlayer เป็นบัญชีที่ถูกจำกัด¶

เมื่อ ConflictPlayer (บัญชี IdP) อยู่ใน สถานะที่จำกัด หาก CurrentPlayer (บัญชี IdP หรือบัญชีผู้เยี่ยมชม) พยายามเชื่อมต่อจากอุปกรณ์อื่นโดยใช้ AuthV4.connect จะไม่มีความขัดแย้งของบัญชี และแทนที่จะมีการแสดงป๊อปอัปข้อจำกัด หากผู้ใช้แอปปิดป๊อปอัปข้อจำกัด AuthV4.connect จะส่งคืนข้อผิดพลาด และความพยายามของ CurrentPlayer ในการเชื่อมต่อกับ IdP นี้จะล้มเหลว

ตัวอย่าง 1: เมื่อ CurrentPlayer เป็นบัญชี IdP¶

หากบัญชี Facebook IdP ที่เชื่อมโยงก่อนหน้านี้ (ConflictPlayer) อยู่ในสถานะถูกระงับและผู้ใช้พยายามเชื่อมโยง Google IdP (CurrentPlayer) จะมีป๊อปอัปการระงับปรากฏขึ้น การปิดป๊อปอัปจะทำให้ผู้ใช้ล็อกเอาต์จาก Facebook IdP

ตัวอย่าง 2: เมื่อ CurrentPlayer เป็นบัญชีแขก¶

หากบัญชี Facebook IdP ที่เชื่อมโยงไว้ก่อนหน้านี้ (ConflictPlayer) อยู่ในสถานะถูกระงับ และผู้ใช้พยายามเชื่อมโยงกับ Facebook IdP ด้วยบัญชีผู้เยี่ยมชม (CurrentPlayer) จะมีป๊อปอัปการระงับปรากฏขึ้น การปิดป๊อปอัปจะทำให้ผู้ใช้ถูกออกจากระบบ Facebook IdP

หมายเหตุเกี่ยวกับการเลือกบัญชี¶

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

การประกอบข้อมูลเกม¶

ข้อมูล ConflictPlayer ประกอบด้วยกุญแจสำคัญสองตัวคือ player_id และ game_data

• player_id: PlayerID ของ ConflictPlayer
• game_data: จัดระเบียบข้อมูลเกม เช่น ชื่อตัวละคร, จำนวนเงินในเกม, และระดับในรูปแบบ Map<String, Object >;

ด้านล่างนี้คือตัวอย่างโค้ดในการจัดเรียงข้อมูลของ ConflictPlayer

{"player_id":123, "game_data":{"Name":"ConflictPlayer", "Level":52}}

การสร้าง UI การเลือกบัญชีจาก Hive SDK (พร้อมข้อมูลการเล่นเกม)¶

เมื่อคุณได้ทำการกำหนดค่าข้อมูล ConflictPlayer เสร็จสิ้นแล้ว เมธอด showConflict () จะถูกเรียกเพื่อเปิดเผย UI ที่จัดเตรียมโดย SDK และการเลือกของผู้ใช้จะถูกส่งกลับเป็นผลลัพธ์ หากผลลัพธ์สำเร็จและผู้ใช้เลือก ConflictPlayer คุณจะต้องโหลดข้อมูลเกมอีกครั้ง ผลลัพธ์จะส่งกลับความล้มเหลวเมื่อผู้ใช้ข้ามหรือไม่สามารถเลือกบัญชีได้ และในกรณีนี้ให้แน่ใจว่าต่อไปจะเล่นเกมตามปกติ อย่างไรก็ตาม หากไม่สามารถตรวจสอบสิทธิ์อุปกรณ์ในบัญชีที่เปลี่ยน (AuthV4NotRegisteredDevice) เกมจะต้องกลับไปที่หน้าต้นฉบับเพื่อเข้าสู่ระบบอีกครั้ง ซึ่งจะทำให้การเข้าสู่ระบบกับ SDK ถูกยกเลิกและ isAutoSignIn จะส่งกลับ true

ต่อไปนี้คือตัวอย่างโค้ดในการ implement UI ที่ Hive SDK ให้โดยการกำหนดข้อมูลเกมของ PlayerID ที่ขัดแย้ง

// สร้างวัตถุข้อมูลเกมของบัญชีที่มีปัญหา    
    AuthV4.Helper.ConflictSingleViewInfo conflictInfo = new AuthV4.Helper.ConflictSingleViewInfo(playerId);    
    conflictInfo.setValue("Gold", 2048);    
    conflictInfo.setValue("Gem", 220);    
    // ขอ Hive SDK AuthV4.Helper UI การเลือกบัญชี    
    AuthV4.Helper.showConflict (conflictInfo, (ResultAPI result, AuthV4.PlayerInfo playerInfo) =>; {    
        if (result. needExit()) {    
            // TODO: implement the termination of the app.    
            // ตัวอย่าง) Application.Quit();    
        } else {    
            switch(result.code) {    
                case ResultAPI.Code.AuthV4PlayerChange:    
                    // การสลับบัญชี: ต้องเริ่มเกมใหม่    
                    break;    
                case ResultAPI.Code.AuthV4PlayerResolved:    
                    // รักษาผู้ใช้ปัจจุบัน    
                    break;    
                case ResultAPI.Code.AuthV4NotRegisteredDevice:    
                    // นี่คือกรณีที่การเข้าสู่ระบบถูกยกเลิกเนื่องจากการตรวจสอบอุปกรณ์ล้มเหลว ลองเข้าสู่ระบบใหม่ด้วย AUTO หรือออกจากระบบ    
                    break;    
                default:    
                    // จัดการข้อยกเว้นอื่น ๆ    
                    break;    
            }    
        }    
});

#include "HiveAuthV4.h"

int64 PlayerId = 12345678;
FHiveConflictSingleViewData ViewData = FHiveConflictSingleViewData(PlayerId);
ViewData.SetData(TEXT("Gold"), TEXT("2048"));
ViewData.SetData(TEXT("Gem"), TEXT("220"));

FHiveAuthV4::Helper::ShowConflict(ViewData, FHiveAuthV4HelperDelegate::CreateLambda([this](const FHiveResultAPI& Result, const TOptional<FHivePlayerInfo>& PlayerInfo) {
        if (Result.NeedExit()) {
                // TODO: implement the termination of the app.    
      // Example) Application.Quit();
        } else {
                switch (Result.Code) {
                        case FHiveResultAPI::ECode::AuthV4PlayerChange:
                                // การสลับบัญชี: ต้องเริ่มเกมใหม่
                                break;
                        case FHiveResultAPI::ECode::AuthV4PlayerResolved:
                                // เก็บผู้ใช้ปัจจุบัน
                                break;
                        case FHiveResultAPI::ECode::AuthV4NotRegisteredDevice:
                                // นี่คือกรณีที่การเข้าสู่ระบบถูกยกเลิกเนื่องจากการตรวจสอบสิทธิ์อุปกรณ์ล้มเหลว ลองเข้าสู่ระบบใหม่ด้วย AUTO หรือออกจากระบบ
                                break;
                        default:
                                // จัดการข้อยกเว้นอื่น ๆ 
                                break;
                }
        }
}));

// create game info object of the conflicted account    
    ConflictSingleViewInfo* conflictInfo = new ConflictSingleViewInfo(playerId);    
    conflictInfo->;SetValue("Gold", 2048);    
    conflictInfo->;SetValue("Gem", 220);    


    // Hive SDK AuthV4::Helper การเลือกบัญชี UI request    
    AuthV4::Helper::showConflict(*conflictInfo, [=](ResultAPI const & result, std::shared_ptr playerInfo) {    
            if (result. needExit()) {    
                // TODO: implement the termination of the app.    
                // ผู้ใช้ของเอนจิน Cocos2d-x    
                // ex) exit(0);    
                // ผู้ใช้เอนจิน Unreal    
                // ตัวอย่าง) UKismetSystemLibrary::QuitGame(GetWorld(), nullptr, EQuitPreference::Quit, false);    


            } else {    
                switch(result.code) {    
                    case ResultAPI::AuthV4PlayerChange:    
                        // การเปลี่ยนบัญชี: ต้องเริ่มเกมใหม่    
                        break;    
                    case ResultAPI::AuthV4PlayerResolved:    
                        // รักษาผู้ใช้ปัจจุบัน    
                        break;    
                    case ResultAPI::Code::AuthV4NotRegisteredDevice:    
                        // นี่คือกรณีที่การเข้าสู่ระบบถูกยกเลิกเนื่องจากความล้มเหลวในการตรวจสอบสิทธิ์อุปกรณ์ ลองเข้าสู่ระบบอีกครั้งด้วย AUTO หรือออกจากระบบ    
                        break;    
                    default:    
                        // จัดการข้อยกเว้นอื่น ๆ    
                        break;    
                }    
            }    
});

// create game info object of the conflicted account    
    val conflictInfo = AuthV4.Helper.ConflictSingleViewInfo(playerId)    
    conflictInfo.setValue("Gold", 2048)    
    conflictInfo.setValue("Gem", 220)    

    // ขอ Hive SDK AuthV4.Helper UI การเลือกบัญชี    
    AuthV4.Helper.showConflict(conflictInfo, object : AuthV4.Helper.AuthV4HelperListener {    
            override fun onAuthV4Helper(result: ResultAPI, playerInfo: AuthV4.PlayerInfo?) {    
                if (result. needExit()) {    
                    // TODO: implement the termination of the app.    
                    // ex) exitProcess(0)    
                } else {    
                    when (result.code) {    
                        ResultAPI.Code.AuthV4PlayerChange ->; {    
                            // การสลับบัญชี: ต้องเริ่มเกมใหม่    
                        }    
                        ResultAPI.Code.AuthV4CancelDialog ->; {    
                            // รักษาผู้ใช้ปัจจุบัน    
                        }    
                        ResultAPI.Code.AuthV4NotRegisteredDevice ->; {    
                            // นี่คือกรณีที่การเข้าสู่ระบบถูกยกเลิกเนื่องจากการตรวจสอบสิทธิ์อุปกรณ์ล้มเหลว ลองเข้าสู่ระบบอีกครั้งด้วย AUTO หรือออกจากระบบ    
                        }    
                        else ->; {    
                            // จัดการข้อยกเว้นอื่น ๆ    
                        }    
                    }    
                }    
            }    
})

// create game info object of the conflicted account    
    AuthV4.Helper.ConflictSingleViewInfo conflictInfo = new AuthV4.Helper.ConflictSingleViewInfo(playerId);    
    conflictInfo.setValue("Gold", 2048);    
    conflictInfo.setValue("Gem", 220);    


    // ขอ Hive SDK AuthV4.Helper UI การเลือกบัญชี    
    AuthV4.Helper.showConflict(conflictInfo, new AuthV4.Helper.AuthV4HelperListener() {    
            @Override    
            public void onAuthV4Helper(ResultAPI result, AuthV4.PlayerInfo playerInfo) {    

                if (result. needExit()) {    
                    // TODO: implement the termination of the app.    
                    // ex) System.exit(0);    
                } else {    
                    switch(result.code) {    
                        case AuthV4PlayerChange:    
                            // account switching: game restart required    
                            break;    
                        case AuthV4CancelDialog:    
                            // keep current user    
                            break;    
                        case AuthV4NotRegisteredDevice:    
                            // This is the case that the login is canceled due to device authentication failure. Try logging in back with AUTO, or log out.    
                            break;    
                        default:    
                            // handle other exceptions    
                            break;    
                    }    
                }    
            }    
});

// create game info object of the conflicted account    
    let conflictInfo = ConflictSingleViewInfo(playerId: 12345678)    
    conflictInfo.setValue("Gold", intValue: 2048)    
    conflictInfo.setValue("Gem", intValue: 220)    

    // Hive SDK AuthV4:Helper การเลือกบัญชี UI request    
    AuthV4Interface.helper().showConflict(conflictInfo) { (result, playerInfo) in    

            if result.needExit() {    
                // TODO: implement the termination of the app.    
                // ex) exit(0)    
            } else {    
                switch result.getCode() {    
                case .authV4PlayerChange:    
                    // account switching: game restart required    
                case .authV4CancelDialog:    
                    // keep current user    
                case .authV4NotRegisteredDevice:    
                    // This is the case that the login is canceled due to device authentication failure. Try logging in back with AUTO, or log out.    
                default:    
                    // handle other exceptions    
                    break    
                }    
            }    
}

// สร้างวัตถุข้อมูลเกมของบัญชีที่มีข้อขัดแย้ง    
    HIVEConflictSingleViewInfo *conflictInfo = [[HIVEConflictSingleViewInfo alloc] initWithPlayerId:12345678];    
    [conflictInfo setValue:@"Gold" intValue:2048];    
    [conflictInfo setValue:@"Gem" intValue:220];    


    // Hive SDK AuthV4:Helper การเลือกบัญชี UI request    
    [[HIVEAuthV4 helper] showConflict:conflictInfo handler:^(HIVEResultAPI *result, HIVEPlayerInfo *playerInfo) {    

            if (result. needExit) {    
                // TODO: implement the termination of the app.    
                // ex) exit(0);    
            } else {    
                switch(result.code) {    
                    case kAuthV4PlayerChange:    
                        // account switching: game restart required    
                        break;    
                    case kAuthV4CancelDialog:    
                        // keep current user    
                        break;    
                    case kAuthV4NotRegisteredDevice:    
                        // This is the case that the login is canceled due to device authentication failure. Try logging in back with AUTO, or log out.    
                        break;    
                    default:    
                        // handle other exceptions    
                        break;    
                }    
            }    
}];

การ implement UI การเลือกบัญชีจาก Hive SDK (โดยไม่มีข้อมูลเกมหรือข้อมูลที่ไม่รู้จัก)¶

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

ต่อไปนี้เป็นตัวอย่างโค้ดในการ implement UI ที่ Hive SDK ให้มาโดยการซ่อนข้อมูลเกมของ PlayerID ที่ขัดแย้ง

// ขอ Hive SDK AuthV4.Helper เลือกบัญชีผู้ใช้    
    AuthV4.Helper.showConflict ((ResultAPI result, AuthV4.PlayerInfo playerInfo) =>; {    
        if (result. needExit()) {    
            // TODO: implement app exit functionality    
            // ตัวอย่าง) Application.Quit();    
        } else {    
            switch(result.code) {    
                case ResultAPI.Code.AuthV4PlayerChange:    
                    // การเปลี่ยนบัญชี: ต้องเริ่มเกมใหม่    
                    break;    
                case ResultAPI.Code.AuthV4PlayerResolved:    
                    // เก็บผู้ใช้ปัจจุบัน    
                    break;    
                case ResultAPI.Code.AuthV4NotRegisteredDevice:    
                    // นี่คือกรณีที่การเข้าสู่ระบบถูกยกเลิกเนื่องจากการตรวจสอบสิทธิ์อุปกรณ์ล้มเหลว ลองเข้าสู่ระบบอีกครั้งด้วย AUTO หรือออกจากระบบ    
                    break;    
                default:    
                    // จัดการข้อยกเว้นอื่น ๆ    
                    break;    
            }    
        }    
});

#include "HiveAuthV4.h"

FHiveAuthV4::Helper::ShowConflict(FHiveAuthV4HelperDelegate::CreateLambda([this](const FHiveResultAPI& Result, const TOptional<FHivePlayerInfo>& PlayerInfo) {
        if (Result.NeedExit()) {
                // TODO: implement app exit functionality    
            // Users of the Cocos2d-x engine    
            // ex) exit(0);    
            // Unreal engine users    
            // Example) UKismetSystemLibrary::QuitGame(GetWorld(), nullptr, EQuitPreference::Quit, false);  
        } else {
                switch (Result.Code) {
                        case FHiveResultAPI::ECode::AuthV4PlayerChange:
                                // account switching: game restart required.
                                break;
                        case FHiveResultAPI::ECode::AuthV4PlayerResolved:
                                // keep current user
                                break;
                        case FHiveResultAPI::ECode::AuthV4NotRegisteredDevice:
                                // This is the case when login is canceled due to device authentication failure. Try logging back in with AUTO or log out.
                                break;
                        default:
                                // handle other exceptions
                                break;
                }
        }
}));

// Hive SDK AuthV4::Helper การเลือกบัญชี UI request    
    AuthV4::Helper::showConflict([=](ResultAPI const & result, std::shared_ptr playerInfo) {    
        if (result. needExit()) {    
            // TODO: implement app exit functionality    
            // ผู้ใช้ของเอนจิน Cocos2d-x    
            // ex) exit(0);    
            // ผู้ใช้เอนจิน Unreal    
            // ตัวอย่าง) UKismetSystemLibrary::QuitGame(GetWorld(), nullptr, EQuitPreference::Quit, false);    
        } else {    
            switch(result.code) {    
                case ResultAPI::AuthV4PlayerChange:    
                    // การเปลี่ยนบัญชี: ต้องเริ่มเกมใหม่    
                    break;    
                case ResultAPI::AuthV4PlayerResolved:    
                    // รักษาผู้ใช้ปัจจุบัน    
                    break;    
                case ResultAPI::Code::AuthV4NotRegisteredDevice:    
                    // นี่คือกรณีเมื่อการเข้าสู่ระบบถูกยกเลิกเนื่องจากการตรวจสอบสิทธิ์อุปกรณ์ล้มเหลว ลองเข้าสู่ระบบอีกครั้งด้วย AUTO หรือออกจากระบบ    
                    break;    
                default:    
                    // จัดการข้อยกเว้นอื่น ๆ    
                    break;    
            }    
        }    
});

// ขอ Hive SDK AuthV4.Helper เลือกบัญชีผู้ใช้    
    AuthV4.Helper.showConflict(object : AuthV4.Helper.AuthV4HelperListener {    
        override fun onAuthV4Helper(result: ResultAPI, playerInfo: AuthV4.PlayerInfo?) {    
            if (result. needExit()) {    
                // TODO: implement app exit functionality    
                // ex) exitProcess(0)    
            } else {    
                when (result.code) {    
                    ResultAPI.Code.AuthV4PlayerChange ->; {    
                        // การเปลี่ยนบัญชี: ต้องเริ่มเกมใหม่    
                    }    
                    ResultAPI.Code.AuthV4CancelDialog ->; {    
                        // รักษาผู้ใช้ปัจจุบัน    
                    }    
                    ResultAPI.Code.AuthV4NotRegisteredDevice ->; {    
                        // นี่คือกรณีเมื่อการเข้าสู่ระบบถูกยกเลิกเนื่องจากความล้มเหลวในการตรวจสอบอุปกรณ์ ลองเข้าสู่ระบบอีกครั้งด้วย AUTO หรือออกจากระบบ    
                    }    
                    else ->; {    
                        // จัดการข้อยกเว้นอื่น ๆ    
                    }    
                }    
            }    
        }    
})

// ขอ Hive SDK AuthV4.Helper สำหรับการเลือกบัญชี    
    AuthV4.Helper.showConflict(new AuthV4.Helper.AuthV4HelperListener() {    
        @Override    
        public void onAuthV4Helper(ResultAPI result, AuthV4.PlayerInfo playerInfo) {    
            if (result. needExit()) {    
                // TODO: implement app exit functionality    
                // ex) System.exit(0);    
            } else {    
                switch(result.code) {    
                    case AuthV4PlayerChange:    
                        // การเปลี่ยนบัญชี: ต้องเริ่มเกมใหม่    
                        break;    
                    case AuthV4CancelDialog:    
                        // รักษาผู้ใช้ปัจจุบัน    
                        break;    
                    case AuthV4NotRegisteredDevice:    
                        // นี่คือกรณีเมื่อการเข้าสู่ระบบถูกยกเลิกเนื่องจากการตรวจสอบสิทธิ์อุปกรณ์ล้มเหลว ลองเข้าสู่ระบบอีกครั้งด้วย AUTO หรือออกจากระบบ    
                        break;    
                    default:    
                        // จัดการข้อยกเว้นอื่น ๆ    
                        break;    
                }    
            }    
        }    
});

// Hive SDK AuthV4:Helper account selection UI request    
    AuthV4Interface.helper().showConflict() { (result, playerInfo) in    

        if result.needExit() {    
            // TODO: implement app exit functionality    
            // ex) exit(0)    
        } else {    
            switch result.getCode() {    
            case .authV4PlayerChange:    
                // account switching: game restart required    
            case .authV4CancelDialog:    
                // keep current user    
            case .authV4NotRegisteredDevice:    
                // This is the case when login is canceled due to device authentication failure. Try logging back in with AUTO or log out.    
            default:    
                // handle other exceptions    
                break    
            }    
        }    
}

// Hive SDK AuthV4:Helper account selection UI request    
    [[HIVEAuthV4 helper] showConflict:^(HIVEResultAPI *result, HIVEPlayerInfo *playerInfo) {    

        ถ้า (result. needExit) {    
            // TODO: implement app exit functionality    
            // ex) exit(0);    
        } else {    
            switch(result.code) {    
                case kAuthV4PlayerChange:    
                    // การเปลี่ยนบัญชี: ต้องเริ่มเกมใหม่    
                    break;    
                case kAuthV4CancelDialog:    
                    // รักษาผู้ใช้ปัจจุบัน    
                    break;    
                case kAuthV4NotRegisteredDevice:    
                    // นี่คือกรณีเมื่อการเข้าสู่ระบบถูกยกเลิกเนื่องจากการตรวจสอบสิทธิ์อุปกรณ์ล้มเหลว ลองเข้าสู่ระบบอีกครั้งด้วย AUTO หรือออกจากระบบ    
                    break;    
                default:    
                    // จัดการข้อยกเว้นอื่น ๆ    
                    break;    
            }    
        }    
}];

การปรับแต่งในกรณีที่มีข้อขัดแย้งของ IdP¶

หาก IdP เกิดความขัดแย้งในระหว่างกระบวนการซิงค์ IdP คุณสามารถกำหนดค่าข้อมูลเกมโดยใช้ PlayerID ที่ขัดแย้งที่ส่งกลับมาและดำเนินการ UI การเลือกบัญชีโดยตรงในเกม หากผู้ใช้เลือกบัญชีใน UI การเลือก ให้ดำเนินการกับเมธอด selectConflict() โดยใช้ PlayerID ของบัญชีที่เลือกเป็นพารามิเตอร์

ในคำอธิบายต่อไปนี้ บัญชีที่เข้าสู่ระบบในขณะนี้เรียกว่า CurrentPlayer และบัญชีที่เกิดความขัดแย้งเรียกว่า ConfilctPlayer เมื่อปรับแต่ง UI การเลือกบัญชี จำเป็นต้องตรวจสอบความแตกต่างของการกระทำตามการเลือกของผู้ใช้และแจ้งข้อควรระวังที่เหมาะสมในรูปแบบการกำหนดค่า UI เมื่อเกิดความขัดแย้งของ IdP ปัญหาต่อไปนี้อาจเกิดขึ้นขึ้นอยู่กับการเลือกของผู้ใช้

• การเลือก ConfilctPlayer: selectConflict(ConfilctPlayer, CB) ถูกเรียก.
  • หาก CurrentPlayer เป็นแขก, CurrentPlayer จะไม่สามารถค้นหาได้.
• การเลือก CurrentPlayer: selectConflict(CurrentPlayer, CB) ถูกเรียก.
  • CurrentPlayer ซิงค์กับ IdP, ดังนั้น ConfilctPlayer จึงไม่ซิงค์.
  • หาก ConflictPlayer ไม่ซิงค์กับ IdP อื่น ๆ สถานะที่เรียกว่าแขกอาจทำให้ ConflictPlayer ไม่สามารถค้นหาได้.
• หากยกเลิก (ผู้ใช้เพียงแค่ปิดหน้าการเลือก): resolveConflict(CB) ถูกเรียก.
  • เล่นเกมต่อไปกับ CurrentPlayer โดยไม่มีการเปลี่ยนแปลงใน IdP sync.

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

เมื่อผู้ใช้เลือกบัญชีใน UI การเลือกบัญชี ให้ดำเนินการเมธอด selectConflict() โดยใช้ PlayerID ของบัญชีที่เลือกเป็นพารามิเตอร์ หากผู้ใช้ยกเลิกการเลือกบัญชี ให้แน่ใจว่าต่อเนื่องเกมโดยไม่เรียก API ใดๆ หลังจากที่ผู้เล่นเลือก ConflictPlayer และได้รับการตอบกลับที่สำเร็จ ให้แน่ใจว่าโหลดข้อมูลเกมอีกครั้ง

ต่อไปนี้เป็นตัวอย่างโค้ดในการเลือกบัญชีเนื่องจากความขัดแย้งของบัญชี

long long selectedPlayerId = 1234567890;    
    // Select Hive SDK AuthV4 Account Conflict    
    AuthV4::selectConflict(selectedPlayerId, [=](ResultAPI const & result,PlayerInfo const & playerInfo) {    

            if (result. isSuccess()) {    
                //การเลือกบัญชีสำเร็จ    
            } else if (result. needExit()) {    
                // TODO: implement app exit functionality    
                // ผู้ใช้ของเอนจิน Cocos2d-x    
                // ex) exit(0);    
                // ผู้ใช้เอนจิน Unreal    
                // ตัวอย่าง) UKismetSystemLibrary::QuitGame(GetWorld(), nullptr, EQuitPreference::Quit, false);    
            }    
});

#include "HiveAuthV4.h"

int64 SelectedPlayerId = 12345678;
FHiveAuthV4::SelectConflict(SelectedPlayerId,
                                                        FHiveAuthV4OnSignInDelegate::CreateLambda([this](const FHiveResultAPI& Result, const FHivePlayerInfo& PlayerInfo) {
        if (Result.IsSuccess()) {
                // การเลือกบัญชีสำเร็จ  
        } else if (Result.NeedExit()) {
                // TODO: implement app exit functionality    
                    // ex) exitProcess(0)
        }
}));

val selectedPlayerId: Long = 1234567890    

    // เลือก Hive SDK AuthV4 ข้อความขัดแย้ง    
    AuthV4.selectConflict(selectedPlayerId, object : AuthV4.AuthV4SignInListener {    
            override fun onAuthV4SignIn(result: ResultAPI, playerInfo: AuthV4.PlayerInfo?) {    
                if (result. isSuccess) {    
                    //การเลือกบัญชีสำเร็จ    
                } else if (result. needExit()) {    
                    // TODO: implement app exit functionality    
                    // ex) exitProcess(0)    
                }    
            }    
})

long selectedPlayerId = 1234567890;    

    // เลือก Hive SDK AuthV4 ข้อขัดแย้งบัญชี    
    AuthV4.selectConflict(selectedPlayerId, new AuthV4.AuthV4SignInListener() {    
            @Override    
            public void onAuthV4SignIn(ResultAPI result, AuthV4.PlayerInfo playerInfo) {    

                if(result. isSuccess()) {    
                    //การเลือกบัญชีสำเร็จ    
                }    
                else if (result. needExit()) {    
                    // TODO: implement app exit functionality    
                    // ex) System.exit(0);    
                }    
            }    
});

let selectedPlayerId: Int64 = 1234567890;    

    // Hive SDK AuthV4 การเลือกความขัดแย้งของบัญชี    
    AuthV4Interface.selectConflict(selectedPlayerId) { (result, playerInfo) in    
            if result. isSuccess() {    
                //การเลือกบัญชีสำเร็จ    
            }    
            else if result. needExit() {    
                // TODO: implement app exit functionality    
                // ex) exit(0)    
            }    
}

long long selectedPlayerId = 1234567890;    

    // Hive SDK AuthV4 การเลือกความขัดแย้งของบัญชี    
    [HIVEAuthV4 selectConflict:selectedPlayerId handler:^(HIVEResultAPI *result, HIVEPlayerInfo *playerInfo) {    

            if (result. isSuccess) {    
                //การเลือกบัญชีสำเร็จ    
            }    
            else if (result. needExit) {    
                // TODO: implement app exit functionality    
                // ex) exit(0);    
            }    
}];

ตัดการเชื่อมต่อจากบัญชี IdP¶

คุณสามารถอนุญาตให้ผู้ใช้ยกเลิกการเชื่อมโยงบัญชี IdP ที่เชื่อมโยงอยู่ใน UI รายการบัญชี IdP หากผู้ใช้ยกเลิกการเชื่อมโยงบัญชี IdP เฉพาะใน UI รายการบัญชี IdP สตูดิโอเกมจะเรียกใช้เมธอด disconnect() พร้อมกับอาร์กิวเมนต์ ProviderType ซึ่งเป็นประเภทเฉพาะของ IdP เพื่อยกเลิกการเชื่อมต่อจากบัญชี IdP หลังจากเรียกใช้เมธอด disconnect() คุณต้องตรวจสอบสถานะการเชื่อมต่อของผู้ใช้และจากนั้นอัปเดตรายการ IdP ที่ซิงค์ใน UI

using hive;    
    AuthV4.Helper.disconnect (AuthV4.ProviderType.HIVE, delegate (ResultAPI result, AuthV4.PlayerInfo playerInfo) {    
       switch (result.code) {    
         case ResultAPI.Code.Success:    
           // การตัดการเชื่อมต่อผู้ให้บริการสำเร็จ    
           break;    
         default:    
           // สถานการณ์ข้อยกเว้นอื่น ๆ    
           break;    
       }    
});

#include "HiveAuthV4.h"

EHiveProviderType ProviderType = EHiveProviderType::HIVE;
FHiveAuthV4::Helper::Disconnect(ProviderType, FHiveAuthV4HelperDelegate::CreateLambda([this](const FHiveResultAPI& Result, const TOptional<FHivePlayerInfo>& PlayerInfo) {
        switch (Result.Code) {
                case FHiveResultAPI::ECode::Success:
                        // การตัดการเชื่อมต่อผู้ให้บริการสำเร็จ
                        break;
                default:
                        // สถานการณ์ข้อยกเว้นอื่นๆ  
                        break;
        }
}));

#include <HIVE_SDK_Plugin/HIVE_CPP.h>    
    using namespace std;    
    using namespace hive;    
    AuthV4::Helper::disconnect(ProviderType::HIVE, [=](ResultAPI const & result, shared_ptr playerInfo) {    
    switch (result.code) {    
    case ResultAPI::Success:    
        // การตัดการเชื่อมต่อผู้ให้บริการสำเร็จ    
        break;    
        default:    
        // สถานการณ์ข้อยกเว้นอื่น ๆ    
        break;    
    }    
});

import com.hive.AuthV4    
    import com.hive.ResultAPI    
    AuthV4.Helper.disconnect(AuthV4.ProviderType.HIVE, object : AuthV4.Helper.AuthV4HelperListener {    
         override fun onAuthV4Helper(result: ResultAPI, playerInfo: AuthV4.PlayerInfo?) {    
             when (result.code) {    
                 ResultAPI.Code.Success -> {    
                     // Provider disconnection successful    
                 }    
                 else -> {    
                     // other exception situations    
                 }    
             }    
         }    
})

import com.hive.AuthV4;    
    import com.hive.ResultAPI;    
    AuthV4.Helper.INSTANCE.disconnect(AuthV4.ProviderType.HIVE, (result, playerInfo) -> {    
         switch (result.getCode()) {    
             case Success:    
                 // Provider disconnection successful    
                 break;    
             default:    
                 // other exception situations    
                 break;    
         }    
});

import HIVEService    
    AuthV4Interface.helper().disconnect(.Hive) { result, playerInfo in    
        switch result.getCode() {    
            case.success:    
            // การตัดการเชื่อมต่อผู้ให้บริการสำเร็จ    
            default:    
            // สถานการณ์ข้อยกเว้นอื่น ๆ    
            break    
        }    
}

#import <HIVEService/HIVEService-Swift.h>    
    [[HIVEAuthV4 helper] disconnect: HIVEProviderTypeHive handler: ^(HIVEResultAPI *result, HIVEPlayerInfo *playerInfo) {    
       switch ([result getCode]) {    
    case HIVEResultAPICodeSuccess:    
           // การตัดการเชื่อมต่อผู้ให้บริการสำเร็จ    
           break;    
         default:    
           // สถานการณ์ข้อยกเว้นอื่น ๆ    
           break;    
       }    
}];

สตูดิโอเกมสามารถเลือกจากนโยบายด้านล่างเมื่อดำเนินการตัดการเชื่อมต่อ IdP 1. ยกเลิกการเชื่อมโยงบัญชี IdP ทั้งหมดและอนุญาตให้ใช้บัญชีแขก 2. บังคับให้ต้องมีบัญชี IdP อย่างน้อยหนึ่งบัญชีที่เชื่อมโยงอยู่

ยกเลิกการเชื่อมต่อจากบัญชี IdP: อนุญาตให้ยกเลิกการเชื่อมต่อบัญชี IdP ทั้งหมด¶

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

• หากคุณต้องการยกเลิกการเชื่อมโยงบัญชี IdP ล่าสุดที่เชื่อมโยง

หากผู้ใช้เลือกที่จะยกเลิกการเชื่อมโยงบัญชี แม้ว่าประโยคข้างต้นจะถูกเปิดเผย ให้เรียกใช้ disconnect() เมื่อบัญชีผู้ใช้กลายเป็นบัญชีแขก ประโยคต่อไปนี้อาจถูกเปิดเผย

• หากบัญชีผู้ใช้กลายเป็นบัญชีผู้เยี่ยมชมหลังจากที่ถูกตัดการเชื่อมต่อจาก IdP ล่าสุดที่เชื่อมโยง

การตัดการเชื่อมต่อจากบัญชี IdP: รักษาบัญชีอย่างน้อย 1 บัญชีที่เชื่อมโยง¶

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

• หากคุณต้องการยกเลิกการเชื่อมโยงบัญชี IdP ล่าสุดที่เชื่อมโยง

การซิงค์ IdP แบบกำหนดเอง¶

การซิงค์ IdP ที่กำหนดเองเป็นฟังก์ชันที่ปรับแต่งได้ซึ่งช่วยให้สามารถใช้งาน IdP ที่กำหนดเองซึ่งเกมนำมาใช้ แยกจาก IdP ที่ให้โดย Hive SDK หลังจากเรียกใช้ API การเข้าสู่ระบบที่กำหนดเอง คุณสามารถตรวจสอบข้อมูลผู้ใช้ที่เข้าสู่ระบบของ IdP ที่กำหนดเองได้โดยการเข้าถึงข้อมูล customProviderInfoData ด้วยอินสแตนซ์ของคลาส PlayerInfo ที่ถูกส่งเป็นผลลัพธ์ของการเรียกกลับ ProviderType (enum) ของ customProviderInfoData ถูกตั้งค่าเป็น CUSTOM และสามารถแยกแยะได้โดยใช้ ProviderName (String)

ต่อไปนี้คือตัวอย่างโค้ดที่ใช้ในการซิงค์ IdP แบบกำหนดเอง

// Twitter sync that is implemented by the game itself.
    Game.Connect"CUSTOM_TWITTER", (string authKey) =>; {

        AuthV4.connectWithAuthKey(authKey, (ResultAPI result, PlayerInfo playerInfo) =>; {
                switchresult.code) {
                case ResultAPI.Code.Success:
                    // sync success
                    break;
                case ResultAPI.Code.AuthV4ConflictPlayer:
                    // account conflict
                    Dictionary<string, ProviderInfo>; customProviderInfoData = playerInfo.customProviderInfoData;
                    ProviderInfo providerInfo = customProviderInfoData["CUSTOM_TWITTER"];
                    // Check the following sync information for the user
                    providerInfo.providerType;     // ProviderType.CUSTOM, providerType is fixed to ProviderType.CUSTOM. To distinguish, use providerName.
                    providerInfo.providerName;   // "CUSTOM_TWITTER"
                    providerInfo.providerUserId;  // the user id for the Twitter login, implemented by the game itself.
                    break;
                default:
                    // Other exceptions
                    break;
                }
        });
    });

#include "HiveAuthV4.h"

// การซิงค์ Twitter ที่ดำเนินการโดยเกมเอง
void GameConnect(const FString& AuthKey)
{
        FHiveAuthV4::ConnectWithAuthKey(AuthKey, FHiveAuthV4OnConnectDelegate::CreateLambda([this](const FHiveResultAPI& Result, const FHivePlayerInfo& ConflictPlayerInfo) {
                switch(Result.Code) {
                        case FHiveResultAPI::ECode::Success:
                                // ซิงค์สำเร็จ
                                break;
                        case FHiveResultAPI::ECode::AuthV4ConflictPlayer: {
                                // ข้อขัดแย้งของบัญชี
                                TMap<FString, FHiveProviderInfo> CustomProviderInfoData = ConflictPlayerInfo.CustomProviderInfoData;
                                if (const FHiveProviderInfo* ProviderInfo = CustomProviderInfoData.Find(TEXT("CUSTOM_TWITTER"))) {
                                        // ตรวจสอบข้อมูลการซิงค์ต่อไปนี้สำหรับผู้ใช้
                                        EHiveProviderType ProviderType = ProviderInfo->ProviderType; // ProviderType::CUSTOM, providerType ถูกกำหนดให้เป็น ProviderType::CUSTOM เพื่อแยกแยะ ใช้ providerName
                                        FString ProviderName = ProviderInfo->ProviderName; // "CUSTOM_TWITTER"
                                        FString ProviderUserId = ProviderInfo->ProviderUserId; // รหัสผู้ใช้สำหรับการเข้าสู่ระบบ Twitter ที่ดำเนินการโดยเกมเอง
                                }
                        }
                                break;
                        default:
                                // ข้อยกเว้นอื่น ๆ
                                break;
                }
        }));
}

// Twitter sync that is implemented by the game itself.
        Game::Connect"CUSTOM_TWITTER", [=]string authKey) {

            AuthV4::connectWithAuthKeyauthKey, [=]ResultAPI const & result, PlayerInfo const & playerInfo) {
                switch (result.code) {
                    case ResultAPI::Success:
                    // sync success
                    break;
                    case ResultAPI::AuthV4ConflictPlayer:
                    // account conflict
                    map<string, ProviderInfo>; customProviderInfoData = playerInfo.customProviderInfoData;
                    ProviderInfo providerInfo = customProviderInfoData["CUSTOM_TWITTER"];
                    // Check the following sync information for the user
                    providerInfo.providerType;     // ProviderType::CUSTOM, providerType is fixed to ProviderType::CUSTOM. To distinguish, use providerName.
                    providerInfo.providerName;   // "CUSTOM_TWITTER"
                    providerInfo.providerUserId;  // the user id for the Twitter login, implemented by the game itself.
                    break;
                    default:
                    // Other exceptions
                    break;
                }
            });
        });

// การซิงค์ Twitter ที่ดำเนินการโดยเกมเอง
        Game.Connect"CUSTOM_TWITTER") { authKey: String ->;

            AuthV4.connectWithAuthKeyresponse.authKey, object : AuthV4.AuthV4ConnectListener {
                override fun onAuthV4Connectresult: ResultAPI, conflictPlayer: AuthV4.PlayerInfo?) {
                    whenresult.code) {
                        case ResultAPI.Code.Success ->; {
                            // sync success
                        }
                        case ResultAPI.Code.AuthV4ConflictPlayer ->; {
                            // account conflict
                            playerInfo.customProviderInfoData["CUSTOM_TWITTER"]?.let { providerInfo ->;
                            providerInfo.providerType     // ProviderType.CUSTOM, providerType is fixed to ProviderType.CUSTOM. To distinguish, use providerName.
                            providerInfo.providerName   // "CUSTOM_TWITTER"
                            providerInfo.providerUserId  // the user id for the Twitter login, implemented by the game itself.
                        }
                        else ->; {
                            // Other exceptions
                        }
                    }
                }
            }
        }

// Twitter sync that is implemented by the game itself.
        Game.Connect"CUSTOM_TWITTER", new Callback) {
            @Override
            public void onResponseString authKey) {

                com.hive.AuthV4.INSTANCE.connectWithAuthKeyauthKey, new com.hive.AuthV4.AuthV4ConnectListener) {
                    @Override
                    public void onAuthV4ConnectResultAPI result, PlayerInfo conflictPlayer) {
                        switch (result.getCode)) {
                            case ResultAPI.Code.Success:
                                // sync success
                                break;
                            case ResultAPI.Code.AuthV4ConflictPlayer:
                                // account conflict
                                ProviderInfo providerInfo = conflictPlayer.getCustomProviderInfoData().get("CUSTOM_TWITTER");
                                providerInfo.getProviderType();     // ProviderType.CUSTOM, providerType is fixed to ProviderType.CUSTOM. To distinguish, use providerName.
                                providerInfo.getProviderName();   // "CUSTOM_TWITTER"
                                providerInfo.getProviderUserId();  // the user id for the Twitter login, implemented by the game itself.
                                break;
                            default:
                                // Other exceptions
                                break;
                        }
                    }
                });
            }
        });

// Twitter sync that is implemented by the game itself.
        Game.connect"CUSTOM_TWITTER") { (authKey) in

            AuthV4Interface.connectWithAuthKeyauthKey) { result, conflictPlayer in
                    switch(result.getCode()){
                    case .success:
                        // sync success
                        break
                    case .authV4ConflictPlayer:
                        // account conflict
                    guard let customProviderInfoData = playerInfo?.customProviderInfoData,
                            let providerInfo = customProviderInfoData["CUSTOM_TWITTER"] else {
                        // No sync information for the user, failure handling
                        return
                    }

                    // ตรวจสอบข้อมูลการซิงค์ต่อไปนี้สำหรับผู้ใช้
                    providerInfo.providerType     // HIVEProviderTypeCustom, providerType ถูกกำหนดเป็น HIVEProviderTypeCustom คงที่ เพื่อให้แตกต่าง ใช้ providerName
                    providerInfo.providerName   // "CUSTOM_TWITTER"
                    providerInfo.providerUserID  // รหัสผู้ใช้สำหรับการเข้าสู่ระบบ Twitter ที่ดำเนินการโดยเกมเอง
                        break
                    default:
                        // ข้อยกเว้นอื่นๆ
                        break
                    }
                }
        }

// Twitter sync that is implemented by the game itself.
        [Game connect:@"CUSTOM_TWITTER" handler:^NSString* authKey) {

            [HIVEAuthV4 connectWithAuthKey:authKey handler:^HIVEResultAPI* result, HIVEPlayerInfo* playerInfo) {
                    switch(result.code) {
                    case kSuccess:
                        // sync success
                        break;
                    case kAuthV4ConflictPlayer:
                        // account conflict
                        NSDictionary<NSString*, HIVEProviderInfo*>;* customProviderInfoData = playerInfo.customProviderInfoData;
                        ProviderInfo* providerInfo = [customProviderInfoData objectForKey:@"CUSTOM_TWITTER"];
                        // Check the following sync information for the user
                        providerInfo.providerType;  
    providerInfo.providerType     // HIVEProviderTypeCustom, providerType is fixed to HIVEProviderTypeCustom. To distinguish, use providerName.
                        providerInfo.providerName;   // "CUSTOM_TWITTER"
                        providerInfo.providerUserId;  // the user id for the Twitter login, implemented by the game itself.
                        break;
                    default:
                        // Other exceptions
                        break;
                    }
            }];
        }];

ยกเลิกการเชื่อมต่อ IdP ที่กำหนดเอง¶

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

ตัวอย่างโค้ดต่อไปนี้แสดงวิธีการดำเนินการตัดการเชื่อมต่อ IdP แบบกำหนดเอง

string customProviderName = "CUSTOM_TWITTER";

AuthV4.disconnectWithName (customProviderName, delegate (ResultAPI result) {
    switch(result.code) {
    case ResultAPI.Code.Success:
        // การตัดการเชื่อมต่อผู้ให้บริการสำเร็จ
        break;
    default:
        // ข้อยกเว้นอื่น ๆ
        break;
    }
});

#include "HiveAuthV4.h"

FString CustomProviderName = TEXT("CUSTOM_TWITTER");
FHiveAuthV4::DisconnectWithName(CustomProviderName, FHiveAuthV4OnDisconnectDelegate::CreateLambda([this](const FHiveResultAPI& Result) {
        if (Result.IsSuccess()) {
                // การตัดการเชื่อมต่อผู้ให้บริการสำเร็จ
        } else {
                // ข้อยกเว้นอื่น ๆ
        }
}));

std::string customProviderName = "CUSTOM_TWITTER"

AuthV4::disconnectWithName(customProviderName, [=](ResultAPI const & result) {
        switch (result.code) {
        case ResultAPI::Success:
            // การตัดการเชื่อมต่อผู้ให้บริการสำเร็จ
            break;
        default:
            // ข้อยกเว้นอื่น ๆ
            break;
        }
});

val customProviderName = "CUSTOM_TWITTER"

AuthV4.disconnectWithName(customProviderName, object : AuthV4.AuthV4DisconnectListener {
    override fun onAuthV4Disconnect(result: ResultAPI) {

            เมื่อ(result.code) {
            สำเร็จ -> {
                // การตัดการเชื่อมต่อผู้ให้บริการสำเร็จ
            }
            อื่น ๆ -> {
                // ข้อยกเว้นอื่น ๆ
            }
        }
    }
})

String customProviderName = "CUSTOM_TWITTER";

AuthV4.INSTANCE.disconnectWithName(customProviderName, new AuthV4.AuthV4DisconnectListener() {

    @Override
    public void onAuthV4Disconnect(ResultAPI result) {
        switch(result.code) {
            case Success:
                // การตัดการเชื่อมต่อของผู้ให้บริการสำเร็จ
                break;
            default:
                // ข้อยกเว้นอื่น ๆ
                break;
        }
    }
});

let customProviderName = "CUSTOM_TWITTER"

AuthV4Interface.disconnectWithName(customProviderName) { result  in
        switch(result.getCode()){
        case .success:
            // การตัดการเชื่อมต่อผู้ให้บริการสำเร็จ
        break
        default:
            // ข้อยกเว้นอื่น ๆ
        break
        }
    }

NSString* customProviderName = @"CUSTOM_TWITTER";

[HIVEAuthV4 disconnectWithName:customProviderName handler:^(HIVEResultAPI *result) {
    switch(result.code) {
    case kSuccess:
        // Provider disconnection success
        break;
    default:
        // Other exceptions
        break;
    }
}];

ลบบัญชี IdP และบัญชีผู้เยี่ยมชม¶

คุณต้องตั้งค่ารูปแบบผู้ใช้เพื่อให้ผู้ใช้สามารถลบบัญชีของตนในเกมได้

• ตัวอย่างของ UI

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

หากคำขอสำหรับการลบบัญชีได้รับการยืนยัน คุณสามารถลบบัญชี Authentication v4 นี้โดยใช้ Hive SDK API หรือ Hive Server API.

• ขั้นตอนในการลบบัญชี

* **เมื่อทำการลบโดยใช้ Hive Server API**: <br>
เมื่อบัญชีถูกลบในฝั่งเกมไคลเอนต์ เซิร์ฟเวอร์เกมควรเรียก Hive Server API [Deleting Authentication v4 Account](../../api/hive-server-api/auth/authv4-account-deletion.md) เพื่อส่งข้อมูลของบัญชีที่ถูกลบไปยัง Authentication Server. Authentication Server จะรับข้อมูลนี้และลบบัญชี หลังจากการลบเสร็จสิ้น Authentication Server จะส่งผลลัพธ์ของการลบบัญชีไปยังเซิร์ฟเวอร์เกม และเซิร์ฟเวอร์เกมจะส่งต่อไปยังเกมไคลเอนต์ เมื่อเกมไคลเอนต์ได้รับผลลัพธ์ของการลบบัญชี มันควรจะแสดงป๊อปอัพที่แจ้งว่าบัญชีถูกลบแล้ว ในฝั่งเกมไคลเอนต์ (Hive SDK) ให้เรียก `signOut()` โดยไม่คำนึงว่าบัญชีเป็น <u>**บัญชีที่ใช้ IdP หรือบัญชีผู้เยี่ยมชม**</u> หลังจากที่บัญชีถูกลบแล้ว.

* **เมื่อทำการลบโดยใช้ Hive SDK API**: <br>
เมื่อบัญชีของผู้เล่นถูกลบในฝั่งเกมไคลเอนต์ เซิร์ฟเวอร์เกมควรเรียกใช้ `playerDelete()
` เพื่อส่งข้อมูลของบัญชีที่ถูกลบไปยังเซิร์ฟเวอร์การตรวจสอบสิทธิ์ หากคุณได้รับผลลัพธ์การเรียกกลับของการลบบัญชีจากเซิร์ฟเวอร์การตรวจสอบสิทธิ์ คุณควรแสดงป๊อปอัปที่แจ้งว่าบัญชีได้ถูกลบในฝั่งเกม

ต่อไปนี้คือตัวอย่างโค้ด AuthV4 สำหรับการลบบัญชีผ่าน Hive SDK API.

// Requesting Hive SDK account deletion
        AuthV4.playerDeletedelegate (ResultAPI result) {
            switchresult.code) {
                case ResultAPI.Code.Success:
                    // Deletion completed
                    break;
                default:
                    // Other exceptions
                    break;
            }
        });

#include "HiveAuthV4.h"

FHiveAuthV4::PlayerDelete(FHiveAuthV4OnSignOutDelegate::CreateLambda([this](const FHiveResultAPI& Result) {
        switch(Result.Code) {
                case FHiveResultAPI::ECode::Success:
                        // การลบเสร็จสมบูรณ์
                        break;
                default:
                        // ข้อยกเว้นอื่น ๆ
                        break;
        }
}));

// Requesting Hive SDK account deletion
        AuthV4::playerDelete[=]ResultAPI const & result) {
                switch (result.code) {
                    case ResultAPI::Success:
                        // Deletion completed
                        break;
                    default:
                        // Other exceptions
                        break;
                }
        });

// Requesting Hive SDK account deletion
    AuthV4.playerDeleteobject : AuthV4.AuthV4SignOutListener {
        override fun onAuthV4SignOutresult: ResultAPI) {
            whenresult.code) {
                ResultAPI.Code.Success ->; {
                    // Deletion completed
                }
                else ->; {
                    // Other exceptions
                }
            }
        }
    })

// การขอให้ลบบัญชี SDK ของ Hive
    AuthV4.INSTANCE.playerDeletenew AuthV4.AuthV4SignOutListener) {
        @Override
        public void onAuthV4SignOutResultAPI result) {
            switchresult.code) {
                case Success:
                    // การลบเสร็จสิ้น
                    break;
                default:
                    // ข้อยกเว้นอื่น ๆ
                    break;
            }
        }
    });

// การขอให้ลบบัญชี SDK Hive    
[[HIVEAuthV4] playerDelete:^HIVEResultAPI *result) {
    switch(result.code) {
    case Success: // การลบเสร็จสมบูรณ์
        break;
    default: // ข้อยกเว้นอื่น ๆ break;
    } 
}];

// Requesting Hive SDK account deletion
    [[HIVEAuthV4] playerDelete:^HIVEResultAPI *result) {
        switchresult.code) {
        case Success:
            // Deletion completed
            break;
        default:
            // Other exceptions
            break;
        }
    }];

ต่อไปนี้คือตัวอย่างโค้ด AuthV4.Helper สำหรับการลบบัญชีผ่าน Hive SDK API.

// Requesting Hive SDK account deletion
        AuthV4.Helper.playerDelete(delegate (ResultAPI result, AuthV4.PlayerInfo playerInfo) {
    switch(result.code) {
        case ResultAPI.Code.Success:
            // ลบสำเร็จ
            break;
        default:
            // สถานการณ์ข้อยกเว้นอื่น ๆ
            break;
    }
});

// Requesting Hive SDK account deletion
AuthV4::Helper::playerDelete([=](ResultAPI const & result, std::shared_ptr playerInfo) {
        switch (result.code) {
            case ResultAPI::Success:
                // ลบสำเร็จ
                break;
            default:
                // สถานการณ์ข้อยกเว้นอื่น ๆ
                break;
        }
});

// Requesting Hive SDK account deletion
AuthV4.Helper.playerDelete(object : AuthV4.Helper.AuthV4HelperListener {
override fun onAuthV4Helper(result: ResultAPI, playerInfo: AuthV4.PlayerInfo?) {
    when(result.code) {
        ResultAPI.Code.Success -> {
            // ลบสำเร็จ
        }
        else -> {
            // สถานการณ์ข้อยกเว้นอื่น ๆ
            }
        }
    }
})