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

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

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

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

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

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

Apple ไม่รองรับ Apple Game Center และการซื้อในแอปใน iOS enterprise builds ดังนั้น การเข้าสู่ระบบโดยอัตโนมัติด้วยบัญชี Apple Game Center ไม่สามารถใช้ได้ใน iOS enterprise builds และการเข้าสู่ระบบแบบชัดเจนก็ไม่สามารถใช้ Apple Game Center ได้เช่นกัน เมื่อสร้างสำหรับ iOS enterprise ประเภทการเข้าสู่ระบบในคอนโซลต้องไม่รวม Apple Game Center

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

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

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

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

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

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

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

ใน 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:
  k              // ข้อยกเว้นอื่น ๆ
                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: นำฟังก์ชันการออกจากแอปไปใช้
        // 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 engine
        // 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: นำฟังก์ชันการออกจากแอปไปใช้
            // e.g.) exitProcess(0)
        } else {
            when (result.code) {
                ResultAPI.Code.AuthV4ConflictPlayer -> {
                    // ขัดแย้งบัญชี
                }
                ResultAPI.Code.AuthV4HelperImplifiedLoginFail -> {
                    // ล้มเหลวในการเข้าสู่ระบบโดยอัตโนมัติ
                    // e.g.) AuthV4.showSignIn(...)
                }
                else -> {
                    // สถานการณ์ข้อยกเว้นอื่น ๆ
                }
            }
        }
    }
})

// Hive SDK AuthV4 authentication UI request
AuthV4.Helper.signIn(new AuthV4.Helper.AuthV4HelperListener() {
    @Override
    public void onAuthV4Helper(ResultAPI result, PlayerInfo playerInfo) {

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

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

    if result.isSuccess() {
        // การตรวจสอบสิทธิ์สำเร็จ
    } else if result.needExit() {
        // TODO: Implement app exit functionality
        // e.g.) exit(0)
    } else {
        switch result.getCode() {
            case .authV4ConflictPlayer:
                // ข้อขัดแย้งบัญชี
                break
            case .authV4HelperImplifiedLoginFail:
                // การเข้าสู่ระบบโดยนัยล้มเหลว
                // ex) AuthV4.showSignIn(...)
                break
            default:
                // สถานการณ์ข้อยกเว้นอื่นๆ
                break
            }
        }
    }
}

// พยายามเข้าสู่ระบบ (signIn) กับ 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 functionality
        // 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 engine users
        // Example) exit(0);
        // Unreal engine users
        // Example) 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
            // e.g. System.exit(0);
        }
    }
});

var email = String()

// Hive SDK AuthV4 การร้องขอ UI การตรวจสอบสิทธิ์
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)
    }
}

__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 succeeded
        // 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()) {
        // การเรียกสำเร็จ
        // playerInfo : ข้อมูลผู้ใช้ที่ผ่านการตรวจสอบสิทธิ์.

        // ตัวอย่างการดึงข้อมูลอีเมลสำหรับ 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.signIn(AuthV4.ProviderType.GOOGLE, (result, playerInfo) -> {
    if (result.isSuccess()) {
        // การเรียกใช้งานสำเร็จ
        // playerInfo: ข้อมูลผู้ใช้ที่ได้รับการตรวจสอบสิทธิ์
        // ตัวอย่างการดึงข้อมูลอีเมลสำหรับ 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() {
        // การเรียกสำเร็จ
        // playerInfo: ข้อมูลผู้ใช้ที่ได้รับการตรวจสอบสิทธิ์.

        // ตัวอย่างการดึงข้อมูลอีเมลของ 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]){
        // การเรียกสำเร็จ
        // playerInfo: ข้อมูลผู้ใช้ที่ได้รับการตรวจสอบสิทธิ์.

        // ตัวอย่างการดึงข้อมูลอีเมลสำหรับ 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) เมื่อทำการใช้งาน 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) เมื่อดำเนินการ 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.syncAccount(providerType, (result, playerInfo) -> {
    switch (result.getCode()) {
        case Success:
            // ปกติ  
        case AuthV4ConflictPlayer:    
            break;   
            // ข้อขัดแย้งของบัญชี
            // ex) เมื่อใช้ Hive UI
            // AuthV4.Helper.showConflict(...);
            // หรือ
            // ex) เมื่อดำเนินการ GameUI
            // AuthV4.Helper.resolverConflict(...);// เมื่อเลือกผู้ใช้ปัจจุบัน
            // AuthV4.Helper.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()) {
        // การตรวจสอบสิทธิ์สำเร็จ
        // playerInfo: ข้อมูลผู้ใช้ที่ตรวจสอบสิทธิ์แล้ว
    }
});

#include "HiveAuthV4.h"

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

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

#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()) {
        // การตรวจสอบสิทธิ์สำเร็จ
        // playerInfo: ข้อมูลผู้ใช้ที่ได้รับการตรวจสอบสิทธิ์
    }
});

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) {
            // การตรวจสอบสิทธิ์สำเร็จ
            // playerInfo: ข้อมูลผู้ใช้ที่ได้รับการตรวจสอบสิทธิ์
        }
    }
})

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

AuthV4.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]) {
        // การตรวจสอบสิทธิ์สำเร็จ
        // playerInfo: ข้อมูลผู้ใช้ที่ได้รับการตรวจสอบสิทธิ์
    }
}];

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

การเข้าสู่ระบบที่กำหนดเอง เป็นฟีเจอร์สำหรับ การเข้าสู่ระบบที่กำหนดเอง ซึ่งช่วยให้คุณสามารถดำเนินการเข้าสู่ระบบผ่าน 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 การเข้าสู่ระบบแบบกำหนดเอง วิธีการ connectWithAuthKey() และ disconnectWithName() รองรับการรวมและการตัดการเชื่อมต่อเพิ่มเติมของ IdP การเข้าสู่ระบบแบบกำหนดเอง

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

// การเข้าสู่ระบบ 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 are fixed
                    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 needed
            }
            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.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, เนื่องจากประเภทที่กำหนดเองนั้นคงที่ ต้องแยกแยะโดย 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: นำฟังก์ชันการออกจากแอปไปใช้
            // e.g. exit(0)
        }
    }
}

// Twitter login implemented directly in the game
[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 Games ของตน หากคุณต้องการตรวจสอบว่าบัญชี 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.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
    }
}

#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 exceptional situations
            }
        }
    }
})