UnityCsReference/Modules/UnityEditorAnalyticsEditor/BuildEventsHandler.cs at 2018.2 · Mathbee/UnityCsReference · 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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
// Unity C# reference source
// Copyright (c) Unity Technologies. For terms of use, see
// https://unity3d.com/legal/licenses/Unity_Reference_Only_License

using System;
using System.Collections.Generic;
using System.IO;
using System.Xml;
using System.Linq;
using UnityEngine;
using Object = UnityEngine.Object;
using UnityEditor.Build;
using UnityEditor.Build.Reporting;
using UnityEditor.Utils;
using UnityEditor.PackageManager;

namespace UnityEditor
{
    internal class BuildEventsHandlerPostProcess : IPostprocessBuildWithReport
    {
        [Serializable]
        internal struct SceneViewInfo
        {
            public int total_scene_views;
            public int num_of_2d_views;
            public bool is_default_2d_mode;
        }

        [Serializable]
        internal struct BuildPackageIds
        {
            public string[] package_ids;
        }

        [Serializable]
        internal struct AndroidBuildPermissions
        {
            public string[] features;
            public string[] permissions;
        }

        private static bool s_EventSent = false;
        private static int s_NumOfSceneViews = 0;
        private static int s_NumOf2dSceneViews = 0;
        private const string s_GradlePath = "Temp/gradleOut/build/intermediates/manifests/full";
        private const string s_StagingArea = "Temp/StagingArea";
        private const string s_AndroidManifest = "AndroidManifest.xml";

        public int callbackOrder {get { return 0; }}
        public void OnPostprocessBuild(BuildReport report)
        {
            ReportSceneViewInfo();
            ReportBuildPackageIds(report.files);
            if (EditorUserBuildSettings.activeBuildTarget == BuildTarget.Android)
            {
                ReportBuildTargetPermissions();
            }
        }

        private void ReportBuildPackageIds(BuildFile[] buildFiles)
        {
            List<string> managedLibraries = new List<string>();
            foreach (BuildFile file in buildFiles)
            {
                if (file.role == "ManagedLibrary")
                    managedLibraries.Add(file.path);
            }

            var matchingPackages = Packages.GetForAssemblyFilePaths(managedLibraries);
            var packageIds = matchingPackages.Select(item => item.packageId).ToArray();
            if (packageIds.Length > 0)
                EditorAnalytics.SendEventBuildPackageList(new BuildPackageIds() { package_ids = packageIds });
        }

        private void ReportSceneViewInfo()
        {
            Object[] views = Resources.FindObjectsOfTypeAll(typeof(SceneView));
            int numOf2dSceneViews = 0;
            foreach (SceneView view in views)
            {
                if (view.in2DMode)
                    numOf2dSceneViews++;
            }
            if ((s_NumOfSceneViews != views.Length) || (s_NumOf2dSceneViews != numOf2dSceneViews) || !s_EventSent)
            {
                s_EventSent = true;
                s_NumOfSceneViews = views.Length;
                s_NumOf2dSceneViews = numOf2dSceneViews;
                EditorAnalytics.SendEventSceneViewInfo(new SceneViewInfo()
                {
                    total_scene_views = s_NumOfSceneViews, num_of_2d_views = s_NumOf2dSceneViews,
                    is_default_2d_mode = EditorSettings.defaultBehaviorMode == EditorBehaviorMode.Mode2D
                });
            }
        }

        private void ReportBuildTargetPermissions()
        {
            List<string> permissionsList = new List<string>();
            List<string> featuresList = new List<string>();
            string manifestFilePath = Path.Combine(s_StagingArea, s_AndroidManifest);
            if (EditorUserBuildSettings.androidBuildSystem == AndroidBuildSystem.Gradle)
            {
                manifestFilePath = (EditorUserBuildSettings.androidBuildType == AndroidBuildType.Release)
                    ? Paths.Combine(s_GradlePath, "release", s_AndroidManifest)
                    : Paths.Combine(s_GradlePath, "debug", s_AndroidManifest);
            }

            XmlDocument manifestFile = new XmlDocument();
            if (File.Exists(manifestFilePath))
            {
                manifestFile.Load(manifestFilePath);
                XmlNodeList permissions = manifestFile.GetElementsByTagName("uses-permission");
                XmlNodeList features = manifestFile.GetElementsByTagName("uses-feature");
                foreach (XmlNode permission in permissions)
                {
                    XmlNode attribute = permission.Attributes ? ["android:name"];
                    if (attribute != null)
                        permissionsList.Add(attribute.Value);
                }

                foreach (XmlNode feature in features)
                {
                    XmlNode attribute = feature.Attributes ? ["android:name"];
                    if (attribute != null)
                        featuresList.Add(attribute.Value);
                }

                EditorAnalytics.SendEventBuildTargetPermissions(new AndroidBuildPermissions()
                {
                    features = featuresList.ToArray(),
                    permissions = permissionsList.ToArray()
                });
            }
        }
    }
} // namespace