unigame.analytics/GameAnalyticsService.cs at main · UnioGame/unigame.analytics · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
namespace UniGame.Runtime.Analytics
{
    using System;
    using System.Collections.Generic;
    using Cysharp.Threading.Tasks;
    using Interfaces;
    using R3;
    using UniGame.GameFlow.Runtime;
    using UnityEngine;

    [Serializable]
    public class GameAnalyticsService : GameService, IAnalyticsService
    {
        private List<IAnalyticsAdapter> _adapters = new();
        private List<IAnalyticsMessageHandler> _handlers = new();

        public GameAnalyticsService()
        {
            LifeTime.AddCleanUpAction(CleanUp);
        }

        public void TrackEvent(IAnalyticsMessage message)
        {
            if(LifeTime.IsTerminated) return;
            TrackEventAsync(message).Forget();
        }

        public IDisposable RegisterMessageHandler(IAnalyticsMessageHandler handler)
        {
            if (LifeTime.IsTerminated)
                return Disposable.Empty;

            if (_handlers.Contains(handler))
                return Disposable.Empty;

            _handlers.Add(handler);

            return Disposable.Create(() =>
            {
                if (_handlers.Contains(handler))
                    _handlers.Remove(handler);
            });
        }

        public void UpdateHandlers(IEnumerable<IAnalyticsMessageHandler> messageHandlers)
        {
            foreach (var messageHandler in messageHandlers)
            {
                RegisterMessageHandler(messageHandler);
            }
        }

        public IDisposable RegisterAdapter(IAnalyticsAdapter adapter)
        {
            if(LifeTime.IsTerminated)
                return Disposable.Empty;

            if (_adapters.Contains(adapter))
                return Disposable.Empty;

            _adapters.Add(adapter);

            return Disposable.Create(() =>
            {
                if (_adapters.Contains(adapter))
                    _adapters.Remove(adapter);
            });
        }

        private async UniTask TrackEventAsync(IAnalyticsMessage message)
        {
            var data = message;
            for (var i = 0; i < _handlers.Count; i++)
            {
                try
                {
                    data = await _handlers[i].UpdateMessageAsync(data);
                }
                catch (Exception exception)
                {
                    Debug.LogException(exception);
                }
            }

            PublishToAdapters(data);
        }

        private void InitializeMessageChannel(IAnalyticsMessageChannel channel)
        {
            channel.ToObservable()
                .Subscribe(PublishToAdapters)
                .AddTo(LifeTime);
        }

        private void PublishToAdapters(IAnalyticsMessage message)
        {
            for (var i = 0; i < _adapters.Count; i++)
            {
                try
                {
                    _adapters[i].TrackEvent(message);
                }
                catch (Exception e)
                {
                    Debug.LogException(e);
                }
            }
        }

        private void CleanUp()
        {
            _adapters.Clear();
            _handlers.Clear();
        }

    }
}