วิธีการเริ่มต้น SDK Hive¶

ในการใช้ฟังก์ชัน SDK ของ Hive ในเกม คุณต้องเริ่มต้น Hive SDK หลังจากการเริ่มต้น ข้อตกลงการให้บริการรวมถึงการอัปเดตและป๊อปอัปการแจ้งเตือนที่ลงทะเบียนในคอนโซล Hive จะถูกเปิดเผยโดยอัตโนมัติ

วิธีการทำงานของการเริ่มต้น¶

เมื่อ Hive SDK ถูกเริ่มต้น มันจะทำฟังก์ชันต่อไปนี้:

• Hive SDK เริ่มต้นรายการต่อไปนี้ด้วยฟังก์ชันการเริ่มต้นเพียงฟังก์ชันเดียว
  • การรับรองความถูกต้อง: เริ่มต้น Hive Client และรับรองผู้ใช้ IdP
  • โปรโมชั่น: ทำการโฆษณาและออกคูปอง
  • การแจ้งเตือน: จัดการและตั้งค่าข้อความดันไปยังผู้ใช้
  • การจัดการการตลาด: สนับสนุนการจัดการทั้งหมดของโมดูลบุคคลที่สามที่ติดตามข้อมูลผู้ใช้ เช่น จำนวนผู้เล่นผ่านการโฆษณาและการวิเคราะห์เหตุการณ์
• Hive SDK ไม่ได้แจ้งสิทธิ์การเข้าถึงแอปโดยตรง สำหรับข้อมูลเพิ่มเติม โปรดตรวจสอบ [คำถามที่พบบ่อย].
• เปิดเผยการอัปเดตและป๊อปอัปการแจ้งเตือนที่ตั้งไว้สำหรับเกมที่เกี่ยวข้อง สำหรับ Google Play store, การอัปเดตในแอป ได้รับการสนับสนุน สำหรับรายละเอียดเพิ่มเติมเกี่ยวกับการลงทะเบียนป๊อปอัปการอัปเดต โปรดดูที่ คู่มือ Hive Console.
• ตรวจสอบ IP ของผู้ใช้และเปิดเผยข้อกำหนดในการให้บริการตามประเทศ

การอัปเดตในแอป¶

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

• รองรับเฉพาะ Google Play Store เท่านั้น
• รองรับเฉพาะอุปกรณ์มือถือ Android, แท็บเล็ต Android และอุปกรณ์ ChromeOS
• รองรับทั้งสองรูปแบบไฟล์แอป: AAB (Android App Bundle) และ APK อย่างไรก็ตาม ไฟล์ขยาย APK (.obb ไฟล์) ไม่ได้รับการสนับสนุน
• สำหรับ AAB รองรับขนาดสูงสุด 200MB และสำหรับ APK รองรับขนาดสูงสุด 150MB

Hive แผนภาพการเริ่มต้น¶

ป๊อปอัป App Tracking Transparency บน iOS จะปรากฏขึ้นเมื่อป๊อปอัปเงื่อนไขการใช้งานปรากฏขึ้นและข้อตกลงเงื่อนไขการใช้งานเสร็จสมบูรณ์

ลงทะเบียน Hive คีย์การรับรองความถูกต้อง¶

ด้วย API ของคลาส Configuration ให้ลงทะเบียนคีย์การรับรอง Hive ที่ออกโดยหน้าคอนโซล Hive ก่อนการเริ่มต้น Hive API ที่เกี่ยวข้องมีให้ตั้งแต่เวอร์ชัน 4.15.0 ขึ้นไป

using hive;    
    String hiveCertKey = "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJIaXZlIiwiaWF0IjoxNjAzNzc4OTU2LCJqdGkiOiIxODczMTExMzIwIn0.OxWo4R6UdI0BLP1ckt8RlMFrPAb5H7TNedmLFV1Cawc";    
Configuration.setHiveCertificationKey(hiveCertKey);

include "HiveConfiguration.h"

    FString hiveCertKey = TEXT("eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJIaXZlIiwiaWF0IjoxNjAzNzc4OTU2LCJqdGkiOiIxODczMTExMzIwIn0.OxWo4R6UdI0BLP1ckt8RlMFrPAb5H7TNedmLFV1Cawc");
    FHiveConfiguration::SetHiveCertificationKey(hiveCertKey);

#include <HIVE_SDK_Plugin/HIVE_CPP.h>    
    using namespace std;    
    using namespace hive;    
    string hiveCertKey = "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJIaXZlIiwiaWF0IjoxNjAzNzc4OTU2LCJqdGkiOiIxODczMTExMzIwIn0.OxWo4R6UdI0BLP1ckt8RlMFrPAb5H7TNedmLFV1Cawc";    
Configuration::setHiveCertificationKey(hiveCertKey);

import com.hive.Configuration    
    val hiveCertKey = "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJIaXZеIiwiaWF0IjoxNjAzNzc4OTU2LCJqdGkiOiIxODczMTExMzIwIn0.OxWo4R6UdI0BLP1ckt8RlMFrPAb5H7TNedmLFV1Cawc"    
Configuration.hiveCertificationKey = hiveCertKey

import com.hive.Configuration;    
    String hiveCertKey = "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJIaXZเIiwiaWF0IjoxNjAzNzc4OTU2LCJqdGkiOiIxODczMTExMzIwIn0.OxWo4R6UdI0BLP1ckt8RlMFrPAb5H7TNedmLFV1Cawc";    
Configuration.INSTANCE.setHiveCertificationKey(hiveCertkey);

import HIVEService    
    let hiveCertKey = "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJIaXZlIiwiaWF0IjoxNjAzNzc4OTU2LCJqdGkiOiIxODczMTExMzIwIn0.OxWo4R6UdI0BLP1ckt8RlMFrPAb5H7TNedmLFV1Cawc"    
ConfigurationInterface.setHiveCertificationKey(hiveCertKey)

#import <HIVEService/HIVEService-Swift.h>    
    NSString *hiveCertKey = @"eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJIaXZlIiwiaWF0IjoxNjAzNzc4OTU2LCJqdGkiOiIxODczMTExMzIwIn0.OxWo4R6UdI0BLP1ckt8RlMFrPAb5H7TNedmLFV1Cawc";    
[HIVEConfiguration setHiveCertificationKey: hiveCertKey];

การตั้งค่าเริ่มต้น¶

ในการเริ่มต้น Hive SDK ให้ดำเนินการ setup() เมธอดในคลาส AuthV4 ข้อมูลต่อไปนี้จะถูกส่งมอบเป็นผลลัพธ์ ดังนั้นคุณสามารถบันทึกข้อมูลในเกมและใช้มันหากจำเป็น

• ข้อมูลผลลัพธ์ของ Hive การเริ่มต้น

ต่อไปนี้คือตัวอย่างโค้ดในการ implement วิธีการ setup()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// Request Hive SDK Initialization
AuthV4::setup([=](ResultAPI const & result, bool isAutoSignIn, std::string did, std::vector<ProviderType> const & providerTypeList) {

    if (result.isSuccess()) {
        // การเริ่มต้นเสร็จสมบูรณ์แล้ว จัดการการเข้าสู่ระบบตามว่าการเข้าสู่ระบบอัตโนมัติเปิดใช้งานหรือไม่
    } else if (result.needExit()) {
        // TODO: นำไปใช้ในการปิดแอป
        // ผู้ใช้ของ Cocos2d-x engine
        // ex) exit(0);
        // ผู้ใช้ Unreal engine
        // ตัวอย่าง) UKismetSystemLibrary::QuitGame(GetWorld(), nullptr, EQuitPreference::Quit, false);    
    } else {
        // การเริ่มต้นล้มเหลว } 
            });

#include "HiveAuthV4.h"

    FHiveAuthV4::Setup(FHiveAuthV4OnSetupDelegate::CreateLambda([this](const FHiveResultAPI& Result,
    bool IsAutoSignIn,
    const FString& Did,
    const TArray<EHiveProviderType>& ProviderTypeArray) 
    {
            if (Result.IsSuccess()) {
                     // การเริ่มต้นสำเร็จแล้ว จัดการการเข้าสู่ระบบตามว่าการเข้าสู่ระบบอัตโนมัติเปิดใช้งานหรือไม่
            } else if (Result.NeedExit()) {
                     // TODO: Implement the termination of the app
        // ผู้ใช้ของเอนจิน Cocos2d-x
        // ex) exit(0);
                    // การเริ่มต้นล้มเหลว } 
            }
    }));

1
2
3
4
5
6
7
8
9

// การร้องขอ Hive การตั้งค่า SDK    
    AuthV4.setup(object: AuthV4.AuthV4SetupListener{    
        override fun onAuthV4Setup(result: ResultAPI, isAutoSignIn: Boolean, did: String?, providerTypeList: ArrayList<AuthV4.ProviderType>?) {        if (result.isSuccess) {    
                // การตั้งค่าเสร็จสมบูรณ์แล้ว จัดการการเข้าสู่ระบบตามว่าการเข้าสู่ระบบอัตโนมัติเปิดใช้งานหรือไม่    
            } else if (result.needExit()) {    
                // TODO: ดำเนินการยุติแอปพลิเคชัน    
                // ex) exitProcess(0)    
            } else {    
            // การตั้งค่าล้มเหลว } } })

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// Request Hive SDK Initialization    
    AuthV4.setup(new AuthV4.AuthV4SetupListener() {    
        @Override    
        public void onAuthV4Setup(ResultAPI result, boolean isAutoSignIn, String did, ArrayList<AuthV4.ProviderType> providerTypeList) {    

                if (result.isSuccess()) {    
                // การเริ่มต้นสำเร็จแล้ว จัดการการเข้าสู่ระบบตามว่าการเข้าสู่ระบบอัตโนมัติเปิดใช้งานหรือไม่    
            } else if (result.needExit()) {    
                // TODO: นำไปใช้ในการสิ้นสุดแอปพลิเคชัน    
                // ex) System.exit(0);    
            } else {    
            // การเริ่มต้นล้มเหลว } } });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

AuthV4Interface.setup { (result, isAutoSignIn, did, providerTypeList) in    
        if result.isSuccess() {    
            // การเริ่มต้นเสร็จสมบูรณ์แล้ว จัดการการเข้าสู่ระบบตามว่าเปิดใช้งานการเข้าสู่ระบบอัตโนมัติหรือไม่    
        } else if result.needExit() {    
            // TODO: Implement the termination of the app    
            // Example) exit(0)    
        } else {    
            // การเริ่มต้นล้มเหลว    
        }    
}

1
2
3
4
5
6
7
8
9

// Request Hive SDK Initialization    
    [HIVEAuthV4 setup:^(HIVEResultAPI *result, BOOL isAutoSignIn, NSString *did, NSArray<NSNumber *> *providerTypeList) {    
        if (result.isSuccess) {    
            // the initialization is successfully done. Handle login based on whether the auto-login is enabled or not.    
        } else if (result.needExit) {    
            // TODO: Implement the termination of the app    
            // ex) exit(0);    
        } else {    
        // Initialization failed } }];

ป๊อปอัพการบำรุงรักษาเซิร์ฟเวอร์¶

สำหรับบริการเกม จำเป็นต้องบล็อกเวอร์ชันหลังจากการอัปเดตของเกมไคลเอนต์ หรือบล็อกการเชื่อมต่อเกมระหว่างการบำรุงรักษาเซิร์ฟเวอร์เกม Hive มีฟังก์ชันในการแสดงป๊อปอัปในลำดับของ การอัปเดตเกมที่บังคับ, การแจ้งเตือน/การบำรุงรักษาเซิร์ฟเวอร์ ตามข้อมูลที่กำหนดใน Hive Console ในเกม คุณสามารถใช้ UI ที่จัดเตรียมโดย Hive SDK หรือสร้าง UI ที่กำหนดเองโดยการรับข้อมูลจาก Hive

หากมีเซิร์ฟเวอร์เกมมากกว่าหนึ่งเซิร์ฟเวอร์ ข้อมูลเซิร์ฟเวอร์เกมที่ผู้ใช้เลือกหรือตั้งค่าต้องถูกตั้งค่าใน Hive หากผู้ใช้ต้องการเลือกเซิร์ฟเวอร์เกม ให้ดำเนินการสร้าง UI สำหรับการเลือกเซิร์ฟเวอร์เพื่อเปลี่ยนการตั้งค่า Hive โดยการเรียกใช้วิธี setServerId() ของคลาส Configuration ก่อนที่จะแสดงป๊อปอัพประเภทต่างๆ หากคุณต้องการปรับปรุงข้อมูลโปรโมชั่น-ข่าวสารโดยการเปลี่ยนการตั้งค่า Hive ให้เรียกใช้วิธี updateServerId() ของคลาส Configuration แทนที่จะใช้วิธี setServerId()

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

ตั้งค่าข้อมูลป๊อปอัพ¶

ตั้งค่ารายละเอียดของป๊อปอัพการบำรุงรักษาเซิร์ฟเวอร์/ป๊อปอัพการอัปเดต/ป๊อปอัพประกาศบน Hive Console สำหรับข้อมูลเพิ่มเติมเกี่ยวกับการตั้งค่า ดูที่ Operation > Provisioning guide.

แสดงป๊อปอัพ¶

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

• การใช้ Hive-providing popups: ตั้งค่าพารามิเตอร์ isShow เป็น true.

• คำขอข้อมูลป๊อปอัพเพื่อปรับแต่งป๊อปอัพ: ตั้งค่าพารามิเตอร์ isShow เป็น false สำหรับข้อมูลเพิ่มเติมเกี่ยวกับข้อมูลป๊อปอัพ โปรดดูที่ ข้อมูลป๊อปอัพที่ส่งกลับโดย Hive ด้านล่าง.

• ตัวอย่างหน้าจอของป๊อปอัพ

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

using hive;    
    // Whether to use Hive SDK UI    
    Boolean isShow = true;    

    AuthV4.checkMaintenance(isShow, (ResultAPI result, List maintenanceInfoList) => {    
        if (result.isSuccess()) {    
            // หากไม่มีข้อมูลการตรวจสอบ    
            // หาก isShow เป็น false    
        }    
        else if (result.needExit()) {    
            // TODO: Implement app termination functionality    
            // ตัวอย่าง) Application.Quit();    
        }    
});

#include "HiveAuthV4.h"

// ว่าจะใช้ Hive SDK UI หรือไม่  
bool bIsShow = true;

FHiveAuthV4::CheckMaintenance(bIsShow, FHiveAuthV4OnMaintenanceInfoDelegate::CreateLambda([this](const FHiveResultAPI& Result, const TArray<FHiveAuthV4MaintenanceInfo>& AuthV4MaintenanceInfoArray) {

        if (Result.IsSuccess()) {
                // หากไม่มีข้อมูลการตรวจสอบ    
      // หาก isShow เป็น false
        } else if (Result.NeedExit()) {
                // TODO: Implement app termination functionality    
      // ตัวอย่าง) Application.Quit(); 
        }

}));

#include <HIVE_SDK_Plugin/HIVE_CPP.h>    
    using namespace std;    
    using namespace hive;    
    // Whether to use Hive SDK UI    
    bool isShow = true;    

    AuthV4::checkMaintenance(isShow, [=](ResultAPI const & result, vector const & maintenanceInfolist){    
        if (result.isSuccess()) {    
            // หากไม่มีข้อมูลการตรวจสอบที่ลงทะเบียน    
            // หาก isShow เป็น false    
        }    
        else if (reuslt.needExit()) {    
            // TODO: Implement app termination functionality    
            // ผู้ใช้ Cocos2d-x engine    
            // ตัวอย่าง) exit(0);    
            // ผู้ใช้ Unreal Engine    
            // ตัวอย่าง) UKismetSystemLibrary::QuitGame(GetWorld(), nullptr, EQuitPreference::Quit, false);    
        }    
});

import com.hive.AuthV4    
import com.hive.AuthV4    
    import com.hive.ResultAPI    
    // Whether to use Hive SDK UI    
    val isShow = true    
    AuthV4.checkMaintenance(isShow, object : AuthV4.AuthV4MaintenanceListener {    
        override fun onAuthV4Maintenance(result: ResultAPI, maintenanceInfo: ArrayList<AuthV4.AuthV4MaintenanceInfo>?) {    
            if (result.isSuccess) {    
                // If there is no registered inspection data    
                // If isShow is false    
            }    
            else if (result.needExit()) {    
                // TODO: Implement app termination functionality    
                // Example) exitProcess(0)    
            }    
        }    
})

import com.hive.AuthV4;    
    import com.hive.ResultAPI;    
    // Whether to use Hive SDK UI    
    boolean isShow = true;    
    AuthV4.INSTANCE.checkMaintenance(isShow, (result, maintenanceInfo) -> {    
        if (result.isSuccess()) {    
            // If there is no registered inspection data    
            // If isShow is false    
        }    
        else if (result.needExit()) {    
            // TODO: Implement app termination functionality    
            // Example) System.exit(0);    
        }    
});

import HIVEService    
    // Whether to use Hive SDK UI    
    let isShow = true    

    AuthV4Interface.checkMaintenance(isShow) { result, maintenances in    
        if result.isSuccess() {    
            // หากไม่มีข้อมูลการตรวจสอบจริง    
            // หาก isShow เป็น false    
        }    
        else if result.needExit() {    
            // TODO: Implement app termination functionality    
            // ตัวอย่าง) exit(0)    
        }    
}

#import <HIVEService/HIVEService-Swift.h>    
    // Whether to use Hive SDK UI    
    BOOL isShow = YES;    

    [HIVEAuthV4 checkMaintenance:isShow handler: ^(HIVEResultAPI *result, NSArray<HIVEAuthV4MaintenanceInfo *> *maintenanceInfolist) {    
        if (result.isSuccess) {    
            // หากไม่มีข้อมูลการตรวจสอบที่ลงทะเบียน    
            // หาก isShow เป็น false    
        }    
        else if (result.needExit) {    
            // TODO: Implement app termination functionality    
            // ตัวอย่าง) exit(0);    
        }    
}];

ข้อมูลป๊อปอัพที่ส่งกลับโดย Hive¶

หาก Hive ได้รับคำขอสำหรับข้อมูลป๊อปอัพที่ตั้งไว้ใน Hive Console ผ่านวิธี checkMaintenance() จะส่งค่าที่สรุปไว้ในตารางต่อไปนี้ในวัตถุ AuthV4MaintenanceInfo และหากค่าดังกล่าวถูกส่งคืนเป็น null จะไม่มีเนื้อหาที่จะป๊อปอัพ

• รายละเอียดของวัตถุ AuthV4MaintenanceInfo

Hive webview¶

ข้อกำหนดในการให้บริการ¶

ในขณะเริ่มต้น, Hive SDK จะเปิดเผยข้อกำหนดในการให้บริการ ("ข้อกำหนด") ที่เหมาะสมสำหรับประเทศที่กำหนดโดย IP การเข้าถึงของผู้ใช้และบริษัทพัฒนาเกมโดยอัตโนมัติ อย่างไรก็ตาม, เกมควรจัดเตรียมลิงก์สำหรับข้อกำหนดและนโยบายความเป็นส่วนตัวให้กับผู้ใช้ทุกคนโดยไม่คำนึงถึงความยินยอมต่อข้อกำหนดและนโยบายความเป็นส่วนตัว หากคุณใช้ลิงก์ที่จัดเตรียมโดย Hive ข้อกำหนดและนโยบายที่เหมาะสมจะถูกเลือกโดยอัตโนมัติเพื่อเปิดเผยต่อผู้ใช้ขึ้นอยู่กับการตั้งค่าบน Hive Console กฎระเบียบในการระบุลิงก์ของข้อกำหนดและนโยบายจะแตกต่างกันไปตามบริษัทพัฒนาเกม.

• ตัวอย่างหน้าจอของข้อกำหนด

เมื่อต้องการแสดงข้อกำหนดในการให้บริการเมื่อคลิกปุ่มหรือลิงก์ ให้เรียกใช้วิธี showTerms() ของคลาส AuthV4 ตัวอย่างโค้ดมีดังนี้

using hive;    
    AuthV4.showTerms((ResultAPI result) => {    
        if (result.isSuccess()) {    
            // API call success    
        }    
});

#include "HiveAuthV4.h"

FHiveAuthV4::ShowTerms(FHiveAuthV4OnShowTermsDelegate::CreateLambda([this](const FHiveResultAPI& Result) {
        if (Result.IsSuccess()) {
                //API call success
        }
}));

#include <HIVE_SDK_Plugin/HIVE_CPP.h>    
    using namespace std;    
    using namespace hive;    
    AuthV4::showTerms([=](ResultAPI const & result) {    
        if (result.isSuccess()) {    
            // API call success    
        }    
});

import com.hive.AuthV4    
    import com.hive.ResultAPI    
    AuthV4.showTerms(object : AuthV4.AuthV4ShowTermsListener {    
        override fun onAuthV4ShowTerms(result: ResultAPI) {    
            if (result.isSuccess) {    
                // API call success    
            }    
        }    
})

import com.hive.AuthV4;    
    import com.hive.ResultAPI;    
    AuthV4.INSTANCE.showTerms(result -> {    
        if (result.isSuccess()) {    
            // API call success    
        }    
});

import HIVEService    
    AuthV4Interface.showTerms() { result in    
        if result.isSuccess() {    
            // API call success    
        }    
}

#import <HIVEService/HIVEService-Swift.h>    
    [HIVEAuthV4 showTerms:^(HIVEResultAPI *result) {     
        if ([result isSuccess]) {    
            // API call success    
        }    
}];

ลบประวัติการตกลงของข้อกำหนดและเงื่อนไข¶

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

using hive;

AuthV4.resetAgreement();

#include "HiveAuthV4.h"

FHiveAuthV4::ResetAgreement();

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

AuthV4::resetAgreement()

import com.hive.AuthV4

AuthV4.resetAgreement()

import com.hive.AuthV4;

AuthV4.INSTANCE.resetAgreement();

import HIVEService

AuthV4Interface.resetAgreement()

#import <HIVEService/HIVEService-Swift.h>

[AuthV4Interface resetAgreement]

Hive โปรไฟล์¶

ในการแสดงหน้าจอ โปรไฟล์ ให้เรียกใช้ showProfile() ของคลาส AuthV4 เมื่อหน้าจอโปรไฟล์แสดงขึ้น ผู้ใช้สามารถตรวจสอบและเปลี่ยนแปลงรูปภาพโปรไฟล์และชื่อเล่นของตนได้

ด้านล่างนี้คือตัวอย่างโค้ดสำหรับการแสดงผล โปรไฟล์.

using hive;    
    // playerId ของผู้ใช้ที่เข้าสู่ระบบ    
    Int64 playerId = 12345;    
    AuthV4.showProfile(playerId, (ResultAPI result) => {    
        if (result.isSuccess()) {    
            // การเรียกสำเร็จ    
        }    
});

#include "HiveAuthV4.h"

// playerId ของผู้ใช้ที่ล็อกอินอยู่  
int64 PlayerId = 12345;

FHiveAuthV4::ShowProfile(PlayerId, FHiveAuthV4OnShowProfileDelegate::CreateLambda([this](const FHiveResultAPI& Result) {
        if (Result.IsSuccess()) {
                // การเรียกสำเร็จ 
        }
}));

#include <HIVE_SDK_Plugin/HIVE_CPP.h>    
    using namespace std;    
    using namespace hive;    
    // playerId ของผู้ใช้ที่เข้าสู่ระบบ    
    long long playerId = 12345;    
    AuthV4::showProfile(playerId, [=](ResultAPI const & result){    
        if (result.isSuccess()) {    
            // การเรียกสำเร็จ    
        }    
});

import com.hive.AuthV4    
    import com.hive.ResultAPI    
    // playerId ของผู้ใช้ที่ล็อกอิน    
    val playerId = 12345L    
    AuthV4.showProfile(playerId, object : AuthV4.AuthV4ShowProfileListener{    
        override fun onAuthV4ShowProfile(result: ResultAPI) {    
            if (result.isSuccess) {    
                // เรียกสำเร็จ    
            }    
        }    
})

import com.hive.AuthV4;    
    import com.hive.ResultAPI;    
    // playerId ของผู้ใช้ที่เข้าสู่ระบบ    
    long playerId = 12345;    
    AuthV4.INSTANCE.showProfile(playerId, result -> {    
        if (result.isSuccess()) {    
            // การเรียกสำเร็จ    
        }    
});

import HIVEService    
    // playerId ของผู้ใช้ที่เข้าสู่ระบบ    
    let playerId: Int64 = 12345    
    AuthV4Interface.showProfile(playerId) { result in    
        if result.isSuccess() {    
            // การเรียกสำเร็จ    
        }    
}

#import <HIVEService/HIVEService-Swift.h>    
    // playerId ของผู้ใช้ที่เข้าสู่ระบบ    
    long long playerId = 12345;    
    [HIVEAuthV4 showProfile: playerId handler: ^(HIVEResultAPI *result) {    
        if ([result isSuccess]) {    
            // การเรียกสำเร็จ    
        }    
}];

หากคุณให้ Membership IdP, Hive Membership จะมีการเปลี่ยนรหัสผ่านและการถอนสมาชิกใน Hive การตั้งค่าบัญชีในหน้าจอโปรไฟล์ Hive ดังนั้นคุณ ต้อง ดำเนินการ showProfile() ให้เสร็จสิ้น

• โปรไฟล์เมื่อ Hive รหัสสมาชิก IdP ถูกผสานรวม.

• โปรไฟล์เมื่อ IdP (รวมถึงแขก) ที่ไม่ใช่ Hive สมาชิกถูกบูรณาการ.

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

การสอบถาม¶

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

• หน้าจอตัวอย่างของการสอบถาม

  

เพื่อแสดงหน้าสอบถาม ให้เรียกใช้เมธอด showInquiry() ในคลาส AuthV4. ต่อไปนี้คือตัวอย่างโค้ดเพื่อแสดงหน้าสอบถาม

using hive;    
    AuthV4.showInquiry((ResultAPI result) => {    
    if (result.isSuccess()) {    
    // call successful    
    }    
});

#include "HiveAuthV4.h"

FHiveAuthV4::ShowInquiry(FHiveAuthV4OnShowInquiryDelegate::CreateLambda([this](const FHiveResultAPI& Result) {
        if (Result.IsSuccess()) {
                // call successful 
        }
}));

#include <HIVE_SDK_Plugin/HIVE_CPP.h>    
    using namespace std;    
    using namespace hive;    
    AuthV4::showInquiry([=](ResultAPI const & result) {    
    if (result.isSuccess()) {    
    // call successful    
    }    
});

import com.hive.AuthV4    
    import com.hive.ResultAPI    
    AuthV4.showInquiry(object : AuthV4.AuthV4ShowInquiryListener {    
         override fun onAuthV4ShowInquiry(result: ResultAPI) {    
             if (result.isSuccess) {    
                 // call successful    
             }    
         }    
})

import com.hive.AuthV4;    
    import com.hive.ResultAPI;    
    AuthV4.INSTANCE.showInquiry(result -> {    
         if (result.isSuccess()) {    
             // call successful    
         }    
});

import HIVEService    
    AuthV4Interface.showInquiry() { result in    
    if result.isSuccess() {    
    // call successful    
    }    
}

#import <HIVEService/HIVEService-Swift.h>    
    [HIVEAuthV4 showInquiry: ^(HIVEResultAPI *result) {    
    if ([result isSuccess]) {    
    // call successful    
    }    
}];

ทางลัดการสอบถามของฉัน¶

ผู้ใช้ที่ซิงค์กับสมาชิก Hive สามารถตรวจสอบประวัติการสอบถามของตนได้ผ่านทางทางลัด My Inquiry เรียกใช้เมธอด showMyInquiry() ในคลาส AuthV4 เพื่อให้ผู้ใช้สอบถามเกี่ยวกับเกมของคุณและแก้ไขได้อย่างง่ายดาย หากผู้ใช้ได้สอบถามผ่านทาง Hive มือถือหรือเว็บไซต์ อย่างไรก็ตาม การสอบถามจะไม่ถูกเปิดเผยแม้จะระบุ Hive ID และ CS Code (PlayerID) เนื่องจากไม่ทราบว่าผู้ใช้ได้เข้าสู่ระบบสมาชิก Hive หรือไม่

ต่อไปนี้คือตัวอย่างโค้ดเพื่อเปิดใช้งานทางลัด My Inquiry

using hive;    
    AuthV4.showMyInquiry((ResultAPI result) => {    
    if (result.isSuccess()) {    
    // call successful    
    }    
});

#include "HiveAuthV4.h"

FHiveAuthV4::ShowMyInquiry(FHiveAuthV4OnShowInquiryDelegate::CreateLambda([this](const FHiveResultAPI& Result) {
        if (Result.IsSuccess()) {
                // call successful
        }
}));

#include <HIVE_SDK_Plugin/HIVE_CPP.h>    
    using namespace std;    
    using namespace hive;    
    AuthV4::showMyInquiry([=](ResultAPI const & result) {    
    if (result.isSuccess()) {    
    // call successful    
    }    
});

import com.hive.AuthV4    
    import com.hive.ResultAPI    
    AuthV4.showMyInquiry(object : AuthV4.AuthV4ShowMyInquiryListener {    
         override fun onAuthV4ShowMyInquiry(result: ResultAPI) {    
             if (result.isSuccess) {    
                 // call successful    
             }    
         }    
})

import com.hive.AuthV4;    
    import com.hive.ResultAPI;    
    AuthV4.INSTANCE.showMyInquiry(result -> {    
         if (result.isSuccess()) {    
             // call successful    
         }    
});

import HIVEService    
    AuthV4Interface.showMyInquiry() { result in    
    if result.isSuccess() {    
    // call successful    
    }    
}

#import <HIVEService/HIVEService-Swift.h>    
    [HIVEAuthV4 showMyInquiry: ^(HIVEResultAPI *result) {    
    if ([result isSuccess]) {    
    // call successful    
    }    
}];

Hive แชทบอท CS¶

การสอบถามผ่านแชทบอท¶

• หน้าจอตัวอย่างสำหรับการสอบถามของแชทบอท

ในการเปิดเผยหน้าช่องแชท ให้เรียกใช้วิธีการ showChatbotInquiry() ในคลาส AuthV4.

ต่อไปนี้คือตัวอย่างโค้ดเพื่อแสดงการสอบถามผ่านหน้าแชทบอท

using hive;    
    // ข้อมูลสตริงในรูปแบบ JSON ที่สัญญาว่าจะถูกส่งเมื่อเรียกใช้ API ทางลัดหน้าแชทบอท    
    String additionalInfo = "{ \"init_path\":\"hive_sdk_api\" }";    
    AuthV4.showChatbotInquiry(additionalInfo, (ResultAPI result) => {    
         if (result.isSuccess()) {    
             // การเรียกใช้สำเร็จ    
         }    
});

#include "HiveAuthV4.h"

// ข้อมูลสตริงในรูปแบบ JSON ที่สัญญาว่าจะถูกส่งเมื่อเรียกใช้ API ทางลัดหน้าช่องแชท
TSharedPtr<FJsonObject> AdditionalInfoJson = MakeShareable(new FJsonObject);
AdditionalInfoJson->SetStringField(TEXT("init_path"), TEXT("hive_sdk_api"));

FString StrAdditionalInfo;
TSharedRef<TJsonWriter<>> JsonWriter = TJsonWriterFactory<>::Create(&StrAdditionalInfo);
FJsonSerializer::Serialize(AdditionalInfoJson.ToSharedRef(), JsonWriter);

FHiveAuthV4::ShowChatbotInquiry(StrAdditionalInfo, FHiveAuthV4OnShowInquiryDelegate::CreateLambda([this](const FHiveResultAPI& Result) {
        if (Result.IsSuccess()) {
                // call successful 
        }
}));

#include <HIVE_SDK_Plugin/HIVE_CPP.h>    
    using namespace std;    
    using namespace hive;    
    // ข้อมูลสตริงในรูปแบบ JSON ที่สัญญาว่าจะถูกส่งเมื่อเรียกใช้ API ทางลัดหน้าแชทบอท    
    string additionalInfo = "{ \"init_path\":\"hive_sdk_api\" }";    
    AuthV4::showChatbotInquiry(additionalInfo, [=](ResultAPI const &result) {    
         if (result.isSuccess()) {    
            // การเรียกใช้สำเร็จ    
         }    
});

import com.hive.AuthV4    
    import com.hive.ResultAPI    
    // ข้อมูลสตริงในรูปแบบ JSON ที่สัญญาว่าจะถูกส่งเมื่อเรียกใช้ API ทางลัดหน้าแชทบอท    
    val additionalInfo = "{ \"init_path\":\"hive_sdk_api\" }"    
    AuthV4.showChatbotInquiry(additionalInfo, object : AuthV4.AuthV4ShowChatbotInquiryListener {    
         override fun onAuthV4ShowChatbotInquiry(result: ResultAPI) {    
             if (result.isSuccess) {    
                 // การเรียกใช้สำเร็จ    
             }    
         }    
})

import com.hive.AuthV4;    
    import com.hive.ResultAPI;    
    // สตริงข้อมูลในรูปแบบ JSON ที่สัญญาว่าจะถูกส่งเมื่อเรียกใช้ API ทางลัดหน้าแชทบอท    
    String additionalInfo = "{ \"init_path\":\"hive_sdk_api\" }";    
    AuthV4.INSTANCE.showChatbotInquiry(additionalInfo, result -> {    
         if (result.isSuccess()) {    
             // การเรียกใช้สำเร็จ    
         }    
});

import HIVEService    
    // String data in JSON format promised to be delivered when calling the chatbot page shortcut API    
    let additionalInfo = "{ \"init_path\":\"hive_sdk_api\" }"    
    AuthV4Interface.showChatbotInquiry(additionalInfo) { result in    
    if result.isSuccess() {    
    // call successful    
    }    
}

#import <HIVEService/HIVEService-Swift.h>    
    // ข้อมูลสตริงในรูปแบบ JSON ที่สัญญาว่าจะถูกส่งเมื่อเรียกใช้ API ทางลัดหน้าแชทบอท    
    NSString *additionalInfo = @"{ \"init_path\":\"hive_sdk_api\" }";    
    [HIVEAuthV4 showChatbotInquiry:additionalInfo handler:^(HIVEResultAPI *result) {    
    if ([result isSuccess]) {    
             // การเรียกใช้สำเร็จ    
         }    
}];

การตั้งค่าแชทบอท¶

AppDelegate ใน chatbot นิยามการกระทำทั่วไป (วิธีการ) ของวัตถุที่อยู่ด้านบนในแอป iOS เมื่อสร้างโปรเจกต์ของคุณด้วย Xcode มันจะสร้างคลาสโดยอัตโนมัติ

Hive SDK เปิดเผย UI แชทบอทในแนวตั้งเท่านั้นเพื่อความสะดวกของผู้ใช้ การใช้ฟีเจอร์นี้บน iOS ต้องการฟังก์ชันที่เกี่ยวข้องกับการหมุนหน้าจอ, application(_:supportedInterfaceOrientationsFor:) ในคลาส AppDelegate ของเอนจินเกม วิธีการนี้จะส่งคืนค่า UIInterfaceOrientationMask สำหรับการใช้งานในเกม มันจะส่งคืนแนวนอนในเกมที่รองรับเฉพาะแนวนอน, แนวตั้งในเกมที่รองรับเฉพาะแนวตั้ง, และทั้งแนวนอนและแนวตั้งในเกมที่รองรับทุกประเภท

// หากเกมเอนจินของคุณเขียนด้วย Objective-c ให้ทำการ implement ฟังก์ชัน AppDelegate ดังต่อไปนี้
- (UIInterfaceOrientationMask)application:(UIApplication *)application supportedInterfaceOrientationsForWindow:(UIWindow *)window 
{
    // TODO: สำหรับแนวนอนเท่านั้น
    return UIInterfaceOrientationMaskLandscape;
    // TODO: สำหรับแนวตั้งเท่านั้น
    return UIInterfaceOrientationMaskPortrait;
    // TODO: สำหรับทั้งแนวนอนและแนวตั้ง
    return UIInterfaceOrientationMaskAll;
}

// หากเกมเอนจินของคุณเขียนด้วย Swift ให้ทำการ implement ฟังก์ชัน AppDelegate ต่อไปนี้
func application(_ application: UIApplication, supportedInterfaceOrientationsFor window: UIWindow?) -> UIInterfaceOrientationMask 
{
    // TODO: สำหรับแนวนอนเท่านั้น
    return [.landscape]
    // TODO: สำหรับแนวตั้งเท่านั้น
    return [.portrait]
    // TODO: สำหรับทั้งแนวนอนและแนวตั้ง
    return .all
}

แชทบอทเฉพาะในแนวตั้งบน iPad จำเป็นต้องสร้างโปรเจ็กต์ Xcode ของคุณด้วยการตั้งค่าเพิ่มเติมด้านล่าง

การเปิดเผยต่อชุมชน¶

สำหรับการประมวลผลการเข้าสู่ระบบอัตโนมัติและการทำงานปกติของชุมชน ให้เปิดเผยเว็บไซต์ชุมชนผ่านการเรียก API ตามที่แสดงด้านล่าง เมื่อทำการตั้งค่าเว็บไซต์ Community ที่ปฏิบัติตามข้อกำหนด Hive หากคุณต้องการใช้ที่อยู่โดเมนที่กำหนดเองนอกเหนือจาก withhive.com และ com2us.com ให้ลงทะเบียนที่อยู่โดเมนใน Hive Console whitelist จากนั้นเรียกใช้ API นี้

สำหรับการเข้าสู่ระบบอัตโนมัติและฟังก์ชันอื่น ๆ ในชุมชน Hive ให้เปิดเผยหน้าชุมชนผ่านการเรียก API ดังนี้

using hive;    
    // ตั้งค่าประเภทการแสดงผล (FullScreen: เต็มหน้าจอ, Frame: หน้าจอกรอบ)    
    SocialV4.ViewType viewType = SocialV4.ViewType.Frame;    
    SocialV4.showCommunity(SocialV4.ProviderType.HIVE, viewType, (ResultAPI result) => {    
    if (result.isSuccess()) {    
    // เรียกใช้สำเร็จแล้ว    
    }    
});

#include "HiveSocialV4.h"

// ตั้งค่าประเภทการแสดงผล (FullScreen: เต็มหน้าจอ, Frame: หน้าจอกรอบ)
ESocialV4ViewType ViewType = ESocialV4ViewType::Frame;

FHiveSocialV4::ShowCommunity(ESocialV4ProviderType::HIVE, ViewType, FHiveSocialV4OnShowCommunityDelegate::CreateLambda([this](const FHiveResultAPI& Result) {

        if (Result.IsSuccess()) {
                // call successful
        }
}));

#include <HIVE_SDK_Plugin/HIVE_CPP.h>    
    using namespace std;    
    using namespace hive;    
    // ตั้งค่าประเภทการแสดงผล (FullScreen: เต็มหน้าจอ, Frame: หน้าจอกรอบ)    
    SocialV4::ViewType viewType = SocialV4::ViewType::Frame;    
    SocialV4.showCommunity(SocialV4::ProviderType::HIVE, viewType, (ResultAPI const & result) {    
    if (result.isSuccess()) {    
    // เรียกสำเร็จ    
    }    
});

import com.hive.SocialV4    
    import com.hive.ResultAPI    
    // ตั้งค่าประเภทการแสดงผล (FullScreen: เต็มหน้าจอ, Frame: หน้าจอกรอบ)    
    val viewType = SocialV4.ViewType.Frame    
    SocialV4.showCommunity(SocialV4.ProviderType.HIVE, viewType, object : SocialV4.SocialV4ShowCommunityListener{    
         override fun onShowCommunity(result: ResultAPI) {    
             if (result.isSuccess) {    
                 // เรียกใช้งานสำเร็จ    
             }    
         }    
})

import com.hive.SocialV4;    
    import com.hive.ResultAPI;    
    // ตั้งค่าประเภทการแสดงผล (FullScreen: เต็มหน้าจอ, Frame: หน้าจอกรอบ)    
    SocialV4.ViewType viewType = SocialV4.ViewType.Frame;    
    SocialV4.INSTANCE.showCommunity(SocialV4.ProviderType.HIVE, viewType, result -> {    
         if (result.isSuccess()) {    
             // เรียกใช้งานสำเร็จ    
         }    
});

import HIVEService    
    // Set view type (FullScreen: full screen, Frame: frame screen)    
    let viewType = SocialViewType.Frame    
    SocialV4Interface.showCommunity(.HIVE, viewType) { result in    
    if result.isSuccess() {    
    // call successful    
    }    
}

#import <HIVEService/HIVEService-Swift.h>    
    // ตั้งค่าประเภทการแสดงผล (FullScreen: เต็มหน้าจอ, Frame: หน้าจอกรอบ)    
    HIVESocialViewType viewType = HIVESocialViewTypeFrame;    
    [HIVESocialV4 showCommunity: HVIESocialProviderTypeHIVE viewType: viewType handler: ^(HIVEResultAPI *result) {    
    if ([result isSuccess]) {    
    // เรียกใช้งานสำเร็จ    
    }    
}];

การใช้งานการบันทึกระยะไกล¶

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

• การเปิดใช้งาน
  หากคุณเปิดใช้งานการบันทึกจากระยะไกล, Hive SDK log และเกม log จะถูกเก็บรวบรวมตามระยะเวลาที่คุณตั้งไว้ใน Hive Console. Hive SDK log ขึ้นอยู่กับการตั้งค่าบน SDK และเกม log มีความยืดหยุ่นสำหรับนักพัฒนาเกมในการตั้งค่าค่า

  Warning

  ตรวจสอบให้แน่ใจว่า

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

  • หากคุณจะใช้การบันทึกระยะไกลในเกมบันทึก โปรดติดต่อ PIC ของฝ่ายสถาปนิกโซลูชัน GAMEVIL COM2US PLATFORM ล่วงหน้า

• การกำหนดเป้าหมาย
  การบันทึกข้อมูลระยะไกลจะกำหนดเป้าหมายเฉพาะผู้ใช้ที่อุปกรณ์ของพวกเขามี ID (DID) ผ่านการเริ่มต้น SDK ของ Hive อย่างน้อยหนึ่งครั้ง อย่างไรก็ตาม ฟังก์ชันนี้ไม่สามารถใช้ได้กับบางเกมหากเกิดการล้มเหลวหรือข้อผิดพลาดก่อนที่จะเริ่มต้น SDK.

• การทำงานของการบันทึกข้อมูลระยะไกล

• ตัวอย่างโค้ด
  ใส่โค้ดต่อไปนี้ในทุกส่วนที่เกมต้องการให้เก็บบันทึก

using hive;    
Logger.log("Enter logging contents");

#include "HiveLogger.h"

FHiveLogger::Log(TEXT("Enter logging contents"));

  #include <HIVE_SDK_Plugin/HIVE_CPP.h>    
    using namespace std;    
    using namespace hive;    
   Logger::log("Enter logging contents");

import com.hive.Logger;    
Logger.INSTANCE.i("Enter logging contents");

import HIVEBase    
LogInterface.log(sourceInfo: "Log source information (class, method name)", type: .Info, tag: "Log tag", msg: "Log message")

#import <HIVEBase/HIVEBase-Swift.h>

[HIVELogger logWithSourceInfo:@"ข้อมูลแหล่งที่มาของล็อก (ชื่อคลาส, ชื่อวิธีการ)" type: LogTypeInfo tag: @"แท็กล็อก" msg: @"ข้อความล็อก"];

การกำหนดค่าทางไกล¶

Hive SDK ช่วยให้เกมสามารถจัดการ URL ของเซิร์ฟเวอร์เกมที่แมพ 1 ต่อ 1 กับแต่ละเวอร์ชันของแอป Remote configuration จะถูกให้ในรูปแบบของสตริงโดยการเรียกใช้ API getMetaData() ของคลาส Configuration ตัวอย่างต่อไปนี้คือโค้ดที่เรียกใช้การตั้งค่าจากระยะไกล

using hive;    
    // data key    
    String key = "game_server_url";    
    // Whether data is updated    
    Boolean forceReload = false;    
    // metadata call    
    Configuration.getMetaData(key, forceReload, (ResultAPI result, String value) => {    
    if (result.isSuccess()) {    
    // call successful    
    }    
});

#include "HiveConfiguration.h"

// data key
FString Key = TEXT("game_server_url");

// ข้อมูลได้รับการอัปเดตหรือไม่
bool bForceReload = false;

// metadata call
FHiveConfiguration::GetMetaData(Key, bForceReload, FHiveConfigurationOnMetaDataDelegate::CreateLambda([this](const FHiveResultAPI& Result, const FString& Value) {
        if (Result.IsSuccess()) {
                // call successfull
        }
}));

#include <HIVE_SDK_Plugin/HIVE_CPP.h>    
    using namespace std;    
    using namespace hive;    
    // data key    
    string key = "game_server_url";    
    // Whether data is updated    
    bool forceReload = false;    

    // การเรียกข้อมูลเมตา    
    Configuration::getMetaData(key, forceReload, [=](ResultAPI const & result, string value) {    
         if (result.isSuccess()) {    
             // การเรียกสำเร็จ    
         }    
});

import com.hive.Configuration    
    import com.hive.ResultAPI    
    // data key    
    val key = "game_server_url"    
    // Whether data is updated    
    val forceReload = false    
    // metadata call    
    Configuration.getMetaData(key, forceReload, object : Configuration.GetMetaDataListener {    
         override fun onGetMetaData(result: ResultAPI, data: String) {    
             if (result.isSuccess) {    
                 // call successful    
             }    
         }    
})

import com.hive.Configuration;    
    import com.hive.ResultAPI;    
    // data key    
    String key = "game_server_url";    
    // Whether data is updated    
    boolean forceReload = false;    
    // metadata call    
    Configuration.INSTANCE.getMetaData(key, forceReload, (result, data) -> {    
         if (result.isSuccess()) {    
             // call successful    
         }    
});

import HIVEService    
    // data key    
    let key = "game_server_url"    
    // Whether data is updated    
    let forceReload = false;    

    // การเรียกข้อมูลเมตาดาต้า    
    ConfigurationInterface.getMetaData(key, forceReload: forceReload) { result, value in    
         if result.isSuccess() {    
             // การเรียกสำเร็จ    
         }    
}

#import <HIVEService/HIVEService-Swift.h>    
    // data key    
    NSString *key = @"game_server_url";    
    // Whether data is updated    
    BOOL forceload = NO;    
    // metadata call    
    [HIVEConfiguration getMegaData: key forceReload: forceReload handler: ^(HIVEResultAPI *result, NSString *value) {    
    if ([result isSuccess]) {    
    // call successful    
    }    
}];