Leahnaya/wut
1
0
Fork 0
mirror of https://github.com/devkitPro/wut.git synced 2026-04-22 09:17:36 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

Implement more functions/classes from nn::sl (#354)

Browse Source
This commit is contained in:
Maschell 2024-04-22 20:06:02 +02:00 committed by GitHub
parent c1457779be
commit f01a0b87ac
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
76 changed files with 5248 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Makefile
View File

@ -29,6 +29,7 @@ SOURCES := cafe \
libraries/libgfd/src \
libraries/libirc/src \
libraries/nn_erreula \
libraries/nn_sl \
libraries/nn_swkbd
DATA := data
INCLUDES := include \

30
include/nn/sl.h
View File

@ -4,6 +4,32 @@
* \defgroup nn_sl nn_sl
*/
#include <nn/sl/sl_cpp.h>
#include <nn/sl/LaunchInfoDatabase.h>
#include <nn/sl/CacheManager.h>
#include <nn/sl/Condition.h>
#include <nn/sl/DataCreator.h>
#include <nn/sl/DrcManager.h>
#include <nn/sl/FileStream.h>
#include <nn/sl/IAccountInfoAccessor.h>
#include <nn/sl/IBlackListAccessor.h>
#include <nn/sl/IDefaultTitleAccessor.h>
#include <nn/sl/IKillerNotificationAccessor.h>
#include <nn/sl/ILaunchedTitleListAccessor.h>
#include <nn/sl/IPreferentialTitleAccessor.h>
#include <nn/sl/ISerializer.h>
#include <nn/sl/ISettingAccessor.h>
#include <nn/sl/IStream.h>
#include <nn/sl/ITimeAccessor.h>
#include <nn/sl/ITitleIconCache.h>
#include <nn/sl/ITitleListAccessor.h>
#include <nn/sl/ITransferrer.h>
#include <nn/sl/IUpdatePackageAccessor.h>
#include <nn/sl/IWhiteListAccessor.h>
#include <nn/sl/KillerNotification.h>
#include <nn/sl/KillerNotificationSelector.h>
#include <nn/sl/KillerNotificationTransferRecordManager.h>
#include <nn/sl/KillerNotificationTransferRecordStream.h>
#include <nn/sl/LaunchInfoDatabase.h>
#include <nn/sl/QuickStartApplicationSelector.h>
#include <nn/sl/TitleIconCache.h>
#include <nn/sl/TitleListCache.h>
#include <nn/sl/sl_cpp.h>

95
include/nn/sl/CacheManager.h Normal file
View File

@ -0,0 +1,95 @@
#pragma once
#include <nn/result.h>
#include <nn/sl/ISerializer.h>
#include <nn/sl/KillerNotification.h>
#include <nn/sl/sl_cpp.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
namespace details {
typedef struct WUT_PACKED CacheManagerInternal {
ISerializerInternal *quickStartTitleInfoSerializer;
ISerializerInternal *killerNotificationSerializer;
ISerializerInternal *jumpTitleInfoSerializer;
} CacheManagerInternal;
WUT_CHECK_SIZE(CacheManagerInternal, 0x0c);
WUT_CHECK_OFFSET(CacheManagerInternal, 0x00, quickStartTitleInfoSerializer);
WUT_CHECK_OFFSET(CacheManagerInternal, 0x04, killerNotificationSerializer);
WUT_CHECK_OFFSET(CacheManagerInternal, 0x08, jumpTitleInfoSerializer);
extern "C" CacheManagerInternal *__ct__Q3_2nn2sl12CacheManagerFv(CacheManagerInternal *);
extern "C" void SetupInitialCache__Q3_2nn2sl12CacheManagerFv(CacheManagerInternal *);
extern "C" nn::Result GetKillerNotificationCache__Q3_2nn2sl12CacheManagerFPQ3_2nn2sl18KillerNotificationPQ3_2nn2sl9TitleInfo(CacheManagerInternal *, KillerNotification *, TitleInfo *);
extern "C" nn::Result GetQuickStartCache__Q3_2nn2sl12CacheManagerFPQ3_2nn2sl9TitleInfoi(CacheManagerInternal *, TitleInfo *, int);
extern "C" nn::Result Get__Q3_2nn2sl12CacheManagerFPQ3_2nn2sl9TitleInfoiPQ3_2nn2sl18KillerNotificationT1(CacheManagerInternal *, TitleInfo *, int, KillerNotification *, TitleInfo *);
extern "C" nn::Result Initialize__Q3_2nn2sl12CacheManagerFRQ3_2nn2sl39ISerializer__tm__20_Q3_2nn2sl9TitleInfoRQ3_2nn2sl49ISerializer__tm__30_Q3_2nn2sl18KillerNotificationT1(
CacheManagerInternal *,
ISerializerInternal *,
ISerializerInternal *,
ISerializerInternal *);
} // namespace details
class CacheManager {
public:
CacheManager() : mQuickStartTitleInfoSerializer(nullptr),
mKillerNotificationSerializer(nullptr),
mJumpTitleInfoSerializer(nullptr) {
if (__ct__Q3_2nn2sl12CacheManagerFv(&mInstance) != nullptr) {
mQuickStartTitleInfoSerializer = details::SerializerFromPtr<TitleInfo>(mInstance.quickStartTitleInfoSerializer);
mKillerNotificationSerializer = details::SerializerFromPtr<KillerNotification>(mInstance.killerNotificationSerializer);
mJumpTitleInfoSerializer = details::SerializerFromPtr<TitleInfo>(mInstance.jumpTitleInfoSerializer);
}
}
[[nodiscard]] details::ISerializerBase<TitleInfo> &GetQuickStartTitleInfoSerializer() {
return mQuickStartTitleInfoSerializer;
}
[[nodiscard]] details::ISerializerBase<KillerNotification> &GetKillerNotificationSerializer() {
return mKillerNotificationSerializer;
}
[[nodiscard]] details::ISerializerBase<TitleInfo> &GetJumpTitleInfoSerializer() {
return mJumpTitleInfoSerializer;
}
void SetupInitialCache() {
SetupInitialCache__Q3_2nn2sl12CacheManagerFv(&mInstance);
}
nn::Result GetKillerNotificationCache(KillerNotification *u1, TitleInfo *u2) {
return GetKillerNotificationCache__Q3_2nn2sl12CacheManagerFPQ3_2nn2sl18KillerNotificationPQ3_2nn2sl9TitleInfo(&mInstance, u1, u2);
}
nn::Result GetQuickStartCache(TitleInfo *u1, int u2) {
return GetQuickStartCache__Q3_2nn2sl12CacheManagerFPQ3_2nn2sl9TitleInfoi(&mInstance, u1, u2);
}
nn::Result Get(TitleInfo *u1, int u2, KillerNotification *u3, TitleInfo *u4) {
return Get__Q3_2nn2sl12CacheManagerFPQ3_2nn2sl9TitleInfoiPQ3_2nn2sl18KillerNotificationT1(&mInstance, u1, u2, u3, u4);
}
void Initialize(details::ISerializerBase<TitleInfo> &quickStartTitleInfoSerializer, details::ISerializerBase<KillerNotification> &killerNotificationSerializer, details::ISerializerBase<TitleInfo> &jumpTitleInfoSerializer) {
Initialize__Q3_2nn2sl12CacheManagerFRQ3_2nn2sl39ISerializer__tm__20_Q3_2nn2sl9TitleInfoRQ3_2nn2sl49ISerializer__tm__30_Q3_2nn2sl18KillerNotificationT1(&mInstance,
quickStartTitleInfoSerializer.GetInternal(),
killerNotificationSerializer.GetInternal(),
jumpTitleInfoSerializer.GetInternal());
mQuickStartTitleInfoSerializer = details::SerializerFromPtr<TitleInfo>(quickStartTitleInfoSerializer.GetInternal());
mKillerNotificationSerializer = details::SerializerFromPtr<KillerNotification>(killerNotificationSerializer.GetInternal());
mJumpTitleInfoSerializer = details::SerializerFromPtr<TitleInfo>(jumpTitleInfoSerializer.GetInternal());
}
~CacheManager() = default;
private:
details::CacheManagerInternal mInstance{};
details::SerializerFromPtr<TitleInfo> mQuickStartTitleInfoSerializer;
details::SerializerFromPtr<KillerNotification> mKillerNotificationSerializer;
details::SerializerFromPtr<TitleInfo> mJumpTitleInfoSerializer;
};
} // namespace nn::sl
#endif

115
include/nn/sl/Condition.h Normal file
View File

@ -0,0 +1,115 @@
#pragma once
#include <coreinit/time.h>
#include <nn/result.h>
#include <nn/sl/ISettingAccessor.h>
#include <nn/sl/ITimeAccessor.h>
#include <nn/sl/IUpdatePackageAccessor.h>
#include <nn/sl/details/ISerializerDetails.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
namespace details {
typedef struct WUT_PACKED ConditionInternal {
ISettingAccessorInternal *settingAccessor;
IUpdatePackageAccessorInternal *updatePackageAccessor;
ISerializerInternal *previousSendingTimeSerializer;
ITimeAccessorInternal *timeAccessor;
void *vtable;
} ConditionInternal;
WUT_CHECK_SIZE(ConditionInternal, 0x14);
WUT_CHECK_OFFSET(ConditionInternal, 0x00, settingAccessor);
WUT_CHECK_OFFSET(ConditionInternal, 0x04, updatePackageAccessor);
WUT_CHECK_OFFSET(ConditionInternal, 0x08, previousSendingTimeSerializer);
WUT_CHECK_OFFSET(ConditionInternal, 0x0C, timeAccessor);
WUT_CHECK_OFFSET(ConditionInternal, 0x10, vtable);
extern "C" ConditionInternal *__ct__Q3_2nn2sl9ConditionFv(ConditionInternal *);
extern "C" nn::Result GetEnability__Q3_2nn2sl9ConditionCFv(ConditionInternal *);
extern "C" nn::Result StoreCurrentTimeAsPreviousSendingTime__Q3_2nn2sl9ConditionCFv(ConditionInternal *);
extern "C" nn::Result NeedsUpdate__Q3_2nn2sl9ConditionCFv(ConditionInternal *);
extern "C" nn::Result GetPreviousSendingTime__Q3_2nn2sl9ConditionCFPL(ConditionInternal *, int64_t *outTime);
extern "C" void Initialize__Q3_2nn2sl9ConditionFRQ3_2nn2sl16ISettingAccessorRQ3_2nn2sl22IUpdatePackageAccessorRQ3_2nn2sl20ISerializer__tm__2_LRQ3_2nn2sl13ITimeAccessor(ConditionInternal *,
ISettingAccessorInternal *,
IUpdatePackageAccessorInternal *,
ISerializerInternal *,
ITimeAccessorInternal *);
} // namespace details
class Condition {
public:
Condition() : mSettingAccessor(nullptr),
mUpdatePackageAccessor(nullptr),
mPreviousSendingTimeSerializer(nullptr),
mTimeAccessor(nullptr) {
if (__ct__Q3_2nn2sl9ConditionFv(&mInstance) != nullptr) {
mSettingAccessor = details::SettingAccessorFromPtr(mInstance.settingAccessor);
mUpdatePackageAccessor = details::UpdatePackageAccessorFromPtr(mInstance.updatePackageAccessor);
mPreviousSendingTimeSerializer = details::SerializerFromPtr<OSTime>(mInstance.previousSendingTimeSerializer);
mTimeAccessor = details::TimeAccessorFromPtr(mInstance.timeAccessor);
}
}
~Condition() = default;
[[nodiscard]] details::ISettingAccessorBase &GetSettingAccessor() {
return mSettingAccessor;
}
[[nodiscard]] details::IUpdatePackageAccessorBase &GetUpdatePackageAccessor() {
return mUpdatePackageAccessor;
}
[[nodiscard]] details::ISerializerBase<OSTime> &GetPreviousSendingTimeSerializer() {
return mPreviousSendingTimeSerializer;
}
[[nodiscard]] details::ITimeAccessorBase &GetTimeAccessor() {
return mTimeAccessor;
}
nn::Result GetEnability() {
return GetEnability__Q3_2nn2sl9ConditionCFv(&mInstance);
}
nn::Result NeedsUpdate() {
return NeedsUpdate__Q3_2nn2sl9ConditionCFv(&mInstance);
}
nn::Result StoreCurrentTimeAsPreviousSendingTime() {
return StoreCurrentTimeAsPreviousSendingTime__Q3_2nn2sl9ConditionCFv(&mInstance);
}
nn::Result GetPreviousSendingTime(int64_t *outTime) {
return GetPreviousSendingTime__Q3_2nn2sl9ConditionCFPL(&mInstance, outTime);
}
void Initialize(details::ISettingAccessorBase &settingAccessor,
details::IUpdatePackageAccessorBase &updatePackageAccessor,
details::ISerializerBase<OSTime> &previousSendingTimeSerializer,
details::ITimeAccessorBase &timeAccessor) {
Initialize__Q3_2nn2sl9ConditionFRQ3_2nn2sl16ISettingAccessorRQ3_2nn2sl22IUpdatePackageAccessorRQ3_2nn2sl20ISerializer__tm__2_LRQ3_2nn2sl13ITimeAccessor(
&mInstance,
settingAccessor.GetInternal(),
updatePackageAccessor.GetInternal(),
previousSendingTimeSerializer.GetInternal(),
timeAccessor.GetInternal());
mSettingAccessor = details::SettingAccessorFromPtr(settingAccessor.GetInternal());
mUpdatePackageAccessor = details::UpdatePackageAccessorFromPtr(updatePackageAccessor.GetInternal());
mPreviousSendingTimeSerializer = details::SerializerFromPtr<OSTime>(previousSendingTimeSerializer.GetInternal());
mTimeAccessor = details::TimeAccessorFromPtr(timeAccessor.GetInternal());
}
private:
details::ConditionInternal mInstance = {};
details::SettingAccessorFromPtr mSettingAccessor;
details::UpdatePackageAccessorFromPtr mUpdatePackageAccessor;
details::SerializerFromPtr<OSTime> mPreviousSendingTimeSerializer;
details::TimeAccessorFromPtr mTimeAccessor;
};
} // namespace nn::sl
#endif

99
include/nn/sl/DataCreator.h Normal file
View File

@ -0,0 +1,99 @@
#pragma once
#include <nn/result.h>
#include <nn/sl/IIconInfoAccessor.h>
#include <nn/sl/ISettingAccessor.h>
#include <nn/sl/ITitleIconCache.h>
#include <nn/sl/KillerNotification.h>
#include <nn/sl/LaunchInfoDatabase.h>
#include <nn/sl/details/IAccountInfoAccessorDetails.h>
#include <nn/sl/sl_cpp.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn ::sl {
namespace details {
typedef struct WUT_PACKED DataCreatorInternal {
IIconInfoAccessorInternal *iconInfoAccessor;
IAccountInfoAccessorInternal *accountInfoAccessor;
ISettingAccessorInternal *settingInfoAccessor;
ITitleIconCacheInternal *titleIconCache;
void *vtable;
} DataCreatorInternal;
WUT_CHECK_SIZE(DataCreatorInternal, 0x14);
WUT_CHECK_OFFSET(DataCreatorInternal, 0x00, iconInfoAccessor);
WUT_CHECK_OFFSET(DataCreatorInternal, 0x04, accountInfoAccessor);
WUT_CHECK_OFFSET(DataCreatorInternal, 0x08, settingInfoAccessor);
WUT_CHECK_OFFSET(DataCreatorInternal, 0x0c, titleIconCache);
WUT_CHECK_OFFSET(DataCreatorInternal, 0x10, vtable);
extern "C" DataCreatorInternal *__ct__Q3_2nn2sl11DataCreatorFv(DataCreatorInternal *);
extern "C" nn::Result Create__Q3_2nn2sl11DataCreatorFPQ3_2nn2sl16TransferableInfoPCQ3_2nn2sl9TitleInfoiRCQ3_2nn2sl18KillerNotificationRCQ3_2nn2sl9TitleInfoRQ3_2nn2sl18LaunchInfoDatabase(
DataCreatorInternal *, TransferableInfo *, const TitleInfo *, int, const KillerNotification &, const TitleInfo &, LaunchInfoDatabase &);
extern "C" nn::Result Initialize__Q3_2nn2sl11DataCreatorFRQ3_2nn2sl17IIconInfoAccessorRQ3_2nn2sl20IAccountInfoAccessorRQ3_2nn2sl16ISettingAccessorRQ3_2nn2sl15ITitleIconCache(
DataCreatorInternal *, IIconInfoAccessorInternal *, IAccountInfoAccessorInternal *, ISettingAccessorInternal *, ITitleIconCacheInternal *);
} // namespace details
class DataCreator {
public:
DataCreator() : mIconInfoAccessor(nullptr),
mAccountInfoAccessor(nullptr),
mSettingAccessor(nullptr),
mTitleIconCache(nullptr) {
if (__ct__Q3_2nn2sl11DataCreatorFv(&mInstance) != nullptr) {
mIconInfoAccessor = details::IconInfoAccessorFromPtr(mInstance.iconInfoAccessor);
mAccountInfoAccessor = details::AccountInfoAccessorFromPtr(mInstance.accountInfoAccessor);
mSettingAccessor = details::SettingAccessorFromPtr(mInstance.settingInfoAccessor);
mTitleIconCache = details::TitleIconCacheFromPtr(mInstance.titleIconCache);
}
}
[[nodiscard]] details::IIconInfoAccessorBase &getIconInfoAccessor() {
return mIconInfoAccessor;
}
[[nodiscard]] details::IAccountInfoAccessorBase &getAccountInfoAccessor() {
return mAccountInfoAccessor;
}
[[nodiscard]] details::ISettingAccessorBase &getSettingAccessor() {
return mSettingAccessor;
}
[[nodiscard]] details::ITitleIconCacheBase &getTitleIconCache() {
return mTitleIconCache;
}
nn::Result Create(TransferableInfo *outTransferableInfo,
const TitleInfo *quickstartTitleInfos,
int numQuickstartTitleInfos,
const KillerNotification &killerNotification,
const TitleInfo &killerNotificationTitleInfo,
LaunchInfoDatabase &launchInfoDatabase) {
return details::Create__Q3_2nn2sl11DataCreatorFPQ3_2nn2sl16TransferableInfoPCQ3_2nn2sl9TitleInfoiRCQ3_2nn2sl18KillerNotificationRCQ3_2nn2sl9TitleInfoRQ3_2nn2sl18LaunchInfoDatabase(
&mInstance, outTransferableInfo, quickstartTitleInfos, numQuickstartTitleInfos, killerNotification, killerNotificationTitleInfo, launchInfoDatabase);
}
void Initialize(details::IIconInfoAccessorBase &iconInfoAccessor, details::IAccountInfoAccessorBase &accountInfoAccessor, details::ISettingAccessorBase &settingAccessor, details::ITitleIconCacheBase &titleIconCache) {
details::Initialize__Q3_2nn2sl11DataCreatorFRQ3_2nn2sl17IIconInfoAccessorRQ3_2nn2sl20IAccountInfoAccessorRQ3_2nn2sl16ISettingAccessorRQ3_2nn2sl15ITitleIconCache(
&mInstance, iconInfoAccessor.GetInternal(), accountInfoAccessor.GetInternal(), settingAccessor.GetInternal(), titleIconCache.GetInternal());
mIconInfoAccessor = details::IconInfoAccessorFromPtr(mInstance.iconInfoAccessor);
mAccountInfoAccessor = details::AccountInfoAccessorFromPtr(mInstance.accountInfoAccessor);
mSettingAccessor = details::SettingAccessorFromPtr(mInstance.settingInfoAccessor);
mTitleIconCache = details::TitleIconCacheFromPtr(mInstance.titleIconCache);
}
~DataCreator() = default;
private:
details::DataCreatorInternal mInstance = {};
details::IconInfoAccessorFromPtr mIconInfoAccessor;
details::AccountInfoAccessorFromPtr mAccountInfoAccessor;
details::SettingAccessorFromPtr mSettingAccessor;
details::TitleIconCacheFromPtr mTitleIconCache;
};
}; // namespace nn::sl
#endif

91
include/nn/sl/DrcManager.h Normal file
View File

@ -0,0 +1,91 @@
#pragma once
#include <nn/result.h>
#include <nn/sl/ISettingAccessor.h>
#include <nn/sl/ITimeAccessor.h>
#include <nn/sl/ITransferrer.h>
#include <nn/sl/KillerNotification.h>
#include <nn/sl/sl_cpp.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
namespace details {
typedef struct WUT_PACKED DrcManagerInternal {
ITransferrerInternal *drcTransferrer;
ISettingAccessorInternal *settingsAccessor;
ITimeAccessorInternal *timeAccessor;
void *vtable;
} DrcManagerInternal;
WUT_CHECK_SIZE(DrcManagerInternal, 0x10);
WUT_CHECK_OFFSET(DrcManagerInternal, 0x00, drcTransferrer);
WUT_CHECK_OFFSET(DrcManagerInternal, 0x04, settingsAccessor);
WUT_CHECK_OFFSET(DrcManagerInternal, 0x08, timeAccessor);
WUT_CHECK_OFFSET(DrcManagerInternal, 0x0C, vtable);
extern "C" DrcManagerInternal *__ct__Q3_2nn2sl10DrcManagerFv(DrcManagerInternal *);
extern "C" nn::Result CancelTransfer__Q3_2nn2sl10DrcManagerFv(DrcManagerInternal *);
extern "C" nn::Result PushNotification__Q3_2nn2sl10DrcManagerFPbPCQ3_2nn2sl18KillerNotificationbT3L(DrcManagerInternal *, bool *, const KillerNotification *, bool, bool, uint64_t);
extern "C" nn::Result Transfer__Q3_2nn2sl10DrcManagerFRCQ3_2nn2sl16TransferableInfobQ4_2nn2sl12ITransferrer12TransferMode(DrcManagerInternal *, TransferableInfo *, bool, TransferMode);
extern "C" nn::Result Initialize__Q3_2nn2sl10DrcManagerFRQ3_2nn2sl12ITransferrerRQ3_2nn2sl16ISettingAccessorRQ3_2nn2sl13ITimeAccessor(
DrcManagerInternal *, ITransferrerInternal *, ISettingAccessorInternal *, ITimeAccessorInternal *);
} // namespace details
class DrcManager {
public:
DrcManager() : mTransferrer(nullptr),
mSettingAccessor(nullptr),
mTimeAccessor(nullptr) {
if (__ct__Q3_2nn2sl10DrcManagerFv(&mInstance) != nullptr) {
mTransferrer = details::TransferrerFromPtr(mInstance.drcTransferrer);
mSettingAccessor = details::SettingAccessorFromPtr(mInstance.settingsAccessor);
mTimeAccessor = details::TimeAccessorFromPtr(mInstance.timeAccessor);
}
}
~DrcManager() = default;
details::ITransferrerBase &GetTransferrer() {
return mTransferrer;
}
details::ISettingAccessorBase &GetSettingAccessor() {
return mSettingAccessor;
}
details::ITimeAccessorBase &GetTimeAccessor() {
return mTimeAccessor;
}
nn::Result CancelTransfer() {
return CancelTransfer__Q3_2nn2sl10DrcManagerFv(&mInstance);
}
nn::Result PushNotification(bool *u1, const KillerNotification *u2, bool u3, bool u4, uint64_t u5) {
return PushNotification__Q3_2nn2sl10DrcManagerFPbPCQ3_2nn2sl18KillerNotificationbT3L(&mInstance, u1, u2, u3, u4, u5);
}
nn::Result Transfer(TransferableInfo *u1, bool u2, TransferMode u3) {
return Transfer__Q3_2nn2sl10DrcManagerFRCQ3_2nn2sl16TransferableInfobQ4_2nn2sl12ITransferrer12TransferMode(&mInstance, u1, u2, u3);
}
void Initialize(details::ITransferrerBase &transferrer, details::ISettingAccessorBase &settingAccessor, details::ITimeAccessorBase &timeAccessor) {
Initialize__Q3_2nn2sl10DrcManagerFRQ3_2nn2sl12ITransferrerRQ3_2nn2sl16ISettingAccessorRQ3_2nn2sl13ITimeAccessor(
&mInstance,
transferrer.GetInternal(),
settingAccessor.GetInternal(),
timeAccessor.GetInternal());
}
private:
details::DrcManagerInternal mInstance = {};
details::TransferrerFromPtr mTransferrer;
details::SettingAccessorFromPtr mSettingAccessor;
details::TimeAccessorFromPtr mTimeAccessor;
};
} // namespace nn::sl
#endif

91
include/nn/sl/FileStream.h
View File

@ -1,47 +1,74 @@
#pragma once
#include <wut.h>
#include <nn/result.h>
#include <coreinit/filesystem.h>
#include <nn/result.h>
#include <nn/sl/IStream.h>
#include <nn/sl/details/IStreamDetails.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn {
namespace nn::sl {
namespace details {
typedef struct WUT_PACKED FileStreamInternal {
void *vtable;
FSClient *fsClient;
FSCmdBlock *fsCmdBlock;
FSFileHandle fileHandle;
} FileStreamInternal;
WUT_CHECK_SIZE(FileStreamInternal, 0x10);
WUT_CHECK_OFFSET(FileStreamInternal, 0x00, vtable);
WUT_CHECK_OFFSET(FileStreamInternal, 0x04, fsClient);
WUT_CHECK_OFFSET(FileStreamInternal, 0x08, fsCmdBlock);
WUT_CHECK_OFFSET(FileStreamInternal, 0x0C, fileHandle);
namespace sl {
typedef struct WUT_PACKED FileStreamInternal {
WUT_UNKNOWN_BYTES(0x10);
} FileStreamInternal;
WUT_CHECK_SIZE(FileStreamInternal, 0x10);
extern "C" nn::Result Initialize__Q3_2nn2sl10FileStreamFP8FSClientP10FSCmdBlockPCcT3(FileStreamInternal *, FSClient *, FSCmdBlock *, char const *, char const *);
extern "C" FileStreamInternal *__ct__Q3_2nn2sl10FileStreamFv(FileStreamInternal *);
extern "C" void __dt__Q3_2nn2sl10FileStreamFv(FileStreamInternal *, int);
} // namespace details
extern "C" nn::Result Initialize__Q3_2nn2sl10FileStreamFP8FSClientP10FSCmdBlockPCcT3(FileStreamInternal *, FSClient *, FSCmdBlock *, char const *, char const *);
extern "C" FileStreamInternal *__ct__Q3_2nn2sl10FileStreamFv(FileStreamInternal *);
extern "C" void __dt__Q3_2nn2sl10FileStreamFv(FileStreamInternal *);
class FileStream {
friend class LaunchInfoDatabase;
public:
FileStream() {
instance = __ct__Q3_2nn2sl10FileStreamFv(nullptr);
}
~FileStream() {
if (instance != nullptr) {
__dt__Q3_2nn2sl10FileStreamFv(instance);
class FileStream : public details::IStreamBase {
public:
FileStream() {
__ct__Q3_2nn2sl10FileStreamFv(&mInstance);
}
}
nn::Result Initialize(FSClient *client, FSCmdBlock *cmdBlock, char const *path, char const *mode) {
return Initialize__Q3_2nn2sl10FileStreamFP8FSClientP10FSCmdBlockPCcT3(this->instance, client, cmdBlock, path, mode);
}
~FileStream() override {
__dt__Q3_2nn2sl10FileStreamFv(&mInstance, 2);
}
private:
FileStreamInternal *instance = nullptr;
};
nn::Result Read(uint32_t *bytesRead, void *buffer, uint32_t readSize) override {
auto *base = reinterpret_cast<details::IStreamInternal *>(&mInstance);
return base->vtable->ReadFn(base, bytesRead, buffer, readSize);
}
nn::Result Write(uint32_t *bytesWritten, void *buffer, uint32_t readSize) override {
auto *base = reinterpret_cast<details::IStreamInternal *>(&mInstance);
return base->vtable->WriteFn(base, bytesWritten, buffer, readSize);
}
nn::Result GetSize(uint32_t *fileSize) override {
auto *base = reinterpret_cast<details::IStreamInternal *>(&mInstance);
return base->vtable->GetSizeFn(base, fileSize);
}
nn::Result Seek(int32_t offset, nn::sl::SeekOrigin seekOrigin) override {
auto *base = reinterpret_cast<details::IStreamInternal *>(&mInstance);
return base->vtable->SeekFn(base, offset, seekOrigin);
}
}; //namespace sl
/**
* The given client and cmd must be valid during the whole liftime of the filestream
*/
nn::Result Initialize(FSClient *client, FSCmdBlock *cmdBlock, char const *path, char const *mode) {
return Initialize__Q3_2nn2sl10FileStreamFP8FSClientP10FSCmdBlockPCcT3(&mInstance, client, cmdBlock, path, mode);
}
}; //namespace nn
details::IStreamInternal *GetInternal() override {
return reinterpret_cast<details::IStreamInternal *>(&mInstance);
}
private:
details::FileStreamInternal mInstance = {};
};
}; // namespace nn::sl
#endif

55
include/nn/sl/IAccountInfoAccessor.h Normal file
View File

@ -0,0 +1,55 @@
#pragma once
#include <nn/result.h>
#include <nn/sl/details/IAccountInfoAccessorDetails.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
class IAccountInfoAccessor : public details::IAccountInfoAccessorBase {
public:
IAccountInfoAccessor() {
InitInternalVtable();
}
IAccountInfoAccessor(IAccountInfoAccessor &src) {
InitInternalVtable();
}
IAccountInfoAccessor &operator=(const IAccountInfoAccessor &other) {
InitInternalVtable();
return *this;
}
IAccountInfoAccessor &operator=(IAccountInfoAccessor &&src) noexcept {
InitInternalVtable();
return *this;
}
~IAccountInfoAccessor() override = default;
private:
static nn::Result GetWrapper(details::IAccountInfoAccessorInternal *instance, AccountInfo *outAccountInfo) {
return instance->vtable->instance->Get(outAccountInfo);
}
details::IAccountInfoAccessorInternal *GetInternal() override {
return &mInstance;
}
void InitInternalVtable() {
mVTable = {.instance = this,
.GetFn = &GetWrapper};
mInstance.vtable = &mVTable;
}
details::IAccountInfoAccessorInternal mInstance{};
details::IAccountInfoAccessorInternalVTable mVTable{};
};
details::IAccountInfoAccessorBase &GetDefaultAccountInfoAccessor();
} // namespace nn::sl
#endif

58
include/nn/sl/IBlackListAccessor.h Normal file
View File

@ -0,0 +1,58 @@
#pragma once
#include <nn/result.h>
#include <nn/sl/details/IBlackListAccessorDetails.h>
#include <nn/sl/sl_cpp.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
class IBlackListAccessor : public details::IBlackListAccessorBase {
public:
IBlackListAccessor() {
InitInternalVtable();
}
IBlackListAccessor(IBlackListAccessor &src) {
InitInternalVtable();
}
IBlackListAccessor &operator=(const IBlackListAccessor &other) {
InitInternalVtable();
return *this;
}
IBlackListAccessor &operator=(IBlackListAccessor &&src) noexcept {
InitInternalVtable();
return *this;
}
~IBlackListAccessor() override = default;
private:
static nn::Result GetWrapper(details::IBlackListAccessorInternal *instance, nn::sl::TitleInfo *outTitleInfos, int *outTitleInfosSize, int maxTitleInfos) {
return instance->vtable->instance->Get(outTitleInfos, outTitleInfosSize, maxTitleInfos);
}
details::IBlackListAccessorInternal *GetInternal() override {
return &mInstance;
}
void InitInternalVtable() {
mVTable = {.instance = this,
.GetFn = &GetWrapper};
mInstance.vtable = &mVTable;
}
details::IBlackListAccessorInternal mInstance{};
details::IBlackListAccessorInternalVTable mVTable{};
};
details::IBlackListAccessorBase &GetDefaultBlackListAccessor();
} // namespace nn::sl
#endif

57
include/nn/sl/IDefaultTitleAccessor.h Normal file
View File

@ -0,0 +1,57 @@
#pragma once
#include <nn/result.h>
#include <nn/sl/details/IDefaultTitleAccessorDetails.h>
#include <nn/sl/sl_cpp.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
class IDefaultTitleAccessor : public details::IDefaultTitleAccessorBase {
public:
IDefaultTitleAccessor() {
InitInternalVtable();
}
IDefaultTitleAccessor(IDefaultTitleAccessor &src) {
InitInternalVtable();
}
IDefaultTitleAccessor &operator=(const IDefaultTitleAccessor &other) {
InitInternalVtable();
return *this;
}
IDefaultTitleAccessor &operator=(IDefaultTitleAccessor &&src) noexcept {
InitInternalVtable();
return *this;
}
~IDefaultTitleAccessor() override = default;
private:
static nn::Result GetWrapper(details::IDefaultTitleAccessorInternal *instance, nn::sl::TitleInfo *outTitleInfos, int *outTitleInfosSize, int maxTitleInfos) {
return instance->vtable->instance->Get(outTitleInfos, outTitleInfosSize, maxTitleInfos);
}
details::IDefaultTitleAccessorInternal *GetInternal() override {
return &mInstance;
}
void InitInternalVtable() {
mVTable = {.instance = this,
.GetFn = &GetWrapper};
mInstance.vtable = &mVTable;
}
details::IDefaultTitleAccessorInternal mInstance{};
details::IDefaultTitleAccessorInternalVTable mVTable{};
};
details::IDefaultTitleAccessorBase &GetDefaultDefaultTitleAccessor();
} // namespace nn::sl
#endif

57
include/nn/sl/IDiscCachedTitleAccessor.h Normal file
View File

@ -0,0 +1,57 @@
#pragma once
#include <nn/result.h>
#include <nn/sl/details/IDiscCachedTitleAccessorDetails.h>
#include <nn/sl/sl_cpp.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
class DiscCachedTitleAccessor : public details::IDiscCachedTitleAccessorBase {
public:
DiscCachedTitleAccessor() {
InitInternalVtable();
}
DiscCachedTitleAccessor(DiscCachedTitleAccessor &src) {
InitInternalVtable();
}
DiscCachedTitleAccessor &operator=(const DiscCachedTitleAccessor &other) {
InitInternalVtable();
return *this;
}
DiscCachedTitleAccessor &operator=(DiscCachedTitleAccessor &&src) noexcept {
InitInternalVtable();
return *this;
}
~DiscCachedTitleAccessor() override = default;
private:
static nn::Result GetWrapper(details::IDiscCachedTitleAccessorInternal *instance, nn::sl::TitleInfo *outTitleInfos, int *outTitleInfosSize, int maxTitleInfos) {
return instance->vtable->instance->Get(outTitleInfos, outTitleInfosSize, maxTitleInfos);
}
details::IDiscCachedTitleAccessorInternal *GetInternal() override {
return &mInstance;
}
void InitInternalVtable() {
mVTable = {.instance = this,
.GetFn = &GetWrapper};
mInstance.vtable = &mVTable;
}
details::IDiscCachedTitleAccessorInternal mInstance{};
details::IDiscCachedTitleAccessorInternalVTable mVTable{};
};
details::IDiscCachedTitleAccessorBase &GetDefaultDiscCachedTitleAccessor();
} // namespace nn::sl
#endif

60
include/nn/sl/IIconInfoAccessor.h Normal file
View File

@ -0,0 +1,60 @@
#pragma once
#include <nn/result.h>
#include <nn/sl/details/IIconInfoAccessorDetails.h>
#include <nn/sl/sl_cpp.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
class IIconInfoAccessor : public details::IIconInfoAccessorBase {
public:
IIconInfoAccessor() {
InitInternalVtable();
}
IIconInfoAccessor(IIconInfoAccessor &src) {
InitInternalVtable();
}
IIconInfoAccessor &operator=(const IIconInfoAccessor &other) {
InitInternalVtable();
return *this;
}
IIconInfoAccessor &operator=(IIconInfoAccessor &&src) noexcept {
InitInternalVtable();
return *this;
}
~IIconInfoAccessor() override = default;
private:
static nn::Result GetTitleIconInfoWrapper(details::IIconInfoAccessorInternal *instance, nn::sl::IconInfo *outIconInfo, const nn::sl::TitleInfo &titleInfo, nn::sl::Language language) {
return instance->vtable->instance->GetTitleIconInfo(outIconInfo, titleInfo, language);
}
static nn::Result GetMiiIconWrapper(details::IIconInfoAccessorInternal *instance, void *buffer, uint32_t buffer_size, uint32_t slot) {
return instance->vtable->instance->GetMiiIcon(buffer, buffer_size, slot);
}
details::IIconInfoAccessorInternal *GetInternal() override {
return &mInstance;
}
void InitInternalVtable() {
mVTable = {.instance = this,
.GetTitleIconInfoFn = GetTitleIconInfoWrapper,
.GetMiiIconFn = GetMiiIconWrapper};
mInstance.vtable = &mVTable;
}
details::IIconInfoAccessorInternal mInstance{};
details::IIconInfoAccessorInternalVTable mVTable{};
};
details::IIconInfoAccessorBase &GetDefaultIconInfoAccessor();
} // namespace nn::sl
#endif

57
include/nn/sl/IInstalledTitleListAccessor.h Normal file
View File

@ -0,0 +1,57 @@
#pragma once
#include <nn/result.h>
#include <nn/sl/details/IInstalledTitleListAccessorDetails.h>
#include <nn/sl/sl_cpp.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
class IInstalledTitleListAccessor : public details::IInstalledTitleListAccessorBase {
public:
IInstalledTitleListAccessor() {
InitInternalVtable();
}
IInstalledTitleListAccessor(IInstalledTitleListAccessor &src) {
InitInternalVtable();
}
IInstalledTitleListAccessor &operator=(const IInstalledTitleListAccessor &other) {
InitInternalVtable();
return *this;
}
IInstalledTitleListAccessor &operator=(IInstalledTitleListAccessor &&src) noexcept {
InitInternalVtable();
return *this;
}
~IInstalledTitleListAccessor() override = default;
private:
static nn::Result GetWrapper(details::IInstalledTitleListAccessorInternal *instance, nn::sl::TitleInfo *outInstalledTitleInfos, int *outInstalledTitleInfosSize, int maxInstalledTitleInfos) {
return instance->vtable->instance->Get(outInstalledTitleInfos, outInstalledTitleInfosSize, maxInstalledTitleInfos);
}
details::IInstalledTitleListAccessorInternal *GetInternal() override {
return &mInstance;
}
void InitInternalVtable() {
mVTable = {.instance = this,
.GetFn = &GetWrapper};
mInstance.vtable = &mVTable;
}
details::IInstalledTitleListAccessorInternal mInstance{};
details::IInstalledTitleListAccessorInternalVTable mVTable{};
};
details::IInstalledTitleListAccessorBase &GetDefaultInstalledTitleListAccessor();
} // namespace nn::sl
#endif

56
include/nn/sl/IKillerNotificationAccessor.h Normal file
View File

@ -0,0 +1,56 @@
#pragma once
#include <nn/result.h>
#include <nn/sl/details/IKillerNotificationAccessorDetails.h>
#include <nn/sl/sl_cpp.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
class IKillerNotificationAccessor : public details::IKillerNotificationAccessorBase {
public:
IKillerNotificationAccessor() {
InitInternalVtable();
}
IKillerNotificationAccessor(IKillerNotificationAccessor &src) {
InitInternalVtable();
}
IKillerNotificationAccessor &operator=(const IKillerNotificationAccessor &other) {
InitInternalVtable();
return *this;
}
IKillerNotificationAccessor &operator=(IKillerNotificationAccessor &&src) noexcept {
InitInternalVtable();
return *this;
}
~IKillerNotificationAccessor() override = default;
private:
static nn::Result GetWrapper(details::IKillerNotificationAccessorInternal *instance, KillerNotification *outBuffer, int *outNum, int outBufferNum) {
return instance->vtable->instance->Get(outBuffer, outNum, outBufferNum);
}
details::IKillerNotificationAccessorInternal *GetInternal() override {
return &mInstance;
}
void InitInternalVtable() {
mVTable = {.instance = this,
.GetFn = &GetWrapper};
mInstance.vtable = &mVTable;
}
details::IKillerNotificationAccessorInternal mInstance{};
details::IKillerNotificationAccessorInternalVTable mVTable{};
};
details::IKillerNotificationAccessorBase &GetDefaultKillerNotificationAccessor();
} // namespace nn::sl
#endif

61
include/nn/sl/ILaunchedTitleListAccessor.h Normal file
View File

@ -0,0 +1,61 @@
#pragma once
#include <nn/result.h>
#include <nn/sl/details/ILaunchedTitleListAccessoDetails.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
class ILaunchedTitleListAccessor : public details::ILaunchedTitleListAccessorBase {
public:
ILaunchedTitleListAccessor() {
InitInternalVtable();
}
ILaunchedTitleListAccessor(ILaunchedTitleListAccessor &src) {
InitInternalVtable();
}
ILaunchedTitleListAccessor &operator=(const ILaunchedTitleListAccessor &other) {
InitInternalVtable();
return *this;
}
ILaunchedTitleListAccessor &operator=(ILaunchedTitleListAccessor &&src) noexcept {
InitInternalVtable();
return *this;
}
~ILaunchedTitleListAccessor() override = default;
private:
static nn::Result GetByAccountWrapper(details::ILaunchedTitleListAccessorInternal *instance, nn::sl::TitleInfo *outTitleInfos, int *outTitleInfoSize, int inTitleInfosSize, int userId) {
return instance->vtable->instance->GetByAccount(outTitleInfos, outTitleInfoSize, inTitleInfosSize, userId);
}
details::ILaunchedTitleListAccessorInternal *GetInternal() override {
return &mInstance;
}
void InitInternalVtable() {
mVTable = {.instance = this,
.GetByAccountFn = &GetByAccountWrapper};
mInstance.vtable = &mVTable;
}
details::ILaunchedTitleListAccessorInternal mInstance{};
details::ILaunchedTitleListAccessorInternalVTable mVTable{};
};
enum LaunchedTitleListAccessorType {
TITLE_LIST_ACCESSOR_LAUNCHED_TITLES = 0,
TITLE_LIST_ACCESSOR_PLAY_STATS = 1,
};
details::ILaunchedTitleListAccessorBase &GetDefaultLaunchedTitleListAccessor(LaunchedTitleListAccessorType type);
details::ILaunchedTitleListAccessorBase &GetDefaultLaunchedTitleListAccessor();
} // namespace nn::sl
#endif

58
include/nn/sl/IMetaInfoAccessor.h Normal file
View File

@ -0,0 +1,58 @@
#pragma once
#include <nn/result.h>
#include <nn/sl/details/IMetaInfoAccessorDetails.h>
#include <nn/sl/sl_cpp.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
class MetaInfoAccessor : public details::IMetaInfoAccessorBase {
public:
MetaInfoAccessor() {
InitInternalVtable();
}
MetaInfoAccessor(MetaInfoAccessor &src) {
InitInternalVtable();
}
MetaInfoAccessor &operator=(const MetaInfoAccessor &other) {
InitInternalVtable();
return *this;
}
MetaInfoAccessor &operator=(MetaInfoAccessor &&src) noexcept {
InitInternalVtable();
return *this;
}
~MetaInfoAccessor() override = default;
private:
static nn::Result GetWrapper(details::IMetaInfoAccessorInternal *instance, nn::sl::TitleMetaInfo *outMetaInfo, const nn::sl::TitleInfo &titleInfo) {
return instance->vtable->instance->Get(outMetaInfo, titleInfo);
}
details::IMetaInfoAccessorInternal *GetInternal() override {
return &mInstance;
}
void InitInternalVtable() {
mVTable = {.instance = this,
.GetFn = &GetWrapper};
mInstance.vtable = &mVTable;
}
details::IMetaInfoAccessorInternal mInstance{};
details::IMetaInfoAccessorInternalVTable mVTable{};
};
details::IMetaInfoAccessorBase &GetDefaultMetaInfoAccessor();
} // namespace nn::sl
#endif

55
include/nn/sl/IPreferentialTitleAccessor.h Normal file
View File

@ -0,0 +1,55 @@
#pragma once
#include <nn/result.h>
#include <nn/sl/details/IPreferentialTitleAccessorDetails.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
class IPreferentialTitleAccessor : public details::IPreferentialTitleAccessorBase {
public:
IPreferentialTitleAccessor() {
InitInternalVtable();
}
IPreferentialTitleAccessor(IPreferentialTitleAccessor &src) {
InitInternalVtable();
}
IPreferentialTitleAccessor &operator=(const IPreferentialTitleAccessor &other) {
InitInternalVtable();
return *this;
}
IPreferentialTitleAccessor &operator=(IPreferentialTitleAccessor &&src) noexcept {
InitInternalVtable();
return *this;
}
~IPreferentialTitleAccessor() override = default;
private:
static nn::Result GetWrapper(details::IPreferentialTitleAccessorInternal *instance, TitleInfo *outTitleInfo, uint32_t *outTitleInfoSize, int maxTitleInfo, uint32_t u1) {
return instance->vtable->instance->Get(outTitleInfo, outTitleInfoSize, maxTitleInfo, u1);
}
details::IPreferentialTitleAccessorInternal *GetInternal() override {
return &mInstance;
}
void InitInternalVtable() {
mVTable = {.instance = this,
.GetFn = &GetWrapper};
mInstance.vtable = &mVTable;
}
details::IPreferentialTitleAccessorInternal mInstance{};
details::IPreferentialTitleAccessorInternalVTable mVTable{};
};
details::IPreferentialTitleAccessorBase &GetDefaultPreferentialTitleAccessor();
} // namespace nn::sl
#endif

85
include/nn/sl/ISerializer.h Normal file
View File

@ -0,0 +1,85 @@
#pragma once
#include <coreinit/time.h>
#include <nn/result.h>
#include <nn/sl/KillerNotification.h>
#include <nn/sl/details/ISerializerDetails.h>
#include <nn/sl/sl_cpp.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
template<typename T>
class ISerializer : public details::ISerializerBase<T> {
public:
ISerializer() {
InitInternalVtable();
}
ISerializer(ISerializer &src) {
InitInternalVtable();
}
ISerializer &operator=(const ISerializer &other) {
InitInternalVtable();
return *this;
}
ISerializer &operator=(ISerializer &&src) noexcept {
InitInternalVtable();
return *this;
}
nn::Result Serialize(T *buffer, uint32_t num) {
return details::ISerializerBase<T>::Serialize(buffer, num * sizeof(buffer));
}
nn::Result Deserialize(T *buffer, uint32_t num) {
return details::ISerializerBase<T>::Deserialize(buffer, num * sizeof(buffer));
}
~ISerializer() override = default;
private:
static nn::Result SerializeWrapper(details::ISerializerInternal *instance, void *buffer, uint32_t size) {
return details::ISerializerBase<T>::instance->vtable->instance->Serialize(buffer, size);
}
static nn::Result DeserializeWrapper(details::ISerializerInternal *instance, void *buffer, uint32_t size) {
return details::ISerializerBase<T>::instance->vtable->instance->Deserialize(buffer, size);
}
static nn::Result GetCountWrapper(details::ISerializerInternal *instance, uint32_t *outCount) {
return details::ISerializerBase<T>::instance->vtable->instance->GetCount(outCount);
}
details::ISerializerInternal *GetInternal() override {
return &mInstance;
}
void InitInternalVtable() {
mVTable = {.instance = this,
.SerializeFn = &SerializeWrapper,
.DeserializeFn = &DeserializeWrapper,
.GetCountFn = &GetCountWrapper};
mInstance.vtable = &mVTable;
}
details::ISerializerInternal mInstance{};
details::ISerializerInternalVTable mVTable{};
};
details::ISerializerBase<nn::sl::IconInfo> &GetDefaultIconInfoSerializer();
details::ISerializerBase<nn::sl::TitleInfo> &GetDefaultQuickStartTitleInfoSerializer();
details::ISerializerBase<nn::sl::KillerNotification> &GetDefaultKillerNotificationSerializer();
details::ISerializerBase<nn::sl::TitleInfo> &GetDefaultJumpTitleInfoSerializer();
details::ISerializerBase<OSTime> &GetDefaultPreviousSendingTimeSerializer();
} // namespace nn::sl
#endif

56
include/nn/sl/ISettingAccessor.h Normal file
View File

@ -0,0 +1,56 @@
#pragma once
#include <nn/result.h>
#include <nn/sl/details/ISettingAccessorDetails.h>
#include <nn/sl/sl_cpp.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
class ISettingAccessor : public details::ISettingAccessorBase {
public:
ISettingAccessor() {
InitInternalVtable();
}
ISettingAccessor(ISettingAccessor &src) {
InitInternalVtable();
}
ISettingAccessor &operator=(const ISettingAccessor &other) {
InitInternalVtable();
return *this;
}
ISettingAccessor &operator=(ISettingAccessor &&src) noexcept {
InitInternalVtable();
return *this;
}
~ISettingAccessor() override = default;
private:
static nn::Result GetWrapper(details::ISettingAccessorInternal *instance, Setting *outSetting) {
return instance->vtable->instance->Get(outSetting);
}
details::ISettingAccessorInternal *GetInternal() override {
return &mInstance;
}
void InitInternalVtable() {
mVTable = {.instance = this,
.GetFn = &GetWrapper};
mInstance.vtable = &mVTable;
}
details::ISettingAccessorInternal mInstance{};
details::ISettingAccessorInternalVTable mVTable{};
};
details::ISettingAccessorBase &GetDefaultSettingAccessor();
} // namespace nn::sl
#endif

69
include/nn/sl/IStream.h Normal file
View File

@ -0,0 +1,69 @@
#pragma once
#include <nn/result.h>
#include <nn/sl/details/IStreamDetails.h>
#include <nn/sl/sl_cpp.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
class IStream : public details::IStreamBase {
public:
IStream() {
InitInternalVtable();
}
IStream(IStream &src) {
InitInternalVtable();
}
IStream &operator=(const IStream &other) {
InitInternalVtable();
return *this;
}
IStream &operator=(IStream &&src) noexcept {
InitInternalVtable();
return *this;
}
~IStream() override = default;
private:
static nn::Result ReadWrapper(details::IStreamInternal *instance, uint32_t *bytesRead, void *buffer, uint32_t readSize) {
return instance->vtable->instance->Read(bytesRead, buffer, readSize);
}
static nn::Result WriteWrapper(details::IStreamInternal *instance, uint32_t *bytesWritten, void *buffer, uint32_t readSize) {
return instance->vtable->instance->Write(bytesWritten, buffer, readSize);
}
static nn::Result GetSizeWrapper(details::IStreamInternal *instance, uint32_t *fileSize) {
return instance->vtable->instance->GetSize(fileSize);
}
static nn::Result SeekWrapper(details::IStreamInternal *instance, int32_t offset, nn::sl::SeekOrigin seekOrigin) {
return instance->vtable->instance->Seek(offset, seekOrigin);
}
details::IStreamInternal *GetInternal() override {
return &mInstance;
}
void InitInternalVtable() {
mVTable = {.instance = this,
.ReadFn = &ReadWrapper,
.WriteFn = &WriteWrapper,
.GetSizeFn = &GetSizeWrapper,
.SeekFn = &SeekWrapper};
mInstance.vtable = &mVTable;
}
details::IStreamInternal mInstance{};
details::IStreamInternalVTable mVTable{};
};
} // namespace nn::sl
#endif

62
include/nn/sl/ITimeAccessor.h Normal file
View File

@ -0,0 +1,62 @@
#pragma once
#include <coreinit/time.h>
#include <nn/result.h>
#include <nn/sl/details/ITimeAccessorDetails.h>
#include <nn/sl/sl_cpp.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
class ITimeAccessor : public details::ITimeAccessorBase {
public:
ITimeAccessor() {
InitInternalVtable();
}
ITimeAccessor(ITimeAccessor &src) {
InitInternalVtable();
}
ITimeAccessor &operator=(const ITimeAccessor &other) {
InitInternalVtable();
return *this;
}
ITimeAccessor &operator=(ITimeAccessor &&src) noexcept {
InitInternalVtable();
return *this;
}
~ITimeAccessor() override = default;
private:
static nn::Result GetNetworkTimeWrapper(details::ITimeAccessorInternal *instance, OSTime *timeOut, bool *successOut) {
return instance->vtable->instance->GetNetworkTime(timeOut, successOut);
}
static nn::Result GetLocalTimeWrapper(details::ITimeAccessorInternal *instance, OSTime *timeOut, bool *successOut) {
return instance->vtable->instance->GetLocalTime(timeOut, successOut);
}
details::ITimeAccessorInternal *GetInternal() override {
return &mInstance;
}
void InitInternalVtable() {
mVTable = {.instance = this,
.GetNetworkTimeFn = &GetNetworkTimeWrapper,
.GetLocalTimeFn = &GetLocalTimeWrapper};
mInstance.vtable = &mVTable;
}
details::ITimeAccessorInternal mInstance{};
details::ITimeAccessorInternalVTable mVTable{};
};
details::ITimeAccessorBase &GetDefaultTimeAccessor();
} // namespace nn::sl
#endif

72
include/nn/sl/ITitleIconCache.h Normal file
View File

@ -0,0 +1,72 @@
#pragma once
#include <nn/result.h>
#include <nn/sl/details/ITitleIconCacheDetails.h>
#include <nn/sl/sl_cpp.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
class ITitleIconCache : public details::ITitleIconCacheBase {
public:
ITitleIconCache() {
InitInternalVtable();
}
ITitleIconCache(ITitleIconCache &src) {
InitInternalVtable();
}
ITitleIconCache &operator=(const ITitleIconCache &other) {
InitInternalVtable();
return *this;
}
ITitleIconCache &operator=(ITitleIconCache &&src) noexcept {
InitInternalVtable();
return *this;
}
~ITitleIconCache() override = default;
private:
static nn::Result LoadWrapper(details::ITitleIconCacheInternal *instance) {
return instance->vtable->instance->Load();
}
static nn::Result UpdateWrapper(details::ITitleIconCacheInternal *instance, TitleInfo *titleInfos, int num) {
return instance->vtable->instance->Update(titleInfos, num);
}
static nn::Result StoreWrapper(details::ITitleIconCacheInternal *instance) {
return instance->vtable->instance->Store();
}
static void GetWrapper(details::ITitleIconCacheInternal *instance, IconInfo *iconInfos, int num) {
return instance->vtable->instance->Get(iconInfos, num);
}
details::ITitleIconCacheInternal *GetInternal() override {
return &mInstance;
}
void InitInternalVtable() {
mVTable = {.instance = this,
.LoadFn = &LoadWrapper,
.UpdateFn = &UpdateWrapper,
.StoreFn = &StoreWrapper,
.GetFn = &GetWrapper};
mInstance.vtable = &mVTable;
}
details::ITitleIconCacheInternal mInstance{};
details::ITitleIconCacheInternalVTable mVTable{};
};
details::ITitleIconCacheBase &GetDefaultTitleIconCache();
} // namespace nn::sl
#endif

58
include/nn/sl/ITitleListAccessor.h Normal file
View File

@ -0,0 +1,58 @@
#pragma once
#include <nn/result.h>
#include <nn/sl/details/ITitleListAccessorDetails.h>
#include <nn/sl/sl_cpp.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
class ITitleListAccessor : public details::ITitleListAccessorBase {
public:
ITitleListAccessor() {
InitInternalVtable();
}
ITitleListAccessor(ITitleListAccessor &src) {
InitInternalVtable();
}
ITitleListAccessor &operator=(const ITitleListAccessor &other) {
InitInternalVtable();
return *this;
}
ITitleListAccessor &operator=(ITitleListAccessor &&src) noexcept {
InitInternalVtable();
return *this;
}
~ITitleListAccessor() override = default;
private:
static nn::Result GetWrapper(details::ITitleListAccessorInternal *instance, nn::sl::TitleInfo *outTitleInfos, int *outTitleInfosSize, int maxTitleInfos) {
return instance->vtable->instance->Get(outTitleInfos, outTitleInfosSize, maxTitleInfos);
}
details::ITitleListAccessorInternal *GetInternal() override {
return &mInstance;
}
void InitInternalVtable() {
mVTable = {.instance = this,
.GetFn = &GetWrapper};
mInstance.vtable = &mVTable;
}
details::ITitleListAccessorInternal mInstance{};
details::ITitleListAccessorInternalVTable mVTable{};
};
details::ITitleListAccessorBase &GetDefaultTitleListAccessor();
} // namespace nn::sl
#endif

72
include/nn/sl/ITransferrer.h Normal file
View File

@ -0,0 +1,72 @@
#pragma once
#include <nn/result.h>
#include <nn/sl/details/ITransferrerDetails.h>
#include <nn/sl/sl_cpp.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
class ITransferrer : public details::ITransferrerBase {
public:
ITransferrer() {
InitInternalVtable();
}
ITransferrer(ITransferrer &src) {
InitInternalVtable();
}
ITransferrer &operator=(const ITransferrer &other) {
InitInternalVtable();
return *this;
}
ITransferrer &operator=(ITransferrer &&src) noexcept {
InitInternalVtable();
return *this;
}
~ITransferrer() override = default;
private:
static nn::Result TransferDeprecatedWrapper(details::ITransferrerInternal *instance, void *buffer, uint32_t size, bool setKillerNotification, int transferMode) {
return instance->vtable->instance->TransferDeprecated(buffer, size, setKillerNotification, transferMode);
}
static nn::Result TransferWrapper(details::ITransferrerInternal *instance, void *buffer, uint32_t size, bool setKillerNotification, TransferMode transferMode) {
return instance->vtable->instance->Transfer(buffer, size, setKillerNotification, transferMode);
}
static nn::Result CancelTransferWrapper(details::ITransferrerInternal *instance) {
return instance->vtable->instance->CancelTransfer();
}
static nn::Result InvalidateNotificationWrapper(details::ITransferrerInternal *instance, uint32_t u1) {
return instance->vtable->instance->InvalidateNotification(u1);
}
static nn::Result DisplayNotificationWrapper(details::ITransferrerInternal *instance, uint32_t u1, uint32_t u2, uint32_t u3) {
return instance->vtable->instance->DisplayNotification(u1, u2, u3);
}
details::ITransferrerInternal *GetInternal() override {
return &mInstance;
}
void InitInternalVtable() {
mVTable = {.instance = this,
.TransferDeprecatedFn = &TransferDeprecatedWrapper,
.TransferFn = &TransferWrapper,
.CancelTransferFn = &CancelTransferWrapper,
.InvalidateNotificationFn = &InvalidateNotificationWrapper,
.DisplayNotificationFn = &DisplayNotificationWrapper};
mInstance.vtable = &mVTable;
}
details::ITransferrerInternal mInstance{};
details::ITransferrerInternalVTable mVTable{};
};
details::ITransferrerBase &GetDrcTransferrer();
} // namespace nn::sl
#endif

59
include/nn/sl/IUpdatePackageAccessor.h Normal file
View File

@ -0,0 +1,59 @@
#pragma once
#include <nn/result.h>
#include <nn/sl/details/IUpdatePackageAccessorDetails.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
class IUpdatePackageAccessor : public details::IUpdatePackageAccessorBase {
public:
IUpdatePackageAccessor() {
InitInternalVtable();
}
IUpdatePackageAccessor(IUpdatePackageAccessor &src) {
InitInternalVtable();
}
IUpdatePackageAccessor &operator=(const IUpdatePackageAccessor &other) {
InitInternalVtable();
return *this;
}
IUpdatePackageAccessor &operator=(IUpdatePackageAccessor &&src) noexcept {
InitInternalVtable();
return *this;
}
~IUpdatePackageAccessor() override = default;
private:
static bool PackageExistsWrapper(details::IUpdatePackageAccessorInternal *instance) {
return instance->vtable->instance->PackageExists();
}
static bool IsUpdatePackageDownloadedWrapper(details::IUpdatePackageAccessorInternal *instance) {
return instance->vtable->instance->IsUpdatePackageDownloaded();
}
details::IUpdatePackageAccessorInternal *GetInternal() override {
return &mInstance;
}
void InitInternalVtable() {
mVTable = {.instance = this,
.PackageExistsFn = PackageExistsWrapper,
.IsUpdatePackageDownloadedFn = IsUpdatePackageDownloadedWrapper};
mInstance.vtable = &mVTable;
}
details::IUpdatePackageAccessorInternal mInstance{};
details::IUpdatePackageAccessorInternalVTable mVTable{};
};
details::IUpdatePackageAccessorBase &GetDefaultUpdatePackageAccessor();
} // namespace nn::sl
#endif

58
include/nn/sl/IWhiteListAccessor.h Normal file
View File

@ -0,0 +1,58 @@
#pragma once
#include <nn/result.h>
#include <nn/sl/details/IWhiteListAccessorDetails.h>
#include <nn/sl/sl_cpp.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
class IWhiteListAccessor : public details::IWhiteListAccessorBase {
public:
IWhiteListAccessor() {
InitInternalVtable();
}
IWhiteListAccessor(IWhiteListAccessor &src) {
InitInternalVtable();
}
IWhiteListAccessor &operator=(const IWhiteListAccessor &other) {
InitInternalVtable();
return *this;
}
IWhiteListAccessor &operator=(IWhiteListAccessor &&src) noexcept {
InitInternalVtable();
return *this;
}
~IWhiteListAccessor() override = default;
private:
static nn::Result GetWrapper(details::IWhiteListAccessorInternal *instance, nn::sl::WhiteList *outWhiteList) {
return instance->vtable->instance->Get(outWhiteList);
}
details::IWhiteListAccessorInternal *GetInternal() override {
return &mInstance;
}
void InitInternalVtable() {
mVTable = {.instance = this,
.GetFn = &GetWrapper};
mInstance.vtable = &mVTable;
}
details::IWhiteListAccessorInternal mInstance{};
details::IWhiteListAccessorInternalVTable mVTable{};
};
details::IWhiteListAccessorBase &GetDefaultWhiteListAccessor();
} // namespace nn::sl
#endif

206
include/nn/sl/KillerNotification.h Normal file
View File

@ -0,0 +1,206 @@
#pragma once
#include "sl_cpp.h"
#include <nn/result.h>
#include <nn/sl/KillerNotification.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
struct KillerNotification;
namespace details {
extern "C" nn::Result __CPR81__CheckEmptyValue__Q3_2nn2sl18KillerNotificationSFPbPCQ3_2nn2slJ26J(bool *u1, const KillerNotification *u2);
extern "C" void __CPR76__GetEmptyValue__Q3_2nn2sl18KillerNotificationSFPQ3_2nn2slJ24J(KillerNotification *u1);
} // namespace details
typedef enum KillerNotificationType {
PROMOTION = 0,
PUSH_APP = 1,
NON_COMMERCIAL = 2
} KillerNotificationType;
typedef enum KillerNotificationNotificationPattern {
NORMAL = 0,
SILENT = 1
} KillerNotificationNotificationPattern;
typedef enum KillerNotificationGender {
UNKNOWN = 0,
MALE = 1,
FEMALE = 2
} KillerNotificationGender;
typedef enum KillerNotificationAllowLocalAccount : int8_t {
ALLOW = 0,
NOT_ALLOW = 1
} KillerNotificationAllowLocalAccount;
typedef enum KillerNotificationAccountMailActivation : int8_t {
NOT_ACTIVATED = 0,
ANYBODY = 1
} KillerNotificationAccountMailActivation;
typedef enum KillerNotificationConjunction {
AND = 0,
OR = 1
} KillerNotificationConjunction;
struct WUT_PACKED KillerNotificationInstalledTitleFilter {
uint64_t titleId;
KillerNotificationConjunction conjunction;
};
WUT_CHECK_SIZE(KillerNotificationInstalledTitleFilter, 0x0C);
WUT_CHECK_OFFSET(KillerNotificationInstalledTitleFilter, 0x00, titleId);
WUT_CHECK_OFFSET(KillerNotificationInstalledTitleFilter, 0x08, conjunction);
struct WUT_PACKED KillerNotificationPlayedTitleFilter {
uint64_t titleId;
enum KillerNotificationConjunction conjunction;
};
WUT_CHECK_SIZE(KillerNotificationPlayedTitleFilter, 0x0C);
WUT_CHECK_OFFSET(KillerNotificationPlayedTitleFilter, 0x00, titleId);
WUT_CHECK_OFFSET(KillerNotificationPlayedTitleFilter, 0x08, conjunction);
struct WUT_PACKED KillerNotificationTitleFilter {
uint64_t titleId;
WUT_UNKNOWN_BYTES(4);
int32_t played;
WUT_UNKNOWN_BYTES(4);
int32_t installed;
};
WUT_CHECK_SIZE(KillerNotificationTitleFilter, 0x18);
WUT_CHECK_OFFSET(KillerNotificationTitleFilter, 0x0C, played);
WUT_CHECK_OFFSET(KillerNotificationTitleFilter, 0x14, installed);
struct WUT_PACKED KillerNotification {
uint32_t serialId;
uint32_t version;
WUT_UNKNOWN_BYTES(16);
bool deleteFlag;
char language[4];
WUT_UNKNOWN_BYTES(3);
KillerNotificationType type;
KillerNotificationNotificationPattern notificationPattern;
struct {
uint64_t titleId;
char parameter[2048];
} launchApplication;
uint32_t priority;
struct {
struct {
DRCImagePalette palette; // the "main" image actually uses the button palette in the quick start menu
uint8_t pixels[400][854]; // index of color in (button) palette - 854x400
} main;
struct {
DRCImagePalette palette;
uint8_t pixels[160][487]; // index of color in palette - 487*160
} button;
WUT_PADDING_BYTES(0);
char banner[290416]; // BMP! 854×85, Bit depth: 32
} images;
struct {
WUT_UNKNOWN_BYTES(12);
struct WUT_PACKED {
uint64_t startUnixTime;
uint64_t endUnixTime;
} duration;
WUT_UNKNOWN_BYTES(4);
uint32_t lifetime;
WUT_UNKNOWN_BYTES(4);
struct {
struct {
uint32_t lowerBound;
uint32_t upperBound;
} age;
KillerNotificationGender gender;
} account;
struct {
uint32_t titleCount;
WUT_UNKNOWN_BYTES(4);
KillerNotificationTitleFilter titles[2];
} titleFilter;
WUT_UNKNOWN_BYTES(1);
struct WUT_PACKED {
KillerNotificationAllowLocalAccount allowLocalAccount;
WUT_UNKNOWN_BYTES(2);
uint32_t ageRestrictionLowerBound;
} ageRestriction;
KillerNotificationAccountMailActivation accountMailActivation;
WUT_UNKNOWN_BYTES(11);
uint32_t accountBirthMonth;
WUT_UNKNOWN_BYTES(4);
int8_t anticipatoryDownload;
WUT_UNKNOWN_BYTES(15);
struct {
int32_t installedTitleCount;
enum KillerNotificationConjunction installedConjunction;
WUT_UNKNOWN_BYTES(4);
struct KillerNotificationInstalledTitleFilter installedTitleFilter[2];
};
WUT_UNKNOWN_BYTES(12);
struct {
uint32_t playedTitleFilterCount;
enum KillerNotificationConjunction playedConjunction;
WUT_UNKNOWN_BYTES(4);
uint32_t played_duration_sinceUnixTime;
WUT_UNKNOWN_BYTES(4);
KillerNotificationPlayedTitleFilter playedTitleFilter[2];
};
} displayCondition;
WUT_UNKNOWN_BYTES(8);
uint32_t formatVersion;
uint32_t tags;
WUT_UNKNOWN_BYTES(256);
static nn::Result CheckEmptyValue(bool *outRes, const KillerNotification *u2) {
return details::__CPR81__CheckEmptyValue__Q3_2nn2sl18KillerNotificationSFPbPCQ3_2nn2slJ26J(outRes, u2);
}
static void GetEmptyValue(KillerNotification *u1) {
return details::__CPR76__GetEmptyValue__Q3_2nn2sl18KillerNotificationSFPQ3_2nn2slJ24J(u1);
}
};
WUT_CHECK_SIZE(KillerNotification, 0xae768);
WUT_CHECK_OFFSET(KillerNotification, 0x0, serialId);
WUT_CHECK_OFFSET(KillerNotification, 0x04, version);
WUT_CHECK_OFFSET(KillerNotification, 0x18, deleteFlag);
WUT_CHECK_OFFSET(KillerNotification, 0x20, type);
WUT_CHECK_OFFSET(KillerNotification, 0x24, notificationPattern);
WUT_CHECK_OFFSET(KillerNotification, 0x28, launchApplication.titleId);
WUT_CHECK_OFFSET(KillerNotification, 0x30, launchApplication.parameter);
WUT_CHECK_OFFSET(KillerNotification, 0x830, priority);
WUT_CHECK_OFFSET(KillerNotification, 0x834, images);
WUT_CHECK_OFFSET(KillerNotification, 0x834, images.main);
WUT_CHECK_OFFSET(KillerNotification, 0x834 + 0x400, images.main.pixels);
WUT_CHECK_OFFSET(KillerNotification, 0x54294, images.button);
WUT_CHECK_OFFSET(KillerNotification, 0x54294 + 0x400, images.button.pixels);
WUT_CHECK_OFFSET(KillerNotification, 0x676f4, images.banner);
WUT_CHECK_OFFSET(KillerNotification, 0xae570, displayCondition.duration.startUnixTime);
WUT_CHECK_OFFSET(KillerNotification, 0xae578, displayCondition.duration.endUnixTime);
WUT_CHECK_OFFSET(KillerNotification, 0xae584, displayCondition.lifetime);
WUT_CHECK_OFFSET(KillerNotification, 0xae58C, displayCondition.account.age.lowerBound);
WUT_CHECK_OFFSET(KillerNotification, 0xae590, displayCondition.account.age.upperBound);
WUT_CHECK_OFFSET(KillerNotification, 0xae594, displayCondition.account.gender);
WUT_CHECK_OFFSET(KillerNotification, 0xae598, displayCondition.titleFilter.titleCount);
WUT_CHECK_OFFSET(KillerNotification, 0xae5a0, displayCondition.titleFilter.titles);
WUT_CHECK_OFFSET(KillerNotification, 0xae5d1, displayCondition.ageRestriction.allowLocalAccount);
WUT_CHECK_OFFSET(KillerNotification, 0xae5d4, displayCondition.ageRestriction.ageRestrictionLowerBound);
WUT_CHECK_OFFSET(KillerNotification, 0xae5d8, displayCondition.accountMailActivation);
WUT_CHECK_OFFSET(KillerNotification, 0xae5e4, displayCondition.accountBirthMonth);
WUT_CHECK_OFFSET(KillerNotification, 0xae5ec, displayCondition.anticipatoryDownload);
WUT_CHECK_OFFSET(KillerNotification, 0xae5fc, displayCondition.installedTitleCount);
WUT_CHECK_OFFSET(KillerNotification, 0xae600, displayCondition.installedConjunction);
WUT_CHECK_OFFSET(KillerNotification, 0xae608, displayCondition.installedTitleFilter);
WUT_CHECK_OFFSET(KillerNotification, 0xae62c, displayCondition.playedTitleFilterCount);
WUT_CHECK_OFFSET(KillerNotification, 0xae630, displayCondition.playedConjunction);
WUT_CHECK_OFFSET(KillerNotification, 0xae638, displayCondition.played_duration_sinceUnixTime);
WUT_CHECK_OFFSET(KillerNotification, 0xae640, displayCondition.playedTitleFilter);
WUT_CHECK_OFFSET(KillerNotification, 0xae660, formatVersion);
WUT_CHECK_OFFSET(KillerNotification, 0xae664, tags);
} // namespace nn::sl
#endif

162
include/nn/sl/KillerNotificationSelector.h Normal file
View File

@ -0,0 +1,162 @@
#pragma once
#include <nn/result.h>
#include <nn/sl/IAccountInfoAccessor.h>
#include <nn/sl/IKillerNotificationAccessor.h>
#include <nn/sl/ILaunchedTitleListAccessor.h>
#include <nn/sl/ISerializer.h>
#include <nn/sl/ISettingAccessor.h>
#include <nn/sl/ITimeAccessor.h>
#include <nn/sl/KillerNotification.h>
#include <nn/sl/KillerNotificationTransferRecordManager.h>
#include <nn/sl/TitleListCache.h>
#include <nn/sl/sl_cpp.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
namespace details {
typedef struct WUT_PACKED KillerNotificationSelectorInternal {
ILaunchedTitleListAccessorInternal *launchedTitleListAccessor;
IKillerNotificationAccessorInternal *killerNotificationAccessor;
ITitleListCacheInternal *titleListCache;
ISerializerInternal *killerNotificationSerializer;
ISettingAccessorInternal *settingsAccessor;
IAccountInfoAccessorInternal *accountInfoAccessor;
ITimeAccessorInternal *timeAccessor;
IKillerNotificationTransferRecordManagerInternal *killerNotificationTransferRecordManager;
void *vtable;
} KillerNotificationSelectorInternal;
WUT_CHECK_SIZE(KillerNotificationSelectorInternal, 0x24);
WUT_CHECK_OFFSET(KillerNotificationSelectorInternal, 0x00, launchedTitleListAccessor);
WUT_CHECK_OFFSET(KillerNotificationSelectorInternal, 0x04, killerNotificationAccessor);
WUT_CHECK_OFFSET(KillerNotificationSelectorInternal, 0x08, titleListCache);
WUT_CHECK_OFFSET(KillerNotificationSelectorInternal, 0x0C, killerNotificationSerializer);
WUT_CHECK_OFFSET(KillerNotificationSelectorInternal, 0x10, settingsAccessor);
WUT_CHECK_OFFSET(KillerNotificationSelectorInternal, 0x14, accountInfoAccessor);
WUT_CHECK_OFFSET(KillerNotificationSelectorInternal, 0x18, timeAccessor);
WUT_CHECK_OFFSET(KillerNotificationSelectorInternal, 0x1C, killerNotificationTransferRecordManager);
WUT_CHECK_OFFSET(KillerNotificationSelectorInternal, 0x20, vtable);
extern "C" KillerNotificationSelectorInternal *__ct__Q3_2nn2sl26KillerNotificationSelectorFv(KillerNotificationSelectorInternal *);
extern "C" void __dt__Q3_2nn2sl26KillerNotificationSelectorFv(KillerNotificationSelectorInternal *, int);
extern "C" nn::Result Select__Q3_2nn2sl26KillerNotificationSelectorFPQ3_2nn2sl18KillerNotificationPQ3_2nn2sl9TitleInfoPb(KillerNotificationSelectorInternal *, KillerNotification *, TitleInfo *, bool *);
extern "C" void Initialize__Q3_2nn2sl26KillerNotificationSelectorFRQ3_2nn2sl26ILaunchedTitleListAccessorRQ3_2nn2sl27IKillerNotificationAccessorRQ3_2nn2sl14TitleListCacheRQ3_2nn2sl49ISerializer__tm__30_Q3_2nn2sl18KillerNotificationRQ3_2nn2sl16ISettingAccessorRQ3_2nn2sl20IAccountInfoAccessorRQ3_2nn2sl13ITimeAccessorRQ3_2nn2sl40IKillerNotificationTransferRecordManager(
KillerNotificationSelectorInternal *,
ILaunchedTitleListAccessorInternal *,
IKillerNotificationAccessorInternal *,
ITitleListCacheInternal *,
ISerializerInternal *,
ISettingAccessorInternal *,
IAccountInfoAccessorInternal *,
ITimeAccessorInternal *,
IKillerNotificationTransferRecordManagerInternal *);
} // namespace details
class KillerNotificationSelector {
public:
KillerNotificationSelector() : mLaunchedTitleListAccessor(nullptr),
mKillerNotificationAccessor(nullptr),
mTitleListCache(nullptr),
mKillerNotificationSerializer(nullptr),
mSettingAccessor(nullptr),
mAccountInfoAccessor(nullptr),
mTimeAccessor(nullptr),
mKillerNotificationTransferRecordManager(nullptr) {
if (__ct__Q3_2nn2sl26KillerNotificationSelectorFv(&mInstance) != nullptr) {
mLaunchedTitleListAccessor = details::LaunchedTitleListAccessorFromPtr(mInstance.launchedTitleListAccessor);
mKillerNotificationAccessor = details::KillerNotificationAccessorFromPtr(mInstance.killerNotificationAccessor);
mTitleListCache = TitleListCacheFromPtr(mInstance.titleListCache);
mKillerNotificationSerializer = details::SerializerFromPtr<KillerNotification>(mInstance.killerNotificationSerializer);
mSettingAccessor = details::SettingAccessorFromPtr(mInstance.settingsAccessor);
mAccountInfoAccessor = details::AccountInfoAccessorFromPtr(mInstance.accountInfoAccessor);
mTimeAccessor = details::TimeAccessorFromPtr(mInstance.timeAccessor);
mKillerNotificationTransferRecordManager = details::KillerNotificationTransferRecordManagerFromPtr(mInstance.killerNotificationTransferRecordManager);
}
}
~KillerNotificationSelector() {
__dt__Q3_2nn2sl26KillerNotificationSelectorFv(&mInstance, 2);
}
details::ILaunchedTitleListAccessorBase &GetLaunchedTitleListAccessor() {
return mLaunchedTitleListAccessor;
}
details::IKillerNotificationAccessorBase &GetKillerNotificationAccessor() {
return mKillerNotificationAccessor;
}
details::ITitleListCacheBase &GetTitleListCache() {
return mTitleListCache;
}
details::ISerializerBase<KillerNotification> &GetKillerNotificationSerializer() {
return mKillerNotificationSerializer;
}
details::ISettingAccessorBase &GetSettingAccessor() {
return mSettingAccessor;
}
details::IAccountInfoAccessorBase &GetAccountInfoAccessor() {
return mAccountInfoAccessor;
}
details::ITimeAccessorBase &GetTimeAccessor() {
return mTimeAccessor;
}
details::IKillerNotificationTransferRecordManagerBase &GetKillerNotificationTransferRecordManager() {
return mKillerNotificationTransferRecordManager;
}
nn::Result Select(KillerNotification *outKillerNotification, TitleInfo *outKillerNotificationTitle, bool *u1) {
return Select__Q3_2nn2sl26KillerNotificationSelectorFPQ3_2nn2sl18KillerNotificationPQ3_2nn2sl9TitleInfoPb(&mInstance, outKillerNotification, outKillerNotificationTitle, u1);
}
void Initialize(details::ILaunchedTitleListAccessorBase &launchedTitleListAccessor,
details::IKillerNotificationAccessorBase &killerNotificationAccessor,
details::ITitleListCacheBase &titleListCache,
details::ISerializerBase<KillerNotification> &killerNotificationSerializer,
details::ISettingAccessorBase &settingAccessor,
details::IAccountInfoAccessorBase &accountInfoAccessor,
details::ITimeAccessorBase &timeAccessor,
details::IKillerNotificationTransferRecordManagerBase &killerNotificationTransferRecordManager) {
Initialize__Q3_2nn2sl26KillerNotificationSelectorFRQ3_2nn2sl26ILaunchedTitleListAccessorRQ3_2nn2sl27IKillerNotificationAccessorRQ3_2nn2sl14TitleListCacheRQ3_2nn2sl49ISerializer__tm__30_Q3_2nn2sl18KillerNotificationRQ3_2nn2sl16ISettingAccessorRQ3_2nn2sl20IAccountInfoAccessorRQ3_2nn2sl13ITimeAccessorRQ3_2nn2sl40IKillerNotificationTransferRecordManager(
&mInstance,
launchedTitleListAccessor.GetInternal(),
killerNotificationAccessor.GetInternal(),
titleListCache.GetInternal(),
killerNotificationSerializer.GetInternal(),
settingAccessor.GetInternal(),
accountInfoAccessor.GetInternal(),
timeAccessor.GetInternal(),
killerNotificationTransferRecordManager.GetInternal());
mLaunchedTitleListAccessor = details::LaunchedTitleListAccessorFromPtr(launchedTitleListAccessor.GetInternal());
mKillerNotificationAccessor = details::KillerNotificationAccessorFromPtr(killerNotificationAccessor.GetInternal());
mTitleListCache = TitleListCacheFromPtr(titleListCache.GetInternal());
mKillerNotificationSerializer = details::SerializerFromPtr<KillerNotification>(killerNotificationSerializer.GetInternal());
mSettingAccessor = details::SettingAccessorFromPtr(settingAccessor.GetInternal());
mAccountInfoAccessor = details::AccountInfoAccessorFromPtr(accountInfoAccessor.GetInternal());
mTimeAccessor = details::TimeAccessorFromPtr(timeAccessor.GetInternal());
mKillerNotificationTransferRecordManager = details::KillerNotificationTransferRecordManagerFromPtr(killerNotificationTransferRecordManager.GetInternal());
}
private:
details::KillerNotificationSelectorInternal mInstance = {};
details::LaunchedTitleListAccessorFromPtr mLaunchedTitleListAccessor;
details::KillerNotificationAccessorFromPtr mKillerNotificationAccessor;
TitleListCacheFromPtr mTitleListCache;
details::SerializerFromPtr<KillerNotification> mKillerNotificationSerializer;
details::SettingAccessorFromPtr mSettingAccessor;
details::AccountInfoAccessorFromPtr mAccountInfoAccessor;
details::TimeAccessorFromPtr mTimeAccessor;
details::KillerNotificationTransferRecordManagerFromPtr mKillerNotificationTransferRecordManager;
};
} // namespace nn::sl
#endif

188
include/nn/sl/KillerNotificationTransferRecordManager.h Normal file
View File

@ -0,0 +1,188 @@
#pragma once
#include <nn/result.h>
#include <nn/sl/FileStream.h>
#include <nn/sl/details/IKillerNotificationTransferRecordManagerDetails.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
class IKillerNotificationTransferRecordManager : public details::IKillerNotificationTransferRecordManagerBase {
public:
IKillerNotificationTransferRecordManager() {
InitInternalVtable();
}
IKillerNotificationTransferRecordManager(IKillerNotificationTransferRecordManager &src) {
InitInternalVtable();
}
IKillerNotificationTransferRecordManager &operator=(const IKillerNotificationTransferRecordManager &other) {
InitInternalVtable();
return *this;
}
IKillerNotificationTransferRecordManager &operator=(IKillerNotificationTransferRecordManager &&src) noexcept {
InitInternalVtable();
return *this;
}
~IKillerNotificationTransferRecordManager() override = default;
private:
static nn::Result LoadWrapper(details::IKillerNotificationTransferRecordManagerInternal *instance, nn::sl::details::IStreamInternal *stream) {
return instance->vtable->instance->Load(*stream->vtable->instance);
}
static nn::Result LoadInitialWrapper(details::IKillerNotificationTransferRecordManagerInternal *instance) {
return instance->vtable->instance->LoadInitial();
}
static nn::Result StoreWrapper(details::IKillerNotificationTransferRecordManagerInternal *instance, nn::sl::details::IStreamInternal *stream) {
return instance->vtable->instance->Store(*stream->vtable->instance);
}
static uint32_t GetRecordCountWrapper(details::IKillerNotificationTransferRecordManagerInternal *instance) {
return instance->vtable->instance->GetRecordCount();
}
static uint32_t GetRecordsWrapper(details::IKillerNotificationTransferRecordManagerInternal *instance, KillerNotificationTransferRecord *u1, uint32_t u2) {
return instance->vtable->instance->GetRecords(u1, u2);
}
static void RegisterRecordsWrapper(details::IKillerNotificationTransferRecordManagerInternal *instance, const KillerNotificationTransferRecord *u1, uint32_t u2) {
return instance->vtable->instance->RegisterRecords(u1, u2);
}
static nn::Result RegisterRecordsOtherWrapper(details::IKillerNotificationTransferRecordManagerInternal *instance, const uint32_t *u1, uint32_t u2) {
return instance->vtable->instance->RegisterRecords(u1, u2);
}
details::IKillerNotificationTransferRecordManagerInternal *GetInternal() override {
return &mInstance;
}
void InitInternalVtable() {
mVTable = {.instance = this,
.LoadFn = &LoadWrapper,
.LoadInitialFn = &LoadInitialWrapper,
.StoreFn = &StoreWrapper,
.GetRecordsFn = &GetRecordsWrapper,
.RegisterRecordsFn = &RegisterRecordsWrapper,
.RegisterRecordsOtherFn = &RegisterRecordsOtherWrapper};
mInstance.vtable = &mVTable;
}
details::IKillerNotificationTransferRecordManagerInternal mInstance{};
details::IKillerNotificationTransferRecordManagerInternalVTable mVTable{};
};
class KillerNotificationTransferRecordManager : public details::IKillerNotificationTransferRecordManagerBase {
public:
KillerNotificationTransferRecordManager() {
__ct__Q3_2nn2sl39KillerNotificationTransferRecordManagerFv(&mInstance);
}
~KillerNotificationTransferRecordManager() override {
__dt__Q3_2nn2sl39KillerNotificationTransferRecordManagerFv(&mInstance, 2);
}
void Finalize() override {
Finalize__Q3_2nn2sl39KillerNotificationTransferRecordManagerFv(&mInstance);
}
nn::Result Load(nn::sl::details::IStreamBase &stream) override {
return Load__Q3_2nn2sl39KillerNotificationTransferRecordManagerFRQ3_2nn2sl7IStream(&mInstance, stream.GetInternal());
}
nn::Result LoadInitial() override {
return LoadInitial__Q3_2nn2sl39KillerNotificationTransferRecordManagerFv(&mInstance);
}
nn::Result Store(nn::sl::details::IStreamBase &stream) override {
return Store__Q3_2nn2sl39KillerNotificationTransferRecordManagerCFRQ3_2nn2sl7IStream(&mInstance, stream.GetInternal());
}
uint32_t GetRecordCount() const override {
return GetRecordCount__Q3_2nn2sl39KillerNotificationTransferRecordManagerCFv((details::IKillerNotificationTransferRecordManagerInternal *) &mInstance);
}
uint32_t GetRecords(KillerNotificationTransferRecord *u1, uint32_t u2) const override {
return GetRecords__Q3_2nn2sl39KillerNotificationTransferRecordManagerCFPQ3_2nn2sl32KillerNotificationTransferRecordUi((details::IKillerNotificationTransferRecordManagerInternal *) &mInstance, u1, u2);
}
void RegisterRecords(const KillerNotificationTransferRecord *u1, uint32_t u2) override {
RegisterRecords__Q3_2nn2sl39KillerNotificationTransferRecordManagerFPCQ3_2nn2sl32KillerNotificationTransferRecordUi(&mInstance, u1, u2);
}
nn::Result RegisterRecords(const uint32_t *u1, uint32_t u2) override {
return mInstance.vtable->RegisterRecordsOtherFn(&mInstance, u1, u2);
}
private:
details::IKillerNotificationTransferRecordManagerInternal *GetInternal() override {
return &mInstance;
}
details::IKillerNotificationTransferRecordManagerInternal mInstance = {};
};
class KillerNotificationTransferRecordManagerInternal : public details::IKillerNotificationTransferRecordManagerBase {
public:
KillerNotificationTransferRecordManagerInternal() {
__ct__Q3_2nn2sl47KillerNotificationTransferRecordManagerInternalFv(&mInstance);
}
~KillerNotificationTransferRecordManagerInternal() override {
__dt__Q3_2nn2sl47KillerNotificationTransferRecordManagerInternalFv(&mInstance, 2);
}
nn::Result Load(nn::sl::details::IStreamBase &stream) override {
auto *base = reinterpret_cast<details::IKillerNotificationTransferRecordManagerInternal *>(&mInstance);
return mInstance.vtable->LoadFn(base, stream.GetInternal());
}
nn::Result LoadInitial() override {
auto *base = reinterpret_cast<details::IKillerNotificationTransferRecordManagerInternal *>(&mInstance);
return mInstance.vtable->LoadInitialFn(base);
}
nn::Result Store(nn::sl::details::IStreamBase &stream) override {
auto *base = reinterpret_cast<details::IKillerNotificationTransferRecordManagerInternal *>(&mInstance);
return mInstance.vtable->StoreFn(base, stream.GetInternal());
}
void Finalize() override {
auto *base = reinterpret_cast<details::IKillerNotificationTransferRecordManagerInternal *>(&mInstance);
return mInstance.vtable->FinalizeFn(base);
}
uint32_t GetRecordCount() const override {
auto *base = (details::IKillerNotificationTransferRecordManagerInternal *) (&mInstance);
return mInstance.vtable->GetRecordCountFn(base);
}
uint32_t GetRecords(KillerNotificationTransferRecord *u1, uint32_t u2) const override {
auto *base = (details::IKillerNotificationTransferRecordManagerInternal *) (&mInstance);
return mInstance.vtable->GetRecordsFn(base, u1, u2);
}
void RegisterRecords(const KillerNotificationTransferRecord *u1, uint32_t u2) override {
auto *base = reinterpret_cast<details::IKillerNotificationTransferRecordManagerInternal *>(&mInstance);
return mInstance.vtable->RegisterRecordsFn(base, u1, u2);
}
nn::Result RegisterRecords(const uint32_t *u1, uint32_t u2) override {
auto *base = reinterpret_cast<details::IKillerNotificationTransferRecordManagerInternal *>(&mInstance);
return mInstance.vtable->RegisterRecordsOtherFn(base, u1, u2);
}
private:
details::KillerNotificationTransferRecordManagerInternalInternal mInstance = {};
};
details::IKillerNotificationTransferRecordManagerBase &GetDefaultKillerNotificationTransferRecordManager();
} // namespace nn::sl
#endif

58
include/nn/sl/KillerNotificationTransferRecordStream.h Normal file
View File

@ -0,0 +1,58 @@
#pragma once
#include <nn/result.h>
#include <nn/sl/FileStream.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
namespace details {
typedef struct WUT_PACKED KillerNotificationTransferRecordStreamInternal {
void *vtable;
FileStreamInternal fileStream;
uint32_t unkn1;
WUT_UNKNOWN_BYTES(0x84);
} KillerNotificationTransferRecordStreamInternal;
WUT_CHECK_SIZE(KillerNotificationTransferRecordStreamInternal, 0x9C);
WUT_CHECK_OFFSET(KillerNotificationTransferRecordStreamInternal, 0x00, vtable);
WUT_CHECK_OFFSET(KillerNotificationTransferRecordStreamInternal, 0x04, fileStream);
WUT_CHECK_OFFSET(KillerNotificationTransferRecordStreamInternal, 0x14, unkn1);
} // namespace details
class KillerNotificationTransferRecordStream : public nn::sl::details::IStreamBase {
public:
explicit KillerNotificationTransferRecordStream(details::KillerNotificationTransferRecordStreamInternal *instance) : mInstance(instance) {
}
nn::Result Read(uint32_t *bytesRead, void *buffer, uint32_t readSize) override {
auto *base = reinterpret_cast<details::IStreamInternal *>(&mInstance);
return base->vtable->ReadFn(base, bytesRead, buffer, readSize);
}
nn::Result Write(uint32_t *bytesWritten, void *buffer, uint32_t readSize) override {
auto *base = reinterpret_cast<details::IStreamInternal *>(&mInstance);
return base->vtable->WriteFn(base, bytesWritten, buffer, readSize);
}
nn::Result GetSize(uint32_t *fileSize) override {
auto *base = reinterpret_cast<details::IStreamInternal *>(&mInstance);
return base->vtable->GetSizeFn(base, fileSize);
}
nn::Result Seek(int32_t offset, nn::sl::SeekOrigin seekOrigin) override {
auto *base = reinterpret_cast<details::IStreamInternal *>(&mInstance);
return base->vtable->SeekFn(base, offset, seekOrigin);
}
~KillerNotificationTransferRecordStream() override = default;
details::IStreamInternal *GetInternal() override {
return reinterpret_cast<details::IStreamInternal *>(mInstance);
}
private:
details::KillerNotificationTransferRecordStreamInternal *mInstance = {};
};
nn::sl::details::IStreamBase &GetDefaultKillerNotificationTransferRecordStream();
} // namespace nn::sl
#endif

176
include/nn/sl/LaunchInfoDatabase.h
View File

@ -1,49 +1,155 @@
#pragma once
#include <wut.h>
#include <nn/result.h>
#include "FileStream.h"
#ifdef __cplusplus
namespace nn {
#include <nn/result.h>
#include <nn/sl/FileStream.h>
#include <nn/sl/sl_cpp.h>
#include <optional>
#include <wut.h>
namespace sl {
typedef struct WUT_PACKED LaunchInfoDatabaseInternal {
WUT_UNKNOWN_BYTES(0x1C);
} LaunchInfoDatabaseInternal;
WUT_CHECK_SIZE(LaunchInfoDatabaseInternal, 0x1C);
namespace nn::sl {
namespace details {
typedef struct WUT_PACKED LaunchInfoDatabaseInternal {
uint64_t *currentIdPtr;
uint32_t *entryCountPtr;
uint32_t *maxEntriesPtr;
void *pDatabase;
LaunchInfoDatabaseEntry *entriesPtr;
LaunchInfoDatabaseEntry *systemTablePtr;
uint32_t systemTableNum;
} LaunchInfoDatabaseInternal;
WUT_CHECK_SIZE(LaunchInfoDatabaseInternal, 0x1C);
WUT_CHECK_OFFSET(LaunchInfoDatabaseInternal, 0x00, currentIdPtr);
WUT_CHECK_OFFSET(LaunchInfoDatabaseInternal, 0x04, entryCountPtr);
WUT_CHECK_OFFSET(LaunchInfoDatabaseInternal, 0x08, maxEntriesPtr);
WUT_CHECK_OFFSET(LaunchInfoDatabaseInternal, 0x0C, pDatabase);
WUT_CHECK_OFFSET(LaunchInfoDatabaseInternal, 0x10, entriesPtr);
WUT_CHECK_OFFSET(LaunchInfoDatabaseInternal, 0x14, systemTablePtr);
WUT_CHECK_OFFSET(LaunchInfoDatabaseInternal, 0x18, systemTableNum);
extern "C" LaunchInfoDatabaseInternal *__ct__Q3_2nn2sl18LaunchInfoDatabaseFv(LaunchInfoDatabaseInternal *);
extern "C" nn::Result Load__Q3_2nn2sl18LaunchInfoDatabaseFRQ3_2nn2sl7IStreamQ3_2nn2sl6Region(LaunchInfoDatabaseInternal *, nn::sl::FileStreamInternal *, nn::sl::Region);
extern "C" void Finalize__Q3_2nn2sl18LaunchInfoDatabaseFv(LaunchInfoDatabaseInternal *);
extern "C" nn::Result GetLaunchInfoById__Q3_2nn2sl18LaunchInfoDatabaseCFPQ3_2nn2sl10LaunchInfoUL(LaunchInfoDatabaseInternal *, nn::sl::LaunchInfo *, uint64_t titleId);
extern "C" LaunchInfoDatabaseInternal *__ct__Q3_2nn2sl18LaunchInfoDatabaseFv(LaunchInfoDatabaseInternal *);
extern "C" nn::Result Store__Q3_2nn2sl18LaunchInfoDatabaseCFRQ3_2nn2sl7IStream(LaunchInfoDatabaseInternal *, nn::sl::details::IStreamInternal *);
extern "C" nn::Result Load__Q3_2nn2sl18LaunchInfoDatabaseFRQ3_2nn2sl7IStreamQ3_2nn2sl6Region(LaunchInfoDatabaseInternal *, nn::sl::details::IStreamInternal *, nn::sl::Region);
extern "C" nn::Result LoadInitial__Q3_2nn2sl18LaunchInfoDatabaseFUiQ3_2nn2sl6Region(LaunchInfoDatabaseInternal *, int, nn::sl::Region);
extern "C" nn::Result GetLaunchInfoById__Q3_2nn2sl18LaunchInfoDatabaseCFPQ3_2nn2sl10LaunchInfoUL(LaunchInfoDatabaseInternal *, nn::sl::LaunchInfo *, uint64_t titleId);
extern "C" void Finalize__Q3_2nn2sl18LaunchInfoDatabaseFv(LaunchInfoDatabaseInternal *);
extern "C" uint32_t GetEntryCount__Q3_2nn2sl18LaunchInfoDatabaseCFv(LaunchInfoDatabaseInternal *);
extern "C" void Clear__Q3_2nn2sl18LaunchInfoDatabaseFv(LaunchInfoDatabaseInternal *);
extern "C" uint64_t GetCurrentId__Q3_2nn2sl18LaunchInfoDatabaseCFv(LaunchInfoDatabaseInternal *);
extern "C" uint64_t Register__Q3_2nn2sl18LaunchInfoDatabaseFRCQ3_2nn2sl10LaunchInfo(LaunchInfoDatabaseInternal *, const nn::sl::LaunchInfo &);
extern "C" nn::Result Unregister__Q3_2nn2sl18LaunchInfoDatabaseFUL(LaunchInfoDatabaseInternal *, uint64_t);
extern "C" nn::Result __CPR84__LoadInitial__Q3_2nn2sl18LaunchInfoDatabaseFUiPCQ4_2nn2slJ22J5EntryT1(LaunchInfoDatabaseInternal *, uint32_t max_entries, nn::sl::LaunchInfoDatabaseEntry *defaultEntries, uint32_t defaultEntryNum);
extern "C" uint32_t __CPR86__ListLaunchInfos__Q3_2nn2sl18LaunchInfoDatabaseCFPQ4_2nn2slJ26J5EntryUi(LaunchInfoDatabaseInternal *, nn::sl::LaunchInfoDatabaseEntry *entriesOut, uint32_t num);
extern "C" nn::Result __CPR93__Load__Q3_2nn2sl18LaunchInfoDatabaseFRQ3_2nn2sl7IStreamPCQ4_2nn2slJ15J5EntryUi(LaunchInfoDatabaseInternal *, details::IStreamInternal *stream, nn::sl::LaunchInfoDatabaseEntry *defaultEntries, uint32_t defaultEntryNum);
} // namespace details
class LaunchInfoDatabase {
public:
LaunchInfoDatabase() {
instance = __ct__Q3_2nn2sl18LaunchInfoDatabaseFv(nullptr);
}
class LaunchInfoDatabase {
public:
LaunchInfoDatabase() {
__ct__Q3_2nn2sl18LaunchInfoDatabaseFv(&mInstance);
}
~LaunchInfoDatabase() {
Finalize__Q3_2nn2sl18LaunchInfoDatabaseFv(instance);
}
~LaunchInfoDatabase() {
Finalize();
}
nn::Result Load(nn::sl::FileStream *fileStream, nn::sl::Region region) {
return Load__Q3_2nn2sl18LaunchInfoDatabaseFRQ3_2nn2sl7IStreamQ3_2nn2sl6Region(instance, fileStream->instance, region);
}
void Finalize() {
// Only actually call finalize if the database is still loaded, otherwise we might trigger an assertion.
if (mInstance.pDatabase != nullptr) {
Finalize__Q3_2nn2sl18LaunchInfoDatabaseFv(&mInstance);
}
}
nn::Result GetLaunchInfoById(nn::sl::LaunchInfo *launchInfo, uint64_t titleId) {
return GetLaunchInfoById__Q3_2nn2sl18LaunchInfoDatabaseCFPQ3_2nn2sl10LaunchInfoUL(instance, launchInfo, titleId);
}
nn::Result Load(nn::sl::details::IStreamBase &fileStream, nn::sl::Region region) {
if (mInstance.pDatabase != nullptr) { // Avoid triggering an assertion
return {Result::LEVEL_FATAL, Result::RESULT_MODULE_NN_SL, 0};
}
return Load__Q3_2nn2sl18LaunchInfoDatabaseFRQ3_2nn2sl7IStreamQ3_2nn2sl6Region(&mInstance, fileStream.GetInternal(), region);
}
private:
LaunchInfoDatabaseInternal *instance;
};
} //namespace sl
nn::Result Store(nn::sl::details::IStreamBase &fileStream) {
if (mInstance.pDatabase == nullptr) { // Avoid triggering an assertion
return {Result::LEVEL_FATAL, Result::RESULT_MODULE_NN_SL, 0};
}
return Store__Q3_2nn2sl18LaunchInfoDatabaseCFRQ3_2nn2sl7IStream(&mInstance, fileStream.GetInternal());
}
} //namespace nn
nn::Result LoadInitial(int maxEntries, nn::sl::Region region) {
if (mInstance.pDatabase != nullptr) { // Avoid triggering an assertion
return {Result::LEVEL_FATAL, Result::RESULT_MODULE_NN_SL, 0};
}
return LoadInitial__Q3_2nn2sl18LaunchInfoDatabaseFUiQ3_2nn2sl6Region(&mInstance, maxEntries, region);
}
nn::Result GetLaunchInfoById(nn::sl::LaunchInfo *launchInfo, uint64_t titleId) const {
if (mInstance.pDatabase == nullptr) { // Avoid triggering an assertion
return {Result::LEVEL_FATAL, Result::RESULT_MODULE_NN_SL, 0};
}
return GetLaunchInfoById__Q3_2nn2sl18LaunchInfoDatabaseCFPQ3_2nn2sl10LaunchInfoUL((details::LaunchInfoDatabaseInternal *) &mInstance, launchInfo, titleId);
}
[[nodiscard]] std::optional<uint32_t> GetEntryCount() const {
if (mInstance.pDatabase == nullptr) { // Avoid triggering an assertion
return {};
}
return details::GetEntryCount__Q3_2nn2sl18LaunchInfoDatabaseCFv((details::LaunchInfoDatabaseInternal *) &mInstance);
}
[[nodiscard]] std::optional<uint64_t> GetCurrentId() const {
if (mInstance.pDatabase == nullptr) { // Avoid triggering an assertion
return {};
}
return details::GetCurrentId__Q3_2nn2sl18LaunchInfoDatabaseCFv((details::LaunchInfoDatabaseInternal *) &mInstance);
}
[[nodiscard]] std::optional<uint64_t> Register(const nn::sl::LaunchInfo &launchInfo) {
if (mInstance.pDatabase == nullptr) { // Avoid triggering an assertion
return {};
}
return details::Register__Q3_2nn2sl18LaunchInfoDatabaseFRCQ3_2nn2sl10LaunchInfo((details::LaunchInfoDatabaseInternal *) &mInstance, launchInfo);
}
[[nodiscard]] nn::Result Unregister(const nn::sl::LaunchInfo &launchInfo, uint64_t id) {
if (mInstance.pDatabase == nullptr) { // Avoid triggering an assertion
return {Result::LEVEL_FATAL, Result::RESULT_MODULE_NN_SL, 0};
}
return details::Unregister__Q3_2nn2sl18LaunchInfoDatabaseFUL((details::LaunchInfoDatabaseInternal *) &mInstance, id);
}
void Clear() {
if (mInstance.pDatabase == nullptr) { // Avoid triggering an assertion
return;
}
return details::Clear__Q3_2nn2sl18LaunchInfoDatabaseFv(&mInstance);
}
static nn::Result LoadInitial(LaunchInfoDatabase &launchDatabase, uint32_t maxEntries, nn::sl::LaunchInfoDatabaseEntry *defaultEntries, uint32_t defaultEntryNum) {
if (launchDatabase.mInstance.pDatabase != nullptr) { // Avoid triggering an assertion
return {Result::LEVEL_FATAL, Result::RESULT_MODULE_NN_SL, 0};
}
return details::__CPR84__LoadInitial__Q3_2nn2sl18LaunchInfoDatabaseFUiPCQ4_2nn2slJ22J5EntryT1(&launchDatabase.mInstance, maxEntries, defaultEntries, defaultEntryNum);
}
static uint32_t ListLaunchInfos(const LaunchInfoDatabase &launchDatabase, nn::sl::LaunchInfoDatabaseEntry *entriesOut, uint32_t num) {
if (launchDatabase.mInstance.pDatabase == nullptr) { // Avoid triggering an assertion
return 0;
}
return details::__CPR86__ListLaunchInfos__Q3_2nn2sl18LaunchInfoDatabaseCFPQ4_2nn2slJ26J5EntryUi((details::LaunchInfoDatabaseInternal *) &launchDatabase.mInstance, entriesOut, num);
}
static nn::Result Load(LaunchInfoDatabase &launchDatabase, nn::sl::details::IStreamBase &fileStream, nn::sl::LaunchInfoDatabaseEntry *defaultEntries, uint32_t defaultEntryNum) {
if (launchDatabase.mInstance.pDatabase != nullptr) { // Avoid triggering an assertion
return {Result::LEVEL_FATAL, Result::RESULT_MODULE_NN_SL, 0};
}
return details::__CPR93__Load__Q3_2nn2sl18LaunchInfoDatabaseFRQ3_2nn2sl7IStreamPCQ4_2nn2slJ15J5EntryUi(&launchDatabase.mInstance, fileStream.GetInternal(), defaultEntries, defaultEntryNum);
}
private:
details::LaunchInfoDatabaseInternal mInstance = {};
};
} // namespace nn::sl
#endif

127
include/nn/sl/QuickStartApplicationSelector.h Normal file
View File

@ -0,0 +1,127 @@
#pragma once
#include <nn/result.h>
#include <nn/sl/IBlackListAccessor.h>
#include <nn/sl/IDefaultTitleAccessor.h>
#include <nn/sl/IPreferentialTitleAccessor.h>
#include <nn/sl/ISettingAccessor.h>
#include <nn/sl/IWhiteListAccessor.h>
#include <nn/sl/TitleListCache.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
namespace details {
typedef struct WUT_PACKED QuickStartApplicationSelectorInternal {
IPreferentialTitleAccessorInternal *preferentialTitleAccessor;
IDefaultTitleAccessorInternal *defaultTitleAccessor;
IWhiteListAccessorInternal *whiteListAccessor;
ITitleListCacheInternal *titleListCache;
ISettingAccessorInternal *settingsAccessor;
IBlackListAccessorInternal *blackListAccessor;
void *vtable;
} QuickStartApplicationSelectorInternal;
WUT_CHECK_SIZE(QuickStartApplicationSelectorInternal, 0x1C);
WUT_CHECK_OFFSET(QuickStartApplicationSelectorInternal, 0x00, preferentialTitleAccessor);
WUT_CHECK_OFFSET(QuickStartApplicationSelectorInternal, 0x04, defaultTitleAccessor);
WUT_CHECK_OFFSET(QuickStartApplicationSelectorInternal, 0x08, whiteListAccessor);
WUT_CHECK_OFFSET(QuickStartApplicationSelectorInternal, 0x0C, titleListCache);
WUT_CHECK_OFFSET(QuickStartApplicationSelectorInternal, 0x10, settingsAccessor);
WUT_CHECK_OFFSET(QuickStartApplicationSelectorInternal, 0x14, blackListAccessor);
WUT_CHECK_OFFSET(QuickStartApplicationSelectorInternal, 0x18, vtable);
extern "C" QuickStartApplicationSelectorInternal *__ct__Q3_2nn2sl29QuickStartApplicationSelectorFv(QuickStartApplicationSelectorInternal *);
extern "C" nn::Result Select__Q3_2nn2sl29QuickStartApplicationSelectorFPQ3_2nn2sl9TitleInfoi(QuickStartApplicationSelectorInternal *, nn::sl::TitleInfo *, int);
extern "C" void Initialize__Q3_2nn2sl29QuickStartApplicationSelectorFRQ3_2nn2sl26IPreferentialTitleAccessorRQ3_2nn2sl21IDefaultTitleAccessorRQ3_2nn2sl18IWhiteListAccessorRQ3_2nn2sl14TitleListCacheRQ3_2nn2sl16ISettingAccessorRQ3_2nn2sl18IBlackListAccessor(
QuickStartApplicationSelectorInternal *,
IPreferentialTitleAccessorInternal *,
IDefaultTitleAccessorInternal *,
IWhiteListAccessorInternal *,
ITitleListCacheInternal *,
ISettingAccessorInternal *,
details::IBlackListAccessorInternal *);
} // namespace details
class QuickStartApplicationSelector {
public:
QuickStartApplicationSelector() : mPreferentialTitleAccessorFromPtr(nullptr),
mDefaultTitleAccessorFromPtr(nullptr),
mWhiteListAccessorFromPtr(nullptr),
mTitleListCacheFromPtr(nullptr),
mSettingAccessorFromPtr(nullptr),
mBlackListAccessorFromPtr(nullptr) {
if (__ct__Q3_2nn2sl29QuickStartApplicationSelectorFv(&mInstance) != nullptr) {
mPreferentialTitleAccessorFromPtr = details::PreferentialTitleAccessorFromPtr(mInstance.preferentialTitleAccessor);
mDefaultTitleAccessorFromPtr = details::DefaultTitleAccessorFromPtr(mInstance.defaultTitleAccessor);
mWhiteListAccessorFromPtr = details::WhiteListAccessorFromPtr(mInstance.whiteListAccessor);
mTitleListCacheFromPtr = TitleListCacheFromPtr(mInstance.titleListCache);
mSettingAccessorFromPtr = details::SettingAccessorFromPtr(mInstance.settingsAccessor);
mBlackListAccessorFromPtr = details::BlackListAccessorFromPtr(mInstance.blackListAccessor);
}
}
~QuickStartApplicationSelector() = default;
details::IPreferentialTitleAccessorBase &GetPreferentialTitleAccessor() {
return mPreferentialTitleAccessorFromPtr;
}
details::IDefaultTitleAccessorBase &GetDefaultTitleAccessor() {
return mDefaultTitleAccessorFromPtr;
}
details::IWhiteListAccessorBase &GetWhiteListAccessor() {
return mWhiteListAccessorFromPtr;
}
details::ITitleListCacheBase &GetTitleListCache() {
return mTitleListCacheFromPtr;
}
details::ISettingAccessorBase &GetSettingAccessor() {
return mSettingAccessorFromPtr;
}
details::IBlackListAccessorBase &GetBlackListAccessor() {
return mBlackListAccessorFromPtr;
}
nn::Result Select(nn::sl::TitleInfo *titleInfos, int num) {
return Select__Q3_2nn2sl29QuickStartApplicationSelectorFPQ3_2nn2sl9TitleInfoi(&mInstance, titleInfos, num);
}
void Initialize(details::IPreferentialTitleAccessorBase &preferentialTitleAccessor,
details::IDefaultTitleAccessorBase &defaultTitleAccessor,
details::IWhiteListAccessorBase &whiteListAccessor,
details::ITitleListCacheBase &titleListCache,
details::ISettingAccessorBase &settingAccessor,
details::IBlackListAccessorBase &blackListAccessor) {
Initialize__Q3_2nn2sl29QuickStartApplicationSelectorFRQ3_2nn2sl26IPreferentialTitleAccessorRQ3_2nn2sl21IDefaultTitleAccessorRQ3_2nn2sl18IWhiteListAccessorRQ3_2nn2sl14TitleListCacheRQ3_2nn2sl16ISettingAccessorRQ3_2nn2sl18IBlackListAccessor(
&mInstance,
preferentialTitleAccessor.GetInternal(),
defaultTitleAccessor.GetInternal(),
whiteListAccessor.GetInternal(),
titleListCache.GetInternal(),
settingAccessor.GetInternal(),
blackListAccessor.GetInternal());
mPreferentialTitleAccessorFromPtr = details::PreferentialTitleAccessorFromPtr(preferentialTitleAccessor.GetInternal());
mDefaultTitleAccessorFromPtr = details::DefaultTitleAccessorFromPtr(defaultTitleAccessor.GetInternal());
mWhiteListAccessorFromPtr = details::WhiteListAccessorFromPtr(whiteListAccessor.GetInternal());
mTitleListCacheFromPtr = TitleListCacheFromPtr(titleListCache.GetInternal());
mSettingAccessorFromPtr = details::SettingAccessorFromPtr(settingAccessor.GetInternal());
mBlackListAccessorFromPtr = details::BlackListAccessorFromPtr(blackListAccessor.GetInternal());
}
private:
details::QuickStartApplicationSelectorInternal mInstance = {};
details::PreferentialTitleAccessorFromPtr mPreferentialTitleAccessorFromPtr;
details::DefaultTitleAccessorFromPtr mDefaultTitleAccessorFromPtr;
details::WhiteListAccessorFromPtr mWhiteListAccessorFromPtr;
TitleListCacheFromPtr mTitleListCacheFromPtr;
details::SettingAccessorFromPtr mSettingAccessorFromPtr;
details::BlackListAccessorFromPtr mBlackListAccessorFromPtr;
};
} // namespace nn::sl
#endif

100
include/nn/sl/TitleIconCache.h Normal file
View File

@ -0,0 +1,100 @@
#pragma once
#ifdef __cplusplus
#include <nn/sl/details/IIconInfoAccessorDetails.h>
#include <nn/sl/details/ISerializerDetails.h>
#include <nn/sl/details/ISettingAccessorDetails.h>
#include <nn/sl/details/ITitleIconCacheDetails.h>
namespace nn::sl {
namespace details {
typedef struct WUT_PACKED TitleIconCacheInternal {
void *vtable;
uint32_t num;
void *cachedIconsBuffer;
IIconInfoAccessorInternal *iconInfoAccessor;
ISerializerInternal *iconInfoSerializer;
ISettingAccessorInternal *settingAccessor;
} TitleIconCacheInternal;
WUT_CHECK_SIZE(TitleIconCacheInternal, 0x18);
WUT_CHECK_OFFSET(TitleIconCacheInternal, 0x00, vtable);
WUT_CHECK_OFFSET(TitleIconCacheInternal, 0x04, num);
WUT_CHECK_OFFSET(TitleIconCacheInternal, 0x08, cachedIconsBuffer);
WUT_CHECK_OFFSET(TitleIconCacheInternal, 0x0C, iconInfoAccessor);
WUT_CHECK_OFFSET(TitleIconCacheInternal, 0x10, iconInfoSerializer);
WUT_CHECK_OFFSET(TitleIconCacheInternal, 0x14, settingAccessor);
extern "C" ITitleIconCacheInternal *__ct__Q3_2nn2sl14TitleIconCacheFv(TitleIconCacheInternal *);
extern "C" ITitleIconCacheInternal *__dt__Q3_2nn2sl14TitleIconCacheFv(TitleIconCacheInternal *, int);
extern "C" void Initialize__Q3_2nn2sl14TitleIconCacheFi(TitleIconCacheInternal *, int);
extern "C" void Initialize__Q3_2nn2sl14TitleIconCacheFiRQ3_2nn2sl17IIconInfoAccessorRQ3_2nn2sl38ISerializer__tm__19_Q3_2nn2sl8IconInfoRQ3_2nn2sl16ISettingAccessor(
TitleIconCacheInternal *,
int,
IIconInfoAccessorInternal *,
ISerializerInternal *,
ISettingAccessorInternal *);
extern "C" void Finalize__Q3_2nn2sl14TitleIconCacheFv(TitleIconCacheInternal *);
extern "C" void Get__Q3_2nn2sl14TitleIconCacheCFPQ3_2nn2sl8IconInfoi(TitleIconCacheInternal *, nn::sl::IconInfo *iconInfos, int num);
extern "C" nn::Result Load__Q3_2nn2sl14TitleIconCacheFv(TitleIconCacheInternal *);
extern "C" nn::Result Update__Q3_2nn2sl14TitleIconCacheFPCQ3_2nn2sl9TitleInfoi(TitleIconCacheInternal *, nn::sl ::TitleInfo *, int);
extern "C" nn::Result Store__Q3_2nn2sl14TitleIconCacheCFv(TitleIconCacheInternal *);
} // namespace details
class TitleIconCache : public details::ITitleIconCacheBase {
public:
TitleIconCache() {
details::__ct__Q3_2nn2sl14TitleIconCacheFv(&mInstance);
}
~TitleIconCache() override {
__dt__Q3_2nn2sl14TitleIconCacheFv(&mInstance, 2);
}
void Initialize(int cacheSize) {
Initialize__Q3_2nn2sl14TitleIconCacheFi(&mInstance, cacheSize);
}
void Initialize(int cacheSize,
details::IIconInfoAccessorBase &iconInfoAccessor,
details::ISerializerBase<nn::sl::IconInfo> &iconInfoSerializer,
details::ISettingAccessorBase &settingAccessor) {
Initialize__Q3_2nn2sl14TitleIconCacheFiRQ3_2nn2sl17IIconInfoAccessorRQ3_2nn2sl38ISerializer__tm__19_Q3_2nn2sl8IconInfoRQ3_2nn2sl16ISettingAccessor(
&mInstance,
cacheSize,
iconInfoAccessor.GetInternal(),
iconInfoSerializer.GetInternal(),
settingAccessor.GetInternal());
}
void Finalize(int cacheSize) {
Finalize__Q3_2nn2sl14TitleIconCacheFv(&mInstance);
}
void Get(nn::sl::IconInfo *iconInfos, int num) const override {
return Get__Q3_2nn2sl14TitleIconCacheCFPQ3_2nn2sl8IconInfoi((details::TitleIconCacheInternal *) &mInstance, iconInfos, num);
}
nn::Result Load() override {
return Load__Q3_2nn2sl14TitleIconCacheFv(&mInstance);
}
nn::Result Update(nn::sl::TitleInfo *titleInfos, int num) override {
return Update__Q3_2nn2sl14TitleIconCacheFPCQ3_2nn2sl9TitleInfoi(&mInstance, titleInfos, num);
}
nn::Result Store() override {
return Store__Q3_2nn2sl14TitleIconCacheCFv(&mInstance);
}
private:
details::ITitleIconCacheInternal *GetInternal() override {
return reinterpret_cast<details::ITitleIconCacheInternal *>(&mInstance);
}
details::TitleIconCacheInternal mInstance{};
};
} // namespace nn::sl
#endif

302
include/nn/sl/TitleListCache.h Normal file
View File

@ -0,0 +1,302 @@
#pragma once
#include <nn/result.h>
#include <nn/sl/IDiscCachedTitleAccessor.h>
#include <nn/sl/IInstalledTitleListAccessor.h>
#include <nn/sl/ILaunchedTitleListAccessor.h>
#include <nn/sl/IMetaInfoAccessor.h>
#include <nn/sl/ISerializer.h>
#include <nn/sl/ITimeAccessor.h>
#include <nn/sl/ITitleListAccessor.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
class QuickStartApplicationSelector;
class KillerNotificationSelector;
namespace details {
typedef struct WUT_PACKED ITitleListCacheInternal {
ITitleListAccessorInternal *titleListAccessor;
ILaunchedTitleListAccessorInternal *launchedTitleListAccessor;
IInstalledTitleListAccessorInternal *installedTitleListAccessor;
IDiscCachedTitleAccessorInternal *discCachedTitleAccessor;
ISerializerInternal *titleInfoSerializer;
ITimeAccessorInternal *timeAccessor;
IMetaInfoAccessorInternal *metaInfoAccessor;
WUT_UNKNOWN_BYTES(0x18);
void *vtable;
} TitleListCacheInternal;
WUT_CHECK_SIZE(ITitleListCacheInternal, 0x38);
WUT_CHECK_OFFSET(ITitleListCacheInternal, 0x00, titleListAccessor);
WUT_CHECK_OFFSET(ITitleListCacheInternal, 0x04, launchedTitleListAccessor);
WUT_CHECK_OFFSET(ITitleListCacheInternal, 0x08, installedTitleListAccessor);
WUT_CHECK_OFFSET(ITitleListCacheInternal, 0x0C, discCachedTitleAccessor);
WUT_CHECK_OFFSET(ITitleListCacheInternal, 0x10, titleInfoSerializer);
WUT_CHECK_OFFSET(ITitleListCacheInternal, 0x14, timeAccessor);
WUT_CHECK_OFFSET(ITitleListCacheInternal, 0x18, metaInfoAccessor);
WUT_CHECK_OFFSET(ITitleListCacheInternal, 0x34, vtable);
extern "C" ITitleListCacheInternal *__ct__Q3_2nn2sl14TitleListCacheFv(ITitleListCacheInternal *);
extern "C" void Finalize__Q3_2nn2sl14TitleListCacheFv(ITitleListCacheInternal *);
extern "C" nn::Result Load__Q3_2nn2sl14TitleListCacheFv(ITitleListCacheInternal *);
extern "C" nn::Result Update__Q3_2nn2sl14TitleListCacheFv(ITitleListCacheInternal *);
extern "C" nn::Result UpdateIfNeeded__Q3_2nn2sl14TitleListCacheFv(ITitleListCacheInternal *);
extern "C" nn::Result Store__Q3_2nn2sl14TitleListCacheFv(ITitleListCacheInternal *);
extern "C" nn::Result Initialize__Q3_2nn2sl14TitleListCacheFiT1(ITitleListCacheInternal *, int, int);
extern "C" void Finalize__Q3_2nn2sl14TitleListCacheFv(ITitleListCacheInternal *);
extern "C" void Initialize__Q3_2nn2sl14TitleListCacheFiN21(
ITitleListCacheInternal *,
int,
int,
int);
extern "C" void Initialize__Q3_2nn2sl14TitleListCacheFiT1RQ3_2nn2sl18ITitleListAccessorRQ3_2nn2sl26ILaunchedTitleListAccessorRQ3_2nn2sl27IInstalledTitleListAccessorRQ3_2nn2sl24IDiscCachedTitleAccessorRQ3_2nn2sl39ISerializer__tm__20_Q3_2nn2sl9TitleInfo(
ITitleListCacheInternal *,
int,
int,
ITitleListAccessorInternal *,
ILaunchedTitleListAccessorInternal *,
IInstalledTitleListAccessorInternal *,
IDiscCachedTitleAccessorInternal *,
ISerializerInternal *);
extern "C" void Initialize__Q3_2nn2sl14TitleListCacheFiN21RQ3_2nn2sl18ITitleListAccessorRQ3_2nn2sl26ILaunchedTitleListAccessorRQ3_2nn2sl27IInstalledTitleListAccessorRQ3_2nn2sl24IDiscCachedTitleAccessorRQ3_2nn2sl39ISerializer__tm__20_Q3_2nn2sl9TitleInfo(
ITitleListCacheInternal *,
int,
int,
int,
ITitleListAccessorInternal *,
ILaunchedTitleListAccessorInternal *,
IInstalledTitleListAccessorInternal *,
IDiscCachedTitleAccessorInternal *,
ISerializerInternal *);
extern "C" void Initialize__Q3_2nn2sl14TitleListCacheFiN21RQ3_2nn2sl18ITitleListAccessorRQ3_2nn2sl26ILaunchedTitleListAccessorRQ3_2nn2sl27IInstalledTitleListAccessorRQ3_2nn2sl24IDiscCachedTitleAccessorRQ3_2nn2sl39ISerializer__tm__20_Q3_2nn2sl9TitleInfoRQ3_2nn2sl13ITimeAccessorRQ3_2nn2sl17IMetaInfoAccessor(
ITitleListCacheInternal *,
int,
int,
int,
ITitleListAccessorInternal *,
ILaunchedTitleListAccessorInternal *,
IInstalledTitleListAccessorInternal *,
IDiscCachedTitleAccessorInternal *,
ISerializerInternal *,
ITimeAccessorInternal *,
IMetaInfoAccessorInternal *);
class ITitleListCacheBase {
friend class nn::sl::QuickStartApplicationSelector;
friend class nn::sl::KillerNotificationSelector;
public:
virtual ~ITitleListCacheBase() = default;
virtual nn::Result Load() = 0;
virtual nn::Result Update() = 0;
virtual nn::Result UpdateIfNeeded() = 0;
virtual nn::Result Store() = 0;
private:
virtual details::ITitleListCacheInternal *GetInternal() = 0;
};
} // namespace details
class TitleListCache final : public details::ITitleListCacheBase {
public:
TitleListCache() : mTitleListAccessor(nullptr),
mLaunchedTitleListAccessor(nullptr),
mInstalledTitleListAccessor(nullptr),
mDiscCachedTitleAccessor(nullptr),
mTitleInfoSerializer(nullptr),
mTimeAccessor(nullptr),
mMetaInfoAccessor(nullptr) {
if (__ct__Q3_2nn2sl14TitleListCacheFv(&mInstance) != nullptr) {
mTitleListAccessor = details::TitleListAccessorFromPtr(mInstance.titleListAccessor);
mLaunchedTitleListAccessor = details::LaunchedTitleListAccessorFromPtr(mInstance.launchedTitleListAccessor);
mInstalledTitleListAccessor = details::InstalledTitleListAccessorFromPtr(mInstance.installedTitleListAccessor);
mDiscCachedTitleAccessor = details::DiscCachedTitleAccessorFromPtr(mInstance.discCachedTitleAccessor);
mTitleInfoSerializer = details::SerializerFromPtr<nn::sl::TitleInfo>(mInstance.titleInfoSerializer);
mTimeAccessor = details::TimeAccessorFromPtr(mInstance.timeAccessor);
mMetaInfoAccessor = details::MetaInfoAccessorFromPtr(mInstance.metaInfoAccessor);
}
}
~TitleListCache() override {
Finalize__Q3_2nn2sl14TitleListCacheFv(&mInstance);
}
details::ITitleListAccessorBase &GetTitleListAccessor() {
return mTitleListAccessor;
}
details::ILaunchedTitleListAccessorBase &GetLaunchedTitleListAccessor() {
return mLaunchedTitleListAccessor;
}
details::IInstalledTitleListAccessorBase &GetInstalledTitleListAccessor() {
return mInstalledTitleListAccessor;
}
details::IDiscCachedTitleAccessorBase &GetDiscCachedTitleAccessor() {
return mDiscCachedTitleAccessor;
}
details::ISerializerBase<nn::sl::TitleInfo> &GetTitleInfoSerializer() {
return mTitleInfoSerializer;
}
details::ITimeAccessorBase &GetTimeAccessor() {
return mTimeAccessor;
}
details::IMetaInfoAccessorBase &GetMetaInfoAccessor() {
return mMetaInfoAccessor;
}
void Initialize(int u1, int num) {
Initialize__Q3_2nn2sl14TitleListCacheFiT1(&mInstance, u1, num);
}
void Initialize(int u1, int num, int u3) {
Initialize__Q3_2nn2sl14TitleListCacheFiN21(&mInstance, u1, num, u3);
}
void Initialize(int u1, int num, int u3,
details::ITitleListAccessorBase &titleListAccessor,
details::ILaunchedTitleListAccessorBase &launchedTitleListAccessor,
details::IInstalledTitleListAccessorBase &installedTitleListAccessor,
details::IDiscCachedTitleAccessorBase &discCachedTitleAccessor,
details::ISerializerBase<nn::sl::TitleInfo> &titleInfoSerializer) {
Initialize__Q3_2nn2sl14TitleListCacheFiN21RQ3_2nn2sl18ITitleListAccessorRQ3_2nn2sl26ILaunchedTitleListAccessorRQ3_2nn2sl27IInstalledTitleListAccessorRQ3_2nn2sl24IDiscCachedTitleAccessorRQ3_2nn2sl39ISerializer__tm__20_Q3_2nn2sl9TitleInfo(
&mInstance, u1, num, u3,
titleListAccessor.GetInternal(),
launchedTitleListAccessor.GetInternal(),
installedTitleListAccessor.GetInternal(),
discCachedTitleAccessor.GetInternal(),
titleInfoSerializer.GetInternal());
mTitleListAccessor = details::TitleListAccessorFromPtr(titleListAccessor.GetInternal());
mLaunchedTitleListAccessor = details::LaunchedTitleListAccessorFromPtr(launchedTitleListAccessor.GetInternal());
mInstalledTitleListAccessor = details::InstalledTitleListAccessorFromPtr(installedTitleListAccessor.GetInternal());
mDiscCachedTitleAccessor = details::DiscCachedTitleAccessorFromPtr(discCachedTitleAccessor.GetInternal());
mTitleInfoSerializer = details::SerializerFromPtr<nn::sl::TitleInfo>(titleInfoSerializer.GetInternal());
mTimeAccessor = details::TimeAccessorFromPtr(mInstance.timeAccessor);
mMetaInfoAccessor = details::MetaInfoAccessorFromPtr(mInstance.metaInfoAccessor);
}
void Initialize(int u1, int num,
details::ITitleListAccessorBase &titleListAccessor,
details::ILaunchedTitleListAccessorBase &launchedTitleListAccessor,
details::IInstalledTitleListAccessorBase &installedTitleListAccessor,
details::IDiscCachedTitleAccessorBase &discCachedTitleAccessor,
details::ISerializerBase<nn::sl::TitleInfo> &titleInfoSerializer) {
Initialize__Q3_2nn2sl14TitleListCacheFiT1RQ3_2nn2sl18ITitleListAccessorRQ3_2nn2sl26ILaunchedTitleListAccessorRQ3_2nn2sl27IInstalledTitleListAccessorRQ3_2nn2sl24IDiscCachedTitleAccessorRQ3_2nn2sl39ISerializer__tm__20_Q3_2nn2sl9TitleInfo(
&mInstance, u1, num,
titleListAccessor.GetInternal(),
launchedTitleListAccessor.GetInternal(),
installedTitleListAccessor.GetInternal(),
discCachedTitleAccessor.GetInternal(),
titleInfoSerializer.GetInternal());
mTitleListAccessor = details::TitleListAccessorFromPtr(titleListAccessor.GetInternal());
mLaunchedTitleListAccessor = details::LaunchedTitleListAccessorFromPtr(launchedTitleListAccessor.GetInternal());
mInstalledTitleListAccessor = details::InstalledTitleListAccessorFromPtr(installedTitleListAccessor.GetInternal());
mDiscCachedTitleAccessor = details::DiscCachedTitleAccessorFromPtr(discCachedTitleAccessor.GetInternal());
mTitleInfoSerializer = details::SerializerFromPtr<nn::sl::TitleInfo>(titleInfoSerializer.GetInternal());
mTimeAccessor = details::TimeAccessorFromPtr(mInstance.timeAccessor);
mMetaInfoAccessor = details::MetaInfoAccessorFromPtr(mInstance.metaInfoAccessor);
}
void Initialize(int u1, int u2, int u3,
details::ITitleListAccessorBase &titleListAccessor,
details::ILaunchedTitleListAccessorBase &launchedTitleListAccessor,
details::IInstalledTitleListAccessorBase &installedTitleListAccessor,
details::IDiscCachedTitleAccessorBase &discCachedTitleAccessor,
details::ISerializerBase<nn::sl::TitleInfo> &titleInfoSerializer,
details::ITimeAccessorBase &timeAccessor,
details::IMetaInfoAccessorBase &metaInfoAccessor) {
Initialize__Q3_2nn2sl14TitleListCacheFiN21RQ3_2nn2sl18ITitleListAccessorRQ3_2nn2sl26ILaunchedTitleListAccessorRQ3_2nn2sl27IInstalledTitleListAccessorRQ3_2nn2sl24IDiscCachedTitleAccessorRQ3_2nn2sl39ISerializer__tm__20_Q3_2nn2sl9TitleInfoRQ3_2nn2sl13ITimeAccessorRQ3_2nn2sl17IMetaInfoAccessor(
&mInstance, u1, u2, u3,
titleListAccessor.GetInternal(),
launchedTitleListAccessor.GetInternal(),
installedTitleListAccessor.GetInternal(),
discCachedTitleAccessor.GetInternal(),
titleInfoSerializer.GetInternal(),
timeAccessor.GetInternal(),
metaInfoAccessor.GetInternal());
mTitleListAccessor = details::TitleListAccessorFromPtr(titleListAccessor.GetInternal());
mLaunchedTitleListAccessor = details::LaunchedTitleListAccessorFromPtr(launchedTitleListAccessor.GetInternal());
mInstalledTitleListAccessor = details::InstalledTitleListAccessorFromPtr(installedTitleListAccessor.GetInternal());
mDiscCachedTitleAccessor = details::DiscCachedTitleAccessorFromPtr(discCachedTitleAccessor.GetInternal());
mTitleInfoSerializer = details::SerializerFromPtr<nn::sl::TitleInfo>(titleInfoSerializer.GetInternal());
mTimeAccessor = details::TimeAccessorFromPtr(timeAccessor.GetInternal());
mMetaInfoAccessor = details::MetaInfoAccessorFromPtr(metaInfoAccessor.GetInternal());
}
void Finalize() {
return Finalize__Q3_2nn2sl14TitleListCacheFv(&mInstance);
}
nn::Result Load() override {
return Load__Q3_2nn2sl14TitleListCacheFv(&mInstance);
}
nn::Result Update() override {
return Update__Q3_2nn2sl14TitleListCacheFv(&mInstance);
}
nn::Result UpdateIfNeeded() override {
return UpdateIfNeeded__Q3_2nn2sl14TitleListCacheFv(&mInstance);
}
nn::Result Store() override {
return Store__Q3_2nn2sl14TitleListCacheFv(&mInstance);
}
private:
details::ITitleListCacheInternal *GetInternal() override {
return &mInstance;
}
details::ITitleListCacheInternal mInstance = {};
details::TitleListAccessorFromPtr mTitleListAccessor;
details::LaunchedTitleListAccessorFromPtr mLaunchedTitleListAccessor;
details::InstalledTitleListAccessorFromPtr mInstalledTitleListAccessor;
details::DiscCachedTitleAccessorFromPtr mDiscCachedTitleAccessor;
details::SerializerFromPtr<nn::sl::TitleInfo> mTitleInfoSerializer;
details::TimeAccessorFromPtr mTimeAccessor;
details::MetaInfoAccessorFromPtr mMetaInfoAccessor;
};
class TitleListCacheFromPtr final : public details::ITitleListCacheBase {
public:
explicit TitleListCacheFromPtr(details::ITitleListCacheInternal *ptr) : mPtrInstance(ptr) {
}
~TitleListCacheFromPtr() override = default;
nn::Result Load() override {
return Load__Q3_2nn2sl14TitleListCacheFv(mPtrInstance);
}
nn::Result Update() override {
return Update__Q3_2nn2sl14TitleListCacheFv(mPtrInstance);
}
nn::Result UpdateIfNeeded() override {
return UpdateIfNeeded__Q3_2nn2sl14TitleListCacheFv(mPtrInstance);
}
nn::Result Store() override {
return Store__Q3_2nn2sl14TitleListCacheFv(mPtrInstance);
}
private:
details::ITitleListCacheInternal *GetInternal() override {
return mPtrInstance;
}
details::ITitleListCacheInternal *mPtrInstance = {};
};
details::ITitleListCacheBase &GetDefaultTitleListCache();
} // namespace nn::sl
#endif

71
include/nn/sl/details/IAccountInfoAccessorDetails.h Normal file
View File

@ -0,0 +1,71 @@
#pragma once
#include <nn/result.h>
#include <nn/sl/sl_cpp.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
class DataCreator;
class KillerNotificationSelector;
namespace details {
class IAccountInfoAccessorBase;
struct IAccountInfoAccessorInternal;
typedef nn::Result (*IAccountInfoAccessor_GetFn)(IAccountInfoAccessorInternal *, nn::sl::AccountInfo *);
struct WUT_PACKED IAccountInfoAccessorInternalVTable {
IAccountInfoAccessorBase *instance; // Is normally padding
uint32_t info;
WUT_PADDING_BYTES(4);
uint32_t destructor;
WUT_PADDING_BYTES(4);
IAccountInfoAccessor_GetFn GetFn;
};
WUT_CHECK_SIZE(IAccountInfoAccessorInternalVTable, 0x18);
WUT_CHECK_OFFSET(IAccountInfoAccessorInternalVTable, 0x00, instance);
WUT_CHECK_OFFSET(IAccountInfoAccessorInternalVTable, 0x14, GetFn);
typedef struct WUT_PACKED IAccountInfoAccessorInternal {
IAccountInfoAccessorInternalVTable *vtable;
} IAccountInfoAccessorInternal;
WUT_CHECK_SIZE(IAccountInfoAccessorInternal, 0x04);
WUT_CHECK_OFFSET(IAccountInfoAccessorInternal, 0x00, vtable);
class IAccountInfoAccessorBase {
friend class nn::sl::DataCreator;
friend class nn::sl::KillerNotificationSelector;
public:
IAccountInfoAccessorBase() = default;
virtual ~IAccountInfoAccessorBase() = default;
virtual nn::Result Get(nn::sl::AccountInfo *) const = 0;
private:
virtual details::IAccountInfoAccessorInternal *GetInternal() = 0;
};
class AccountInfoAccessorFromPtr : public IAccountInfoAccessorBase {
public:
explicit AccountInfoAccessorFromPtr(details::IAccountInfoAccessorInternal *ptr) : mInstancePtr(ptr) {
}
nn::Result Get(nn::sl::AccountInfo *outAccountInfo) const override {
if (!mInstancePtr) {
return {Result::LEVEL_FATAL, Result::RESULT_MODULE_NN_SL, 1};
}
return mInstancePtr->vtable->GetFn(mInstancePtr, outAccountInfo);
}
private:
details::IAccountInfoAccessorInternal *GetInternal() override {
return mInstancePtr;
}
details::IAccountInfoAccessorInternal *mInstancePtr;
};
} // namespace details
} // namespace nn::sl
#endif

72
include/nn/sl/details/IBlackListAccessorDetails.h Normal file
View File

@ -0,0 +1,72 @@
#pragma once
#include <nn/result.h>
#include <nn/sl/sl_cpp.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
class DataCreator;
class QuickStartApplicationSelector;
namespace details {
class IBlackListAccessorBase;
struct IBlackListAccessorInternal;
typedef nn::Result (*IBlackListAccessor_GetFn)(IBlackListAccessorInternal *, TitleInfo *outTitleInfos, int *outTitleInfosSize, int maxTitleInfos);
struct WUT_PACKED IBlackListAccessorInternalVTable {
IBlackListAccessorBase *instance; // normally this is padding
uint32_t info;
WUT_PADDING_BYTES(4);
uint32_t destructor;
WUT_PADDING_BYTES(4);
IBlackListAccessor_GetFn GetFn;
};
WUT_CHECK_SIZE(IBlackListAccessorInternalVTable, 0x18);
WUT_CHECK_OFFSET(IBlackListAccessorInternalVTable, 0x00, instance);
WUT_CHECK_OFFSET(IBlackListAccessorInternalVTable, 0x14, GetFn);
typedef struct WUT_PACKED IBlackListAccessorInternal {
IBlackListAccessorInternalVTable *vtable;
} IBlackListAccessorInternal;
WUT_CHECK_SIZE(IBlackListAccessorInternal, 0x04);
WUT_CHECK_OFFSET(IBlackListAccessorInternal, 0x00, vtable);
class IBlackListAccessorBase {
friend class nn::sl::DataCreator;
friend class nn::sl::QuickStartApplicationSelector;
public:
IBlackListAccessorBase() = default;
virtual ~IBlackListAccessorBase() = default;
virtual nn::Result Get(nn::sl::TitleInfo *outTitleInfos, int *outTitleInfosSize, int maxTitleInfos) const = 0;
private:
virtual details::IBlackListAccessorInternal *GetInternal() = 0;
};
class BlackListAccessorFromPtr : public IBlackListAccessorBase {
public:
explicit BlackListAccessorFromPtr(details::IBlackListAccessorInternal *ptr) : mInstancePtr(ptr) {
}
nn::Result Get(nn::sl::TitleInfo *outTitleInfos, int *outTitleInfosSize, int maxTitleInfos) const override {
if (!mInstancePtr) {
return {Result::LEVEL_FATAL, Result::RESULT_MODULE_NN_SL, 1};
}
return mInstancePtr->vtable->GetFn(mInstancePtr, outTitleInfos, outTitleInfosSize, maxTitleInfos);
}
private:
nn::sl::details::IBlackListAccessorInternal *GetInternal() override {
return mInstancePtr;
}
details::IBlackListAccessorInternal *mInstancePtr;
};
} // namespace details
} // namespace nn::sl
#endif

70
include/nn/sl/details/IDefaultTitleAccessorDetails.h Normal file
View File

@ -0,0 +1,70 @@
#pragma once
#include <nn/result.h>
#include <nn/sl/sl_cpp.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
class QuickStartApplicationSelector;
namespace details {
class IDefaultTitleAccessorBase;
struct IDefaultTitleAccessorInternal;
typedef nn::Result (*IDefaultTitleAccessor_GetFn)(IDefaultTitleAccessorInternal *, TitleInfo *outTitleInfos, int *outTitleInfosSize, int maxTitleInfos);
struct WUT_PACKED IDefaultTitleAccessorInternalVTable {
IDefaultTitleAccessorBase *instance; // normally this is padding
uint32_t info;
WUT_PADDING_BYTES(4);
uint32_t destructor;
WUT_PADDING_BYTES(4);
IDefaultTitleAccessor_GetFn GetFn;
};
WUT_CHECK_SIZE(IDefaultTitleAccessorInternalVTable, 0x18);
WUT_CHECK_OFFSET(IDefaultTitleAccessorInternalVTable, 0x00, instance);
WUT_CHECK_OFFSET(IDefaultTitleAccessorInternalVTable, 0x14, GetFn);
typedef struct WUT_PACKED IDefaultTitleAccessorInternal {
IDefaultTitleAccessorInternalVTable *vtable;
} IDefaultTitleAccessorInternal;
WUT_CHECK_SIZE(IDefaultTitleAccessorInternal, 0x04);
WUT_CHECK_OFFSET(IDefaultTitleAccessorInternal, 0x00, vtable);
class IDefaultTitleAccessorBase {
friend class nn::sl::QuickStartApplicationSelector;
public:
IDefaultTitleAccessorBase() = default;
virtual ~IDefaultTitleAccessorBase() = default;
virtual nn::Result Get(TitleInfo *outTitleInfos, int *outTitleInfosSize, int maxTitleInfos) = 0;
private:
virtual details::IDefaultTitleAccessorInternal *GetInternal() = 0;
};
class DefaultTitleAccessorFromPtr : public IDefaultTitleAccessorBase {
public:
explicit DefaultTitleAccessorFromPtr(details::IDefaultTitleAccessorInternal *ptr) : mInstancePtr(ptr) {
}
nn::Result Get(TitleInfo *outTitleInfos, int *outTitleInfosSize, int maxTitleInfos) override {
if (!mInstancePtr) {
return {Result::LEVEL_FATAL, Result::RESULT_MODULE_NN_SL, 1};
}
return mInstancePtr->vtable->GetFn(mInstancePtr, outTitleInfos, outTitleInfosSize, maxTitleInfos);
}
private:
nn::sl::details::IDefaultTitleAccessorInternal *GetInternal() override {
return mInstancePtr;
}
details::IDefaultTitleAccessorInternal *mInstancePtr;
};
} // namespace details
} // namespace nn::sl
#endif

70
include/nn/sl/details/IDiscCachedTitleAccessorDetails.h Normal file
View File

@ -0,0 +1,70 @@
#pragma once
#include <nn/result.h>
#include <nn/sl/sl_cpp.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
class TitleListCache;
namespace details {
class IDiscCachedTitleAccessorBase;
struct IDiscCachedTitleAccessorInternal;
typedef nn::Result (*IDiscCachedTitleAccessor_GetFn)(IDiscCachedTitleAccessorInternal *, nn::sl::TitleInfo *outTitleInfos, int *outTitleInfosSize, int maxTitleInfos);
struct WUT_PACKED IDiscCachedTitleAccessorInternalVTable {
IDiscCachedTitleAccessorBase *instance; // normally this is padding
uint32_t info;
WUT_PADDING_BYTES(4);
uint32_t destructor;
WUT_PADDING_BYTES(4);
IDiscCachedTitleAccessor_GetFn GetFn;
};
WUT_CHECK_SIZE(IDiscCachedTitleAccessorInternalVTable, 0x18);
WUT_CHECK_OFFSET(IDiscCachedTitleAccessorInternalVTable, 0x00, instance);
WUT_CHECK_OFFSET(IDiscCachedTitleAccessorInternalVTable, 0x14, GetFn);
typedef struct WUT_PACKED IDiscCachedTitleAccessorInternal {
IDiscCachedTitleAccessorInternalVTable *vtable;
} IDiscCachedTitleAccessorInternal;
WUT_CHECK_SIZE(IDiscCachedTitleAccessorInternal, 0x04);
WUT_CHECK_OFFSET(IDiscCachedTitleAccessorInternal, 0x00, vtable);
class IDiscCachedTitleAccessorBase {
friend class nn::sl::TitleListCache;
public:
IDiscCachedTitleAccessorBase() = default;
virtual ~IDiscCachedTitleAccessorBase() = default;
virtual nn::Result Get(nn::sl::TitleInfo *outTitleInfos, int *outTitleInfosSize, int maxTitleInfos) const = 0;
private:
virtual details::IDiscCachedTitleAccessorInternal *GetInternal() = 0;
};
class DiscCachedTitleAccessorFromPtr : public IDiscCachedTitleAccessorBase {
public:
explicit DiscCachedTitleAccessorFromPtr(details::IDiscCachedTitleAccessorInternal *ptr) : mInstancePtr(ptr) {
}
nn::Result Get(nn::sl::TitleInfo *outTitleInfos, int *outTitleInfosSize, int maxTitleInfos) const override {
if (!mInstancePtr) {
return {Result::LEVEL_FATAL, Result::RESULT_MODULE_NN_SL, 1};
}
return mInstancePtr->vtable->GetFn(mInstancePtr, outTitleInfos, outTitleInfosSize, maxTitleInfos);
}
private:
nn::sl::details::IDiscCachedTitleAccessorInternal *GetInternal() override {
return mInstancePtr;
}
details::IDiscCachedTitleAccessorInternal *mInstancePtr;
};
} // namespace details
} // namespace nn::sl
#endif

86
include/nn/sl/details/IIconInfoAccessorDetails.h Normal file
View File

@ -0,0 +1,86 @@
#pragma once
#include <nn/result.h>
#include <nn/sl/sl_cpp.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
class DataCreator;
class TitleIconCache;
namespace details {
class IIconInfoAccessorBase;
struct IIconInfoAccessorInternal;
typedef nn::Result (*IconInfoAccessor_GetTitleIconInfoFn)(IIconInfoAccessorInternal *, nn::sl::IconInfo *, const nn::sl::TitleInfo &, nn::sl::Language);
typedef nn::Result (*IconInfoAccessor_GetMiiIconFn)(IIconInfoAccessorInternal *, void *buffer, uint32_t buffer_size, uint32_t slot);
struct WUT_PACKED IIconInfoAccessorInternalVTable {
IIconInfoAccessorBase *instance; // normally this is padding
uint32_t info;
WUT_PADDING_BYTES(4);
uint32_t destructor;
WUT_PADDING_BYTES(4);
IconInfoAccessor_GetTitleIconInfoFn GetTitleIconInfoFn;
WUT_PADDING_BYTES(4);
IconInfoAccessor_GetMiiIconFn GetMiiIconFn;
WUT_PADDING_BYTES(4);
};
WUT_CHECK_SIZE(IIconInfoAccessorInternalVTable, 0x24);
WUT_CHECK_OFFSET(IIconInfoAccessorInternalVTable, 0x14, GetTitleIconInfoFn);
WUT_CHECK_OFFSET(IIconInfoAccessorInternalVTable, 0x1C, GetMiiIconFn);
typedef struct WUT_PACKED IIconInfoAccessorInternal {
IIconInfoAccessorInternalVTable *vtable;
} IIconInfoAccessorInternal;
WUT_CHECK_SIZE(IIconInfoAccessorInternal, 0x04);
WUT_CHECK_OFFSET(IIconInfoAccessorInternal, 0x00, vtable);
class IIconInfoAccessorBase {
friend class nn::sl::DataCreator;
friend class nn::sl::TitleIconCache;
public:
IIconInfoAccessorBase() = default;
virtual ~IIconInfoAccessorBase() = default;
virtual nn::Result GetTitleIconInfo(nn::sl::IconInfo *outIconInfo, const nn::sl::TitleInfo &titleInfo, nn::sl::Language language) const = 0;
virtual nn::Result GetMiiIcon(void *buffer, uint32_t buffer_size, uint32_t slot) const = 0;
private:
virtual details::IIconInfoAccessorInternal *GetInternal() = 0;
};
class IconInfoAccessorFromPtr : public IIconInfoAccessorBase {
public:
explicit IconInfoAccessorFromPtr(details::IIconInfoAccessorInternal *ptr) : mInstancePtr(ptr) {
}
nn::Result GetTitleIconInfo(nn::sl::IconInfo *outIconInfo, const nn::sl::TitleInfo &titleInfo, nn::sl::Language language) const override {
if (!mInstancePtr) {
return {Result::LEVEL_FATAL, Result::RESULT_MODULE_NN_SL, 1};
}
return mInstancePtr->vtable->GetTitleIconInfoFn(mInstancePtr, outIconInfo, titleInfo, language);
}
nn::Result GetMiiIcon(void *buffer, uint32_t buffer_size, uint32_t slot) const override {
if (!mInstancePtr) {
return {Result::LEVEL_FATAL, Result::RESULT_MODULE_NN_SL, 1};
}
return mInstancePtr->vtable->GetMiiIconFn(mInstancePtr, buffer, buffer_size, slot);
}
private:
nn::sl::details::IIconInfoAccessorInternal *GetInternal() override {
return mInstancePtr;
}
details::IIconInfoAccessorInternal *mInstancePtr;
};
} // namespace details
} // namespace nn::sl
#endif

70
include/nn/sl/details/IInstalledTitleListAccessorDetails.h Normal file
View File

@ -0,0 +1,70 @@
#pragma once
#include <nn/result.h>
#include <nn/sl/sl_cpp.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
class TitleListCache;
namespace details {
class IInstalledTitleListAccessorBase;
struct IInstalledTitleListAccessorInternal;
typedef nn::Result (*IInstalledTitleListAccessor_GetFn)(IInstalledTitleListAccessorInternal *, nn::sl::TitleInfo *outTitleInfos, int *outTitleInfosSize, int maxTitleInfos);
struct WUT_PACKED IInstalledTitleListAccessorInternalVTable {
IInstalledTitleListAccessorBase *instance; // normally this is padding
uint32_t info;
WUT_PADDING_BYTES(4);
uint32_t destructor;
WUT_PADDING_BYTES(4);
IInstalledTitleListAccessor_GetFn GetFn;
};
WUT_CHECK_SIZE(IInstalledTitleListAccessorInternalVTable, 0x18);
WUT_CHECK_OFFSET(IInstalledTitleListAccessorInternalVTable, 0x00, instance);
WUT_CHECK_OFFSET(IInstalledTitleListAccessorInternalVTable, 0x14, GetFn);
typedef struct WUT_PACKED IInstalledTitleListAccessorInternal {
IInstalledTitleListAccessorInternalVTable *vtable;
} IInstalledTitleListAccessorInternal;
WUT_CHECK_SIZE(IInstalledTitleListAccessorInternal, 0x04);
WUT_CHECK_OFFSET(IInstalledTitleListAccessorInternal, 0x00, vtable);
class IInstalledTitleListAccessorBase {
friend class nn::sl::TitleListCache;
public:
IInstalledTitleListAccessorBase() = default;
virtual ~IInstalledTitleListAccessorBase() = default;
virtual nn::Result Get(nn::sl::TitleInfo *outTitleInfos, int *outTitleInfosSize, int maxTitleInfos) const = 0;
private:
virtual details::IInstalledTitleListAccessorInternal *GetInternal() = 0;
};
class InstalledTitleListAccessorFromPtr : public IInstalledTitleListAccessorBase {
public:
explicit InstalledTitleListAccessorFromPtr(details::IInstalledTitleListAccessorInternal *ptr) : mInstancePtr(ptr) {
}
nn::Result Get(nn::sl::TitleInfo *outTitleInfos, int *outTitleInfosSize, int maxTitleInfos) const override {
if (!mInstancePtr) {
return {Result::LEVEL_FATAL, Result::RESULT_MODULE_NN_SL, 1};
}
return mInstancePtr->vtable->GetFn(mInstancePtr, outTitleInfos, outTitleInfosSize, maxTitleInfos);
}
private:
nn::sl::details::IInstalledTitleListAccessorInternal *GetInternal() override {
return mInstancePtr;
}
details::IInstalledTitleListAccessorInternal *mInstancePtr;
};
} // namespace details
} // namespace nn::sl
#endif

72
include/nn/sl/details/IKillerNotificationAccessorDetails.h Normal file
View File

@ -0,0 +1,72 @@
#pragma once
#include "nn/sl/KillerNotification.h"
#include <nn/result.h>
#include <nn/sl/sl_cpp.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
class KillerNotificationSelector;
namespace details {
class IKillerNotificationAccessorBase;
struct IKillerNotificationAccessorInternal;
typedef nn::Result (*IKillerNotificationAccessor_GetFn)(IKillerNotificationAccessorInternal *, KillerNotification *outKillerNotifications, int *outKillerNotificationsNum, int maxKillerNotifications);
struct WUT_PACKED IKillerNotificationAccessorInternalVTable {
IKillerNotificationAccessorBase *instance; // Is normally padding
uint32_t info;
WUT_PADDING_BYTES(4);
uint32_t destructor;
WUT_PADDING_BYTES(4);
IKillerNotificationAccessor_GetFn GetFn;
};
WUT_CHECK_SIZE(IKillerNotificationAccessorInternalVTable, 0x18);
WUT_CHECK_OFFSET(IKillerNotificationAccessorInternalVTable, 0x00, instance);
WUT_CHECK_OFFSET(IKillerNotificationAccessorInternalVTable, 0x14, GetFn);
typedef struct WUT_PACKED IKillerNotificationAccessorInternal {
IKillerNotificationAccessorInternalVTable *vtable;
} IKillerNotificationAccessorInternal;
WUT_CHECK_SIZE(IKillerNotificationAccessorInternal, 0x04);
WUT_CHECK_OFFSET(IKillerNotificationAccessorInternal, 0x00, vtable);
class IKillerNotificationAccessorBase {
friend class nn::sl::KillerNotificationSelector;
public:
IKillerNotificationAccessorBase() = default;
virtual ~IKillerNotificationAccessorBase() = default;
virtual nn::Result Get(KillerNotification *outKillerNotifications, int *outKillerNotificationsNum, int maxKillerNotifications) const = 0;
private:
virtual details::IKillerNotificationAccessorInternal *GetInternal() = 0;
};
class KillerNotificationAccessorFromPtr : public IKillerNotificationAccessorBase {
public:
explicit KillerNotificationAccessorFromPtr(details::IKillerNotificationAccessorInternal *ptr) : mInstancePtr(ptr) {
}
nn::Result Get(nn::sl::KillerNotification *outKillerNotifications, int *outKillerNotificationsNum, int maxKillerNotifications) const override {
if (!mInstancePtr) {
return {Result::LEVEL_FATAL, Result::RESULT_MODULE_NN_SL, 1};
}
return mInstancePtr->vtable->GetFn(mInstancePtr, outKillerNotifications, outKillerNotificationsNum, maxKillerNotifications);
}
private:
nn::sl::details::IKillerNotificationAccessorInternal *GetInternal() override {
return mInstancePtr;
}
details::IKillerNotificationAccessorInternal *mInstancePtr;
};
} // namespace details
} // namespace nn::sl
#endif

178
include/nn/sl/details/IKillerNotificationTransferRecordManagerDetails.h Normal file
View File

@ -0,0 +1,178 @@
#pragma once
#include <nn/result.h>
#include <nn/sl/FileStream.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
class KillerNotificationSelector;
namespace details {
class IKillerNotificationTransferRecordManagerBase;
struct IKillerNotificationTransferRecordManagerInternal;
typedef nn::Result (*IKillerNotificationTransferRecordManagerInternVTable_LoadFn)(IKillerNotificationTransferRecordManagerInternal *, nn::sl::details::IStreamInternal *);
typedef nn::Result (*IKillerNotificationTransferRecordManagerInternVTable_LoadInitialFn)(IKillerNotificationTransferRecordManagerInternal *);
typedef nn::Result (*IKillerNotificationTransferRecordManagerInternVTable_StoreFn)(IKillerNotificationTransferRecordManagerInternal *, nn::sl::details::IStreamInternal *);
typedef void (*IKillerNotificationTransferRecordManagerInternVTable_FinalizeFn)(IKillerNotificationTransferRecordManagerInternal *);
typedef uint32_t (*IKillerNotificationTransferRecordManagerInternVTable_GetRecordCountFn)(IKillerNotificationTransferRecordManagerInternal *);
typedef uint32_t (*IKillerNotificationTransferRecordManagerInternVTable_GetRecordsFn)(IKillerNotificationTransferRecordManagerInternal *, KillerNotificationTransferRecord *, uint32_t);
typedef void (*IKillerNotificationTransferRecordManagerInternVTable_RegisterRecordsFn)(IKillerNotificationTransferRecordManagerInternal *, const KillerNotificationTransferRecord *, uint32_t);
typedef nn::Result (*IKillerNotificationTransferRecordManagerInternVTable_RegisterRecordsOtherFn)(IKillerNotificationTransferRecordManagerInternal *, const uint32_t *, uint32_t);
typedef struct WUT_PACKED IKillerNotificationTransferRecordManagerInternalVTable {
IKillerNotificationTransferRecordManagerBase *instance; // Normally this is padding
WUT_UNKNOWN_BYTES(0x10);
IKillerNotificationTransferRecordManagerInternVTable_LoadFn LoadFn;
WUT_UNKNOWN_BYTES(0x4);
IKillerNotificationTransferRecordManagerInternVTable_LoadInitialFn LoadInitialFn;
WUT_UNKNOWN_BYTES(0x4);
IKillerNotificationTransferRecordManagerInternVTable_StoreFn StoreFn;
WUT_UNKNOWN_BYTES(0x4);
IKillerNotificationTransferRecordManagerInternVTable_FinalizeFn FinalizeFn;
WUT_UNKNOWN_BYTES(0x4);
IKillerNotificationTransferRecordManagerInternVTable_GetRecordCountFn GetRecordCountFn;
WUT_UNKNOWN_BYTES(0x4);
IKillerNotificationTransferRecordManagerInternVTable_GetRecordsFn GetRecordsFn;
WUT_UNKNOWN_BYTES(0x4);
IKillerNotificationTransferRecordManagerInternVTable_RegisterRecordsFn RegisterRecordsFn;
WUT_UNKNOWN_BYTES(0x4);
IKillerNotificationTransferRecordManagerInternVTable_RegisterRecordsOtherFn RegisterRecordsOtherFn;
} IKillerNotificationTransferRecordManagerInternalVTable;
WUT_CHECK_SIZE(IKillerNotificationTransferRecordManagerInternalVTable, 0x50);
WUT_CHECK_OFFSET(IKillerNotificationTransferRecordManagerInternalVTable, 0x14, LoadFn);
WUT_CHECK_OFFSET(IKillerNotificationTransferRecordManagerInternalVTable, 0x1C, LoadInitialFn);
WUT_CHECK_OFFSET(IKillerNotificationTransferRecordManagerInternalVTable, 0x24, StoreFn);
WUT_CHECK_OFFSET(IKillerNotificationTransferRecordManagerInternalVTable, 0x2C, FinalizeFn);
WUT_CHECK_OFFSET(IKillerNotificationTransferRecordManagerInternalVTable, 0x34, GetRecordCountFn);
WUT_CHECK_OFFSET(IKillerNotificationTransferRecordManagerInternalVTable, 0x3C, GetRecordsFn);
WUT_CHECK_OFFSET(IKillerNotificationTransferRecordManagerInternalVTable, 0x44, RegisterRecordsFn);
WUT_CHECK_OFFSET(IKillerNotificationTransferRecordManagerInternalVTable, 0x4C, RegisterRecordsOtherFn);
typedef struct WUT_PACKED IKillerNotificationTransferRecordManagerInternal {
IKillerNotificationTransferRecordManagerInternalVTable *vtable;
} IKillerNotificationTransferRecordManagerIntern;
WUT_CHECK_SIZE(IKillerNotificationTransferRecordManagerInternal, 0x4);
WUT_CHECK_OFFSET(IKillerNotificationTransferRecordManagerInternal, 0x00, vtable);
typedef struct WUT_PACKED KillerNotificationTransferRecordManagerInternalInternal {
IKillerNotificationTransferRecordManagerInternalVTable *vtable;
void *killerNotificationTransferRecordManagerImpl;
} KillerNotificationTransferRecordManagerInternalInternal;
WUT_CHECK_SIZE(KillerNotificationTransferRecordManagerInternalInternal, 0x8);
WUT_CHECK_OFFSET(KillerNotificationTransferRecordManagerInternalInternal, 0x00, vtable);
WUT_CHECK_OFFSET(KillerNotificationTransferRecordManagerInternalInternal, 0x04, killerNotificationTransferRecordManagerImpl);
extern "C" IKillerNotificationTransferRecordManagerIntern *__ct__Q3_2nn2sl39KillerNotificationTransferRecordManagerFv(IKillerNotificationTransferRecordManagerInternal *);
extern "C" void *__dt__Q3_2nn2sl39KillerNotificationTransferRecordManagerFv(IKillerNotificationTransferRecordManagerInternal *, int);
extern "C" void Finalize__Q3_2nn2sl39KillerNotificationTransferRecordManagerFv(IKillerNotificationTransferRecordManagerInternal *);
extern "C" nn::Result Load__Q3_2nn2sl39KillerNotificationTransferRecordManagerFRQ3_2nn2sl7IStream(IKillerNotificationTransferRecordManagerInternal *, details::IStreamInternal *);
extern "C" nn::Result LoadInitial__Q3_2nn2sl39KillerNotificationTransferRecordManagerFv(IKillerNotificationTransferRecordManagerInternal *);
extern "C" uint32_t GetRecordCount__Q3_2nn2sl39KillerNotificationTransferRecordManagerCFv(IKillerNotificationTransferRecordManagerInternal *);
extern "C" uint32_t GetRecords__Q3_2nn2sl39KillerNotificationTransferRecordManagerCFPQ3_2nn2sl32KillerNotificationTransferRecordUi(IKillerNotificationTransferRecordManagerInternal *, KillerNotificationTransferRecord *, uint32_t);
extern "C" void RegisterRecords__Q3_2nn2sl39KillerNotificationTransferRecordManagerFPCQ3_2nn2sl32KillerNotificationTransferRecordUi(IKillerNotificationTransferRecordManagerInternal *, const KillerNotificationTransferRecord *, uint32_t);
extern "C" nn::Result Store__Q3_2nn2sl39KillerNotificationTransferRecordManagerCFRQ3_2nn2sl7IStream(IKillerNotificationTransferRecordManagerInternal *, details::IStreamInternal *);
extern "C" KillerNotificationTransferRecordManagerInternalInternal *__ct__Q3_2nn2sl47KillerNotificationTransferRecordManagerInternalFv(KillerNotificationTransferRecordManagerInternalInternal *);
extern "C" void *__dt__Q3_2nn2sl47KillerNotificationTransferRecordManagerInternalFv(KillerNotificationTransferRecordManagerInternalInternal *, int);
class IKillerNotificationTransferRecordManagerBase {
friend class nn::sl::KillerNotificationSelector;
public:
virtual ~IKillerNotificationTransferRecordManagerBase() = default;
virtual nn::Result Load(nn::sl::details::IStreamBase &stream) = 0;
virtual nn::Result LoadInitial() = 0;
virtual nn::Result Store(nn::sl::details::IStreamBase &stream) = 0;
virtual void Finalize() = 0;
virtual uint32_t GetRecordCount() const = 0;
virtual uint32_t GetRecords(KillerNotificationTransferRecord *outTransferRecords, uint32_t maxTransferRecords) const = 0;
virtual void RegisterRecords(const KillerNotificationTransferRecord *transferRecords, uint32_t numTransferRecords) = 0;
virtual nn::Result RegisterRecords(const uint32_t *u1, uint32_t u2) = 0;
private:
virtual details::IKillerNotificationTransferRecordManagerInternal *GetInternal() = 0;
};
class KillerNotificationTransferRecordManagerFromPtr : public IKillerNotificationTransferRecordManagerBase {
public:
explicit KillerNotificationTransferRecordManagerFromPtr(details::IKillerNotificationTransferRecordManagerInternal *instance) : mInstancePtr(instance) {
}
~KillerNotificationTransferRecordManagerFromPtr() override = default;
void Finalize() override {
if (!mInstancePtr) {
return;
}
mInstancePtr->vtable->FinalizeFn(mInstancePtr);
}
nn::Result Load(nn::sl::details::IStreamBase &stream) override {
if (!mInstancePtr) {
return {Result::LEVEL_FATAL, Result::RESULT_MODULE_NN_SL, 1};
}
return mInstancePtr->vtable->LoadFn(mInstancePtr, stream.GetInternal());
}
nn::Result LoadInitial() override {
if (!mInstancePtr) {
return {Result::LEVEL_FATAL, Result::RESULT_MODULE_NN_SL, 1};
}
return mInstancePtr->vtable->LoadInitialFn(mInstancePtr);
}
nn::Result Store(nn::sl::details::IStreamBase &stream) override {
if (!mInstancePtr) {
return {Result::LEVEL_FATAL, Result::RESULT_MODULE_NN_SL, 1};
}
return mInstancePtr->vtable->StoreFn(mInstancePtr, stream.GetInternal());
}
uint32_t GetRecordCount() const override {
if (!mInstancePtr) {
return 0;
}
return mInstancePtr->vtable->GetRecordCountFn(mInstancePtr);
}
uint32_t GetRecords(KillerNotificationTransferRecord *outTransferRecords, uint32_t maxTransferRecords) const override {
if (!mInstancePtr) {
return 0;
}
return mInstancePtr->vtable->GetRecordsFn(mInstancePtr, outTransferRecords, maxTransferRecords);
}
void RegisterRecords(const KillerNotificationTransferRecord *transferRecords, uint32_t numTransferRecords) override {
if (!mInstancePtr) {
return;
}
mInstancePtr->vtable->RegisterRecordsFn(mInstancePtr, transferRecords, numTransferRecords);
}
nn::Result RegisterRecords(const uint32_t *u1, uint32_t u2) override {
if (!mInstancePtr) {
return {Result::LEVEL_FATAL, Result::RESULT_MODULE_NN_SL, 1};
}
return mInstancePtr->vtable->RegisterRecordsOtherFn(mInstancePtr, u1, u2);
}
private:
details::IKillerNotificationTransferRecordManagerInternal *GetInternal() override {
return mInstancePtr;
}
details::IKillerNotificationTransferRecordManagerInternal *mInstancePtr = {};
};
} // namespace details
} // namespace nn::sl
#endif

74
include/nn/sl/details/ILaunchedTitleListAccessoDetails.h Normal file
View File

@ -0,0 +1,74 @@
#pragma once
#include <nn/result.h>
#include <nn/sl/sl_cpp.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
class KillerNotificationSelector;
class TitleListCache;
namespace details {
class ILaunchedTitleListAccessorBase;
struct ILaunchedTitleListAccessorInternal;
typedef nn::Result (*ILaunchedTitleListAccessor_GetByAccountFn)(ILaunchedTitleListAccessorInternal *, nn::sl::TitleInfo *outTitleInfos, int *outTitleInfoSize, int inTitleInfosSize, int userId);
struct WUT_PACKED ILaunchedTitleListAccessorInternalVTable {
ILaunchedTitleListAccessorBase *instance; // normally this is padding
uint32_t info;
WUT_PADDING_BYTES(4);
uint32_t destructor;
WUT_PADDING_BYTES(4);
ILaunchedTitleListAccessor_GetByAccountFn GetByAccountFn;
};
WUT_CHECK_SIZE(ILaunchedTitleListAccessorInternalVTable, 0x18);
WUT_CHECK_OFFSET(ILaunchedTitleListAccessorInternalVTable, 0x14, GetByAccountFn);
typedef struct WUT_PACKED ILaunchedTitleListAccessorInternal {
ILaunchedTitleListAccessorInternalVTable *vtable;
} ILaunchedTitleListAccessorInternal;
WUT_CHECK_SIZE(ILaunchedTitleListAccessorInternal, 0x04);
WUT_CHECK_OFFSET(ILaunchedTitleListAccessorInternal, 0x00, vtable);
class ILaunchedTitleListAccessorBase {
friend class nn::sl::KillerNotificationSelector;
friend class nn::sl::TitleListCache;
public:
ILaunchedTitleListAccessorBase() = default;
virtual ~ILaunchedTitleListAccessorBase() = default;
virtual nn::Result GetByAccount(nn::sl::TitleInfo *outTitleInfos, int *outTitleInfoSize, int inTitleInfosSize, int userId) const = 0;
private:
virtual details::ILaunchedTitleListAccessorInternal *GetInternal() = 0;
};
class LaunchedTitleListAccessorFromPtr : public ILaunchedTitleListAccessorBase {
public:
explicit LaunchedTitleListAccessorFromPtr(details::ILaunchedTitleListAccessorInternal *ptr) : mInstancePtr(ptr) {
}
nn::Result GetByAccount(nn::sl::TitleInfo *outTitleInfos, int *outTitleInfoNum, int maxNumTitleInfos, int userId) const override {
if (!mInstancePtr) {
return {Result::LEVEL_FATAL, Result::RESULT_MODULE_NN_SL, 1};
}
return mInstancePtr->vtable->GetByAccountFn(mInstancePtr, outTitleInfos, outTitleInfoNum, maxNumTitleInfos, userId);
}
details::ILaunchedTitleListAccessorInternal *GetInternal() override {
return mInstancePtr;
}
private:
details::ILaunchedTitleListAccessorInternal *mInstancePtr;
};
} // namespace details
} // namespace nn::sl
#endif

70
include/nn/sl/details/IMetaInfoAccessorDetails.h Normal file
View File

@ -0,0 +1,70 @@
#pragma once
#include <nn/result.h>
#include <nn/sl/sl_cpp.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
class TitleListCache;
namespace details {
class IMetaInfoAccessorBase;
struct IMetaInfoAccessorInternal;
typedef nn::Result (*IMetaInfoAccessor_GetFn)(IMetaInfoAccessorInternal *, nn::sl::TitleMetaInfo *, const nn::sl::TitleInfo &);
struct WUT_PACKED IMetaInfoAccessorInternalVTable {
IMetaInfoAccessorBase *instance; // normally this is padding
uint32_t info;
WUT_PADDING_BYTES(4);
uint32_t destructor;
WUT_PADDING_BYTES(4);
IMetaInfoAccessor_GetFn GetFn;
};
WUT_CHECK_SIZE(IMetaInfoAccessorInternalVTable, 0x18);
WUT_CHECK_OFFSET(IMetaInfoAccessorInternalVTable, 0x00, instance);
WUT_CHECK_OFFSET(IMetaInfoAccessorInternalVTable, 0x14, GetFn);
typedef struct WUT_PACKED IMetaInfoAccessorInternal {
IMetaInfoAccessorInternalVTable *vtable;
} IMetaInfoAccessorInternal;
WUT_CHECK_SIZE(IMetaInfoAccessorInternal, 0x04);
WUT_CHECK_OFFSET(IMetaInfoAccessorInternal, 0x00, vtable);
class IMetaInfoAccessorBase {
friend class nn::sl::TitleListCache;
public:
IMetaInfoAccessorBase() = default;
virtual ~IMetaInfoAccessorBase() = default;
virtual nn::Result Get(nn::sl::TitleMetaInfo *outMetaInfo, const nn::sl::TitleInfo &titleInfo) const = 0;
private:
virtual details::IMetaInfoAccessorInternal *GetInternal() = 0;
};
class MetaInfoAccessorFromPtr : public IMetaInfoAccessorBase {
public:
explicit MetaInfoAccessorFromPtr(details::IMetaInfoAccessorInternal *ptr) : mInstancePtr(ptr) {
}
nn::Result Get(nn::sl::TitleMetaInfo *outMetaInfo, const nn::sl::TitleInfo &titleInfo) const override {
if (!mInstancePtr) {
return {Result::LEVEL_FATAL, Result::RESULT_MODULE_NN_SL, 1};
}
return mInstancePtr->vtable->GetFn(mInstancePtr, outMetaInfo, titleInfo);
}
private:
nn::sl::details::IMetaInfoAccessorInternal *GetInternal() override {
return mInstancePtr;
}
details::IMetaInfoAccessorInternal *mInstancePtr;
};
} // namespace details
} // namespace nn::sl
#endif

70
include/nn/sl/details/IPreferentialTitleAccessorDetails.h Normal file
View File

@ -0,0 +1,70 @@
#pragma once
#include <nn/result.h>
#include <nn/sl/sl_cpp.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
class QuickStartApplicationSelector;
namespace details {
class IPreferentialTitleAccessorBase;
struct IPreferentialTitleAccessorInternal;
typedef nn::Result (*IPreferentialTitleAccessorBase_GetFn)(IPreferentialTitleAccessorInternal *, TitleInfo *, uint32_t *, int, uint32_t);
struct WUT_PACKED IPreferentialTitleAccessorInternalVTable {
IPreferentialTitleAccessorBase *instance; // Is normally padding
uint32_t info;
WUT_PADDING_BYTES(4);
uint32_t destructor;
WUT_PADDING_BYTES(4);
IPreferentialTitleAccessorBase_GetFn GetFn;
};
WUT_CHECK_SIZE(IPreferentialTitleAccessorInternalVTable, 0x18);
WUT_CHECK_OFFSET(IPreferentialTitleAccessorInternalVTable, 0x00, instance);
WUT_CHECK_OFFSET(IPreferentialTitleAccessorInternalVTable, 0x14, GetFn);
typedef struct WUT_PACKED IPreferentialTitleAccessorInternal {
IPreferentialTitleAccessorInternalVTable *vtable;
} IPreferentialTitleAccessorInternal;
WUT_CHECK_SIZE(IPreferentialTitleAccessorInternal, 0x04);
WUT_CHECK_OFFSET(IPreferentialTitleAccessorInternal, 0x00, vtable);
class IPreferentialTitleAccessorBase {
friend class nn::sl::QuickStartApplicationSelector;
public:
IPreferentialTitleAccessorBase() = default;
virtual ~IPreferentialTitleAccessorBase() = default;
virtual nn::Result Get(TitleInfo *outTitleInfo, uint32_t *outTitleInfoNum, int maxNumTitleInfos, uint32_t u1) const = 0;
private:
virtual details::IPreferentialTitleAccessorInternal *GetInternal() = 0;
};
class PreferentialTitleAccessorFromPtr : public IPreferentialTitleAccessorBase {
public:
explicit PreferentialTitleAccessorFromPtr(details::IPreferentialTitleAccessorInternal *ptr) : mInstancePtr(ptr) {
}
nn::Result Get(TitleInfo *outTitleInfo, uint32_t *outTitleInfoNum, int maxNumTitleInfos, uint32_t u1) const override {
if (!mInstancePtr) {
return {Result::LEVEL_FATAL, Result::RESULT_MODULE_NN_SL, 1};
}
return mInstancePtr->vtable->GetFn(mInstancePtr, outTitleInfo, outTitleInfoNum, maxNumTitleInfos, u1);
}
private:
details::IPreferentialTitleAccessorInternal *GetInternal() override {
return mInstancePtr;
}
details::IPreferentialTitleAccessorInternal *mInstancePtr;
};
} // namespace details
} // namespace nn::sl
#endif

113
include/nn/sl/details/ISerializerDetails.h Normal file
View File

@ -0,0 +1,113 @@
#pragma once
#include <nn/result.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
template<typename T>
class ISerializerBase;
class TitleIconCache;
class DataCreator;
class CacheManager;
class Condition;
class KillerNotificationSelector;
class TitleListCache;
namespace details {
struct ISerializerInternal;
typedef nn::Result (*ISerializer_SerializeFn)(ISerializerInternal *, void *, uint32_t);
typedef nn::Result (*ISerializer_DeserializeFn)(ISerializerInternal *, void *, uint32_t);
typedef nn::Result (*ISerializer_GetCountFn)(ISerializerInternal *, uint32_t *);
struct WUT_PACKED ISerializerInternalVTable {
ISerializerBase<uint8_t> *instance; // Is normally padding
uint32_t info;
WUT_PADDING_BYTES(4);
uint32_t destructor;
WUT_PADDING_BYTES(4);
ISerializer_SerializeFn SerializeFn;
WUT_PADDING_BYTES(4);
ISerializer_DeserializeFn DeserializeFn;
WUT_PADDING_BYTES(4);
ISerializer_GetCountFn GetCountFn;
};
WUT_CHECK_SIZE(ISerializerInternalVTable, 0x28);
WUT_CHECK_OFFSET(ISerializerInternalVTable, 0x00, instance);
WUT_CHECK_OFFSET(ISerializerInternalVTable, 0x14, SerializeFn);
WUT_CHECK_OFFSET(ISerializerInternalVTable, 0x1C, DeserializeFn);
WUT_CHECK_OFFSET(ISerializerInternalVTable, 0x24, GetCountFn);
typedef struct WUT_PACKED ISerializerInternal {
ISerializerInternalVTable *vtable;
} ISerializerInternal;
WUT_CHECK_SIZE(ISerializerInternal, 0x04);
WUT_CHECK_OFFSET(ISerializerInternal, 0x00, vtable);
template<typename T>
class ISerializerBase {
friend class nn::sl::TitleIconCache;
friend class nn::sl::DataCreator;
friend class nn::sl::CacheManager;
friend class nn::sl::Condition;
friend class nn::sl::KillerNotificationSelector;
friend class nn::sl::TitleListCache;
public:
ISerializerBase() = default;
virtual ~ISerializerBase() = default;
virtual nn::Result Serialize(void *buffer, uint32_t size) const = 0;
virtual nn::Result Deserialize(void *buffer, uint32_t size) const = 0;
virtual nn::Result GetCount(uint32_t *outCount) const = 0;
private:
virtual details::ISerializerInternal *GetInternal() = 0;
};
template<typename T>
class SerializerFromPtr : public ISerializerBase<T> {
public:
explicit SerializerFromPtr(details::ISerializerInternal *ptr) : mInstancePtr(ptr) {
}
nn::Result Serialize(void *buffer, uint32_t size) const override {
if (!mInstancePtr) {
return {Result::LEVEL_FATAL, Result::RESULT_MODULE_NN_SL, 1};
}
return mInstancePtr->vtable->SerializeFn(mInstancePtr, buffer, size);
}
nn::Result Deserialize(void *buffer, uint32_t size) const override {
if (!mInstancePtr) {
return {Result::LEVEL_FATAL, Result::RESULT_MODULE_NN_SL, 1};
}
return mInstancePtr->vtable->DeserializeFn(mInstancePtr, buffer, size);
}
nn::Result GetCount(uint32_t *outCount) const override {
if (!mInstancePtr) {
return {Result::LEVEL_FATAL, Result::RESULT_MODULE_NN_SL, 1};
}
return mInstancePtr->vtable->GetCountFn(mInstancePtr, outCount);
}
private:
details::ISerializerInternal *GetInternal() override {
return mInstancePtr;
}
details::ISerializerInternal *mInstancePtr;
};
} // namespace details
} // namespace nn::sl
#endif

82
include/nn/sl/details/ISettingAccessorDetails.h Normal file
View File

@ -0,0 +1,82 @@
#pragma once
#include <nn/result.h>
#include <nn/sl/sl_cpp.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
class TitleIconCache;
class DataCreator;
class Condition;
class DrcManager;
class KillerNotificationSelector;
class QuickStartApplicationSelector;
namespace details {
class ISettingAccessorBase;
struct ISettingAccessorInternal;
typedef nn::Result (*ISettingAccessor_GetFn)(ISettingAccessorInternal *, Setting *);
struct WUT_PACKED ISettingAccessorInternalVTable {
ISettingAccessorBase *instance; // Is normally padding
uint32_t info;
WUT_PADDING_BYTES(4);
uint32_t destructor;
WUT_PADDING_BYTES(4);
ISettingAccessor_GetFn GetFn;
};
WUT_CHECK_SIZE(ISettingAccessorInternalVTable, 0x18);
WUT_CHECK_OFFSET(ISettingAccessorInternalVTable, 0x00, instance);
WUT_CHECK_OFFSET(ISettingAccessorInternalVTable, 0x14, GetFn);
typedef struct WUT_PACKED ISettingAccessorInternal {
ISettingAccessorInternalVTable *vtable;
} ISettingAccessorInternal;
WUT_CHECK_SIZE(ISettingAccessorInternal, 0x04);
WUT_CHECK_OFFSET(ISettingAccessorInternal, 0x00, vtable);
class ISettingAccessorBase {
friend class nn::sl::TitleIconCache;
friend class nn::sl::DataCreator;
friend class nn::sl::Condition;
friend class nn::sl::DrcManager;
friend class nn::sl::KillerNotificationSelector;
friend class nn::sl::QuickStartApplicationSelector;
public:
ISettingAccessorBase() = default;
virtual ~ISettingAccessorBase() = default;
virtual nn::Result Get(nn::sl::Setting *) const = 0;
private:
virtual details::ISettingAccessorInternal *GetInternal() = 0;
};
class SettingAccessorFromPtr : public ISettingAccessorBase {
public:
explicit SettingAccessorFromPtr(details::ISettingAccessorInternal *ptr) : mInstancePtr(ptr) {
}
nn::Result Get(nn::sl::Setting *outSetting) const override {
if (!mInstancePtr) {
return {Result::LEVEL_FATAL, Result::RESULT_MODULE_NN_SL, 1};
}
return mInstancePtr->vtable->GetFn(mInstancePtr, outSetting);
}
private:
details::ISettingAccessorInternal *GetInternal() override {
return mInstancePtr;
}
details::ISettingAccessorInternal *mInstancePtr;
};
} // namespace details
} // namespace nn::sl
#endif

76
include/nn/sl/details/IStreamDetails.h Normal file
View File

@ -0,0 +1,76 @@
#pragma once
#include <coreinit/filesystem.h>
#include <nn/result.h>
#include <nn/sl/sl_cpp.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
class LaunchInfoDatabase;
class KillerNotificationTransferRecordManager;
class KillerNotificationTransferRecordManagerInternal;
namespace details {
class KillerNotificationTransferRecordManagerFromPtr;
class IStreamBase;
struct IStreamInternal;
typedef nn::Result (*IStream_ReadFn)(IStreamInternal *, uint32_t *bytesRead, void *buffer, uint32_t readSize);
typedef nn::Result (*IStream_WriteFn)(IStreamInternal *, uint32_t *bytesWritten, void *buffer, uint32_t writeSize);
typedef nn::Result (*IStream_GetSizeFn)(IStreamInternal *, uint32_t *fileSize);
typedef nn::Result (*IStream_SeekFn)(IStreamInternal *, int32_t offset, nn::sl::SeekOrigin seekOrigin);
struct WUT_PACKED IStreamInternalVTable {
IStreamBase *instance; // normally this is padding
uint32_t info;
WUT_PADDING_BYTES(4);
uint32_t destructor;
WUT_PADDING_BYTES(4);
IStream_ReadFn ReadFn;
WUT_PADDING_BYTES(4);
IStream_WriteFn WriteFn;
WUT_PADDING_BYTES(4);
IStream_GetSizeFn GetSizeFn;
WUT_PADDING_BYTES(4);
IStream_SeekFn SeekFn;
};
WUT_CHECK_SIZE(IStreamInternalVTable, 0x30);
WUT_CHECK_OFFSET(IStreamInternalVTable, 0x14, ReadFn);
WUT_CHECK_OFFSET(IStreamInternalVTable, 0x1C, WriteFn);
WUT_CHECK_OFFSET(IStreamInternalVTable, 0x24, GetSizeFn);
WUT_CHECK_OFFSET(IStreamInternalVTable, 0x2C, SeekFn);
typedef struct WUT_PACKED IStreamInternal {
IStreamInternalVTable *vtable;
} IStreamInternal;
WUT_CHECK_SIZE(IStreamInternal, 0x04);
class IStreamBase {
friend class nn::sl::LaunchInfoDatabase;
friend class nn::sl::KillerNotificationTransferRecordManager;
friend class nn::sl::KillerNotificationTransferRecordManagerInternal;
friend class nn::sl::details::KillerNotificationTransferRecordManagerFromPtr;
public:
IStreamBase() = default;
virtual ~IStreamBase() = default;
virtual nn::Result Read(uint32_t *bytesRead, void *buffer, uint32_t readSize) = 0;
virtual nn::Result Write(uint32_t *bytesWritten, void *buffer, uint32_t writeSize) = 0;
virtual nn::Result GetSize(uint32_t *fileSize) = 0;
virtual nn::Result Seek(int32_t offset, nn::sl::SeekOrigin seekOrigin) = 0;
private:
virtual details::IStreamInternal *GetInternal() = 0;
};
} // namespace details
} // namespace nn::sl
#endif

90
include/nn/sl/details/ITimeAccessorDetails.h Normal file
View File

@ -0,0 +1,90 @@
#pragma once
#include <coreinit/time.h>
#include <nn/result.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
class Condition;
class DrcManager;
class KillerNotificationSelector;
class TitleListCache;
namespace details {
class ITimeAccessorBase;
struct ITimeAccessorInternal;
typedef nn::Result (*ITimeAccessor_GetNetworkTimeFn)(ITimeAccessorInternal *, OSTime *, bool *);
typedef nn::Result (*ITimeAccessor_GetLocalTimeFn)(ITimeAccessorInternal *, OSTime *, bool *);
struct WUT_PACKED ITimeAccessorInternalVTable {
ITimeAccessorBase *instance; // Is normally padding
uint32_t info;
WUT_PADDING_BYTES(4);
uint32_t destructor;
WUT_PADDING_BYTES(4);
ITimeAccessor_GetNetworkTimeFn GetNetworkTimeFn;
WUT_PADDING_BYTES(4);
ITimeAccessor_GetLocalTimeFn GetLocalTimeFn;
};
WUT_CHECK_SIZE(ITimeAccessorInternalVTable, 0x20);
WUT_CHECK_OFFSET(ITimeAccessorInternalVTable, 0x00, instance);
WUT_CHECK_OFFSET(ITimeAccessorInternalVTable, 0x14, GetNetworkTimeFn);
WUT_CHECK_OFFSET(ITimeAccessorInternalVTable, 0x1C, GetLocalTimeFn);
typedef struct WUT_PACKED ITimeAccessorInternal {
ITimeAccessorInternalVTable *vtable;
} ITimeAccessorInternal;
WUT_CHECK_SIZE(ITimeAccessorInternal, 0x04);
WUT_CHECK_OFFSET(ITimeAccessorInternal, 0x00, vtable);
class ITimeAccessorBase {
friend class nn::sl::Condition;
friend class nn::sl::DrcManager;
friend class nn::sl::KillerNotificationSelector;
friend class nn::sl::TitleListCache;
public:
ITimeAccessorBase() = default;
virtual ~ITimeAccessorBase() = default;
virtual nn::Result GetNetworkTime(OSTime *, bool *) const = 0;
virtual nn::Result GetLocalTime(OSTime *, bool *) const = 0;
private:
virtual details::ITimeAccessorInternal *GetInternal() = 0;
};
class TimeAccessorFromPtr : public ITimeAccessorBase {
public:
explicit TimeAccessorFromPtr(details::ITimeAccessorInternal *ptr) : mInstancePtr(ptr) {
}
nn::Result GetNetworkTime(OSTime *outTime, bool *outSuccess) const override {
if (!mInstancePtr) {
return {Result::LEVEL_FATAL, Result::RESULT_MODULE_NN_SL, 1};
}
return mInstancePtr->vtable->GetNetworkTimeFn(mInstancePtr, outTime, outSuccess);
}
nn::Result GetLocalTime(OSTime *outTime, bool *outSuccess) const override {
if (!mInstancePtr) {
return {Result::LEVEL_FATAL, Result::RESULT_MODULE_NN_SL, 1};
}
return mInstancePtr->vtable->GetLocalTimeFn(mInstancePtr, outTime, outSuccess);
}
private:
details::ITimeAccessorInternal *GetInternal() override {
return mInstancePtr;
}
details::ITimeAccessorInternal *mInstancePtr;
};
} // namespace details
} // namespace nn::sl
#endif

112
include/nn/sl/details/ITitleIconCacheDetails.h Normal file
View File

@ -0,0 +1,112 @@
#pragma once
#include <nn/result.h>
#include <nn/sl/sl_cpp.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
class DataCreator;
namespace details {
class ITitleIconCacheBase;
struct ITitleIconCacheInternal;
struct WUT_PACKED ITitleIconCacheInternal;
typedef nn::Result (*TitleIconCache_LoadFn)(ITitleIconCacheInternal *);
typedef nn::Result (*TitleIconCache_UpdateFn)(ITitleIconCacheInternal *, TitleInfo *, int);
typedef nn::Result (*TitleIconCache_StoreFn)(ITitleIconCacheInternal *);
typedef void (*TitleIconCache_GetFn)(ITitleIconCacheInternal *, IconInfo *, int);
typedef struct WUT_PACKED ITitleIconCacheInternalVTable {
ITitleIconCacheBase *instance; // this is normally padding
WUT_UNKNOWN_BYTES(0x4);
WUT_UNKNOWN_BYTES(0x4);
void *destructor;
WUT_UNKNOWN_BYTES(0x4);
TitleIconCache_LoadFn LoadFn;
WUT_UNKNOWN_BYTES(0x4);
TitleIconCache_UpdateFn UpdateFn;
WUT_UNKNOWN_BYTES(0x4);
TitleIconCache_StoreFn StoreFn;
WUT_UNKNOWN_BYTES(0x4);
TitleIconCache_GetFn GetFn;
} ITitleIconCacheInternalVTable;
WUT_CHECK_SIZE(ITitleIconCacheInternalVTable, 0x30);
WUT_CHECK_OFFSET(ITitleIconCacheInternalVTable, 0x14, LoadFn);
WUT_CHECK_OFFSET(ITitleIconCacheInternalVTable, 0x1c, UpdateFn);
WUT_CHECK_OFFSET(ITitleIconCacheInternalVTable, 0x24, StoreFn);
WUT_CHECK_OFFSET(ITitleIconCacheInternalVTable, 0x2C, GetFn);
typedef struct WUT_PACKED ITitleIconCacheInternal {
ITitleIconCacheInternalVTable *vtable;
} ITitleIconCacheInternal;
WUT_CHECK_SIZE(ITitleIconCacheInternal, 0x04);
WUT_CHECK_OFFSET(ITitleIconCacheInternal, 0x00, vtable);
class ITitleIconCacheBase {
friend class nn::sl::DataCreator;
public:
ITitleIconCacheBase() = default;
virtual ~ITitleIconCacheBase() = default;
virtual nn::Result Load() = 0;
virtual nn::Result Update(nn::sl::TitleInfo *titleInfos, int num) = 0;
virtual nn::Result Store() = 0;
virtual void Get(nn::sl::IconInfo *iconInfos, int num) const = 0;
private:
virtual details::ITitleIconCacheInternal *GetInternal() = 0;
};
class TitleIconCacheFromPtr : public ITitleIconCacheBase {
public:
explicit TitleIconCacheFromPtr(details::ITitleIconCacheInternal *ptr) : mInstancePtr(ptr) {
}
nn::Result Load() override {
if (!mInstancePtr) {
return {Result::LEVEL_FATAL, Result::RESULT_MODULE_NN_SL, 1};
}
return mInstancePtr->vtable->LoadFn(mInstancePtr);
}
nn::Result Update(nn::sl::TitleInfo *titleInfos, int num) override {
if (!mInstancePtr) {
return {Result::LEVEL_FATAL, Result::RESULT_MODULE_NN_SL, 1};
}
return mInstancePtr->vtable->UpdateFn(mInstancePtr, titleInfos, num);
}
nn::Result Store() override {
if (!mInstancePtr) {
return {Result::LEVEL_FATAL, Result::RESULT_MODULE_NN_SL, 1};
}
return mInstancePtr->vtable->StoreFn(mInstancePtr);
}
void Get(nn::sl::IconInfo *iconInfos, int num) const override {
if (!mInstancePtr) {
return;
}
mInstancePtr->vtable->GetFn(mInstancePtr, iconInfos, num);
}
private:
details::ITitleIconCacheInternal *GetInternal() override {
return mInstancePtr;
}
details::ITitleIconCacheInternal *mInstancePtr;
};
} // namespace details
} // namespace nn::sl
#endif

70
include/nn/sl/details/ITitleListAccessorDetails.h Normal file
View File

@ -0,0 +1,70 @@
#pragma once
#include <nn/result.h>
#include <nn/sl/sl_cpp.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
class TitleListCache;
namespace details {
class ITitleListAccessorBase;
struct ITitleListAccessorInternal;
typedef nn::Result (*ITitleListAccessor_GetFn)(ITitleListAccessorInternal *, nn::sl::TitleInfo *outTitleInfos, int *outTitleInfosNum, int maxTitleInfosNum);
struct WUT_PACKED ITitleListAccessorInternalVTable {
ITitleListAccessorBase *instance; // normally this is padding
uint32_t info;
WUT_PADDING_BYTES(4);
uint32_t destructor;
WUT_PADDING_BYTES(4);
ITitleListAccessor_GetFn GetFn;
};
WUT_CHECK_SIZE(ITitleListAccessorInternalVTable, 0x18);
WUT_CHECK_OFFSET(ITitleListAccessorInternalVTable, 0x00, instance);
WUT_CHECK_OFFSET(ITitleListAccessorInternalVTable, 0x14, GetFn);
typedef struct WUT_PACKED ITitleListAccessorInternal {
ITitleListAccessorInternalVTable *vtable;
} ITitleListAccessorInternal;
WUT_CHECK_SIZE(ITitleListAccessorInternal, 0x04);
WUT_CHECK_OFFSET(ITitleListAccessorInternal, 0x00, vtable);
class ITitleListAccessorBase {
friend class nn::sl::TitleListCache;
public:
ITitleListAccessorBase() = default;
virtual ~ITitleListAccessorBase() = default;
virtual nn::Result Get(nn::sl::TitleInfo *outTitleInfos, int *outTitleInfosNum, int maxTitleInfosNum) const = 0;
private:
virtual details::ITitleListAccessorInternal *GetInternal() = 0;
};
class TitleListAccessorFromPtr : public ITitleListAccessorBase {
public:
explicit TitleListAccessorFromPtr(details::ITitleListAccessorInternal *ptr) : mInstancePtr(ptr) {
}
nn::Result Get(nn::sl::TitleInfo *outTitleInfos, int *outTitleInfosNum, int maxTitleInfosNum) const override {
if (!mInstancePtr) {
return {Result::LEVEL_FATAL, Result::RESULT_MODULE_NN_SL, 1};
}
return mInstancePtr->vtable->GetFn(mInstancePtr, outTitleInfos, outTitleInfosNum, maxTitleInfosNum);
}
private:
nn::sl::details::ITitleListAccessorInternal *GetInternal() override {
return mInstancePtr;
}
details::ITitleListAccessorInternal *mInstancePtr;
};
} // namespace details
} // namespace nn::sl
#endif

115
include/nn/sl/details/ITransferrerDetails.h Normal file
View File

@ -0,0 +1,115 @@
#pragma once
#include <nn/result.h>
#include <nn/sl/sl_cpp.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
class DrcManager;
namespace details {
class ITransferrerBase;
struct ITransferrerInternal;
typedef nn::Result (*ITransferrer_TransferDeprecatedFn)(ITransferrerInternal *, void *, uint32_t, bool, int);
typedef nn::Result (*ITransferrer_TransferFn)(ITransferrerInternal *, void *, uint32_t, bool, TransferMode);
typedef nn::Result (*ITransferrer_CancelTransferFn)(ITransferrerInternal *);
typedef nn::Result (*ITransferrer_InvalidateNotificationFn)(ITransferrerInternal *, uint32_t);
typedef nn::Result (*ITransferrer_DisplayNotificationFn)(ITransferrerInternal *, uint32_t, uint32_t, uint32_t);
struct WUT_PACKED ITransferrerInternalVTable {
ITransferrerBase *instance; // Is normally padding
uint32_t info;
WUT_PADDING_BYTES(4);
uint32_t destructor;
WUT_PADDING_BYTES(4);
ITransferrer_TransferDeprecatedFn TransferDeprecatedFn;
WUT_PADDING_BYTES(4);
ITransferrer_TransferFn TransferFn;
WUT_PADDING_BYTES(4);
ITransferrer_CancelTransferFn CancelTransferFn;
WUT_PADDING_BYTES(4);
ITransferrer_InvalidateNotificationFn InvalidateNotificationFn;
WUT_PADDING_BYTES(4);
ITransferrer_DisplayNotificationFn DisplayNotificationFn;
};
WUT_CHECK_SIZE(ITransferrerInternalVTable, 0x38);
WUT_CHECK_OFFSET(ITransferrerInternalVTable, 0x00, instance);
WUT_CHECK_OFFSET(ITransferrerInternalVTable, 0x14, TransferDeprecatedFn);
WUT_CHECK_OFFSET(ITransferrerInternalVTable, 0x1C, TransferFn);
WUT_CHECK_OFFSET(ITransferrerInternalVTable, 0x24, CancelTransferFn);
WUT_CHECK_OFFSET(ITransferrerInternalVTable, 0x2C, InvalidateNotificationFn);
WUT_CHECK_OFFSET(ITransferrerInternalVTable, 0x34, DisplayNotificationFn);
typedef struct WUT_PACKED ITransferrerInternal {
ITransferrerInternalVTable *vtable;
} ITransferrerInternal;
WUT_CHECK_SIZE(ITransferrerInternal, 0x04);
WUT_CHECK_OFFSET(ITransferrerInternal, 0x00, vtable);
class ITransferrerBase {
friend class nn::sl::DrcManager;
public:
ITransferrerBase() = default;
virtual ~ITransferrerBase() = default;
virtual nn::Result TransferDeprecated(void *buffer, uint32_t size, bool setKillerNotification, int transferMode) const = 0;
virtual nn::Result Transfer(void *buffer, uint32_t size, bool setKillerNotification, TransferMode transferMode) const = 0;
virtual nn::Result CancelTransfer() const = 0;
virtual nn::Result InvalidateNotification(uint32_t) const = 0;
virtual nn::Result DisplayNotification(uint32_t, uint32_t, uint32_t) const = 0;
private:
virtual details::ITransferrerInternal *GetInternal() = 0;
};
class TransferrerFromPtr : public ITransferrerBase {
public:
explicit TransferrerFromPtr(details::ITransferrerInternal *ptr) : mInstancePtr(ptr) {
}
nn::Result TransferDeprecated(void *buffer, uint32_t size, bool setKillerNotification, int transferMode) const override {
if (!mInstancePtr) {
return {Result::LEVEL_FATAL, Result::RESULT_MODULE_NN_SL, 1};
}
return mInstancePtr->vtable->TransferDeprecatedFn(mInstancePtr, buffer, size, setKillerNotification, transferMode);
}
nn::Result Transfer(void *buffer, uint32_t size, bool setKillerNotification, TransferMode transferMode) const override {
if (!mInstancePtr) {
return {Result::LEVEL_FATAL, Result::RESULT_MODULE_NN_SL, 1};
}
return mInstancePtr->vtable->TransferFn(mInstancePtr, buffer, size, setKillerNotification, transferMode);
}
nn::Result CancelTransfer() const override {
if (!mInstancePtr) {
return {Result::LEVEL_FATAL, Result::RESULT_MODULE_NN_SL, 1};
}
return mInstancePtr->vtable->CancelTransferFn(mInstancePtr);
}
nn::Result InvalidateNotification(uint32_t u1) const override {
if (!mInstancePtr) {
return {Result::LEVEL_FATAL, Result::RESULT_MODULE_NN_SL, 1};
}
return mInstancePtr->vtable->InvalidateNotificationFn(mInstancePtr, u1);
}
nn::Result DisplayNotification(uint32_t u1, uint32_t u2, uint32_t u3) const override {
if (!mInstancePtr) {
return {Result::LEVEL_FATAL, Result::RESULT_MODULE_NN_SL, 1};
}
return mInstancePtr->vtable->DisplayNotificationFn(mInstancePtr, u1, u2, u3);
}
private:
details::ITransferrerInternal *GetInternal() override {
return mInstancePtr;
}
details::ITransferrerInternal *mInstancePtr;
};
} // namespace details
} // namespace nn::sl
#endif

83
include/nn/sl/details/IUpdatePackageAccessorDetails.h Normal file
View File

@ -0,0 +1,83 @@
#pragma once
#include <nn/result.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
class Condition;
namespace details {
class IUpdatePackageAccessorBase;
struct IUpdatePackageAccessorInternal;
typedef bool (*IUpdatePackageAccessor_PackageExistsFn)(IUpdatePackageAccessorInternal *);
typedef bool (*IUpdatePackageAccessor_IsUpdatePackageDownloadedFn)(IUpdatePackageAccessorInternal *);
struct WUT_PACKED IUpdatePackageAccessorInternalVTable {
IUpdatePackageAccessorBase *instance; // normally this is padding
uint32_t info;
WUT_PADDING_BYTES(4);
uint32_t destructor;
WUT_PADDING_BYTES(4);
IUpdatePackageAccessor_PackageExistsFn PackageExistsFn;
WUT_PADDING_BYTES(4);
IUpdatePackageAccessor_IsUpdatePackageDownloadedFn IsUpdatePackageDownloadedFn;
WUT_PADDING_BYTES(4);
};
WUT_CHECK_SIZE(IUpdatePackageAccessorInternalVTable, 0x24);
WUT_CHECK_OFFSET(IUpdatePackageAccessorInternalVTable, 0x14, PackageExistsFn);
WUT_CHECK_OFFSET(IUpdatePackageAccessorInternalVTable, 0x1C, IsUpdatePackageDownloadedFn);
typedef struct WUT_PACKED IUpdatePackageAccessorInternal {
IUpdatePackageAccessorInternalVTable *vtable;
} IUpdatePackageAccessorInternal;
WUT_CHECK_SIZE(IUpdatePackageAccessorInternal, 0x04);
WUT_CHECK_OFFSET(IUpdatePackageAccessorInternal, 0x00, vtable);
extern "C" IUpdatePackageAccessorInternal *GetDefaultUpdatePackageAccessor__Q2_2nn2slFv();
class IUpdatePackageAccessorBase {
friend class nn::sl::Condition;
public:
IUpdatePackageAccessorBase() = default;
virtual ~IUpdatePackageAccessorBase() = default;
virtual bool PackageExists() const = 0;
virtual bool IsUpdatePackageDownloaded() const = 0;
private:
virtual details::IUpdatePackageAccessorInternal *GetInternal() = 0;
};
class UpdatePackageAccessorFromPtr : public IUpdatePackageAccessorBase {
public:
explicit UpdatePackageAccessorFromPtr(details::IUpdatePackageAccessorInternal *ptr) : mInstancePtr(ptr) {
}
bool PackageExists() const override {
if (!mInstancePtr) {
return false;
}
return mInstancePtr->vtable->PackageExistsFn(mInstancePtr);
}
bool IsUpdatePackageDownloaded() const override {
if (!mInstancePtr) {
return false;
}
return mInstancePtr->vtable->IsUpdatePackageDownloadedFn(mInstancePtr);
}
details::IUpdatePackageAccessorInternal *GetInternal() override {
return mInstancePtr;
}
private:
details::IUpdatePackageAccessorInternal *mInstancePtr;
};
} // namespace details
} // namespace nn::sl
#endif

70
include/nn/sl/details/IWhiteListAccessorDetails.h Normal file
View File

@ -0,0 +1,70 @@
#pragma once
#include <nn/result.h>
#include <nn/sl/sl_cpp.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn::sl {
class QuickStartApplicationSelector;
namespace details {
class IWhiteListAccessorBase;
struct IWhiteListAccessorInternal;
typedef nn::Result (*IWhiteListAccessor_GetFn)(IWhiteListAccessorInternal *, nn::sl::WhiteList *);
struct WUT_PACKED IWhiteListAccessorInternalVTable {
IWhiteListAccessorBase *instance; // normally this is padding
uint32_t info;
WUT_PADDING_BYTES(4);
uint32_t destructor;
WUT_PADDING_BYTES(4);
IWhiteListAccessor_GetFn GetFn;
};
WUT_CHECK_SIZE(IWhiteListAccessorInternalVTable, 0x18);
WUT_CHECK_OFFSET(IWhiteListAccessorInternalVTable, 0x00, instance);
WUT_CHECK_OFFSET(IWhiteListAccessorInternalVTable, 0x14, GetFn);
typedef struct WUT_PACKED IWhiteListAccessorInternal {
IWhiteListAccessorInternalVTable *vtable;
} IWhiteListAccessorInternal;
WUT_CHECK_SIZE(IWhiteListAccessorInternal, 0x04);
WUT_CHECK_OFFSET(IWhiteListAccessorInternal, 0x00, vtable);
class IWhiteListAccessorBase {
friend class nn::sl::QuickStartApplicationSelector;
public:
IWhiteListAccessorBase() = default;
virtual ~IWhiteListAccessorBase() = default;
virtual nn::Result Get(nn::sl::WhiteList *outWhiteList) const = 0;
private:
virtual details::IWhiteListAccessorInternal *GetInternal() = 0;
};
class WhiteListAccessorFromPtr : public IWhiteListAccessorBase {
public:
explicit WhiteListAccessorFromPtr(details::IWhiteListAccessorInternal *ptr) : mInstancePtr(ptr) {
}
nn::Result Get(nn::sl::WhiteList *outWhiteList) const override {
if (!mInstancePtr) {
return {Result::LEVEL_FATAL, Result::RESULT_MODULE_NN_SL, 1};
}
return mInstancePtr->vtable->GetFn(mInstancePtr, outWhiteList);
}
private:
nn::sl::details::IWhiteListAccessorInternal *GetInternal() override {
return mInstancePtr;
}
details::IWhiteListAccessorInternal *mInstancePtr;
};
} // namespace details
} // namespace nn::sl
#endif

312
include/nn/sl/sl_cpp.h
View File

@ -1,56 +1,292 @@
#pragma once
#include <wut.h>
#include <nn/result.h>
#include <coreinit/memdefaultheap.h>
#include <coreinit/mcp.h>
#include <coreinit/memdefaultheap.h>
#include <nn/result.h>
#include <wut.h>
#ifdef __cplusplus
namespace nn {
namespace nn::sl {
typedef enum MediaType {
NN_SL_MEDIA_TYPE_MLC = 0x00,
NN_SL_MEDIA_TYPE_SLC = 0x01,
NN_SL_MEDIA_TYPE_ODD = 0x02,
NN_SL_MEDIA_TYPE_USB = 0x03,
NN_SL_MEDIA_TYPE_HFIO = 0x04,
} MediaType;
namespace sl {
typedef struct WUT_PACKED LaunchInfo {
uint64_t titleId;
MCPAppType appType;
MediaType mediaType;
char parameter[0x800];
} LaunchInfo;
WUT_CHECK_OFFSET(LaunchInfo, 0x00, titleId);
WUT_CHECK_OFFSET(LaunchInfo, 0x08, appType);
WUT_CHECK_OFFSET(LaunchInfo, 0x0C, mediaType);
WUT_CHECK_SIZE(LaunchInfo, 0x810);
typedef enum MediaType {
NN_SL_MEDIA_TYPE_MLC = 0x00,
NN_SL_MEDIA_TYPE_SLC = 0x01,
NN_SL_MEDIA_TYPE_ODD = 0x02,
NN_SL_MEDIA_TYPE_USB = 0x03,
NN_SL_MEDIA_TYPE_HFIO = 0x04,
} MediaType;
typedef struct WUT_PACKED LaunchInfoDatabaseEntry {
uint64_t id;
LaunchInfo launchInfo;
} LaunchInfoDatabaseEntry;
WUT_CHECK_SIZE(LaunchInfoDatabaseEntry, 0x818);
WUT_CHECK_OFFSET(LaunchInfoDatabaseEntry, 0x0, id);
WUT_CHECK_OFFSET(LaunchInfoDatabaseEntry, 0x8, launchInfo);
typedef struct WUT_PACKED LaunchInfo {
uint64_t titleId;
MCPAppType appType;
MediaType mediaType;
WUT_UNKNOWN_BYTES(0x800);
} LaunchInfo;
// This struct has a variable length, the hash is always expected at the end
typedef struct WUT_PACKED LaunchInfoDatabaseHeader {
uint32_t version; // 1
uint32_t magic; // "LIDB"
uint32_t maxEntries;
uint32_t entryCount;
uint64_t currentId; // start at 0x1000000000000000
LaunchInfoDatabaseEntry entries[0]; // Dynamic, actually this array should be entries[maxEntries]
char sha1Hash[20];
} LaunchInfoDatabaseHeader;
WUT_CHECK_SIZE(LaunchInfoDatabaseHeader, 0x2C);
WUT_CHECK_OFFSET(LaunchInfoDatabaseHeader, 0x0, version);
WUT_CHECK_OFFSET(LaunchInfoDatabaseHeader, 0x4, magic);
WUT_CHECK_OFFSET(LaunchInfoDatabaseHeader, 0x8, maxEntries);
WUT_CHECK_OFFSET(LaunchInfoDatabaseHeader, 0xC, entryCount);
WUT_CHECK_OFFSET(LaunchInfoDatabaseHeader, 0x10, currentId);
WUT_CHECK_OFFSET(LaunchInfoDatabaseHeader, 0x18, entries);
WUT_CHECK_OFFSET(LaunchInfoDatabaseHeader, 0x18, sha1Hash);
WUT_CHECK_OFFSET(LaunchInfo, 0x00, titleId);
WUT_CHECK_OFFSET(LaunchInfo, 0x08, appType);
WUT_CHECK_OFFSET(LaunchInfo, 0x0C, mediaType);
WUT_CHECK_SIZE(LaunchInfo, 0x810);
struct WUT_PACKED IconInfo {
uint8_t data[65580]; // tga
char name[0x80];
};
WUT_CHECK_SIZE(IconInfo, 0x100ac);
WUT_CHECK_OFFSET(IconInfo, 0, data);
WUT_CHECK_OFFSET(IconInfo, 0x1002c, name);
typedef enum Region {
REGION_JPN = 0,
REGION_USA = 1,
REGION_EUR = 2
} Region;
struct WUT_PACKED AccountUUID {
char uuid[10];
};
WUT_CHECK_SIZE(AccountUUID, 10);
void
GetDefaultDatabasePath(char *, int size, uint64_t titleId)
asm("GetDefaultDatabasePath__Q2_2nn2slFPcUiUL");
struct DRCImagePaletteColor {
uint8_t b;
uint8_t g;
uint8_t r;
uint8_t a;
};
WUT_CHECK_SIZE(DRCImagePaletteColor, 4);
WUT_CHECK_OFFSET(DRCImagePaletteColor, 0, b);
WUT_CHECK_OFFSET(DRCImagePaletteColor, 1, g);
WUT_CHECK_OFFSET(DRCImagePaletteColor, 2, r);
WUT_CHECK_OFFSET(DRCImagePaletteColor, 3, a);
nn::Result
Initialize(MEMAllocFromDefaultHeapExFn, MEMFreeToDefaultHeapFn)
asm("Initialize__Q2_2nn2slFPFUiT1_PvPFPv_v");
struct DRCImagePalette {
DRCImagePaletteColor values[0x100];
};
WUT_CHECK_SIZE(DRCImagePalette, 0x400);
WUT_CHECK_OFFSET(DRCImagePalette, 0, values);
nn::Result
Finalize()
asm("Finalize__Q2_2nn2slFv");
struct WUT_PACKED TransferableInfo {
uint8_t numAccounts;
uint8_t defaultAccountIndex;
AccountUUID uuids[12];
WUT_PADDING_BYTES(0x48);
uint8_t isNetworkAccount[12];
uint8_t isPasswordCacheEnabled[12];
uint64_t titleIds[10];
uint8_t isOnDisc[10];
uint64_t killerNotificationsTitleId;
uint32_t serialId;
WUT_PADDING_BYTES(192);
struct {
DRCImagePalette palette;
uint8_t pixelIndex[206][412]; // index of color in palette
} accountSceneImage;
struct {
DRCImagePalette palette;
uint8_t pixelIndex[129][1630]; // index of color in palette
} quickStartScene1;
struct {
DRCImagePalette palette;
uint8_t pixelIndex[85][854]; // index of color in palette
} quickStartScene2;
struct {
DRCImagePalette palette; // this is actually unused. The quick start menu uses the button color palette for the main image as well.
uint8_t pixel[400][854]; // index of color in (button) palette
} killerNotificationMain;
struct {
DRCImagePalette palette;
uint8_t pixelIndex[160][487]; // index of color in palette
} killerNotificationButton;
};
WUT_CHECK_SIZE(TransferableInfo, 0xc1934);
WUT_CHECK_OFFSET(TransferableInfo, 0x00, numAccounts);
WUT_CHECK_OFFSET(TransferableInfo, 0x01, defaultAccountIndex);
WUT_CHECK_OFFSET(TransferableInfo, 0x02, uuids);
WUT_CHECK_OFFSET(TransferableInfo, 0xC2, isNetworkAccount);
WUT_CHECK_OFFSET(TransferableInfo, 0xCE, isPasswordCacheEnabled);
WUT_CHECK_OFFSET(TransferableInfo, 0xda, titleIds);
WUT_CHECK_OFFSET(TransferableInfo, 0x12a, isOnDisc);
WUT_CHECK_OFFSET(TransferableInfo, 0x134, killerNotificationsTitleId);
WUT_CHECK_OFFSET(TransferableInfo, 0x13C, serialId);
WUT_CHECK_OFFSET(TransferableInfo, 0x200, accountSceneImage);
WUT_CHECK_OFFSET(TransferableInfo, 0x15188, quickStartScene1);
WUT_CHECK_OFFSET(TransferableInfo, 0x48ae6, quickStartScene2);
WUT_CHECK_OFFSET(TransferableInfo, 0x5aa74, killerNotificationMain);
WUT_CHECK_OFFSET(TransferableInfo, 0xae4d4, killerNotificationButton);
}; //namespace sl
struct WUT_PACKED TitleInfo {
uint64_t titleId;
MCPAppType appType;
MediaType mediaType;
WUT_UNKNOWN_BYTES(0x10);
};
WUT_CHECK_SIZE(TitleInfo, 0x20);
WUT_CHECK_OFFSET(TitleInfo, 0x00, titleId);
WUT_CHECK_OFFSET(TitleInfo, 0x08, appType);
WUT_CHECK_OFFSET(TitleInfo, 0x0C, mediaType);
}; //namespace nn
struct WUT_PACKED TitleMetaInfo {
bool isPreOrder;
WUT_PADDING_BYTES(3);
};
WUT_CHECK_SIZE(TitleMetaInfo, 0x4);
WUT_CHECK_OFFSET(TitleMetaInfo, 0x00, isPreOrder);
struct WUT_PACKED WhiteList {
MCPAppType titleTypes[50];
uint32_t titleTypeCount;
WUT_PADDING_BYTES(4);
uint64_t titleIds[50];
uint32_t titleIdCount;
};
WUT_CHECK_SIZE(WhiteList, 0x264);
WUT_CHECK_OFFSET(WhiteList, 0x00, titleTypes);
WUT_CHECK_OFFSET(WhiteList, 0xC8, titleTypeCount);
WUT_CHECK_OFFSET(WhiteList, 0xD0, titleIds);
WUT_CHECK_OFFSET(WhiteList, 0x260, titleIdCount);
struct WUT_PACKED Account {
char uuid[0x10];
uint32_t isNetworkAccount;
uint8_t isPasswordCacheEnabled;
uint8_t age;
WUT_PADDING_BYTES(2);
uint32_t gender;
uint32_t simpleAddressId;
uint8_t isMailAddressValidated;
WUT_PADDING_BYTES(1);
uint16_t bday_year;
uint8_t bday_month;
uint8_t bday_day;
WUT_PADDING_BYTES(2);
};
WUT_CHECK_SIZE(Account, 0x28);
WUT_CHECK_OFFSET(Account, 0x00, uuid);
WUT_CHECK_OFFSET(Account, 0x10, isNetworkAccount);
WUT_CHECK_OFFSET(Account, 0x14, isPasswordCacheEnabled);
WUT_CHECK_OFFSET(Account, 0x15, age);
WUT_CHECK_OFFSET(Account, 0x18, gender);
WUT_CHECK_OFFSET(Account, 0x1C, simpleAddressId);
WUT_CHECK_OFFSET(Account, 0x20, isMailAddressValidated);
WUT_CHECK_OFFSET(Account, 0x22, bday_year);
WUT_CHECK_OFFSET(Account, 0x24, bday_month);
WUT_CHECK_OFFSET(Account, 0x25, bday_day);
struct WUT_PACKED AccountInfo {
uint8_t account_index[12];
WUT_UNKNOWN_BYTES(4);
uint32_t num_of_accounts;
Account accounts[12];
};
WUT_CHECK_SIZE(AccountInfo, 0x1f4);
WUT_CHECK_OFFSET(AccountInfo, 0, account_index);
WUT_CHECK_OFFSET(AccountInfo, 0x10, num_of_accounts);
WUT_CHECK_OFFSET(AccountInfo, 0x14, accounts);
struct WUT_PACKED Setting {
struct {
bool enabled;
bool pushEnabled;
bool adEnabled;
bool drcLedEnable;
uint16_t pushInterval;
WUT_PADDING_BYTES(2);
uint32_t pushTimeSlot;
} caffeine;
bool pushAutoDelivery;
WUT_PADDING_BYTES(3);
uint32_t edmStandbyModeLength;
uint32_t language;
uint32_t prodArea;
};
WUT_CHECK_SIZE(Setting, 0x1C);
WUT_CHECK_OFFSET(Setting, 0x0, caffeine.enabled);
WUT_CHECK_OFFSET(Setting, 0x01, caffeine.pushEnabled);
WUT_CHECK_OFFSET(Setting, 0x02, caffeine.adEnabled);
WUT_CHECK_OFFSET(Setting, 0x03, caffeine.drcLedEnable);
WUT_CHECK_OFFSET(Setting, 0x04, caffeine.pushInterval);
WUT_CHECK_OFFSET(Setting, 0x08, caffeine.pushTimeSlot);
WUT_CHECK_OFFSET(Setting, 0x0C, pushAutoDelivery);
WUT_CHECK_OFFSET(Setting, 0x10, edmStandbyModeLength);
WUT_CHECK_OFFSET(Setting, 0x14, language);
WUT_CHECK_OFFSET(Setting, 0x18, prodArea);
struct KillerNotificationTransferRecord {
WUT_UNKNOWN_BYTES(0x18);
};
WUT_CHECK_SIZE(KillerNotificationTransferRecord, 0x18);
typedef enum Region {
REGION_JPN = 0,
REGION_USA = 1,
REGION_EUR = 2
} Region;
enum TransferMode {
TRANSFER_MODE_UNKWN_1 = 1,
TRANSFER_MODE_UNKWN_2 = 2,
TRANSFER_MODE_UNKWN_3 = 3,
};
enum Language {
Japanese = 0,
English = 1,
French = 2,
German = 3,
Italian = 4,
Spanish = 5,
SimplifiedChinese = 6,
Korean = 7,
Dutch = 8,
Portuguese = 9,
Russian = 10,
TraditionalChinese = 11,
};
enum SeekOrigin {
SeekSet = 0
};
void
GetDefaultDatabasePath(char *, int size, uint64_t titleId) asm("GetDefaultDatabasePath__Q2_2nn2slFPcUiUL");
void
GetDefaultDatabasePath(char *, int size) asm("GetDefaultDatabasePath__Q2_2nn2slFPcUi");
void
GetDefaultKillerNotificationTransferRecordPath(char *, int size, uint64_t titleId, const char *) asm("GetDefaultKillerNotificationTransferRecordPath__Q2_2nn2slFPcUiUL");
void Initialize(MEMAllocFromDefaultHeapExFn, MEMFreeToDefaultHeapFn) asm("Initialize__Q2_2nn2slFPFUiT1_PvPFPv_v");
void
Finalize() asm("Finalize__Q2_2nn2slFv");
void
FinalizeForEcoProcess() asm("FinalizeForEcoProcess__Q2_2nn2slFv");
void
InitializeForEcoProcess(MEMAllocFromDefaultHeapExFn allocFn, MEMFreeToDefaultHeapFn freeFn) asm("InitializeForEcoProcess__Q2_2nn2slFPFUiT1_PvPFPv_v");
}; // namespace nn::sl
#endif

13
libraries/nn_sl/IAccountInfoAccessor.cpp Normal file
View File

@ -0,0 +1,13 @@
#include <nn/sl/IAccountInfoAccessor.h>
namespace nn::sl {
namespace {
extern "C" details::IAccountInfoAccessorInternal *GetDefaultAccountInfoAccessor__Q2_2nn2slFv();
}
static details::AccountInfoAccessorFromPtr gAccountInfoAccessor(GetDefaultAccountInfoAccessor__Q2_2nn2slFv());
details::IAccountInfoAccessorBase &GetDefaultAccountInfoAccessor() {
return gAccountInfoAccessor;
}
} // namespace nn::sl

14
libraries/nn_sl/IBlackListAccessor.cpp Normal file
View File

@ -0,0 +1,14 @@
#include <nn/sl/IBlackListAccessor.h>
namespace nn::sl {
namespace {
extern "C" details::IBlackListAccessorInternal *GetDefaultBlackListAccessor__Q2_2nn2slFv();
}
static details::BlackListAccessorFromPtr sDefaultIconInfoAccessor(GetDefaultBlackListAccessor__Q2_2nn2slFv());
details::IBlackListAccessorBase &GetDefaultBlackListAccessor() {
return sDefaultIconInfoAccessor;
}
} // namespace nn::sl

14
libraries/nn_sl/IDefaultTitleAccessor.cpp Normal file
View File

@ -0,0 +1,14 @@
#include <nn/sl/IDefaultTitleAccessor.h>
namespace nn::sl {
namespace {
extern "C" details::IDefaultTitleAccessorInternal *GetDefaultDefaultTitleAccessor__Q2_2nn2slFv();
}
static details::DefaultTitleAccessorFromPtr sDefaultDefaultTitleAccessor(GetDefaultDefaultTitleAccessor__Q2_2nn2slFv());
details::IDefaultTitleAccessorBase &GetDefaultDefaultTitleAccessor() {
return sDefaultDefaultTitleAccessor;
}
} // namespace nn::sl

14
libraries/nn_sl/IDiscCachedTitleAccessor.cpp Normal file
View File

@ -0,0 +1,14 @@
#include <nn/sl/IDiscCachedTitleAccessor.h>
namespace nn::sl {
namespace {
extern "C" details::IDiscCachedTitleAccessorInternal *GetDefaultDiscCachedTitleAccessor__Q2_2nn2slFv();
}
static details::DiscCachedTitleAccessorFromPtr sDefaultDiscCachedTitleListAccessor(GetDefaultDiscCachedTitleAccessor__Q2_2nn2slFv());
details::IDiscCachedTitleAccessorBase &GetDefaultDiscCachedTitleAccessor() {
return sDefaultDiscCachedTitleListAccessor;
}
} // namespace nn::sl

14
libraries/nn_sl/IIconInfoAccessor.cpp Normal file
View File

@ -0,0 +1,14 @@
#include <nn/sl/IIconInfoAccessor.h>
namespace nn::sl {
namespace {
extern "C" details::IIconInfoAccessorInternal *GetDefaultIconInfoAccessor__Q2_2nn2slFv();
}
static details::IconInfoAccessorFromPtr sDefaultIconInfoAccessor(GetDefaultIconInfoAccessor__Q2_2nn2slFv());
details::IIconInfoAccessorBase &GetDefaultIconInfoAccessor() {
return sDefaultIconInfoAccessor;
}
} // namespace nn::sl

14
libraries/nn_sl/IInstalledTitleListAccessor.cpp Normal file
View File

@ -0,0 +1,14 @@
#include <nn/sl/IInstalledTitleListAccessor.h>
namespace nn::sl {
namespace {
extern "C" details::IInstalledTitleListAccessorInternal *GetDefaultInstalledTitleListAccessor__Q2_2nn2slFv();
}
static details::InstalledTitleListAccessorFromPtr sDefaultInstalledTitleListAccessor(GetDefaultInstalledTitleListAccessor__Q2_2nn2slFv());
details::IInstalledTitleListAccessorBase &GetDefaultInstalledTitleListAccessor() {
return sDefaultInstalledTitleListAccessor;
}
} // namespace nn::sl

13
libraries/nn_sl/IKillerNotificationAccessor.cpp Normal file
View File

@ -0,0 +1,13 @@
#include <nn/sl/IKillerNotificationAccessor.h>
namespace nn::sl {
namespace {
extern "C" details::IKillerNotificationAccessorInternal *GetDefaultKillerNotificationAccessor__Q2_2nn2slFv();
}
static details::KillerNotificationAccessorFromPtr sDefaultKillerNotificationAccessor(GetDefaultKillerNotificationAccessor__Q2_2nn2slFv());
details::IKillerNotificationAccessorBase &GetDefaultKillerNotificationAccessor() {
return sDefaultKillerNotificationAccessor;
}
} // namespace nn::sl

26
libraries/nn_sl/ILaunchedTitleListAccessor.cpp Normal file
View File

@ -0,0 +1,26 @@
#include <coreinit/debug.h>
#include <nn/sl/ILaunchedTitleListAccessor.h>
namespace nn::sl {
namespace {
extern "C" details::ILaunchedTitleListAccessorInternal *GetDefaultLaunchedTitleListAccessor__Q2_2nn2slFQ3_2nn2sl29LaunchedTitleListAccessorType(LaunchedTitleListAccessorType type);
extern "C" details::ILaunchedTitleListAccessorInternal *GetDefaultLaunchedTitleListAccessor__Q2_2nn2slFv();
} // namespace
static details::LaunchedTitleListAccessorFromPtr sDefaultLaunchedTitleListAccessorType0(GetDefaultLaunchedTitleListAccessor__Q2_2nn2slFQ3_2nn2sl29LaunchedTitleListAccessorType(TITLE_LIST_ACCESSOR_LAUNCHED_TITLES));
static details::LaunchedTitleListAccessorFromPtr sDefaultLaunchedTitleListAccessorType1(GetDefaultLaunchedTitleListAccessor__Q2_2nn2slFQ3_2nn2sl29LaunchedTitleListAccessorType(TITLE_LIST_ACCESSOR_PLAY_STATS));
details::ILaunchedTitleListAccessorBase &GetDefaultLaunchedTitleListAccessor(LaunchedTitleListAccessorType type) {
if (type == TITLE_LIST_ACCESSOR_LAUNCHED_TITLES) {
return sDefaultLaunchedTitleListAccessorType0;
} else if (type == TITLE_LIST_ACCESSOR_PLAY_STATS) {
return sDefaultLaunchedTitleListAccessorType1;
}
OSFatal("Called GetDefaultLaunchedTitleListAccessor with invalid type");
// not reached
return sDefaultLaunchedTitleListAccessorType1;
}
details::ILaunchedTitleListAccessorBase &GetDefaultLaunchedTitleListAccessor() {
return sDefaultLaunchedTitleListAccessorType0;
}
} // namespace nn::sl

14
libraries/nn_sl/IMetaInfoAccessor.cpp Normal file
View File

@ -0,0 +1,14 @@
#include <nn/sl/IMetaInfoAccessor.h>
namespace nn::sl {
namespace {
extern "C" details::IMetaInfoAccessorInternal *GetDefaultMetaInfoAccessor__Q2_2nn2slFv();
}
static details::MetaInfoAccessorFromPtr sDefaultMetaInfoAccessor(GetDefaultMetaInfoAccessor__Q2_2nn2slFv());
details::IMetaInfoAccessorBase &GetDefaultMetaInfoAccessor() {
return sDefaultMetaInfoAccessor;
}
} // namespace nn::sl

14
libraries/nn_sl/IPreferentialTitleAccessor.cpp Normal file
View File

@ -0,0 +1,14 @@
#include <nn/sl/IPreferentialTitleAccessor.h>
namespace nn::sl {
namespace {
extern "C" details::IPreferentialTitleAccessorInternal *GetDefaultPreferentialTitleAccessor__Q2_2nn2slFv();
}
static details::PreferentialTitleAccessorFromPtr sDefaultPreferentialTitleAccessor(GetDefaultPreferentialTitleAccessor__Q2_2nn2slFv());
details::IPreferentialTitleAccessorBase &GetDefaultPreferentialTitleAccessor() {
return sDefaultPreferentialTitleAccessor;
}
} // namespace nn::sl

38
libraries/nn_sl/ISerializer.cpp Normal file
View File

@ -0,0 +1,38 @@
#include <nn/sl/ISerializer.h>
#include <nn/sl/sl_cpp.h>
namespace nn::sl {
namespace {
extern "C" details::ISerializerInternal *GetDefaultIconInfoSerializer__Q2_2nn2slFv();
extern "C" details::ISerializerInternal *GetDefaultQuickStartTitleInfoSerializer__Q2_2nn2slFv();
extern "C" details::ISerializerInternal *GetDefaultKillerNotificationSerializer__Q2_2nn2slFv();
extern "C" details::ISerializerInternal *GetDefaultJumpTitleInfoSerializer__Q2_2nn2slFv();
extern "C" details::ISerializerInternal *GetDefaultPreviousSendingTimeSerializer__Q2_2nn2slFv();
} // namespace
static details::SerializerFromPtr<nn::sl::IconInfo> sDefaultIconInfoSerializer(GetDefaultIconInfoSerializer__Q2_2nn2slFv());
static details::SerializerFromPtr<nn::sl::TitleInfo> sDefaultQuickStartTitleInfoSerializer(GetDefaultQuickStartTitleInfoSerializer__Q2_2nn2slFv());
static details::SerializerFromPtr<nn::sl::KillerNotification> sDefaultKillerNotificationSerializer(GetDefaultKillerNotificationSerializer__Q2_2nn2slFv());
static details::SerializerFromPtr<nn::sl::TitleInfo> sDefaultJumpTitleInfoSerializer(GetDefaultJumpTitleInfoSerializer__Q2_2nn2slFv());
static details::SerializerFromPtr<OSTime> sDefaultPreviousSendingTimeSerializer(GetDefaultPreviousSendingTimeSerializer__Q2_2nn2slFv());
details::ISerializerBase<nn::sl::IconInfo> &GetDefaultIconInfoSerializer() {
return sDefaultIconInfoSerializer;
}
details::ISerializerBase<nn::sl::TitleInfo> &GetDefaultQuickStartTitleInfoSerializer() {
return sDefaultQuickStartTitleInfoSerializer;
}
details::ISerializerBase<nn::sl::KillerNotification> &GetDefaultKillerNotificationSerializer() {
return sDefaultKillerNotificationSerializer;
}
details::ISerializerBase<nn::sl::TitleInfo> &GetDefaultJumpTitleInfoSerializer() {
return sDefaultJumpTitleInfoSerializer;
}
details::ISerializerBase<OSTime> &GetDefaultPreviousSendingTimeSerializer() {
return sDefaultPreviousSendingTimeSerializer;
}
} // namespace nn::sl

13
libraries/nn_sl/ISettingAccessor.cpp Normal file
View File

@ -0,0 +1,13 @@
#include <nn/sl/ISettingAccessor.h>
namespace nn::sl {
namespace {
extern "C" details::ISettingAccessorInternal *GetDefaultSettingAccessor__Q2_2nn2slFv();
}
static details::SettingAccessorFromPtr sDefaultSettingAccessor(GetDefaultSettingAccessor__Q2_2nn2slFv());
details::ISettingAccessorBase &GetDefaultSettingAccessor() {
return sDefaultSettingAccessor;
}
} // namespace nn::sl

13
libraries/nn_sl/ITimeAccessor.cpp Normal file
View File

@ -0,0 +1,13 @@
#include <nn/sl/ITimeAccessor.h>
namespace nn::sl {
namespace {
extern "C" details::ITimeAccessorInternal *GetDefaultTimeAccessor__Q2_2nn2slFv();
}
static details::TimeAccessorFromPtr sDefaultTimeAccessor(GetDefaultTimeAccessor__Q2_2nn2slFv());
details::ITimeAccessorBase &GetDefaultTimeAccessor() {
return sDefaultTimeAccessor;
}
} // namespace nn::sl

15
libraries/nn_sl/ITitleIconCache.cpp Normal file
View File

@ -0,0 +1,15 @@
#include <nn/sl/ITitleIconCache.h>
#include <nn/sl/TitleIconCache.h>
namespace nn::sl {
namespace {
extern "C" details::ITitleIconCacheInternal *GetDefaultTitleIconCache__Q2_2nn2slFv();
}
static details::TitleIconCacheFromPtr sDefaultTitleIconCache(GetDefaultTitleIconCache__Q2_2nn2slFv());
details::ITitleIconCacheBase &GetDefaultTitleIconCache() {
return sDefaultTitleIconCache;
}
} // namespace nn::sl

14
libraries/nn_sl/ITitleListAccessor.cpp Normal file
View File

@ -0,0 +1,14 @@
#include <nn/sl/ITitleListAccessor.h>
namespace nn::sl {
namespace {
extern "C" details::ITitleListAccessorInternal *GetDefaultTitleListAccessor__Q2_2nn2slFv();
}
static details::TitleListAccessorFromPtr sDefaultTitleListAccessor(GetDefaultTitleListAccessor__Q2_2nn2slFv());
details::ITitleListAccessorBase &GetDefaultTitleListAccessor() {
return sDefaultTitleListAccessor;
}
} // namespace nn::sl

13
libraries/nn_sl/ITransferrer.cpp Normal file
View File

@ -0,0 +1,13 @@
#include <nn/sl/ITransferrer.h>
namespace nn::sl {
namespace {
extern "C" details::ITransferrerInternal *GetDrcTransferrer__Q2_2nn2slFv();
}
static details::TransferrerFromPtr sDrcTransferrer(GetDrcTransferrer__Q2_2nn2slFv());
details::ITransferrerBase &GetDrcTransferrer() {
return sDrcTransferrer;
}
} // namespace nn::sl

14
libraries/nn_sl/IUpdatePackageAccessor.cpp Normal file
View File

@ -0,0 +1,14 @@
#include <nn/sl/IUpdatePackageAccessor.h>
namespace nn::sl {
namespace {
extern "C" details::IUpdatePackageAccessorInternal *GetDefaultUpdatePackageAccessor__Q2_2nn2slFv();
}
static details::UpdatePackageAccessorFromPtr sDefaultUpdatePackageAccessor(GetDefaultUpdatePackageAccessor__Q2_2nn2slFv());
details::IUpdatePackageAccessorBase &GetDefaultUpdatePackageAccessor() {
return sDefaultUpdatePackageAccessor;
}
} // namespace nn::sl

14
libraries/nn_sl/IWhiteListAccessor.cpp Normal file
View File

@ -0,0 +1,14 @@
#include <nn/sl/IWhiteListAccessor.h>
namespace nn::sl {
namespace {
extern "C" details::IWhiteListAccessorInternal *GetDefaultWhiteListAccessor__Q2_2nn2slFv();
}
static details::WhiteListAccessorFromPtr sDefaultIconInfoAccessor(GetDefaultWhiteListAccessor__Q2_2nn2slFv());
details::IWhiteListAccessorBase &GetDefaultWhiteListAccessor() {
return sDefaultIconInfoAccessor;
}
} // namespace nn::sl

13
libraries/nn_sl/KillerNotificationTransferRecordManager.cpp Normal file
View File

@ -0,0 +1,13 @@
#include <nn/sl/KillerNotificationTransferRecordManager.h>
namespace nn::sl {
namespace {
extern "C" details::IKillerNotificationTransferRecordManagerInternal *GetDefaultKillerNotificationTransferRecordManager__Q2_2nn2slFv();
}
static details::KillerNotificationTransferRecordManagerFromPtr sDefaultKillerNotificationTransferRecordManager(GetDefaultKillerNotificationTransferRecordManager__Q2_2nn2slFv());
details::IKillerNotificationTransferRecordManagerBase &GetDefaultKillerNotificationTransferRecordManager() {
return sDefaultKillerNotificationTransferRecordManager;
}
} // namespace nn::sl

13
libraries/nn_sl/KillerNotificationTransferRecordStream.cpp Normal file
View File

@ -0,0 +1,13 @@
#include <nn/sl/KillerNotificationTransferRecordStream.h>
namespace nn::sl {
namespace {
extern "C" details::KillerNotificationTransferRecordStreamInternal *GetDefaultKillerNotificationTransferRecordStream__Q2_2nn2slFv();
}
static KillerNotificationTransferRecordStream sDefaultKillerNotificationTransferRecordStream(GetDefaultKillerNotificationTransferRecordStream__Q2_2nn2slFv());
nn::sl::details::IStreamBase &GetDefaultKillerNotificationTransferRecordStream() {
return sDefaultKillerNotificationTransferRecordStream;
}
} // namespace nn::sl

13
libraries/nn_sl/TitleListCache.cpp Normal file
View File

@ -0,0 +1,13 @@
#include <nn/sl/TitleListCache.h>
namespace nn::sl {
namespace {
extern "C" details::ITitleListCacheInternal *GetDefaultTitleListCache__Q2_2nn2slFv();
}
static TitleListCacheFromPtr sDefaultTitleListCache(GetDefaultTitleListCache__Q2_2nn2slFv());
details::ITitleListCacheBase &GetDefaultTitleListCache() {
return sDefaultTitleListCache;
}
} // namespace nn::sl