เข้าสู่ระบบและออกจากระบบ

การเข้าสู่ระบบในกระบวนการตรวจสอบสิทธิ์ประกอบด้วยขั้นตอนดังต่อไปนี้

เข้าสู่ระบบ¶

การเข้าสู่ระบบในกระบวนการตรวจสอบสิทธิ์ประกอบด้วยขั้นตอนต่อไปนี้

1. การเข้าสู่ระบบอัตโนมัติและการเข้าสู่ระบบโดยนัย
2. การเข้าสู่ระบบอย่างชัดเจน
3. ตรวจสอบบัญชี IdP ที่เข้าสู่ระบบบนอุปกรณ์
4. การเข้าสู่ระบบแขก

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

• หากเกมมีเป้าหมายหลักสำหรับเด็กอายุต่ำกว่า 13 ปี บริการเกม Google Play จะไม่สามารถใช้งานได้ และการเข้าสู่ระบบโดยอัตโนมัติใน Google builds จะไม่สามารถใช้ได้ สำหรับรายละเอียดเพิ่มเติม โปรดดูที่ Quality Checklist for Google Play Games Services.
  • การเข้าสู่ระบบโดยอัตโนมัติสำหรับเกม Google Play ควรพยายามทำในช่วงการเข้าสู่ระบบครั้งแรกเท่านั้น สำหรับรายละเอียดเพิ่มเติม โปรดดูที่คู่มือสำหรับนักพัฒนาของ Google 1.5 Remember if players declined signing-in.

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

การเข้าสู่ระบบอัตโนมัติและการเข้าสู่ระบบโดยนัย¶

การเข้าสู่ระบบอัตโนมัติ¶

หมายความว่าผู้ใช้เข้าสู่ระบบโดยอัตโนมัติด้วยการเชื่อมโยงบัญชี Apple Game Center ของตนบน iOS และบัญชี Google Play Games ของตนบน Android โดยไม่ต้องเลือกวิธีการเข้าสู่ระบบ มันจะดำเนินการเข้าสู่ระบบอัตโนมัติและทำการเข้าสู่ระบบโดยปริยายหากการเข้าสู่ระบบอัตโนมัติล้มเหลว

ในการใช้การเข้าสู่ระบบอัตโนมัติในสภาพแวดล้อม iOS คุณต้องเพิ่ม Game Center Entitlement ซึ่ง Unity จะเพิ่มโดยอัตโนมัติผ่าน Unity PostProcess หากคุณได้ทำเครื่องหมายที่ 'Apple GameCenter' Dependency ใน iOS Native Xcode จะเพิ่ม Game Center Entitlement โดยอัตโนมัติ

ในการใช้การเข้าสู่ระบบอัตโนมัติในสภาพแวดล้อม iOS คุณต้องเพิ่ม Game Center Entitlement ใน Unity หากคุณได้ทำเครื่องหมายที่การพึ่งพา 'Apple GameCenter' มันจะเพิ่มสิทธิ์โดยอัตโนมัติผ่าน Unity PostProcess สำหรับ iOS Native Xcode จะเพิ่ม Game Center Entitlement โดยอัตโนมัติ

โหมดออฟไลน์¶

ใน Hive SDK v4 23.1.0 ขึ้นไป ฟีเจอร์การเข้าสู่ระบบอัตโนมัติ (AuthV4.signIn โดยใช้ ProviderType.AUTO หรือ AuthV4.Helper.signIn) สามารถใช้งานได้แม้ว่าอุปกรณ์ของผู้ใช้จะไม่ได้เชื่อมต่อกับเครือข่ายเมื่อแอปถูกเปิดใช้งาน เพื่อใช้โหมดออฟไลน์ กรุณาทำตามคำแนะนำด้านล่าง

1. คุณต้องได้ดำเนินการแอปออนไลน์สำเร็จสำหรับการเข้าสู่ระบบที่ชัดเจน, โดยนัย, แขก, หรือการเข้าสู่ระบบแบบกำหนดเอง และได้รับ playerId และ playerToken。

จากมุมมองของนักพัฒนาแอป จำเป็นต้องมีการเรียกใช้ AuthV4.Helper.signIn, AuthV4.showSignIn, หรือ AuthV4.signInWithAuthKey อย่างน้อยหนึ่งครั้งในขณะที่ออนไลน์และได้รับ playerId และ playerToken เป็นการตอบกลับ จากมุมมองของผู้ใช้ ผู้ใช้ต้องเข้าสู่ระบบแอปอย่างน้อยหนึ่งครั้งในขณะที่อุปกรณ์ของพวกเขาเชื่อมต่อกับเครือข่าย อย่างไรก็ตาม หากบัญชีของผู้ใช้ถูกระงับหรือจำกัดในครั้งสุดท้ายที่พวกเขาพยายามเข้าสู่ระบบในขณะที่ออนไลน์ ผู้ใช้จะไม่สามารถเข้าสู่ระบบได้แม้ในโหมดออฟไลน์

1. เปิดโหมดออฟไลน์ใน Hive คอนโซล App Center > Project Management > Game Details > Hive Product Settings.

การเข้าสู่ระบบอัตโนมัติในสภาพแวดล้อม Windows¶

สภาพแวดล้อม Windows ยังรองรับการเข้าสู่ระบบอัตโนมัติ ซึ่งสามารถเปิดหรือปิดใช้งานได้ใน Hive Console App Center อย่างไรก็ตาม การเข้าสู่ระบบอัตโนมัติใน Windows มีพฤติกรรมที่แตกต่างจากมือถือ ความแตกต่างในการเข้าสู่ระบบอัตโนมัติใน Windows มีดังนี้

• บนอุปกรณ์มือถือ สถานะการเข้าสู่ระบบจะถูกเก็บรักษาโดยอัตโนมัติหลังจากเข้าสู่ระบบ แต่บน Windows จะถูกเก็บรักษาเฉพาะเมื่อผู้ใช้เปิดใช้งานช่องทำเครื่องหมาย "จดจำการเข้าสู่ระบบ" (แสดงที่ด้านล่างของรายการ IdP บน UI การเข้าสู่ระบบ) ในสถานการณ์อื่น ๆ สถานะการเข้าสู่ระบบจะไม่ถูกเก็บรักษา
• เมื่อดำเนินการ AuthV4Helper.Connect บนอุปกรณ์มือถือ หากสลับไปยังบัญชีใหม่ บัญชีใหม่จะยังคงสถานะการเข้าสู่ระบบอัตโนมัติ แต่บน Windows หากสลับไปยังบัญชีใหม่ บัญชีใหม่จะไม่รักษาสถานะการเข้าสู่ระบบอัตโนมัติ

การลงชื่อเข้าใช้โดยปริยาย¶

• กระบวนการเข้าสู่ระบบโดยไม่ต้องระบุชื่อผู้ใช้และรหัสผ่าน

AuthV4.Helper.signIn จะพยายามเข้าสู่ระบบโดยอัตโนมัติด้วยการใช้กุญแจโทเค็นการตรวจสอบสิทธิ์ของ PlayerID หากไม่มีการตรวจสอบสิทธิ์ที่เข้าสู่ระบบก่อนหน้านี้ มันจะเข้าสู่ระบบ Apple Game Center สำหรับ iOS และ Google Play Games สำหรับ Android โดยอัตโนมัติ หากการเข้าสู่ระบบล้มเหลว มันจะกำหนดค่าหน้าจอเข้าสู่ระบบที่เหมาะสมตามค่าการตอบกลับ

เมื่อใช้คลาส AuthV4Helper

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

ต่อไปนี้คือตัวอย่างโค้ดที่ทำการเข้าสู่ระบบอัตโนมัติ

// Attempt to sign in (signIn) with Hive SDK    
    AuthV4.Helper.signIn (delegate (ResultAPI result, AuthV4.PlayerInfo playerInfo) {    

    if (result.isSuccess()) {    
        // การเข้าสู่ระบบสำเร็จ    
    } else if (result.needExit()) {    
        // TODO: Implement app exit functionality    
        // e.g.) Application.Quit();    
    } else {    
        switch (result.code) {    
            case ResultAPI.Code.AuthV4ConflictPlayer:    
                // ข้อขัดแย้งบัญชี    
                break;    
            case ResultAPI.Code.AuthV4HelperImplifiedLoginFail:    
                // การเข้าสู่ระบบโดยปริยายล้มเหลว                   
                // ex) AuthV4.showSignIn(...);    
                break;    
            default:    
                // ข้อยกเว้นอื่น ๆ    
                break;    
        }    
    }    
});

#include "HiveAuthV4.h"

// พยายามเข้าสู่ระบบ (signIn) ไปยัง Hive SDK
FHiveAuthV4::Helper::SignIn(FHiveAuthV4HelperDelegate::CreateLambda([this](const FHiveResultAPI& Result, const TOptional<FHivePlayerInfo>& PlayerInfo) {
        if (Result.IsSuccess()) {
                // เข้าสู่ระบบสำเร็จ
        } else if (Result.NeedExit()) {
                // TODO: Implement app exit functionality
                // e.g. UKismetSystemLibrary::QuitGame(GetWorld(), nullptr, EQuitPreference::Quit, false);
        } else {
                switch (Result.Code) {
                        case FHiveResultAPI::ECode::AuthV4ConflictPlayer:
                                // ข้อขัดแย้งของบัญชี
                                break;
                        case FHiveResultAPI::ECode::AuthV4HelperImplifiedLoginFail:
                                // ล้มเหลวในการเข้าสู่ระบบโดยอัตโนมัติ
                                // ex) FHiveAuthV4::ShowSigIn()
                                break;
                        default:
                                // ข้อยกเว้นอื่นๆ
                                break;
                }
        }
}));

// Attempt to sign in (signIn) with Hive SDK    
    AuthV4::Helper::signIn([=](ResultAPI const & result, std::shared_ptr playerInfo) {    

    if (result.isSuccess()) {    
        // การเข้าสู่ระบบสำเร็จ    
    } else if (result.needExit()) {    
        // TODO: Implement app exit functionality              
        // ผู้ใช้ Cocos2d-x    
        // e.g. exit(0);    
        // ผู้ใช้ Unreal engine    
        // e.g. UKismetSystemLibrary::QuitGame(GetWorld(), nullptr, EQuitPreference::Quit, false);    
    } else {    
        switch (result.code) {    
            case ResultAPI::AuthV4ConflictPlayer:    
                // ข้อขัดแย้งบัญชี    
                break;    
            case ResultAPI::AuthV4HelperImplifiedLoginFail:    
                // การเข้าสู่ระบบโดยนัยล้มเหลว    
                // ex) AuthV4.showSignIn(...);    
                break;    
            default:    
                break;    
        }    
    }    
});

// พยายามลงชื่อเข้าใช้ด้วย Hive SDK
 AuthV4.Helper.signIn(object : AuthV4.Helper.AuthV4HelperListener {
    override fun onAuthV4Helper(result: ResultAPI, playerInfo: AuthV4.PlayerInfo?) {
            if (result.isSuccess) {
                    // ลงชื่อเข้าใช้สำเร็จ
            } else if (result.needExit()) {
                    // TODO: Implement app exit functionality
                    // e.g. exitProcess(0)
            } else {
                    when (result.code) {
                            ResultAPI.Code.AuthV4ConflictPlayer -> {
                                    // ข้อขัดแย้งบัญชี
                            }
                            ResultAPI.Code.AuthV4HelperImplifiedLoginFail -> {
                                    // ลงชื่อเข้าใช้โดยปริยายล้มเหลว
                                    // ex) AuthV4.showSignIn(...);
                            }
                            else -> {
                                    // สถานการณ์พิเศษอื่น ๆ
                            }
                    }
            }
    }
    })

// Hive SDK AuthV4 authentication UI request    
    AuthV4.showSignIn(new AuthV4.AuthV4SignInListener() {    
    @Override    
    public void onAuthV4SignIn(ResultAPI result, AuthV4.PlayerInfo playerInfo) {    

        if (result.isSuccess()) {    
            // การตรวจสอบสิทธิ์สำเร็จ    
            // playerInfo: ข้อมูลผู้ใช้ที่ได้รับการตรวจสอบสิทธิ์    
            // ตัวอย่างการดึงข้อมูลอีเมล    
            if(playerInfo != null) {    
                for (Map.Entry<AuthV4.ProviderType, AuthV4.ProviderInfo> entry : playerInfo.getProviderInfoData().entrySet()) {    
                    AuthV4.ProviderInfo providerInfo = entry.getValue();    
                    if (providerInfo.getProviderEmail() != "") {    
                        String email = providerInfo.getProviderEmail();    
                        break;    
                    }    
                }    
            }    
        }    
        else if (result.needExit()) {    
            // TODO: Implement app exit functionality    
            // e.g. System.exit(0);    
        }    
    }    
});

var email = String()    
    // Hive SDK AuthV4 authentication UI request    
    AuthV4Interface.showSignIn { (result, playerInfo) in    

    if result.isSuccess() {    
        // การตรวจสอบสิทธิ์สำเร็จ    
        // playerInfo: ข้อมูลผู้ใช้ที่ตรวจสอบสิทธิ์    
        // ตัวอย่างการดึงข้อมูลอีเมล    
        if let playerInfo = playerInfo {    
            // ค้นหาข้อมูล providerInfo ด้วย providerEmail (ผู้ให้บริการที่เข้าสู่ระบบในปัจจุบัน)    
            for key in playerInfo.providerInfoData.keys {    
                if let providerInfo = playerInfo.providerInfoData[key],    
                    providerInfo.providerEmail.count > 0 {    
                    // providerEmail != ""    
                    email = providerInfo.providerEmail    
                    break    
                }    
            }    
        }    
    } else if result.needExit() {    
        // TODO: Implement app exit functionality    
        // e.g. exit(0)    
    }    
}

// Attempt to sign in (signIn) with Hive SDK    
[[HIVEAuthV4 helper] signIn:^(HIVEResultAPI *result, HIVEPlayerInfo *playerInfo) {

        if (result.isSuccess) {
                // การเข้าสู่ระบบสำเร็จ 
        }
        else if (result.needExit) {
                // TODO: Implement app exit functionality
                // ex) exit(0);
        }
        else {
                switch (result.code) {
                        case kAuthV4ConflictPlayer:
                                // ข้อขัดแย้งของบัญชี
                                break;    
                        case kAuthV4HelperImplifiedLoginFail:
                                // การเข้าสู่ระบบโดยนัยล้มเหลว
                                // ex) [HIVEAuthV4 showSignIn:^(HIVEResultAPI *result, HIVEPlayerInfo *playerInfo) {
                                // // ทำอะไรบางอย่าง...
                                // }];
                                break;
                        default:
                                // ข้อยกเว้นอื่น ๆ
                                break;   
                }
        }
        }];

พฤติกรรมการเข้าสู่ระบบโดยปริยาย: มือถือ¶

การเข้าสู่ระบบโดยปริยายบนมือถือ (เช่น Hive SDK Unity Android สำหรับแพลตฟอร์ม Android/iOS) (AuthV4.Helper.signIn) จะมีการเรียกผู้ใช้ด้วยกล่องโต้ตอบที่ถามว่าต้องการเข้าสู่ระบบด้วยบัญชีที่เข้าสู่ระบบล่าสุดในกรณีที่มีความขัดแย้งของบัญชีเมื่อเข้าสู่ระบบด้วยบัญชีที่แตกต่างหลังจากการเข้าสู่ระบบครั้งแรก

พฤติกรรมการเข้าสู่ระบบโดยอัตโนมัติ: PC¶

การเข้าสู่ระบบโดยอัตโนมัติบน PC (แพลตฟอร์ม Windows เช่น Hive SDK Unity Windows) (AuthV4.Helper.signIn) จะเข้าสู่ระบบโดยอัตโนมัติด้วยบัญชีที่เข้าสู่ระบบล่าสุดเมื่อเข้าสู่ระบบด้วยบัญชีที่แตกต่างหลังจากการเข้าสู่ระบบครั้งแรก ข้อขัดแย้งของบัญชีจะไม่เกิดขึ้น

การเข้าสู่ระบบที่ชัดเจน¶

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

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

รายการ IdP ถูกควบคุมและจัดเตรียมโดยแพลตฟอร์ม Hive ตามนโยบายของแต่ละประเทศ ตัวอย่างเช่น ในประเทศจีน เกม Google Play และ Facebook รวมถึงแขกจะไม่ได้รับการจัดเตรียม

สกรีนช็อตการเข้าสู่ระบบที่ชัดเจน¶

UI การเลือก IdP ที่จัดทำโดย SDK

เมื่อทำการติดตั้งโดยใช้ UI ที่จัดเตรียมโดย SDK¶

ในการดำเนินการเข้าสู่ระบบแบบชัดเจนโดยใช้ UI ที่ให้โดย SDK คุณสามารถเรียกใช้ showSignIn() เมธอดเพื่อเรียก UI รายการ IdP ได้ง่ายๆ

// Hive SDK AuthV4 authentication UI request
AuthV4.showSignIn((ResultAPI result, AuthV4.PlayerInfo playerInfo)=>{
if (result.isSuccess()) {
        // Authentication successful
        // playerInfo : Authenticated user information

        // ตัวอย่างการดึงข้อมูลอีเมล
        foreach (KeyValuePair<AuthV4.ProviderType, AuthV4.ProviderInfo> entry in playerInfo.providerInfoData) {

                AuthV4.ProviderInfo providerInfo = entry.Value;
                if(providerInfo.providerEmail != null && providerInfo.providerEmail != "") {
                        string email = providerInfo.providerEmail;
                        break;
                }
        }
}
else if (result.needExit()) {
        // TODO: Implement the app exit feature
        // e.g.) Application.Quit();
}
});

#include "HiveAuthV4.h"

// Hive SDK AuthV4 การร้องขอ UI การตรวจสอบสิทธิ์
FHiveAuthV4::ShowSignIn(FHiveAuthV4OnSignInDelegate::CreateLambda([this](const FHiveResultAPI& Result, const FHivePlayerInfo& PlayerInfo) {
        if (Result.IsSuccess()) {
                // การตรวจสอบสิทธิ์สำเร็จ (PlayerInfo: ข้อมูลผู้ใช้ที่ตรวจสอบสิทธิ์) 

                // ตัวอย่างการดึงข้อมูลอีเมล
                for (const auto& ProviderInfoEntry : PlayerInfo.ProviderInfoData) {
                        FHiveProviderInfo ProviderInfo = ProviderInfoEntry.Value;
                        FString Email = ProviderInfo.ProviderEmail;
                }
        } else if (Result.NeedExit()) {
                // TODO: Implement app exit functionality
                // ตัวอย่าง) UKismetSystemLibrary::QuitGame(GetWorld(), nullptr, EQuitPreference::Quit, false);
        }
}));

// Hive SDK AuthV4 authentication UI request
AuthV4::showSignIn([=](ResultAPI const & result, PlayerInfo const & playerInfo) {
if (result.isSuccess()) {
        // Authentication successful
        // playerInfo: Authenticated user information

        // ตัวอย่างการดึงข้อมูลอีเมล
        for(auto it = playerInfo.providerInfoData.begin(); it != playerInfo.providerInfoData.end(); ++it) {
                hive::ProviderInfo providerInfo = it->second;
                if(!providerInfo.providerEmail.empty()) {
                        std::string email = providerInfo.providerEmail;
                        break;
                }
        }
}
else if (result.needExit()) {
        // TODO: Implement app exit functionality
        // สำหรับผู้ใช้เครื่องยนต์ Cocos2d-x
        // ตัวอย่าง) exit(0);
        // สำหรับผู้ใช้เครื่อง Unreal
        // ตัวอย่าง) UKismetSystemLibrary::QuitGame(GetWorld(), nullptr, EQuitPreference::Quit, false);
}
});

// Hive SDK AuthV4 authentication UI request
AuthV4.showSignIn(object : AuthV4.AuthV4SignInListener {
override fun onAuthV4SignIn(result: ResultAPI, playerInfo: AuthV4.PlayerInfo?) {
        if (result.isSuccess) {
                // Authentication successful
                // playerInfo: Authenticated user information

                // ตัวอย่างการดึงข้อมูลอีเมล
                playerInfo?.let {
                        for ((key, value) in it.providerInfoData) {
                                var providerInfo: AuthV4.ProviderInfo = value
                                if(providerInfo.providerEmail.isNotEmpty()) {
                                        val email = providerInfo.providerEmail
                                        break
                                }
                        }
                }
        } else if (result.needExit()) {
                // TODO: Implement app exit functionality
                // e.g.) exitProcess(0)
        }
}
})

// Hive SDK AuthV4 authentication UI request
AuthV4.showSignIn(new AuthV4.AuthV4SignInListener() {
@Override
public void onAuthV4SignIn(ResultAPI result, AuthV4.PlayerInfo playerInfo) {

        if (result.isSuccess()) {
                // การตรวจสอบสิทธิ์สำเร็จ
                // playerInfo: ข้อมูลผู้ใช้ที่ได้รับการตรวจสอบสิทธิ์

                // ตัวอย่างการดึงข้อมูลอีเมล
                if(playerInfo != null) {
                        for (Map.Entry<AuthV4.ProviderType, AuthV4.ProviderInfo> entry : playerInfo.getProviderInfoData().entrySet()) {
                                AuthV4.ProviderInfo providerInfo = entry.getValue();
                                if (providerInfo.getProviderEmail() != "") {
                                        String email = providerInfo.getProviderEmail();
                                        break;
                                }
                        }
                }
        }
        else if (result.needExit()) {
                // TODO: Implement app exit functionality
                // ตัวอย่าง) System.exit(0);
        }
}
});

var email = String()

// Hive SDK AuthV4 authentication UI request
AuthV4Interface.showSignIn { (result, playerInfo) in

if result.isSuccess() {
        // การตรวจสอบสิทธิ์สำเร็จ
        // playerInfo: ข้อมูลผู้ใช้ที่ได้รับการตรวจสอบสิทธิ์

        // ตัวอย่างการดึงข้อมูลอีเมล
        if let playerInfo = playerInfo {
                // ค้นหาข้อมูล providerInfo ด้วย providerEmail (ผู้ให้บริการที่เข้าสู่ระบบในขณะนี้)
                for key in playerInfo.providerInfoData.keys {
                        if let providerInfo = playerInfo.providerInfoData[key],
                                providerInfo.providerEmail.count > 0 {
                                // providerEmail != ""
                                email = providerInfo.providerEmail
                                break
                        }
                }
        }
} else if result.needExit() {
        // TODO: Implement app exit functionality
        // ตัวอย่าง) exit(0)
}
}

__block NSString* email = @"";

// Hive SDK AuthV4 การร้องขอ UI การตรวจสอบสิทธิ์
[HIVEAuthV4 showSignIn:^(HIVEResultAPI *result, HIVEPlayerInfo *playerInfo) {

if([result isSuccess]){
        // การตรวจสอบสิทธิ์สำเร็จ
        // playerInfo: ข้อมูลผู้ใช้ที่ตรวจสอบสิทธิ์แล้ว

        // ตัวอย่างการดึงข้อมูลอีเมล
        if(playerInfo != nil) {
                // กำลังค้นหาข้อมูล providerInfo ด้วย providerEmail (ผู้ให้บริการที่เข้าสู่ระบบในปัจจุบัน)
                for (NSString* key in playerInfo.providerInfoData.allKeys) {
                        HIVEProviderInfo* providerInfo = playerInfo.providerInfoData[key];
                        if (providerInfo != nil && providerInfo.providerEmail.length > 0) {
                                // providerEmail != ""
                                email = providerInfo.providerEmail;
                                break;
                        }
                }
        }
} else if ([result needExit]) {
        // TODO: Implement app exit functionality
        // e.g. exit(0);
}
}];

การปรับแต่งการเข้าสู่ระบบแบบชัดเจน¶

UI ที่ปรับแต่งได้สำหรับการเข้าสู่ระบบแบบชัดเจนสามารถนำไปใช้ได้โดยใช้ providerTypeList ซึ่ง providerTypeList คือ ตัวจัดการการตอบกลับที่ส่งกลับเมื่อเรียกใช้วิธี AuthV4.setup() เพื่อวัตถุประสงค์ในการเริ่มต้น Hive SDK หรือเมื่อเรียกใช้วิธี AuthV4.Helper.getIDPList() หลังจากการเริ่มต้น ฟีเจอร์นี้ใช้เมื่อคุณต้องการแสดงหน้าจอเข้าสู่ระบบตาม UI ของเกมหรือเปิดเผยการรวมกับ IdP ที่เฉพาะเจาะจง หลังจากที่คุณได้ดำเนินการ UI ที่ปรับแต่งได้แล้ว ให้เรียกใช้วิธี signIn() พร้อมกับ ProviderType ที่ต้องการตามการกระทำของผู้ใช้เพื่อดำเนินการเข้าสู่ระบบ

• ตัวอย่างภาพหน้าจอ UI ที่แสดงเฉพาะปุ่มการรวม Facebook บนหน้าจอเข้าสู่ระบบ

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

using hive;    
    AuthV4.signIn(AuthV4.ProviderType.GOOGLE, (ResultAPI result, AuthV4.PlayerInfo playerInfo) => {    
        if (result.isSuccess()) {    
            // Call successful    
            // playerInfo : authenticated user information.    
            // Example of retrieving email information for ProviderType.GOOGLE    
            Dictionary<AuthV4.ProviderType, AuthV4.ProviderInfo> providerInfoData = playerInfo.providerInfoData;    
            AuthV4.ProviderInfo providerInfo = providerInfoData[AuthV4.ProviderType.GOOGLE];    
            string email = providerInfo.providerEmail;    
        }    
});

#include "HiveAuthV4.h"

FHiveAuthV4::SignIn(EHiveProviderType::GOOGLE,
                                        FHiveAuthV4OnSignInDelegate::CreateLambda([this](const FHiveResultAPI& Result, const FHivePlayerInfo& PlayerInfo) {

        if (Result.IsSuccess()) {
                // การเรียกสำเร็จ (PlayerInfo: ข้อมูลผู้ใช้ที่ผ่านการตรวจสอบแล้ว)

                // ตัวอย่างการดึงข้อมูลอีเมลสำหรับ EHiveProviderType::GOOGLE
                TMap<EHiveProviderType, FHiveProviderInfo> ProviderInfoData = PlayerInfo.ProviderInfoData;
                if (const FHiveProviderInfo* ProviderInfo = ProviderInfoData.Find(EHiveProviderType::GOOGLE)) {
                        FString Email = ProviderInfo->ProviderEmail;
                }
        }
}));

#include <HIVE_SDK_Plugin/HIVE_CPP.h>    
    AuthV4::signIn(ProviderType::GOOGLE, [=](ResultAPI const & result, PlayerInfo const & playerInfo) {    
        if (result.isSuccess()) {    
            // Call successful    
            // playerInfo : Authenticated user information.    

            // ตัวอย่างการดึงข้อมูลอีเมลสำหรับ ProviderType::GOOGLE    
            map<ProviderType, ProviderInfo> providerInfoData = playerInfo.providerInfoData;    
            ProviderInfo providerInfo = providerInfoData[ProviderType::GOOGLE];    
            string email = providerInfo.providerEmail;    
        }    
});

import com.hive.AuthV4    
    import com.hive.ResultAPI    
    AuthV4.signIn(AuthV4.ProviderType.GOOGLE, object : AuthV4.AuthV4SignInListener {    
        override fun onAuthV4SignIn(result: ResultAPI, playerInfo: AuthV4.PlayerInfo?) {    
            if (result.isSuccess) {    
                // การเรียกใช้สำเร็จ    
                // playerInfo: ข้อมูลผู้ใช้ที่ได้รับการตรวจสอบสิทธิ์    
                // ตัวอย่างการดึงข้อมูลอีเมลสำหรับ ProviderType.GOOGLE    
                if (playerInfo != null) {    
                    val providerInfoData = playerInfo.providerInfoData    
                    val providerInfo = providerInfoData[AuthV4.ProviderType.GOOGLE]    
                    if (providerInfo != null) {    
                        val email = providerInfo.providerEmail    
                    }    
                }    
            }    
        }    
})

import com.hive.AuthV4;    
    import com.hive.ResultAPI;    
    AuthV4.INSTANCE.signIn(AuthV4.ProviderType.GOOGLE, (result, playerInfo) -> {    
        if (result.isSuccess()) {    
            // Call successful    
            // playerInfo: authenticated user information    
            // Example of retrieving email information for ProviderType.GOOGLE    
            if (playerInfo != null) {    
                HashMap<AuthV4.ProviderType, AuthV4.ProviderInfo> providerInfoData = playerInfo.getProviderInfoData();    
                AuthV4.ProviderInfo providerInfo = providerInfoData.get(AuthV4.ProviderType.GOOGLE);    
                if (providerInfo != null) {    
                    String email = providerInfo.getProviderEmail();    
                }    
            }    
        }    
});

import HIVEService    
    AuthV4Interface.signIn(.Google) { result, playerInfo in    
        if result.isSuccess() {    
            // Call successful    
            // playerInfo: Authenticated user information.    

            // ตัวอย่างการดึงข้อมูลอีเมลของ Google    
            if     
                let playerInfo = playerInfo,    
                let providerInfo = playerInfo.providerInfoData["GOOGLE"] {    
                    let email = providerInfo.providerEmail    
            }    
        }    
}

#import <HIVEService/HIVEService-Swift.h>    
    [HIVEAuthV4 signIn:HIVEProviderTypeGoogle handler:^(HIVEResultAPI *result, HIVEPlayerInfo *playerInfo) {    
        if ([result isSuccess]){    
            // Call succeeded    
            // playerInfo: Authenticated user information.    

            // ตัวอย่างการดึงข้อมูลอีเมลสำหรับ HIVEProviderTypeGoogle    
            if(playerInfo != nil) {    
                HIVEProviderInfo *providerInfo = playerInfo.providerInfoData[@"GOOGLE"];    
                if(providerInfo != nil){    
                    NSString *email = providerInfo.providerEmail;    
                }    
            }    
        }    
}];    

ตรวจสอบบัญชี IdP ที่เข้าสู่ระบบบนอุปกรณ์¶

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

• ตรวจสอบ UI สำหรับ DevicePlayer ที่จัดเตรียมโดย SDK

นี่คือตัวอย่างโค้ดเพื่อตรวจสอบข้อมูล IdP

using hive;    
    AuthV4.ProviderType providerType = AuthV4.ProviderType.GOOGLE;     
    AuthV4.Helper.syncAccount (providerType, delegate (ResultAPI result, AuthV4.PlayerInfo playerInfo) {    

        switch (result.code) {    
            case ResultAPI.Code.Success:    
                // ปกติ    
                break;    
            case ResultAPI.Code.AuthV4ConflictPlayer:    
                // ความขัดแย้งของบัญชี    
                // ex) เมื่อใช้ Hive UI     
                // AuthV4.Helper.showConflict(...);    
                // หรือ    
                // ex) เมื่อทำการ implement GameUI    
                // AuthV4.Helper.resolverConflict(...);// เมื่อเลือกผู้ใช้ปัจจุบัน    
                // AuthV4.Helper.switchAccount(...);// เมื่อเลือกสลับผู้ใช้    
                break;    
            default:    
                // ข้อยกเว้นอื่นๆ    
                break;    
        }    
});

#include "HiveAuthV4.h"

FHiveAuthV4::Helper::SyncAccount(ProviderType, FHiveAuthV4HelperDelegate::CreateLambda([this](const FHiveResultAPI& Result, const TOptional<FHivePlayerInfo>& PlayerInfo) {

        switch (Result.Code) {
                case FHiveResultAPI::ECode::Success:
                        // การตอบสนองปกติ
                        break;
                case FHiveResultAPI::ECode::AuthV4ConflictPlayer:
                        // ข้อขัดแย้งของบัญชี
                        // ex) เมื่อใช้ Hive UI
                        // FHiveAuthV4::Helper::ShowConflict()
                        // ex) เมื่อดำเนินการ Game UI
                        // FHiveAuthV4::Helper::ResolveConflict() // การเลือกผู้ใช้ปัจจุบัน
                        // FHiveAuthV4::Helper::SwitchAccount() // การเลือกเปลี่ยนผู้ใช้
                        break;
                default:
                        // สถานการณ์พิเศษอื่นๆ
                        break;
        }
}));

#include <HIVE_SDK_Plugin/HIVE_CPP.h>    
    using namespace std;    
    using namespace hive;    
    ProviderType providerType = ProviderType::GOOGLE;    
    AuthV4::Helper::syncAccount(providerType, [=](ResultAPI const & result, shared_ptr<PlayerInfo> playerInfo) {    

        switch (result.code) {    
          case ResultAPI::Success:    
            // ปกติ    
            break;    
          case ResultAPI::AuthV4ConflictPlayer:    
            // ความขัดแย้งของบัญชี    
            // ex) เมื่อใช้ Hive UI     
            // AuthV4::Helper::showConflict(...);    
            // หรือ    
            // ex) เมื่อดำเนินการ GameUI    
            // AuthV4::Helper::resolverConflict(...);// เมื่อเลือกผู้ใช้ปัจจุบัน    
            // AuthV4::Helper::switchAccount(...);// เมื่อเลือกที่จะเปลี่ยนผู้ใช้    
            break;    
          default:    
            // ข้อยกเว้นอื่น ๆ    
            break;    
         }        
});

import com.hive.AuthV4    
    import com.hive.ResultAPI    
    val providerType = AuthV4.ProviderType.GOOGLE    
    AuthV4.Helper.syncAccount(providerType, object : AuthV4.Helper.AuthV4HelperListener {    
        override fun onAuthV4Helper(result: ResultAPI, playerInfo: AuthV4.PlayerInfo?) {    
            when (result.code) {    
                ResultAPI.Code.Success -> {    
                    // ปกติ    
                }    
                ResultAPI.Code.AuthV4ConflictPlayer -> {    
                    // ความขัดแย้งของบัญชี    
                    // ex) เมื่อใช้ Hive UI    
                    // AuthV4.Helper.showConflict(...);    
                    // หรือ    
                    // ex) เมื่อใช้งาน GameUI    
                    // AuthV4.Helper.resolverConflict(...);// เมื่อเลือกผู้ใช้ปัจจุบัน    
                    // AuthV4.Helper.switchAccount(...);// เมื่อเลือกการสลับผู้ใช้    
                }    
                else -> {    
                    // ข้อยกเว้นอื่น ๆ    
                }    
            }    
        }    
})

import com.hive.AuthV4;    
    import com.hive.ResultAPI;    
    AuthV4.ProviderType providerType = AuthV4.ProviderType.GOOGLE;    
    AuthV4.Helper.INSTANCE.syncAccount(providerType, (result, playerInfo) -> {    
        switch (result.getCode()) {    
            case Success:    
                // ปกติ    
                break;    
            case AuthV4ConflictPlayer:    
                // ข้อขัดแย้งของบัญชี    
                // ex) เมื่อใช้ Hive UI    
                // AuthV4.Helper.INSTANCE.showConflict(...);    
                // หรือ    
                // ex) เมื่อทำการใช้งาน GameUI    
                // AuthV4.Helper.INSTANCE.resolverConflict(...);// เมื่อเลือกผู้ใช้ปัจจุบัน    
                // AuthV4.Helper.INSTANCE.switchAccount(...);// เมื่อเลือกสลับผู้ใช้    
                break;    
            default:    
                // ข้อยกเว้นอื่น ๆ    
                break;    
        }    
});

import HIVEService    
    let providerType: ProviderType = .Google    
    AuthV4Interface.helper().syncAccount(providerType) { result, playerInfo in    
        switch result.getCode() {    
          case .success:    
            // ปกติ    
          case .authV4ConflictPlayer:    
            // ข้อขัดแย้งของบัญชี    
            // ex) เมื่อใช้ Hive UI     
            // AuthV4Interface.helper().showConflict(...);    
            // หรือ    
            // ex) เมื่อดำเนินการ GameUI    
            // AuthV4Interface.helper().resolverConflict(...);// เมื่อเลือกผู้ใช้ปัจจุบัน    
            // AuthV4Interface.helper().switchAccount(...);// เมื่อเลือกการเปลี่ยนผู้ใช้    
          default:    
            // ข้อยกเว้นอื่น ๆ    
            break    
        }      
}

#import <HIVEService/HIVEService-Swift.h>    
    HIVEProviderType providerType = HIVEProviderTypeGoogle    
    [[HIVEAuthV4 helper] syncAccount: providerType handler: ^(HIVEResultAPI *result, HIVEPlayerInfo *playerInfo) {    
        switch ([result getCode]) {    
            case HIVEResultAPICodeSuccess:    
                // สำเร็จ    
                break;    
            case HIVEResultAPICodeAuthV4ConflictPlayer:    
                // ข้อขัดแย้งของบัญชี    
                // ex) เมื่อใช้ Hive UI     
                // [[HIVEAuthV4 helper] showConflict: ...];    
                // หรือ    
                // ex) เมื่อดำเนินการ GameUI    
                // [[HIVEAuthV4 helper] resolverConflict:...];// เมื่อเลือกผู้ใช้ปัจจุบัน    
                // [[HIVEAuthV4 helper] switchAccount:...];// เมื่อเลือกสลับผู้ใช้     
                break;    
            default:    
                // ข้อยกเว้นอื่นๆ    
                break;    
        }    
}];

การเข้าสู่ระบบแขก¶

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

เมื่อเข้าสู่ระบบในฐานะแขก คุณต้องปฏิบัติตามนโยบายต่อไปนี้

นโยบายการเข้าสู่ระบบของแขก¶

• ดำเนินการเกมเพื่อให้ผู้ใช้ที่ยืนยันตัวตนด้วย IdP และผู้ใช้ที่เป็นแขกสามารถใช้งานได้ในลักษณะเดียวกัน แม้เมื่อเข้าสู่ระบบในฐานะแขก ฟีเจอร์ส่วนใหญ่ของแพลตฟอร์ม Hive สามารถใช้งานได้ ดังนั้นโปรดตรวจสอบให้แน่ใจว่าผู้ใช้ที่เข้าสู่ระบบในฐานะแขกสามารถใช้เกมได้ในลักษณะเดียวกับผู้ใช้ที่เชื่อมโยงกับ IdP ตัวอย่างเช่น ผู้ใช้ที่เป็นแขกควรสามารถซื้อไอเทมและทำการชำระเงินภายในเกมได้
  • ไม่ให้ฟังก์ชันออกจากระบบสำหรับผู้ใช้ที่เป็นแขก หากผู้ใช้ทำการออกจากระบบหลังจากเข้าสู่ระบบในฐานะแขก พวกเขาจะไม่สามารถเข้าสู่ระบบด้วย PlayerID เดิมได้ ดังนั้นเมื่อผู้ใช้เข้าสู่ระบบในฐานะแขก อย่าให้ปุ่มออกจากระบบเพื่อป้องกันไม่ให้พวกเขาออกจากระบบ
  • ห้ามนโยบายการเข้าสู่ระบบของแขกในประเทศจีน เมื่อใช้ IP ของจีน ผู้ใช้ที่ผ่านการตรวจสอบชื่อจริงเท่านั้นที่สามารถเติมเงินและใช้ทรัพยากรได้ (มีผลตั้งแต่วันที่ 1 พฤษภาคม 2017) ดังนั้นการเข้าสู่ระบบของแขกจึงไม่รวมอยู่ในรายชื่อ IdP ที่สามารถเข้าสู่ระบบด้วย IP ของจีน

ในการเข้าสู่ระบบในฐานะแขก ให้เรียกใช้วิธีการ signIn() โดยใช้ ProviderType.GUEST เป็นพารามิเตอร์
นี่คือตัวอย่างโค้ดสำหรับการเข้าสู่ระบบในฐานะแขก

using hive;    
    AuthV4.signIn(AuthV4.ProviderType.GUEST, (ResultAPI result, AuthV4.PlayerInfo playerInfo) => {    
        if (result.isSuccess()) {    
            // Authentication successful    
            // playerInfo: Authenticated user information    
        }    
});

#include "HiveAuthV4.h"

FHiveAuthV4::SignIn(EHiveProviderType::GUEST,
                                        FHiveAuthV4OnSignInDelegate::CreateLambda([this](const FHiveResultAPI& Result, const FHivePlayerInfo& PlayerInfo) {

        if (Result.IsSuccess()) {
                // Call successful (PlayerInfo: authenticated user information)
        }
}));

#include <HIVE_SDK_Plugin/HIVE_CPP.h>    
    using namespace std;     
    using namespace hive;    
    AuthV4::signIn(ProviderType::GUEST, [=](ResultAPI const & result, PlayerInfo const & playerInfo) {    
        if (result.isSuccess()) {    
            // Authentication successful    
            // playerInfo: Authenticated user information    
        }    
});

import com.hive.AuthV4    
    import com.hive.ResultAPI    
    AuthV4.signIn(AuthV4.ProviderType.GUEST, object : AuthV4.AuthV4SignInListener {    
        override fun onAuthV4SignIn(result: ResultAPI, playerInfo: AuthV4.PlayerInfo?) {    
            if (result.isSuccess) {    
                // Authentication successful    
                // playerInfo: Authenticated user information    
            }    
        }    
})

import com.hive.AuthV4;    
    import com.hive.ResultAPI;    
    AuthV4.INSTANCE.signIn(AuthV4.ProviderType.GUEST, (result, playerInfo) -> {    
        if (result.isSuccess()) {    
            // Authentication successful    
            // playerInfo: Authenticated user information    
        }    
});

import HIVEService    
    AuthV4Interface.signIn(.Guest) { result, playerInfo in    
        if result.isSuccess() {    
            // Authentication successful    
            // playerInfo: Authenticated user information    
        }    
}

#import <HIVEService/HIVEService-Swift.h>    
    [HIVEAuthV4 signIn: HIVEProviderTypeGuest handler: ^(ResultAPI *result, HIVEPlayerInfo *playerInfo) {    
        if ([result isSuccess]) {    
            // Authentication successful    
            // playerInfo: Authenticated user information    
        }    
}];

การเข้าสู่ระบบแบบกำหนดเอง¶

การเข้าสู่ระบบแบบกำหนดเอง เป็นฟีเจอร์ที่ช่วยให้คุณสามารถใช้การเข้าสู่ระบบด้วย IdP ที่รวมเข้ากับเกมเอง นอกเหนือจาก IdP ที่ Hive ให้บริการ ลองสร้างคีย์การตรวจสอบสิทธิ์ (authKey) เพื่อใช้เมื่อเรียกใช้ API การเข้าสู่ระบบแบบกำหนดเองตามที่ระบุใน Authenticate v4 Custom Authentication.

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

ข้อมูลของ IdP ที่ใช้การเข้าสู่ระบบแบบกำหนดเองในเกมไม่ได้รวมอยู่ในผลลัพธ์ของการเรียกใช้วิธีการ setup() และ showSignIn() ของคลาส AuthV4。

หากคุณได้รับ playerId และ playerToken หลังจากการดำเนินการครั้งแรกของการเข้าสู่ระบบแบบกำหนดเอง API ผลลัพธ์ของ authV4SessionExist(code) จะถูกส่งเป็น callback เมื่อเรียกใช้ API การเข้าสู่ระบบแบบกำหนดเองอีกครั้ง ในกรณีนี้คุณควรเรียกใช้ signIn() โดยใช้ ProviderType.Auto เป็นพารามิเตอร์เพื่อดำเนินการเข้าสู่ระบบอัตโนมัติด้วยบัญชีที่เข้าสู่ระบบอยู่แล้ว กรุณาอ้างอิงจากโค้ดตัวอย่างด้านล่าง。

วิธีการ connect() และ disconnect() ของคลาส AuthV4 ไม่รองรับการรวมและการตัดการเชื่อมต่อเพิ่มเติมของ IdP การเข้าสู่ระบบแบบกำหนดเอง การรวมและการตัดการเชื่อมต่อเพิ่มเติมของ IdP การเข้าสู่ระบบแบบกำหนดเองได้รับการสนับสนุนโดยวิธีการ connectWithAuthKey() และ disconnectWithName()。

นี่คือตัวอย่างโค้ดสำหรับการนำไปใช้เข้าสู่ระบบแบบกำหนดเอง

// การเข้าสู่ระบบ Twitter ที่ดำเนินการโดยตรงในเกม    
    Game.Login("CUSTOM_TWITTER", (string authKey) => {    
    AuthV4.signInWithAuthKey(authKey, (ResultAPI result, PlayerInfo playerInfo) => {    
        if (result.isSuccess()) {    
            Dictionary<string, ProviderInfo> customProviderInfoData = playerInfo.customProviderInfoData;    
            ProviderInfo providerInfo = customProviderInfoData["CUSTOM_TWITTER"];    
            // ตรวจสอบข้อมูลการเชื่อมโยงผู้ใช้ต่อไปนี้    
            providerInfo.providerType;     // ProviderType.CUSTOM, ประเภทที่กำหนดเองจะต้องแยกแยะโดย providerName    
            providerInfo.providerName;   // "CUSTOM_TWITTER"    
            providerInfo.providerUserId;  // รหัสผู้ใช้ที่ใช้สำหรับการเข้าสู่ระบบ Twitter ที่ดำเนินการโดยตรง    
            return;    
        }    
        else if (result.code == ResultAPI.Code.AuthV4SessionExist) {    
            // หาก playerId และ playerToken ได้รับการออกแล้วและต้องการการเข้าสู่ระบบอัตโนมัติ    
            // TODO: AuthV4.signIn(ProviderType.AUTO, (ResultAPI _result, PlayerInfo playerInfo) => {});    
        }    
        else if (result.code == ResultAPI.Code.AuthV4NotInitialized) {    
            // TODO: ต้องมีการเริ่มต้น SDK    
        }    
        else if (result.code == ResultAPI.Code.AuthV4InvalidParam) {    
            // TODO: ตรวจสอบว่าค่าของ authKey ที่ให้มาคือ NULL หรือว่างเปล่า    
        }    
        else if (result.needExit()) {    
            // TODO: นำฟังก์ชันการออกจากแอปไปใช้     
            // ตัวอย่างเช่น Application.Quit();    
        }    
    });    
});

#include "HiveAuthV4.h"

// ดำเนินการเข้าสู่ระบบ Twitter โดยตรงในเกมด้วยประเภท "CUSTOM_TWITTER"
void GameLogin(const FString& AuthKey)
{
        FHiveAuthV4::SignInWithAuthKey(AuthKey, FHiveAuthV4OnSignInDelegate::CreateLambda([this](const FHiveResultAPI& Result, const FHivePlayerInfo& PlayerInfo) {

                if (Result.IsSuccess()) {
                        TMap<FString, FHiveProviderInfo> CustomProviderInfoData = PlayerInfo.CustomProviderInfoData;
                        if (const FHiveProviderInfo* ProviderInfo = CustomProviderInfoData.Find(TEXT("CUSTOM_TWITTER"))) {
                                EHiveProviderType ProviderType = ProviderInfo->ProviderType; // EHiveProviderType::CUSTOM, custom types have fixed Type
                                FString ProviderName = ProviderInfo->ProviderName; // Need to distinguish by ProviderName
                                FString ProviderUserId = ProviderInfo->ProviderUserId; // User id used in the custom Twitter login
                        }
                } else if (Result.NeedExit()) {
                        // TODO: Implement app exit functionality
                        // e.g.) UKismetSystemLibrary::QuitGame(GetWorld(), nullptr, EQuitPreference::Quit, false);
                } else if (Result.Code == FHiveResultAPI::ECode::AuthV4SessionExist) {
                        // If playerId and playerToken have already been issued and automatic login is needed
                        // TODO: FHiveAuthV4.SignIn(EHiveProviderType::GUEST, Delegate);
                } else if (Result.Code == FHiveResultAPI::ECode::AuthV4NotInitialized) {
                        // TODO: SDK initialization needed
                } else if (Result.Code == FHiveResultAPI::ECode::AuthV4InvalidParam) {
                        // TODO: Check if the value of the provided authKey is empty
                }
        }));
}

using namespace std;    
    using namespace hive;    
    // การเข้าสู่ระบบ Twitter ถูกนำไปใช้โดยตรงในเกม    
    Game::Login("CUSTOM_TWITTER", [=](string authKey) {    
    AuthV4::signInWithAuthKey(authKey, [=](ResultAPI const & result, PlayerInfo const & playerInfo) {    
        if (result.isSuccess()) {    
            map<string, ProviderInfo> customProviderInfoData = playerInfo.customProviderInfoData;    
            ProviderInfo providerInfo = customProviderInfoData["CUSTOM_TWITTER"];    
            // ตรวจสอบข้อมูลการเชื่อมโยงผู้ใช้ต่อไปนี้    
            providerInfo.providerType; // ProviderType::CUSTOM, ประเภทที่กำหนดเองจะถูกกำหนดไว้ ดังนั้นต้องแยกแยะตาม providerName    
            providerInfo.providerName; // "CUSTOM_TWITTER"    
            providerInfo.providerUserId; // รหัสผู้ใช้ที่ใช้สำหรับการเข้าสู่ระบบ Twitter แบบกำหนดเอง    
            return;    
        }    
        else if (result.code == ResultAPI::Code::AuthV4SessionExist) {    
            // หาก playerId และ playerToken ได้รับการออกแล้วและต้องการการเข้าสู่ระบบอัตโนมัติ    
            // TODO: AuthV4.signIn(ProviderType::AUTO, [=](ResultAPI const & _result, PlayerInfo const & playerInfo) {});    
        }    
        else if (result.code == ResultAPI::Code::AuthV4NotInitialized) {    
            // TODO: ต้องมีการเริ่มต้น SDK    
        }    
        else if (result.code == ResultAPI::Code::AuthV4InvalidParam) {    
            // TODO: ตรวจสอบว่าค่าของ authKey ที่ให้มานั้นเป็น NULL หรือว่างเปล่าหรือไม่    
        }    
        else if (result.needExit()) {    
            // TODO: นำฟังก์ชันการออกจากแอปไปใช้    
            // สำหรับผู้ใช้เครื่องยนต์ Cocos2d-x    
            // ตัวอย่าง) exit(0);    
            // สำหรับผู้ใช้เครื่องยนต์ Unreal    
            // ตัวอย่าง) UKismetSystemLibrary::QuitGame(GetWorld(), nullptr, EQuitPreference::Quit, false);      
        }    
    });    
});

// Twitter login implemented directly in the game
    Game.Login("CUSTOM_TWITTER") { authKey: String ->

    AuthV4.signInWithAuthKey(authKey, object : AuthV4.AuthV4SignInListener {
            override fun onAuthV4SignIn(result: ResultAPI, playerInfo: AuthV4.PlayerInfo?) {

                    if (result.isSuccess && playerInfo != null) {
                            playerInfo.customProviderInfoData["CUSTOM_TWITTER"]?.let { providerInfo ->
                                    providerInfo.providerType   // ProviderType.CUSTOM, custom types are fixed, so need to distinguish by providerName
                                    providerInfo.providerName   // "CUSTOM_TWITTER"
                                    providerInfo.providerUserId // User id used for the custom Twitter login
                            }
                    }
                    else if (result.needExit()) {
                            // TODO: Implement app exit functionality
                            // e.g.) exitProcess(0)
                    }
                    else if (result.code == ResultAPI.Code.AuthV4SessionExist) {
                            // If playerId and playerToken have already been issued and automatic login is needed
                            // TODO: AuthV4.signIn(AuthV4.ProviderType.AUTO, authV4SignInListener)
                    }
                    else if (result.code == ResultAPI.Code.AuthV4NotInitialized) {
                            // TODO: SDK initialization required
                    }
                    else if (result.code == ResultAPI.Code.AuthV4InvalidParam) {
                            // TODO: Check if the value of the provided authKey is NULL or empty
                    }
            }
    })

    }

// Twitter login implemented directly in the game
    Game.Login("CUSTOM_TWITTER") { authKey: String ->
            AuthV4.INSTANCE.signInWithAuthKey(authKey, new AuthV4.AuthV4SignInListener() {
                    @Override
                    public void onAuthV4SignIn(@NonNull ResultAPI result, @Nullable AuthV4.PlayerInfo playerInfo) {

                            if(result.isSuccess() && playerInfo != null) {
                                    HashMap<String, AuthV4.ProviderInfo> customProviderInfoData = playerInfo.getCustomProviderInfoData();
                                    AuthV4.ProviderInfo providerInfo = customProviderInfoData.get("CUSTOM_TWITTER");
                                    // ตรวจสอบข้อมูลการเชื่อมโยงผู้ใช้ต่อไปนี้
                                    if (providerInfo != null){
                                            providerInfo.getProviderType(); // AuthV4.ProviderType.CUSTOM, ประเภทที่กำหนดเองจะถูกกำหนดโดย Type ดังนั้นต้องแยกแยะตาม providerName
                                            providerInfo.getProviderName(); // "CUSTOM_TWITTER"
                                            providerInfo.getProviderUserId(); // รหัสผู้ใช้ที่ใช้ในการเข้าสู่ระบบ Twitter แบบกำหนดเอง
                                    }
                            } else if (result.needExit()) {
                                    // TODO: Implement app exit functionality
                                    // e.g.) System.exit(0);
                            } else if (result.getCode() == ResultAPI.Code.AuthV4SessionExist) {
                                    // หาก playerId และ playerToken ได้รับการออกแล้วและต้องการเข้าสู่ระบบอัตโนมัติ
                                    // TODO: AuthV4.signIn(AuthV4.ProviderType.AUTO, authV4SignInListener)
                            } else if (result.getCode() == ResultAPI.Code.AuthV4NotInitialized) {
                                    // TODO: ต้องมีการเริ่มต้น SDK
                            } else if (result.getCode() == ResultAPI.Code.AuthV4InvalidParam) {
                                    // TODO: ตรวจสอบว่าค่าของ authKey ที่ให้มาคือ NULL หรือว่างเปล่า
                            }
                    }
            });
    }

// การเข้าสู่ระบบ Twitter ที่ดำเนินการโดยตรงในเกม
    Game.login("CUSTOM_TWITTER") { (authKey) in
    AuthV4Interface.signInWithAuthKey(authKey) { (result, playerInfo) in
            if result.isSuccess() {
                    let customProviderInfoData = playerInfo?.customProviderInfoData;
                    let providerInfo = customProviderInfoData?["CUSTOM_TWITTER"]
                    // ตรวจสอบข้อมูลการเชื่อมโยงผู้ใช้ต่อไปนี้
                    providerInfo?.providerType;     // AuthProviderType, ประเภทที่กำหนดเองจะถูกกำหนดไว้ดังนั้นต้องแยกแยะตาม providerName
                    providerInfo?.providerName;     // "CUSTOM_TWITTER"
                    providerInfo?.providerUserId;   // รหัสผู้ใช้ที่ใช้สำหรับการเข้าสู่ระบบ Twitter แบบกำหนดเอง
                    return
            }
            else if result.getCode() == .authV4SessionExist {
                    // หาก playerId และ playerToken ได้ถูกออกแล้วและต้องการเข้าสู่ระบบอัตโนมัติ
                    // TODO: AuthV4Interface.signIn(.auto) { (result, playerInfo) in }
            }
            else if result.getCode() == .authV4NotInitialized {
                    // TODO: ต้องมีการเริ่มต้น SDK
            }
            else if result.getCode() == .authV4invalidParam {
                    // TODO: ตรวจสอบว่าค่าของ authKey ที่ให้มานั้นเป็น nil หรือว่างเปล่าหรือไม่
            }
            else if result.needExit() {
                            // TODO: นำฟังก์ชันการออกจากแอปไปใช้
                    // ตัวอย่าง) exit(0)
            }
    }
    }

// ดำเนินการเข้าสู่ระบบ Twitter โดยตรงในเกม
    [Game login:@"CUSTOM_TWITTER" handler:^(NSString* authKey) {

    [HIVEAuthV4 signInWithAuthKey:authKey handler:^(HIVEResultAPI* result, HIVEPlayerInfo* playerInfo) {
                    if (result.isSuccess) {
                            NSDictionary<NSString*, HIVEProviderInfo*>* customProviderInfoData = playerInfo.customProviderInfoData;
                            ProviderInfo* providerInfo = [customProviderInfoData objectForKey:@"CUSTOM_TWITTER"];
                            // ตรวจสอบข้อมูลการเชื่อมโยงผู้ใช้ดังต่อไปนี้
                            providerInfo.providerType;     // HIVEProviderTypeCustom, ประเภทที่กำหนดเองมีการกำหนดไว้ ดังนั้นต้องแยกแยะตาม providerName
                            providerInfo.providerName;   // "CUSTOM_TWITTER"
                            providerInfo.providerUserId;  // รหัสผู้ใช้ที่ใช้สำหรับการเข้าสู่ระบบ Twitter แบบกำหนดเอง
                            return;
                    }
                    else if (result.getCode == HIVEResultAPICodeAuthV4SessionExist) {
                            // หาก playerId และ playerToken ได้ออกแล้วและต้องการการเข้าสู่ระบบอัตโนมัติ
                            // TODO: [HIVEAuthV4 signIn:HIVEProviderTypeAuto, handler:^(HIVEResultAPI* _result, HIVEPlayerInfo* playerInfo) {}];
                    }
                    else if (result.getCode == HIVEResultAPICodeAuthV4NotInitialized) {
                            // TODO: ต้องมีการเริ่มต้น SDK
                    }
                    else if (result.getCode == HIVEResultAPICodeAuthV4InvalidParam) {
                            // TODO: ตรวจสอบว่าค่าของ authKey ที่ให้มานั้นเป็น NULL หรือว่างเปล่าหรือไม่
                    }
                    else if (result.needExit) {
                            // TODO: นำฟังก์ชันการออกจากแอปไปใช้
                            // e.g.) exit(0);
                    }
    }];   
    }];

ชื่อผู้ใช้¶

เนื่องจากปัญหาต่างๆ เช่น COPPA ในสหรัฐอเมริกา เมื่อเข้าถึงจากสหรัฐอเมริกาและดินแดนของสหรัฐอเมริกาและเข้าสู่ระบบในฐานะ IdP คุณต้องป้อนชื่อผู้ใช้เพื่อเปิดใช้งานการประมวลผลการรับรองความถูกต้องของผู้ใช้เพิ่มเติม สำหรับข้อมูลอ้างอิง ประเทศที่รวมอยู่ในดินแดนของสหรัฐอเมริกาคือ อเมริกันซามัว (AS), กวม (GU), หมู่เกาะนอร์เทิร์นมาเรียนา (MP), เปอร์โตริโก (PR), หมู่เกาะเล็กน้อยของสหรัฐอเมริกา (UM) และหมู่เกาะเวอร์จินของสหรัฐอเมริกา (VI) หน้าจอสำหรับการป้อนชื่อผู้ใช้เพื่อการระบุตัวตนของผู้ใช้มีดังนี้

• หน้าจอป้อนชื่อผู้ใช้ใช้เพื่อวัตถุประสงค์ในการระบุผู้ใช้เท่านั้น ดังนั้นจึงจะแสดงเพียงครั้งเดียวในระหว่างการรวม IdP เบื้องต้นและจะไม่แสดงอีกต่อไป
• หน้าจอป้อนชื่อผู้ใช้จะไม่แสดงในระหว่างการเข้าสู่ระบบแขก.

การตรวจสอบความถูกต้องของกุญแจโทเค็น¶

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

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

โปรดดูที่ API เซิร์ฟเวอร์การตรวจสอบความถูกต้องของโทเค็น เพื่อดำเนินการฟีเจอร์นี้

การตรวจสอบการเปลี่ยนแปลงบัญชี IdP ในพื้นหลัง¶

ผู้ใช้สามารถไปที่การตั้งค่าอุปกรณ์ระหว่างการเล่นเกมเพื่อเปลี่ยนบัญชีเกม Apple Game Center หรือ Google Play ของตน หากคุณต้องการตรวจสอบว่าบัญชี IdP ในระหว่างการเล่นเกมแตกต่างจากบัญชี IdP ที่เชื่อมโยงกับ PlayerID ปัจจุบันหรือไม่ ให้เรียกใช้ setProviderChangedListener() หลังจากเริ่มต้น SDK โดยการเรียกใช้ API นี้ คุณจะได้รับเหตุการณ์ที่บ่งชี้ว่าบัญชี IdP ที่ตั้งไว้ในอุปกรณ์ได้เปลี่ยนแปลงเมื่อเกมกลับมาทำงานอีกครั้ง

iOS ทำงานเมื่อบัญชี Apple Game Center ถูกเปลี่ยนแปลง และ Android ทำงานเมื่อบัญชี Google Play Games ถูกเปลี่ยนแปลง และการตอบสนองจะถูกส่งมอบเฉพาะเมื่อ PlayerID ที่เข้าสู่ระบบในปัจจุบันเชื่อมโยงกับ IdP นั้น เมื่อได้รับเหตุการณ์การเปลี่ยนแปลงบัญชี IdP UI จะถูกกำหนดค่าเพื่อให้ผู้ใช้เลือกว่าจะใช้บัญชี IdP ที่เข้าสู่ระบบในอุปกรณ์หรือไม่ หากผู้ใช้เลือกบัญชี IdP ที่เข้าสู่ระบบในอุปกรณ์ signOut จะถูกเรียกเพื่อออกจากระบบ และจากนั้นจะทำการเข้าสู่ระบบโดยอัตโนมัติ

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

using hive;

AuthV4.setProviderChangedListener((ResultAPI result, AuthV4.ProviderInfo providerInfo) => {
    if (!result.isSuccess()) {
        return;
    }

        if (providerInfo != null && providerInfo.providerType == AuthV4.ProviderType.APPLE) {
                // เปลี่ยนข้อมูลผู้ใช้ GameCenter
        }
});

#include "HiveAuthV4.h"

FHiveAuthV4::SetProviderChangedListener(FHiveAuthV4OnCheckProviderDelegate::CreateLambda([this](const FHiveResultAPI& Result, const FHiveProviderInfo& ProviderInfo) {
        if (Result.IsSuccess()) {
                // การเรียกสำเร็จ ตรวจสอบข้อมูลผู้ใช้ที่เปลี่ยนแปลงผ่านวัตถุ ProviderInfo
        }
}));

#include <HIVE_SDK_Plugin/HIVE_CPP.h>
using namespace std;
using namespace hive;

AuthV4::setProviderChangedListener([=](ResultAPI const & result, ProviderInfo const & providerInfo) {
    if (!result.isSuccess()) {
        return;
    }

    if (providerInfo != null && providerInfo.providerType == ProviderType::GOOGLE) {
        // เปลี่ยนบัญชีบริการเกม Google Play
    }
});

import com.hive.AuthV4
import com.hive.ResultAPI

AuthV4.setProviderChangedListener(object : AuthV4.AuthV4CheckProviderListener {
        override fun onDeviceProviderInfo(result: ResultAPI, providerInfo: AuthV4.ProviderInfo?) {
                if (!result.isSuccess) {
                        return
                }

                if (providerInfo != null && providerInfo.providerType == AuthV4.ProviderType.GOOGLE) {
                        // เปลี่ยนบัญชี Google Play Game Service
                }
        }
})

import com.hive.AuthV4;
import com.hive.ResultAPI;

AuthV4.INSTANCE.setProviderChangedListener((result, providerInfo) -> {
        if (!result.isSuccess()) {
                return;
        }

        if (providerInfo != null && providerInfo.getProviderType() == AuthV4.ProviderType.GOOGLE) {
                // เปลี่ยนบัญชีบริการเกม Google Play
        }
});

import HIVEService

AuthV4Interface.setProviderChangedListener() { result, providerInfo in 
    if !result.isSuccess() {
        return
    }

    if let providerInfo = providerInfo, providerInfo.providerType == .Apple {
        // GameCenter user information change
    }
}

#import <HIVEService/HIVEService-Swift.h>

[HIVEAuthV4 setProviderChangedListener: ^(HIVEResultAPI *result, ProviderInfo *providerInfo) {
    if (![result isSuccess]) {
        return;
    }

    if (providerInfo != nil && providerInfo.providerType == HIVEProviderTypeApple) {
        // เปลี่ยนข้อมูลผู้ใช้ GameCenter
    }
}];

การเริ่มต้นข้อมูลเกม¶

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

ออกจากระบบ¶

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

นี่คือตัวอย่างโค้ดที่ทำการออกจากระบบ

using hive;    

    AuthV4.Helper.signOut (delegate (ResultAPI result, AuthV4.PlayerInfo playerInfo) {    
        switch(result.code) {    
            case ResultAPI.Code.Success:    
                // Logout successful    
                break;    
            default:    
                // Other exceptions    
                break;    
        }    
});

#include "HiveAuthV4.h"

FHiveAuthV4::Helper::SignOut(FHiveAuthV4HelperDelegate::CreateLambda([this](const FHiveResultAPI& Result, const TOptional<FHivePlayerInfo>& PlayerInfo) {
        AHIVESDKV4TesterGameMode::getGameModeInstance()->appendLogString(ELogType::AuthV4Helper ,TEXT("Helper::SignOut Result = %s"), *(Result.ToString()));
        switch (Result.Code) {
                case FHiveResultAPI::ECode::Success:
                        // Logout successful
                        break;
                default:
                        // Other exceptions
                        break;
        }
}));

#include <HIVE_SDK_Plugin/HIVE_CPP.h>    
    using namespace std;    
    using namespace hive;    

    AuthV4::Helper::signOut([=](ResultAPI const & result, shared_ptr playerInfo) {    
        switch (result.code) {    
            case ResultAPI::Success:    
                // Logout successful    
                break;    
            default:    
                // Other exceptions    
                break;    
        }    
});

import com.hive.AuthV4
import com.hive.ResultAPI

AuthV4.Helper.signOut(object : AuthV4.Helper.AuthV4HelperListener {
        override fun onAuthV4Helper(result: ResultAPI, playerInfo: AuthV4.PlayerInfo?) {
                when (result.code) {
                        ResultAPI.Code.Success -> {
                                // Logout successful
                        }
                        else -> {
                                // Other exception cases
                        }
                }
        }
})