Analytics

"com.idlekit.analytics": "ssh://git[com](github/com)/Idlekit/idlekit-analytics.git#[release-branch]"

using System;
using System.Collections.Generic;
using IdleKit.Analytics;
using IdleKit.Gameplay;
using IdleKit.Core;
using UnityEngine;

namespace [Project.Namespace]
{
    [Serializable]
    public class [ProjectName]AnalyticsUserData : KraangUserDataBase
    {
        private IResolver _resolver;
        private IUserSavedData _userSavedData;
        private IEntityLoaderService _entityLoaderService;

        public override void Inject(IResolver resolver)
        {
            _resolver = resolver;
            _userSavedData = resolver.Resolve<IUserSavedData>();
            _entityLoaderSesrvice = resolver.Resolve<IEntityLoaderService>();
        }

        // Overriding this method allows you to inject user and game specific data into Analytics events.
        public override Dictionary<string, object> GetUserData()
        {
            // Some events happen before IdleKit has been initialized.
            int level = 1;
            if (_resolver.CanResolve<IContentData>())
            {
                IContent content = _entityLoaderService.LoadEntity<IContent, IContentData>(_userSavedData.ContentId);
                level = Array.IndexOf(content.ContentData.StageIds, content.ContentSavedData.CurrentStageId) + 1;
            }

            _id = SystemInfo.deviceUniqueIdentifier; // Required. 
            _level = level; // Required.
            _levelVersion = "1"; // Optionally used to track multiple playthroughs.
            _assetVersion = ""; // Optionally used to track the version of the assets the player has downloaded.

            return base.GetUserData();
        }
    }
}

public void Install(IContainer container)
{
    container.Bind<IAnalyticsUserData>().To<[ProjectName]AnalyticsUserData>().AsTransient().Conclude();
}

public void Uninstall(IContainer container)
{
    container.Unbind<IAnalyticsUserData>();
}

// The EnvironmentProvider lets you define which development environment the code is running in. DEV, STAGE oor PROD.
// These are totally customizable and you can freely adjust them. You can also provide them to the load flow as you see fit.
// This example is just using a simple serialized reference.
[SerializeField]
protected EnvironmentProvider _environmentProvider;

protected override void SetInitializationLoadPhases()
{
    Loader.OnForegroundLoadCompleted += HandlePreloadCompleted;
    Loader.Enqueue(
        SequenceFlow.InSequence,

        // Initialize Addressables. Analytics Configuration is stored in Addressables by default.
        Context.Container.Resolve<InitializeAddressablesPhase>(),

        // Preload required assets.
        Context.Container.Resolve<InitializeServicesPhase>().Initialize(typeof(IAssetService)),
        Context.Container.Resolve<LoadAssetsPhase>().Initialize(CoreConstants.PRELOAD_ASSET_LABEL),

        // Bind and load the EnvironmentConfig. This is used in the Analytics configuration to allow for development and production environments.
        Context.Container.Resolve<BindDataPhase>().Initialize(typeof(IEnvironmentConfig), _environmentProvider),
        Context.Container.Resolve<LoadDataPhase>().Initialize(CoreConstants.CONFIG_ASSET_LABEL),

        // Other Load Phases...

        Context.Container.Resolve<InitializeServicesPhase>().Initialize(

            // Other Services...

            // Analytics Service
            typeof(IAnalyticsService),

            // Analytics Tracking Services. These provide out of the box tracking for common IdleKit events.
            typeof(UserAcquisitionAnalyticsTrackingService),
            typeof(CurrencyChangeAnalyticsTrackingService),
            typeof(ContentProgressionAnalyticsTrackingService)
        ),

        // Other Load Phases...

    );
}

// Get a reference to the IAnalyticsService
protected IAnalyticsService _analyticsService;

public override void Inject(IResolver resolver)
{
    base.Inject(resolver);

    _analyticsService = resolver.Resolve<IAnalyticsService>();
}

// Send the Event.
_analyticsService.LogEvent<TEvent>(analyticsEvent => {
    // Pass in any relevant values here. The will vary based on the type of Event you are sending.
    analyticsEvent.Initialize();
});

using System;
using System.Collections.Generic;
using UnityEngine;

namespace Your.Game
{
    /// <summmary>
    /// Tracks when a player sends a gift and to whom.
    /// </summary>
    [Serializable]
    public class GiftSentEvent : AnalyticsEventBase
    {
        // The EventName property must be overriden to indicate the type of event when sent
        // to the backend.
        public override string EventName = "giftSent";

        // You may optionally override the IncludeDeviceId property to include the device ID
        // within the event payload. This defaults to false.
        protected override bool IncludeDeviceId => true;

        // Any fields need to be serializable so they can be saved to disk.
        [SerializeField]
        protected string _senderId;
        [SerializeField]
        protected string _receiverId;
        [SerializeField]
        protected string[] _itemIds;

        // When you log an event you get to call Initialize with whatever data is necessary.
        public virtual void Initialize(string senderId, string receiverId, string[] itemIds)
        {
            _senderId = senderId;
            _receiverId = receiverId;
            _itemIds = itemIds;
        }

        // Implement the EventContent method to provide a dictionary of values to be placed in
        // the event payload. Most of the time you will simply need to return a dictionary
        // without any other processing.
        protected override Dictionary<string, object> EventContent()
        {
            return new Dictionary<string, object>()
            {
                {"senderId", _senderId},
                {"receiverId", _receiverId},
                {"itemIds", _itemIds},
            };
        }
    }
}