/* * This file is part of Checkpoint * Copyright (C) 2017-2018 Bernardo Giordano * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . * * Additional Terms 7.b and 7.c of GPLv3 apply to this file: * * Requiring preservation of specified reasonable legal notices or * author attributions in that material or in the Appropriate Legal * Notices displayed by works containing it. * * Prohibiting misrepresentation of the origin of that material, * or requiring that modified versions of such material be marked in * reasonable ways as different from the original version. */ #include "title.hpp" static std::unordered_map> titles; static std::unordered_map> icons; void freeIcons(void) { for (auto& i : icons) { free(i.second.first); free(i.second.second); } } static void loadIcon(u64 id, NsApplicationControlData* nsacd, size_t iconsize) { auto it = icons.find(id); if (it == icons.end()) { uint8_t* imageptr = NULL; size_t imagesize = 256*256*3; njInit(); if (njDecode(nsacd->icon, iconsize) != NJ_OK) { njDone(); return; } if (njGetWidth() != 256 || njGetHeight() != 256 || (size_t)njGetImageSize() != imagesize || njIsColor() != 1) { njDone(); return; } imageptr = njGetImage(); if (imageptr == NULL) { njDone(); return; } u8* mIcon = (u8*)malloc(imagesize); std::copy(imageptr, imageptr + imagesize, mIcon); u8* mSmallIcon = (u8*)malloc(128*128*3); downscaleRGBImg(mIcon, mSmallIcon, 256, 256, 128, 128); icons.insert({id, std::make_pair(mIcon, mSmallIcon)}); imageptr = NULL; njDone(); } } void Title::init(u8 saveDataType, u64 id, u128 userID, const std::string& name, const std::string& author) { mId = id; mUserId = userID; mSaveDataType = saveDataType; mUserName = Account::username(userID); mAuthor = author; mDisplayName = name; mSafeName = StringUtils::containsInvalidChar(name) ? StringUtils::format("0x%016llX", mId) : StringUtils::removeForbiddenCharacters(name); mPath = "sdmc:/switch/Checkpoint/saves/" + StringUtils::format("0x%016llX", mId) + " " + mSafeName; if (!io::directoryExists(mPath)) { io::createDirectory(mPath); } refreshDirectories(); } bool Title::systemSave(void) { return mSaveDataType != FsSaveDataType_SaveData; } u8 Title::saveDataType(void) { return mSaveDataType; } u64 Title::id(void) { return mId; } u128 Title::userId(void) { return mUserId; } std::string Title::userName(void) { return mUserName; } std::string Title::author(void) { return mAuthor; } std::string Title::name(void) { return mDisplayName; } std::string Title::path(void) { return mPath; } std::string Title::fullPath(size_t index) { return mFullSavePaths.at(index); } std::vector Title::saves() { return mSaves; } u8* Title::icon(void) { auto it = icons.find(mId); return it != icons.end() ? it->second.first : NULL; } u8* Title::smallIcon(void) { auto it = icons.find(mId); return it != icons.end() ? it->second.second : NULL; } void Title::refreshDirectories(void) { mSaves.clear(); mFullSavePaths.clear(); Directory savelist(mPath); if (savelist.good()) { for (size_t i = 0, sz = savelist.size(); i < sz; i++) { if (savelist.folder(i)) { mSaves.push_back(savelist.entry(i)); mFullSavePaths.push_back(mPath + "/" + savelist.entry(i)); } } std::sort(mSaves.rbegin(), mSaves.rend()); std::sort(mFullSavePaths.rbegin(), mFullSavePaths.rend()); mSaves.insert(mSaves.begin(), "New..."); mFullSavePaths.insert(mFullSavePaths.begin(), "New..."); } else { Gui::createError(savelist.error(), "Couldn't retrieve the directory list for the title " + name() + "."); } // save backups from configuration std::vector additionalFolders = Configuration::getInstance().additionalSaveFolders(mId); for (std::vector::const_iterator it = additionalFolders.begin(); it != additionalFolders.end(); it++) { // we have other folders to parse Directory list(*it); if (list.good()) { for (size_t i = 0, sz = list.size(); i < sz; i++) { if (list.folder(i)) { mSaves.push_back(list.entry(i)); mFullSavePaths.push_back(*it + "/" + list.entry(i)); } } } } } void loadTitles(void) { titles.clear(); FsSaveDataIterator iterator; FsSaveDataInfo info; size_t total_entries = 0; size_t outsize = 0; NacpLanguageEntry* nle = NULL; NsApplicationControlData* nsacd = (NsApplicationControlData*)malloc(sizeof(NsApplicationControlData)); if (nsacd == NULL) { return; } memset(nsacd, 0, sizeof(NsApplicationControlData)); Result res = fsOpenSaveDataIterator(&iterator, FsSaveDataSpaceId_NandUser); if (R_FAILED(res)) { return; } while(1) { res = fsSaveDataIteratorRead(&iterator, &info, 1, &total_entries); if (R_FAILED(res) || total_entries == 0) { break; } if (info.SaveDataType == FsSaveDataType_SaveData) { u64 tid = info.titleID; u128 uid = info.userID; if (!Configuration::getInstance().filter(tid)) { res = nsGetApplicationControlData(1, tid, nsacd, sizeof(NsApplicationControlData), &outsize); if (R_SUCCEEDED(res) && !(outsize < sizeof(nsacd->nacp))) { res = nacpGetLanguageEntry(&nsacd->nacp, &nle); if (R_SUCCEEDED(res) && nle != NULL) { Title title; title.init(info.SaveDataType, tid, uid, std::string(nle->name), std::string(nle->author)); loadIcon(tid, nsacd, outsize - sizeof(nsacd->nacp)); // check if the vector is already created std::unordered_map>::iterator it = titles.find(uid); if (it != titles.end()) { // found it->second.push_back(title); } else { // not found, insert into map std::vector v; v.push_back(title); titles.emplace(uid, v); } } } nle = NULL; } } } free(nsacd); fsSaveDataIteratorClose(&iterator); for (auto& vect : titles) { std::sort(vect.second.begin(), vect.second.end(), [](Title& l, Title& r) { return l.name() < r.name() && Configuration::getInstance().favorite(l.id()) > Configuration::getInstance().favorite(r.id()); }); } } void getTitle(Title &dst, u128 uid, size_t i) { std::unordered_map<u128, std::vector<Title>>::iterator it = titles.find(uid); if (it != titles.end() && i < getTitleCount(uid)) { dst = it->second.at(i); } } size_t getTitleCount(u128 uid) { std::unordered_map<u128, std::vector<Title>>::iterator it = titles.find(uid); return it != titles.end() ? it->second.size() : 0; } bool favorite(u128 uid, int i) { std::unordered_map<u128, std::vector<Title>>::iterator it = titles.find(uid); return it != titles.end() ? Configuration::getInstance().favorite(it->second.at(i).id()) : false; } void refreshDirectories(u64 id) { for (auto& pair : titles) { for (size_t i = 0; i < pair.second.size(); i++) { if (pair.second.at(i).id() == id) { pair.second.at(i).refreshDirectories(); } } } } u8* smallIcon(u128 uid, size_t i) { std::unordered_map<u128, std::vector<Title>>::iterator it = titles.find(uid); return it != titles.end() ? it->second.at(i).smallIcon() : NULL; }