scip2cip/ControlSystem.cs at main · akellai/scip2cip · 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
138
139
140
141
142
using Crestron.SimplSharp;
using Crestron.SimplSharpPro;
using Newtonsoft.Json;

namespace scip2cip
{
    public class ControlSystem : CrestronControlSystem
    {
        private ProxyClass? pc;
        private const string ConfigFilePath = "/nvram/scip2cip.cfg";

        private class Settings
        {
            public string Username { get; set; }
            public string Password { get; set; }
            public int CipPort { get; set; }
            public int HttpPort { get; set; }
            public int SerialJoinIp { get; set; }

            public Settings()
            {
                Username = "user";
                Password = "password123";
                CipPort = 41784;
                HttpPort = 8080;
                SerialJoinIp = -1;
            }
        }

        public ControlSystem() : base()
        {
            try
            {
                Crestron.SimplSharpPro.CrestronThread.Thread.MaxNumberOfUserThreads = 80;

                Settings settings = LoadSettings();

                pc = new ProxyClass(settings.Username, settings.Password, settings.CipPort, settings.HttpPort, settings.SerialJoinIp);

                CrestronEnvironment.SystemEventHandler += new SystemEventHandler(_ControllerSystemEventHandler);
                CrestronEnvironment.ProgramStatusEventHandler += new ProgramStatusEventHandler(_ControllerProgramEventHandler);
                CrestronEnvironment.EthernetEventHandler += new EthernetEventHandler(_ControllerEthernetEventHandler);
            }
            catch (Exception e)
            {
                ErrorLog.Error("Error in constructor: {0}", e.Message);
            }
        }

        private Settings LoadSettings()
        {
            Settings settings = new Settings(); // Start with default settings

            try
            {
                string json = File.ReadAllText(ConfigFilePath);
                Settings loadedSettings = JsonConvert.DeserializeObject<Settings>(json);
                if (loadedSettings != null)
                    settings = loadedSettings;
                else
                    ErrorLog.Error("Settings file empty or invalid JSON, using default settings.");
            }
            catch (Exception e)
            {
                ErrorLog.Error("Error reading settings file: {0}", e.Message);
                try
                {
                    string json = JsonConvert.SerializeObject(settings, Formatting.Indented);
                    File.WriteAllText(ConfigFilePath, json);
                }
                catch (Exception e2)
                {
                    ErrorLog.Error("Error writing default settings file: {0}", e2.Message);
                }
            }
            return settings;
        }

        public override void InitializeSystem()
        {
            try
            {
                pc?.StartProxy();
            }
            catch (Exception e)
            {
                ErrorLog.Error("Error in InitializeSystem: {0}", e.Message);
            }
        }

        void _ControllerProgramEventHandler(eProgramStatusEventType programStatusEventType)
        {
            switch (programStatusEventType)
            {
                case eProgramStatusEventType.Paused:
                    // Pause any operations if needed
                    break;
                case eProgramStatusEventType.Resumed:
                    // Resume operations if needed
                    break;
                case eProgramStatusEventType.Stopping:
                    pc?.StopProxy();
                    break;
            }
        }

        void _ControllerSystemEventHandler(eSystemEventType systemEventType)
        {
            switch (systemEventType)
            {
                case eSystemEventType.DiskInserted:
                    // Handle disk inserted event
                    break;
                case eSystemEventType.DiskRemoved:
                    // Handle disk removed event
                    break;
                case eSystemEventType.Rebooting:
                    // Handle reboot event
                    break;
            }
        }

        void _ControllerEthernetEventHandler(EthernetEventArgs ethernetEventArgs)
        {
            switch (ethernetEventArgs.EthernetEventType)
            {
                case eEthernetEventType.LinkDown:
                    if (ethernetEventArgs.EthernetAdapter == EthernetAdapterType.EthernetLANAdapter)
                    {
                        // Handle LAN link down
                    }
                    break;
                case eEthernetEventType.LinkUp:
                    if (ethernetEventArgs.EthernetAdapter == EthernetAdapterType.EthernetLANAdapter)
                    {
                        // Handle LAN link up
                    }
                    break;
            }
        }
    }
}