aboutsummaryrefslogtreecommitdiff
path: root/Ryujinx.HLE/HOS/Services/Ns/IApplicationManagerInterface.cs
blob: d09403f9d06a36051bd815529b11995fabad20aa (plain) (blame)
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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
using LibHac;
using System;
using System.Text;

namespace Ryujinx.HLE.HOS.Services.Ns
{
    [Service("ns:am")]
    class IApplicationManagerInterface : IpcService
    {
        public IApplicationManagerInterface(ServiceCtx context) { }

        [Command(400)]
        // GetApplicationControlData(unknown<0x10>) -> (unknown<4>, buffer<unknown, 6>)
        public ResultCode GetApplicationControlData(ServiceCtx context)
        {
            long position = context.Request.ReceiveBuff[0].Position;

            Nacp nacp = context.Device.System.ControlData;

            for (int i = 0; i < 0x10; i++)
            {
                NacpDescription description = nacp.Descriptions[i];

                byte[] titleData     = new byte[0x200];
                byte[] developerData = new byte[0x100];

                if (description !=null && description.Title != null)
                {
                    byte[] titleDescriptionData = Encoding.ASCII.GetBytes(description.Title);
                    Buffer.BlockCopy(titleDescriptionData, 0, titleData, 0, titleDescriptionData.Length);

                }

                if (description != null && description.Developer != null)
                {
                    byte[] developerDescriptionData = Encoding.ASCII.GetBytes(description.Developer);
                    Buffer.BlockCopy(developerDescriptionData, 0, developerData, 0, developerDescriptionData.Length);
                }

                context.Memory.WriteBytes(position, titleData);
                context.Memory.WriteBytes(position + 0x200, developerData);

                position += i * 0x300;
            }

            byte[] isbn = new byte[0x25];

            if (nacp.Isbn != null)
            {
                byte[] isbnData = Encoding.ASCII.GetBytes(nacp.Isbn);
                Buffer.BlockCopy(isbnData, 0, isbn, 0, isbnData.Length);
            }

            context.Memory.WriteBytes(position, isbn);
            position += isbn.Length;

            context.Memory.WriteByte(position++, nacp.StartupUserAccount);
            context.Memory.WriteByte(position++, nacp.UserAccountSwitchLock);
            context.Memory.WriteByte(position++, nacp.AocRegistrationType);

            context.Memory.WriteInt32(position, nacp.AttributeFlag);
            position += 4;

            context.Memory.WriteUInt32(position, nacp.SupportedLanguageFlag);
            position += 4;

            context.Memory.WriteUInt32(position, nacp.ParentalControlFlag);
            position += 4;

            context.Memory.WriteByte(position++, nacp.Screenshot);
            context.Memory.WriteByte(position++, nacp.VideoCapture);
            context.Memory.WriteByte(position++, nacp.DataLossConfirmation);
            context.Memory.WriteByte(position++, nacp.PlayLogPolicy);

            context.Memory.WriteUInt64(position, nacp.PresenceGroupId);
            position += 8;

            for (int i = 0; i < nacp.RatingAge.Length; i++)
            {
                context.Memory.WriteSByte(position++, nacp.RatingAge[i]);
            }

            byte[] displayVersion = new byte[0x10];

            if (nacp.DisplayVersion != null)
            {
                byte[] displayVersionData = Encoding.ASCII.GetBytes(nacp.DisplayVersion);
                Buffer.BlockCopy(displayVersionData, 0, displayVersion, 0, displayVersionData.Length);
            }

            context.Memory.WriteBytes(position, displayVersion);
            position += displayVersion.Length;

            context.Memory.WriteUInt64(position, nacp.AddOnContentBaseId);
            position += 8;

            context.Memory.WriteUInt64(position, nacp.SaveDataOwnerId);
            position += 8;

            context.Memory.WriteInt64(position, nacp.UserAccountSaveDataSize);
            position += 8;

            context.Memory.WriteInt64(position, nacp.UserAccountSaveDataJournalSize);
            position += 8;

            context.Memory.WriteInt64(position, nacp.DeviceSaveDataSize);
            position += 8;

            context.Memory.WriteInt64(position, nacp.DeviceSaveDataJournalSize);
            position += 8;

            context.Memory.WriteInt64(position, nacp.BcatDeliveryCacheStorageSize);
            position += 8;

            byte[] applicationErrorCodeCategory = new byte[0x8];

            if (nacp.ApplicationErrorCodeCategory != null)
            {
                byte[] applicationErrorCodeCategoryData = Encoding.ASCII.GetBytes(nacp.ApplicationErrorCodeCategory);
                Buffer.BlockCopy(applicationErrorCodeCategoryData, 0, applicationErrorCodeCategoryData, 0, applicationErrorCodeCategoryData.Length);
            }

            context.Memory.WriteBytes(position, applicationErrorCodeCategory);
            position += applicationErrorCodeCategory.Length;

            for (int i = 0; i < nacp.LocalCommunicationId.Length; i++)
            {
                context.Memory.WriteUInt64(position, nacp.LocalCommunicationId[i]);
                position += 8;
            }

            context.Memory.WriteByte(position++, nacp.LogoType);
            context.Memory.WriteByte(position++, nacp.LogoHandling);
            context.Memory.WriteByte(position++, nacp.RuntimeAddOnContentInstall);

            byte[] reserved000 = new byte[0x3];
            context.Memory.WriteBytes(position, reserved000);
            position += reserved000.Length;

            context.Memory.WriteByte(position++, nacp.CrashReport);
            context.Memory.WriteByte(position++, nacp.Hdcp);
            context.Memory.WriteUInt64(position, nacp.SeedForPseudoDeviceId);
            position += 8;

            byte[] bcatPassphrase = new byte[65];
            if (nacp.BcatPassphrase != null)
            {
                byte[] bcatPassphraseData = Encoding.ASCII.GetBytes(nacp.BcatPassphrase);
                Buffer.BlockCopy(bcatPassphraseData, 0, bcatPassphrase, 0, bcatPassphraseData.Length);
            }

            context.Memory.WriteBytes(position, bcatPassphrase);
            position += bcatPassphrase.Length;

            context.Memory.WriteByte(position++, nacp.Reserved01);

            byte[] reserved02 = new byte[0x6];
            context.Memory.WriteBytes(position, reserved02);
            position += reserved02.Length;

            context.Memory.WriteInt64(position, nacp.UserAccountSaveDataSizeMax);
            position += 8;

            context.Memory.WriteInt64(position, nacp.UserAccountSaveDataJournalSizeMax);
            position += 8;

            context.Memory.WriteInt64(position, nacp.DeviceSaveDataSizeMax);
            position += 8;

            context.Memory.WriteInt64(position, nacp.DeviceSaveDataJournalSizeMax);
            position += 8;

            context.Memory.WriteInt64(position, nacp.TemporaryStorageSize);
            position += 8;

            context.Memory.WriteInt64(position, nacp.CacheStorageSize);
            position += 8;

            context.Memory.WriteInt64(position, nacp.CacheStorageJournalSize);
            position += 8;

            context.Memory.WriteInt64(position, nacp.CacheStorageDataAndJournalSizeMax);
            position += 8;

            context.Memory.WriteInt16(position, nacp.CacheStorageIndex);
            position += 2;

            byte[] reserved03 = new byte[0x6];
            context.Memory.WriteBytes(position, reserved03);
            position += reserved03.Length;

            for (int i = 0; i < 16; i++)
            {
                ulong value = 0;

                if (nacp.PlayLogQueryableApplicationId.Count > i)
                {
                    value = nacp.PlayLogQueryableApplicationId[i];
                }

                context.Memory.WriteUInt64(position, value);
                position += 8;
            }

            context.Memory.WriteByte(position++, nacp.PlayLogQueryCapability);
            context.Memory.WriteByte(position++, nacp.RepairFlag);
            context.Memory.WriteByte(position++, nacp.ProgramIndex);

            return ResultCode.Success;
        }
    }
}