CStdString SystemFolderInfo::GetCommonStartMenu()
{
CStdString sPath;
switch (GetWindowsVersion())
{
case WINDOWS_95:
case WINDOWS_ME:
case WINDOWS_98:
{
if (HasWin98UserGotProfile())
sPath = GetProfilePath();
else
sPath = GetWindowsPath();
sPath += _T("\\Local Settings\\Start Menu");
}
break;
case WINDOWS_NT:
case WINDOWS_2K:
case WINDOWS_XP:
case WINDOWS_2003SERVER:
default:
sPath = GetFolderPath(CSIDL_COMMON_STARTMENU, NULL);
break;
}
ValidatePath(sPath, CSIDL_COMMON_STARTMENU);
return sPath;
}
NS_IMETHODIMP
nsDogbertProfileMigrator::Migrate(PRUint16 aItems, nsIProfileStartup* aStartup,
const PRUnichar* aProfile)
{
nsresult rv = NS_OK;
PRBool aReplace = aStartup ? PR_TRUE : PR_FALSE;
if (!mTargetProfile) {
GetProfilePath(aStartup, mTargetProfile);
if (!mTargetProfile) return NS_ERROR_FAILURE;
}
if (!mSourceProfile) {
GetSourceProfile(aProfile);
if (!mSourceProfile)
return NS_ERROR_FAILURE;
}
NOTIFY_OBSERVERS(MIGRATION_STARTED, nsnull);
COPY_DATA(CopyPreferences, aReplace, nsIBrowserProfileMigrator::SETTINGS);
COPY_DATA(CopyCookies, aReplace, nsIBrowserProfileMigrator::COOKIES);
COPY_DATA(CopyBookmarks, aReplace, nsIBrowserProfileMigrator::BOOKMARKS);
NOTIFY_OBSERVERS(MIGRATION_ENDED, nsnull);
return rv;
}
NS_IMETHODIMP
nsMacIEProfileMigrator::Migrate(PRUint16 aItems, nsIProfileStartup* aStartup, const PRUnichar* aProfile)
{
nsresult rv = NS_OK;
PRBool replace = aStartup ? PR_TRUE : PR_FALSE;
if (!mTargetProfile) {
GetProfilePath(aStartup, mTargetProfile);
if (!mTargetProfile) return NS_ERROR_FAILURE;
}
if (!mSourceProfile) {
nsCOMPtr<nsIProperties> fileLocator =
do_GetService("@mozilla.org/file/directory_service;1", &rv);
NS_ENSURE_SUCCESS(rv, rv);
fileLocator->Get(NS_OSX_USER_PREFERENCES_DIR,
NS_GET_IID(nsILocalFile),
getter_AddRefs(mSourceProfile));
mSourceProfile->Append(MACIE_PREFERENCES_FOLDER_NAME);
}
NOTIFY_OBSERVERS(MIGRATION_STARTED, nsnull);
COPY_DATA(CopyBookmarks, replace, nsIBrowserProfileMigrator::BOOKMARKS);
NOTIFY_OBSERVERS(MIGRATION_ENDED, nsnull);
return rv;
}
CStdString SystemFolderInfo::GetLocalUserAppDataPath()
{
CStdString sPath;
switch (GetWindowsVersion())
{
case WINDOWS_95:
case WINDOWS_ME:
case WINDOWS_98:
{
if (HasWin98UserGotProfile())
sPath = GetProfilePath() + _T("\\Application Data");
else
sPath = GetWindowsPath() + _T("\\Local Settings\\Application Data");
}
break;
case WINDOWS_NT:
case WINDOWS_2K:
case WINDOWS_XP:
case WINDOWS_2003SERVER:
default:
sPath = GetFolderPath(CSIDL_APPDATA, NULL);
break;
}
ValidatePath(sPath, CSIDL_APPDATA);
return sPath;
}
NS_IMETHODIMP
nsThunderbirdProfileMigrator::Migrate(uint16_t aItems,
nsIProfileStartup* aStartup,
const PRUnichar* aProfile)
{
nsresult rv = NS_OK;
bool aReplace = aStartup ? true : false;
if (!mTargetProfile) {
GetProfilePath(aStartup, getter_AddRefs(mTargetProfile));
if (!mTargetProfile)
return NS_ERROR_FILE_NOT_FOUND;
}
if (!mSourceProfile) {
GetSourceProfile(aProfile);
if (!mSourceProfile)
return NS_ERROR_FILE_NOT_FOUND;
}
NOTIFY_OBSERVERS(MIGRATION_STARTED, nullptr);
COPY_DATA(CopyPreferences, aReplace, nsISuiteProfileMigrator::SETTINGS);
COPY_DATA(CopyCookies, aReplace, nsISuiteProfileMigrator::COOKIES);
COPY_DATA(CopyHistory, aReplace, nsISuiteProfileMigrator::HISTORY);
COPY_DATA(CopyPasswords, aReplace, nsISuiteProfileMigrator::PASSWORDS);
COPY_DATA(CopyOtherData, aReplace, nsISuiteProfileMigrator::OTHERDATA);
// fake notifications for things we've already imported as part of
// CopyPreferences
nsAutoString index;
index.AppendInt(nsISuiteProfileMigrator::ACCOUNT_SETTINGS);
NOTIFY_OBSERVERS(MIGRATION_ITEMBEFOREMIGRATE, index.get());
NOTIFY_OBSERVERS(MIGRATION_ITEMAFTERMIGRATE, index.get());
index.Truncate();
index.AppendInt(nsISuiteProfileMigrator::NEWSDATA);
NOTIFY_OBSERVERS(MIGRATION_ITEMBEFOREMIGRATE, index.get());
NOTIFY_OBSERVERS(MIGRATION_ITEMAFTERMIGRATE, index.get());
// copy junk mail training file
COPY_DATA(CopyJunkTraining, aReplace, nsISuiteProfileMigrator::JUNKTRAINING);
if (aReplace &&
(aItems & nsISuiteProfileMigrator::SETTINGS ||
aItems & nsISuiteProfileMigrator::COOKIES ||
aItems & nsISuiteProfileMigrator::PASSWORDS ||
!aItems)) {
// Permissions (Images, Cookies, Popups)
rv |= CopyFile(FILE_NAME_SITEPERM_NEW, FILE_NAME_SITEPERM_NEW);
rv |= CopyFile(FILE_NAME_SITEPERM_OLD, FILE_NAME_SITEPERM_OLD);
}
// the last thing to do is to actually copy over any mail folders
// we have marked for copying we want to do this last and it will be
// asynchronous so the UI doesn't freeze up while we perform
// this potentially very long operation.
CopyMailFolders();
return rv;
}
// Serializes the profiles to disk.
void ProfileManager::SaveCache()
{
String path = GetProfilePath(true);
Lock::Locker lockScope(&ProfileLock);
// TODO: Since there is only a single device type now, a full tree overwrite
// is sufficient but in the future a selective device branch replacement will
// be necessary
Ptr<JSON> root = *JSON::CreateObject();
root->AddNumberItem("Oculus Profile Version", PROFILE_VERSION);
root->AddStringItem("CurrentProfile", DefaultProfile);
root->AddNumberItem("ProfileCount", (double) ProfileCache.GetSize());
// Generate a JSON subtree for each profile
for (unsigned int i=0; i<ProfileCache.GetSize(); i++)
{
Profile* profile = ProfileCache[i];
JSON* json_profile = JSON::CreateObject();
json_profile->Name = "Profile";
json_profile->AddStringItem("Name", profile->Name);
const char* gender;
switch (profile->GetGender())
{
case Profile::Gender_Male: gender = "Male"; break;
case Profile::Gender_Female: gender = "Female"; break;
default: gender = "Unspecified";
}
json_profile->AddStringItem("Gender", gender);
json_profile->AddNumberItem("PlayerHeight", profile->PlayerHeight);
json_profile->AddNumberItem("IPD", profile->IPD);
if (profile->Type == Profile_RiftDK1)
{
RiftDK1Profile* riftdk1 = (RiftDK1Profile*)profile;
JSON* json_riftdk1 = JSON::CreateObject();
json_profile->AddItem("RiftDK1", json_riftdk1);
const char* eyecup = "A";
switch (riftdk1->EyeCups)
{
case RiftDK1Profile::EyeCup_A: eyecup = "A"; break;
case RiftDK1Profile::EyeCup_B: eyecup = "B"; break;
case RiftDK1Profile::EyeCup_C: eyecup = "C"; break;
}
json_riftdk1->AddStringItem("EyeCup", eyecup);
json_riftdk1->AddNumberItem("LL", riftdk1->LL);
json_riftdk1->AddNumberItem("LR", riftdk1->LR);
json_riftdk1->AddNumberItem("RL", riftdk1->RL);
json_riftdk1->AddNumberItem("RR", riftdk1->RR);
}
root->AddItem("Profile", json_profile);
}
root->Save(path);
}
// Serializes the profiles to disk.
void ProfileManager::Save()
{
Lock::Locker lockScope(&ProfileLock);
if (ProfileCache == NULL)
return;
// Save the profile to disk
BasePath = GetBaseOVRPath(true); // create the base directory if it doesn't exist
String path = GetProfilePath();
ProfileCache->Save(path);
Changed = false;
}
static BOOL CmpCurrentAndRegistry()
{
HKEY hKey;
if ( RegOpenKeyEx(ROOT_KEY, SUB_KEY, 0, KEY_QUERY_VALUE, &hKey) != ERROR_SUCCESS)
return FALSE;
TCHAR result[MAX_PATH], dbpath[MAX_PATH];
DWORD dwBufLen = MAX_PATH;
if ( RegQueryValueEx(hKey, _T("MirandaNG"), NULL, NULL, (LPBYTE)dbpath, &dwBufLen) != ERROR_SUCCESS)
return FALSE;
GetProfilePath(result, _countof(result));
return mir_tstrcmpi(result, dbpath) == 0;
}
void plProfileManagerFull::ILogStats()
{
wchar_t statFilename[256];
hsSnwprintf(statFilename, 256, L"%s%s.csv", GetProfilePath(), fLogAgeName.c_str());
bool exists = plFileUtils::FileExists(statFilename);
hsUNIXStream s;
if (s.Open(statFilename, L"ab"))
{
GroupSet groups;
GetGroups(groups);
GroupSet::iterator it;
if (!exists)
{
const char* kSpawn = "Spawn";
s.Write(strlen(kSpawn), kSpawn);
s.WriteByte(',');
for (it = groups.begin(); it != groups.end(); it++)
{
plString groupName = *it;
IPrintGroup(&s, groupName.c_str(), true);
}
s.WriteByte('\r');
s.WriteByte('\n');
}
s.Write(fLogSpawnName.length(), fLogSpawnName.c_str());
s.WriteByte(',');
for (it = groups.begin(); it != groups.end(); it++)
{
plString groupName = *it;
IPrintGroup(&s, groupName.c_str());
}
s.WriteByte('\r');
s.WriteByte('\n');
s.Close();
}
fLogStats = false;
fLogAgeName = L"";
fLogSpawnName = "";
}
NS_IMETHODIMP
nsSeamonkeyProfileMigrator::Migrate(PRUint16 aItems, nsIProfileStartup* aStartup, const PRUnichar* aProfile)
{
nsresult rv = NS_OK;
PRBool aReplace = aStartup ? PR_TRUE : PR_FALSE;
if (!mTargetProfile) {
GetProfilePath(aStartup, mTargetProfile);
if (!mTargetProfile) return NS_ERROR_FAILURE;
}
if (!mSourceProfile)
GetSourceProfile(aProfile);
NOTIFY_OBSERVERS(MIGRATION_STARTED, nsnull);
COPY_DATA(CopyPreferences, aReplace, nsIBrowserProfileMigrator::SETTINGS);
COPY_DATA(CopyCookies, aReplace, nsIBrowserProfileMigrator::COOKIES);
COPY_DATA(CopyHistory, aReplace, nsIBrowserProfileMigrator::HISTORY);
COPY_DATA(CopyPasswords, aReplace, nsIBrowserProfileMigrator::PASSWORDS);
COPY_DATA(CopyOtherData, aReplace, nsIBrowserProfileMigrator::OTHERDATA);
// Need to do startup before trying to copy bookmarks, since bookmarks
// import requires a profile. Can't do it earlier because services might
// end up creating the files we try to copy above.
if (aStartup) {
rv = aStartup->DoStartup();
NS_ENSURE_SUCCESS(rv, rv);
}
COPY_DATA(CopyBookmarks, aReplace, nsIBrowserProfileMigrator::BOOKMARKS);
if (aReplace &&
(aItems & nsIBrowserProfileMigrator::SETTINGS ||
aItems & nsIBrowserProfileMigrator::COOKIES ||
aItems & nsIBrowserProfileMigrator::PASSWORDS ||
!aItems)) {
// Permissions (Images, Cookies, Popups)
rv |= CopyFile(FILE_NAME_SITEPERM_NEW, FILE_NAME_SITEPERM_NEW);
rv |= CopyFile(FILE_NAME_SITEPERM_OLD, FILE_NAME_SITEPERM_OLD);
}
NOTIFY_OBSERVERS(MIGRATION_ENDED, nsnull);
return rv;
}
static OBSData OpenServiceSettings(std::string &type)
{
char serviceJsonPath[512];
int ret = GetProfilePath(serviceJsonPath, sizeof(serviceJsonPath),
SERVICE_PATH);
if (ret <= 0)
return OBSData();
OBSData data = obs_data_create_from_json_file_safe(serviceJsonPath,
"bak");
obs_data_release(data);
obs_data_set_default_string(data, "type", "rtmp_common");
type = obs_data_get_string(data, "type");
OBSData settings = obs_data_get_obj(data, "settings");
obs_data_release(settings);
return settings;
}
static void SetAutorun(BOOL autorun)
{
HKEY hKey;
DWORD dw;
switch (autorun) {
case TRUE:
if ( RegCreateKeyEx(ROOT_KEY, SUB_KEY, 0, NULL, 0, KEY_CREATE_SUB_KEY|KEY_SET_VALUE,NULL,&hKey,&dw) == ERROR_SUCCESS) {
TCHAR result[MAX_PATH];
GetProfilePath(result, _countof(result));
RegSetValueEx(hKey, _T("MirandaNG"), 0, REG_SZ, (BYTE*)result, sizeof(TCHAR)*(DWORD)mir_tstrlen(result));
RegCloseKey(hKey);
}
break;
case FALSE:
if ( RegOpenKey(ROOT_KEY, SUB_KEY, &hKey) == ERROR_SUCCESS) {
RegDeleteValue(hKey, _T("MirandaNG"));
RegCloseKey(hKey);
}
break;
}
}
NS_IMETHODIMP
nsSeamonkeyProfileMigrator::Migrate(PRUint16 aItems, nsIProfileStartup* aStartup, const PRUnichar* aProfile)
{
nsresult rv = NS_OK;
PRBool aReplace = aStartup ? PR_TRUE : PR_FALSE;
if (!mTargetProfile) {
GetProfilePath(aStartup, mTargetProfile);
if (!mTargetProfile) return NS_ERROR_FAILURE;
}
if (!mSourceProfile)
GetSourceProfile(aProfile);
NOTIFY_OBSERVERS(MIGRATION_STARTED, nsnull);
COPY_DATA(CopyPreferences, aReplace, nsIBrowserProfileMigrator::SETTINGS);
COPY_DATA(CopyCookies, aReplace, nsIBrowserProfileMigrator::COOKIES);
COPY_DATA(CopyHistory, aReplace, nsIBrowserProfileMigrator::HISTORY);
COPY_DATA(CopyPasswords, aReplace, nsIBrowserProfileMigrator::PASSWORDS);
COPY_DATA(CopyOtherData, aReplace, nsIBrowserProfileMigrator::OTHERDATA);
COPY_DATA(CopyBookmarks, aReplace, nsIBrowserProfileMigrator::BOOKMARKS);
if (aReplace &&
(aItems & nsIBrowserProfileMigrator::SETTINGS ||
aItems & nsIBrowserProfileMigrator::COOKIES ||
aItems & nsIBrowserProfileMigrator::PASSWORDS ||
!aItems)) {
// Permissions (Images, Cookies, Popups)
rv |= CopyFile(FILE_NAME_SITEPERM_NEW, FILE_NAME_SITEPERM_NEW);
rv |= CopyFile(FILE_NAME_SITEPERM_OLD, FILE_NAME_SITEPERM_OLD);
}
NOTIFY_OBSERVERS(MIGRATION_ENDED, nsnull);
return rv;
}
// Poplulates the local profile cache. This occurs on the first access of the profile
// data. All profile operations are performed against the local cache until the
// ProfileManager is released or goes out of scope at which time the cache is serialized
// to disk.
void ProfileManager::LoadCache(ProfileType device)
{
Lock::Locker lockScope(&ProfileLock);
ClearCache();
String path = GetProfilePath(false);
Ptr<JSON> root = *JSON::Load(path);
if (!root || root->GetItemCount() < 3)
return;
// First read the file type and version to make sure this is a valid file
JSON* item0 = root->GetFirstItem();
JSON* item1 = root->GetNextItem(item0);
JSON* item2 = root->GetNextItem(item1);
if (OVR_strcmp(item0->Name, "Oculus Profile Version") == 0)
{ // In the future I may need to check versioning to determine parse method
}
else
{
return;
}
DefaultProfile = item1->Value;
// Read the number of profiles
int profileCount = (int)item2->dValue;
JSON* profileItem = item2;
for (int p=0; p<profileCount; p++)
{
profileItem = profileItem->GetNextItem(profileItem);
if (!profileItem)
break;
// Read the required Name field
const char* profileName;
JSON* item = profileItem->GetFirstItem();
if (item && (OVR_strcmp(item->Name, "Name") == 0))
{
profileName = item->Value;
}
else
{
return; // invalid field
}
const char* deviceName = 0;
bool deviceFound = false;
Ptr<Profile> profile = *CreateProfileObject(profileName, device, &deviceName);
// Read the base profile fields.
if (profile)
{
while (item = profileItem->GetNextItem(item), item)
{
if (item->Type != JSON_Object)
{
profile->ParseProperty(item->Name, item->Value);
}
else
{ // Search for the matching device to get device specific fields
if (!deviceFound && OVR_strcmp(item->Name, deviceName) == 0)
{
deviceFound = true;
for (JSON* deviceItem = item->GetFirstItem(); deviceItem;
deviceItem = item->GetNextItem(deviceItem))
{
profile->ParseProperty(deviceItem->Name, deviceItem->Value);
}
}
}
}
}
// Add the new profile
if (deviceFound)
ProfileCache.PushBack(profile);
}
CacheDevice = device;
}
nsresult
nsOperaProfileMigrator::CopyBookmarksBatched(PRBool aReplace)
{
// Find Opera Bookmarks
nsCOMPtr<nsIFile> operaBookmarks;
mOperaProfile->Clone(getter_AddRefs(operaBookmarks));
operaBookmarks->Append(OPERA_BOOKMARKS_FILE_NAME);
nsCOMPtr<nsIInputStream> fileInputStream;
NS_NewLocalFileInputStream(getter_AddRefs(fileInputStream), operaBookmarks);
NS_ENSURE_TRUE(fileInputStream, NS_ERROR_OUT_OF_MEMORY);
nsCOMPtr<nsILineInputStream> lineInputStream(do_QueryInterface(fileInputStream));
nsresult rv;
nsCOMPtr<nsINavBookmarksService> bms =
do_GetService(NS_NAVBOOKMARKSSERVICE_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
PRInt64 bookmarksMenuFolderId;
rv = bms->GetBookmarksMenuFolder(&bookmarksMenuFolderId);
NS_ENSURE_SUCCESS(rv, rv);
PRInt64 parentFolder = bookmarksMenuFolderId;
nsCOMPtr<nsIStringBundleService> bundleService =
do_GetService(NS_STRINGBUNDLE_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIStringBundle> bundle;
rv = bundleService->CreateBundle(MIGRATION_BUNDLE, getter_AddRefs(bundle));
NS_ENSURE_SUCCESS(rv, rv);
if (!aReplace) {
nsString sourceNameOpera;
rv = bundle->GetStringFromName(NS_LITERAL_STRING("sourceNameOpera").get(),
getter_Copies(sourceNameOpera));
NS_ENSURE_SUCCESS(rv, rv);
const PRUnichar* sourceNameStrings[] = { sourceNameOpera.get() };
nsString importedOperaHotlistTitle;
rv = bundle->FormatStringFromName(NS_LITERAL_STRING("importedBookmarksFolder").get(),
sourceNameStrings, 1,
getter_Copies(importedOperaHotlistTitle));
NS_ENSURE_SUCCESS(rv, rv);
rv = bms->CreateFolder(parentFolder,
NS_ConvertUTF16toUTF8(importedOperaHotlistTitle),
nsINavBookmarksService::DEFAULT_INDEX,
&parentFolder);
NS_ENSURE_SUCCESS(rv, rv);
}
else {
nsCOMPtr<nsIFile> profile;
GetProfilePath(nsnull, profile);
rv = InitializeBookmarks(profile);
NS_ENSURE_SUCCESS(rv, rv);
}
#if defined(XP_WIN) || (defined(XP_UNIX) && !defined(XP_MACOSX))
CopySmartKeywords(bms, bundle, parentFolder);
#endif
PRInt64 bookmarksToolbarFolderId;
rv = bms->GetToolbarFolder(&bookmarksToolbarFolderId);
NS_ENSURE_SUCCESS(rv, rv);
rv = ParseBookmarksFolder(lineInputStream, parentFolder,
bookmarksToolbarFolderId, bms);
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
// Serializes the profiles to disk.
void ProfileManager::SaveCache()
{
String path = GetProfilePath(true);
Lock::Locker lockScope(&ProfileLock);
Ptr<JSON> oldroot = *JSON::Load(path);
if (oldroot)
{
if (oldroot->GetItemCount() >= 3)
{
JSON* item0 = oldroot->GetFirstItem();
JSON* item1 = oldroot->GetNextItem(item0);
oldroot->GetNextItem(item1);
if (item0->Name == "Oculus Profile Version")
{
int major = atoi(item0->Value.ToCStr());
if (major > MAX_PROFILE_MAJOR_VERSION)
oldroot.Clear(); // don't use the file on unsupported major version number
}
else
{
oldroot.Clear();
}
}
else
{
oldroot.Clear();
}
}
// Create a new json root
Ptr<JSON> root = *JSON::CreateObject();
root->AddNumberItem("Oculus Profile Version", PROFILE_VERSION);
root->AddStringItem("CurrentProfile", DefaultProfile);
root->AddNumberItem("ProfileCount", (double) ProfileCache.GetSize());
// Generate a JSON subtree for each profile
for (unsigned int i=0; i<ProfileCache.GetSize(); i++)
{
Profile* profile = ProfileCache[i];
// Write the base profile information
JSON* json_profile = JSON::CreateObject();
json_profile->Name = "Profile";
json_profile->AddStringItem("Name", profile->Name);
const char* gender;
switch (profile->GetGender())
{
case Profile::Gender_Male: gender = "Male"; break;
case Profile::Gender_Female: gender = "Female"; break;
default: gender = "Unspecified";
}
json_profile->AddStringItem("Gender", gender);
json_profile->AddNumberItem("PlayerHeight", profile->PlayerHeight);
json_profile->AddNumberItem("IPD", profile->IPD);
const char* device_name = NULL;
// Create a device-specific subtree for the cached device
if (profile->Type == Profile_RiftDK1)
{
device_name = "RiftDK1";
RiftDK1Profile* rift = (RiftDK1Profile*)profile;
JSON* json_rift = JSON::CreateObject();
json_profile->AddItem(device_name, json_rift);
const char* eyecup = "A";
switch (rift->EyeCups)
{
case EyeCup_A: eyecup = "A"; break;
case EyeCup_B: eyecup = "B"; break;
case EyeCup_C: eyecup = "C"; break;
}
json_rift->AddStringItem("EyeCup", eyecup);
json_rift->AddNumberItem("LL", rift->LL);
json_rift->AddNumberItem("LR", rift->LR);
json_rift->AddNumberItem("RL", rift->RL);
json_rift->AddNumberItem("RR", rift->RR);
}
else if (profile->Type == Profile_RiftDKHD)
{
device_name = "RiftDKHD";
RiftDKHDProfile* rift = (RiftDKHDProfile*)profile;
JSON* json_rift = JSON::CreateObject();
json_profile->AddItem(device_name, json_rift);
const char* eyecup = "A";
switch (rift->EyeCups)
{
case EyeCup_A: eyecup = "A"; break;
case EyeCup_B: eyecup = "B"; break;
case EyeCup_C: eyecup = "C"; break;
}
json_rift->AddStringItem("EyeCup", eyecup);
//json_rift->AddNumberItem("LL", rift->LL);
//json_rift->AddNumberItem("LR", rift->LR);
//json_rift->AddNumberItem("RL", rift->RL);
//json_rift->AddNumberItem("RR", rift->RR);
}
// There may be multiple devices stored per user, but only a single
// device is represented by this root. We don't want to overwrite
// the other devices so we need to examine the older root
// and merge previous devices into new json root
if (oldroot)
{
JSON* old_profile = oldroot->GetFirstItem();
while (old_profile)
{
if (old_profile->Name == "Profile")
{
JSON* profile_name = old_profile->GetItemByName("Name");
if (profile_name && OVR_strcmp(profile->Name, profile_name->Value) == 0)
{ // Now that we found the user in the older root, add all the
// object children to the new root - except for the one for the
// current device
JSON* old_item = old_profile->GetFirstItem();
while (old_item)
{
if (old_item->Type == JSON_Object
&& (device_name == NULL || OVR_strcmp(old_item->Name, device_name) != 0))
{
JSON* old_device = old_item;
old_item = old_profile->GetNextItem(old_item);
// remove the node from the older root to avoid multiple reference
old_device->RemoveNode();
// add the node pointer to the new root
json_profile->AddItem(old_device->Name, old_device);
}
else
{
old_item = old_profile->GetNextItem(old_item);
}
}
break;
}
}
old_profile = oldroot->GetNextItem(old_profile);
}
}
// Add the completed user profile to the new root
root->AddItem("Profile", json_profile);
}
// Save the profile to disk
root->Save(path);
}
// Poplulates the local profile cache. This occurs on the first access of the profile
// data. All profile operations are performed against the local cache until the
// ProfileManager is released or goes out of scope at which time the cache is serialized
// to disk.
void ProfileManager::LoadCache(ProfileType device)
{
Lock::Locker lockScope(&ProfileLock);
ClearCache();
String path = GetProfilePath(false);
Ptr<JSON> root = *JSON::Load(path);
if (!root || root->GetItemCount() < 3)
return;
// First read the file type and version to make sure this is a valid file
JSON* item0 = root->GetFirstItem();
JSON* item1 = root->GetNextItem(item0);
JSON* item2 = root->GetNextItem(item1);
if (item0->Name == "Oculus Profile Version")
{
int major = atoi(item0->Value.ToCStr());
if (major > MAX_PROFILE_MAJOR_VERSION)
return; // don't parse the file on unsupported major version number
}
else
{
return;
}
DefaultProfile = item1->Value;
// Read the number of profiles
int profileCount = (int)item2->dValue;
JSON* profileItem = item2;
for (int p=0; p<profileCount; p++)
{
profileItem = root->GetNextItem(profileItem);
if (profileItem == NULL)
break;
if (profileItem->Name == "Profile")
{
// Read the required Name field
const char* profileName;
JSON* item = profileItem->GetFirstItem();
if (item && (item->Name == "Name"))
{
profileName = item->Value;
}
else
{
return; // invalid field
}
const char* deviceName = 0;
bool deviceFound = false;
Ptr<Profile> profile = *CreateProfileObject(profileName, device, &deviceName);
// Read the base profile fields.
if (profile)
{
while (item = profileItem->GetNextItem(item), item)
{
if (item->Type != JSON_Object)
{
profile->ParseProperty(item->Name, item->Value);
}
else
{ // Search for the matching device to get device specific fields
if (!deviceFound && deviceName && OVR_strcmp(item->Name, deviceName) == 0)
{
deviceFound = true;
for (JSON* deviceItem = item->GetFirstItem(); deviceItem;
deviceItem = item->GetNextItem(deviceItem))
{
profile->ParseProperty(deviceItem->Name, deviceItem->Value);
}
}
}
}
}
// Add the new profile
ProfileCache.PushBack(profile);
}
}
CacheDevice = device;
}
nsresult
nsSafariProfileMigrator::CopyBookmarksBatched(bool aReplace)
{
// If "aReplace" is true, merge into the root level of bookmarks. Otherwise, create
// a folder called "Imported Safari Favorites" and place all the Bookmarks there.
nsresult rv;
nsCOMPtr<nsINavBookmarksService> bms =
do_GetService(NS_NAVBOOKMARKSSERVICE_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
PRInt64 bookmarksMenuFolderId;
rv = bms->GetBookmarksMenuFolder(&bookmarksMenuFolderId);
NS_ENSURE_SUCCESS(rv, rv);
PRInt64 folder;
if (!aReplace) {
nsCOMPtr<nsIStringBundleService> bundleService =
do_GetService(NS_STRINGBUNDLE_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIStringBundle> bundle;
rv = bundleService->CreateBundle(MIGRATION_BUNDLE, getter_AddRefs(bundle));
NS_ENSURE_SUCCESS(rv, rv);
nsString sourceNameSafari;
rv = bundle->GetStringFromName(NS_LITERAL_STRING("sourceNameSafari").get(),
getter_Copies(sourceNameSafari));
NS_ENSURE_SUCCESS(rv, rv);
const PRUnichar* sourceNameStrings[] = { sourceNameSafari.get() };
nsString importedSafariBookmarksTitle;
rv = bundle->FormatStringFromName(NS_LITERAL_STRING("importedBookmarksFolder").get(),
sourceNameStrings, 1,
getter_Copies(importedSafariBookmarksTitle));
NS_ENSURE_SUCCESS(rv, rv);
rv = bms->CreateFolder(bookmarksMenuFolderId,
NS_ConvertUTF16toUTF8(importedSafariBookmarksTitle),
nsINavBookmarksService::DEFAULT_INDEX, &folder);
NS_ENSURE_SUCCESS(rv, rv);
}
else {
nsCOMPtr<nsIFile> profile;
GetProfilePath(nsnull, profile);
rv = InitializeBookmarks(profile);
NS_ENSURE_SUCCESS(rv, rv);
// In replace mode we are merging at the top level.
folder = bookmarksMenuFolderId;
}
nsCOMPtr<nsIProperties> fileLocator(do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID));
nsCOMPtr<nsILocalFile> safariBookmarksFile;
fileLocator->Get(NS_MAC_USER_LIB_DIR, NS_GET_IID(nsILocalFile),
getter_AddRefs(safariBookmarksFile));
safariBookmarksFile->Append(NS_LITERAL_STRING("Safari"));
safariBookmarksFile->Append(SAFARI_BOOKMARKS_FILE_NAME);
CFDictionaryRef safariBookmarks =
static_cast<CFDictionaryRef>(CopyPListFromFile(safariBookmarksFile));
if (!safariBookmarks)
return NS_OK;
// The Safari Bookmarks file looks like this:
// At the top level are all the Folders, Special Folders and Proxies. Proxies
// are references to other data sources such as History, Rendezvous etc.
// We ignore these. Special folders exist for the Bookmarks Toolbar folder
// (called "BookmarksBar" and the Bookmarks Menu (called "BookmarksMenu").
// We put the contents of the "BookmarksBar" folder into our Personal Toolbar
// and merge the contents of the "BookmarksMenu" folder and the other toplevel
// non-special folders under our NC:BookmarksRoot.
if (::CFDictionaryContainsKey(safariBookmarks, CFSTR("Children")) &&
::CFDictionaryContainsKey(safariBookmarks, CFSTR("WebBookmarkFileVersion")) ) {
CFNumberRef intValue =
(CFNumberRef)::CFDictionaryGetValue(safariBookmarks,
CFSTR("WebBookmarkFileVersion"));
PRInt32 value = 0;
if (::CFNumberGetValue(intValue, kCFNumberSInt32Type, &value) && value ==1) {
CFArrayRef children =
(CFArrayRef)::CFDictionaryGetValue(safariBookmarks, CFSTR("Children"));
if (children) {
rv = ParseBookmarksFolder(children, folder, bms, true);
}
}
}
::CFRelease(safariBookmarks);
return rv;
}
bool CGUIDialogProfileSettings::ShowForProfile(unsigned int iProfile, bool firstLogin)
{
CProfilesManager &profileManager = CServiceBroker::GetProfileManager();
if (firstLogin && iProfile > profileManager.GetNumberOfProfiles())
return false;
CGUIDialogProfileSettings *dialog = CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogProfileSettings>(WINDOW_DIALOG_PROFILE_SETTINGS);
if (dialog == NULL)
return false;
dialog->m_needsSaving = false;
dialog->m_isDefault = iProfile == 0;
dialog->m_showDetails = !firstLogin;
const CProfile *profile = profileManager.GetProfile(iProfile);
if (profile == NULL)
{
dialog->m_name.clear();
dialog->m_dbMode = 2;
dialog->m_sourcesMode = 2;
dialog->m_locks = CProfile::CLock();
bool bLock = profileManager.GetMasterProfile().getLockMode() != LOCK_MODE_EVERYONE && !g_passwordManager.bMasterUser;
dialog->m_locks.addonManager = bLock;
dialog->m_locks.settings = (bLock) ? LOCK_LEVEL::ALL : LOCK_LEVEL::NONE;
dialog->m_locks.files = bLock;
dialog->m_directory.clear();
dialog->m_thumb.clear();
// prompt for a name
std::string profileName;
if (!CGUIKeyboardFactory::ShowAndGetInput(profileName, CVariant{g_localizeStrings.Get(20093)}, false) || profileName.empty())
return false;
dialog->m_name = profileName;
// create a default path
std::string defaultDir = URIUtils::AddFileToFolder("profiles", CUtil::MakeLegalFileName(dialog->m_name));
URIUtils::AddSlashAtEnd(defaultDir);
XFILE::CDirectory::Create(URIUtils::AddFileToFolder("special://masterprofile/", defaultDir));
// prompt for the user to change it if they want
std::string userDir = defaultDir;
if (GetProfilePath(userDir, false)) // can't be the master user
{
if (!URIUtils::PathHasParent(userDir, defaultDir)) // user chose a different folder
XFILE::CDirectory::Remove(URIUtils::AddFileToFolder("special://masterprofile/", defaultDir));
}
dialog->m_directory = userDir;
dialog->m_needsSaving = true;
}
else
{
dialog->m_name = profile->getName();
dialog->m_thumb = profile->getThumb();
dialog->m_directory = profile->getDirectory();
dialog->m_dbMode = profile->canWriteDatabases() ? 0 : 1;
if (profile->hasDatabases())
dialog->m_dbMode += 2;
dialog->m_sourcesMode = profile->canWriteSources() ? 0 : 1;
if (profile->hasSources())
dialog->m_sourcesMode += 2;
dialog->m_locks = profile->GetLocks();
}
dialog->Open();
if (dialog->m_needsSaving)
{
if (iProfile >= profileManager.GetNumberOfProfiles())
{
if (dialog->m_name.empty() || dialog->m_directory.empty())
return false;
/*std::string strLabel;
strLabel.Format(g_localizeStrings.Get(20047),dialog->m_strName);
if (!CGUIDialogYesNo::ShowAndGetInput(20058, strLabel, dialog->m_strDirectory, ""))
{
CDirectory::Remove(URIUtils::AddFileToFolder(profileManager.GetUserDataFolder(), dialog->m_strDirectory));
return false;
}*/
// check for old profile settings
CProfile profile(dialog->m_directory, dialog->m_name, profileManager.GetNextProfileId());
profileManager.AddProfile(profile);
bool exists = XFILE::CFile::Exists(URIUtils::AddFileToFolder("special://masterprofile/", dialog->m_directory, "guisettings.xml"));
if (exists && !CGUIDialogYesNo::ShowAndGetInput(CVariant{20058}, CVariant{20104}))
exists = false;
if (!exists)
{
// copy masterprofile guisettings to new profile guisettings
// If the user selects 'start fresh', do nothing as a fresh
// guisettings.xml will be created on first profile use.
if (CGUIDialogYesNo::ShowAndGetInput(CVariant{20058}, CVariant{20048}, CVariant{""}, CVariant{""}, CVariant{20044}, CVariant{20064}))
{
XFILE::CFile::Copy(URIUtils::AddFileToFolder("special://masterprofile/", "guisettings.xml"),
URIUtils::AddFileToFolder("special://masterprofile/", dialog->m_directory, "guisettings.xml"));
}
}
exists = XFILE::CFile::Exists(URIUtils::AddFileToFolder("special://masterprofile/", dialog->m_directory, "sources.xml"));
if (exists && !CGUIDialogYesNo::ShowAndGetInput(CVariant{20058}, CVariant{20106}))
exists = false;
if (!exists)
{
if ((dialog->m_sourcesMode & 2) == 2)
// prompt user to copy masterprofile's sources.xml file
// If 'start fresh' (no) is selected, do nothing.
if (CGUIDialogYesNo::ShowAndGetInput(CVariant{20058}, CVariant{20071}, CVariant{""}, CVariant{""}, CVariant{20044}, CVariant{20064}))
{
XFILE::CFile::Copy(URIUtils::AddFileToFolder("special://masterprofile/", "sources.xml"),
URIUtils::AddFileToFolder("special://masterprofile/", dialog->m_directory, "sources.xml"));
}
}
}
/*if (!dialog->m_bIsNewUser)
if (!CGUIDialogYesNo::ShowAndGetInput(20067, 20103))
return false;*/
CProfile *profile = profileManager.GetProfile(iProfile);
assert(profile);
profile->setName(dialog->m_name);
profile->setDirectory(dialog->m_directory);
profile->setThumb(dialog->m_thumb);
profile->setWriteDatabases(!((dialog->m_dbMode & 1) == 1));
profile->setWriteSources(!((dialog->m_sourcesMode & 1) == 1));
profile->setDatabases((dialog->m_dbMode & 2) == 2);
profile->setSources((dialog->m_sourcesMode & 2) == 2);
profile->SetLocks(dialog->m_locks);
profileManager.Save();
return true;
}
return dialog->m_needsSaving;
}
void CGUIDialogProfileSettings::OnSettingAction(std::shared_ptr<const CSetting> setting)
{
if (setting == NULL)
return;
CGUIDialogSettingsManualBase::OnSettingAction(setting);
const std::string &settingId = setting->GetId();
if (settingId == SETTING_PROFILE_IMAGE)
{
VECSOURCES shares;
g_mediaManager.GetLocalDrives(shares);
CFileItemList items;
if (!m_thumb.empty())
{
CFileItemPtr item(new CFileItem("thumb://Current", false));
item->SetArt("thumb", m_thumb);
item->SetLabel(g_localizeStrings.Get(20016));
items.Add(item);
}
CFileItemPtr item(new CFileItem("thumb://None", false));
item->SetArt("thumb", "DefaultUser.png");
item->SetLabel(g_localizeStrings.Get(20018));
items.Add(item);
std::string thumb;
if (CGUIDialogFileBrowser::ShowAndGetImage(items, shares, g_localizeStrings.Get(1030), thumb) &&
!StringUtils::EqualsNoCase(thumb, "thumb://Current"))
{
m_needsSaving = true;
m_thumb = StringUtils::EqualsNoCase(thumb, "thumb://None") ? "" : thumb;
UpdateProfileImage();
}
}
else if (settingId == SETTING_PROFILE_DIRECTORY)
{
if (!GetProfilePath(m_directory, m_isDefault))
return;
m_needsSaving = true;
updateProfileDirectory();
}
else if (settingId == SETTING_PROFILE_LOCKS)
{
if (m_showDetails)
{
const CProfilesManager &profileManager = CServiceBroker::GetProfileManager();
if (profileManager.GetMasterProfile().getLockMode() == LOCK_MODE_EVERYONE && !m_isDefault)
{
if (CGUIDialogYesNo::ShowAndGetInput(CVariant{20066}, CVariant{20118}))
g_passwordManager.SetMasterLockMode(false);
if (profileManager.GetMasterProfile().getLockMode() == LOCK_MODE_EVERYONE)
return;
}
if (CGUIDialogLockSettings::ShowAndGetLock(m_locks, m_isDefault ? 12360 : 20068,
profileManager.GetMasterProfile().getLockMode() == LOCK_MODE_EVERYONE || m_isDefault))
m_needsSaving = true;
}
else
{
if (CGUIDialogLockSettings::ShowAndGetLock(m_locks, m_isDefault ? 12360 : 20068, false, false))
m_needsSaving = true;
}
}
}
// Populates the local profile cache. This occurs on the first access of the profile
// data. All profile operations are performed against the local cache until the
// ProfileManager is released or goes out of scope at which time the cache is serialized
// to disk.
void ProfileManager::LoadCache(bool create)
{
Lock::Locker lockScope(&ProfileLock);
ClearProfileData();
String path = GetProfilePath();
Ptr<JSON> root = *JSON::Load(path);
if (root == NULL)
{
path = BasePath + "/Profiles.json"; // look for legacy profile
root = *JSON::Load(path);
if (root == NULL)
{
if (create)
{ // Generate a skeleton profile database
root = *JSON::CreateObject();
root->AddNumberItem("Oculus Profile Version", 2.0);
root->AddItem("Users", JSON::CreateArray());
root->AddItem("TaggedData", JSON::CreateArray());
ProfileCache = root;
}
return;
}
// Verify the legacy version
JSON* version_item = root->GetFirstItem();
if (version_item->Name == "Oculus Profile Version")
{
int major = atoi(version_item->Value.ToCStr());
if (major != 1)
return; // don't use the file on unsupported major version number
}
else
{
return; // invalid file
}
// Convert the legacy format to the new database format
LoadV1Profiles(root);
}
else
{
// Verify the file format and version
JSON* version_item = root->GetFirstItem();
if (version_item->Name == "Oculus Profile Version")
{
int major = atoi(version_item->Value.ToCStr());
if (major != 2)
return; // don't use the file on unsupported major version number
}
else
{
return; // invalid file
}
ProfileCache = root; // store the database contents for traversal
}
}
