1/* 2 * Copyright 2010, Haiku. 3 * Distributed under the terms of the MIT License. 4 * 5 * Authors: 6 * Clemens Zeidler <haiku@clemens-zeidler.de> 7 */ 8 9#include "IndexServerAddOn.h" 10 11#include <Debug.h> 12#include <Directory.h> 13#include <File.h> 14#include <Path.h> 15 16#include "IndexServerPrivate.h" 17 18 19analyser_settings::analyser_settings() 20 : 21 catchUpEnabled(true), 22 23 syncPosition(0), 24 watchingStart(0), 25 watchingPosition(0) 26{ 27 28} 29 30 31const char* kAnalyserStatusFile = "AnalyserStatus"; 32 33const char* kCatchUpEnabledAttr = "CatchUpEnabled"; 34const char* kSyncPositionAttr = "SyncPosition"; 35const char* kWatchingStartAttr = "WatchingStart"; 36const char* kWatchingPositionAttr = "WatchingPosition"; 37 38 39AnalyserSettings::AnalyserSettings(const BString& name, const BVolume& volume) 40 : 41 fName(name), 42 fVolume(volume) 43{ 44 ReadSettings(); 45} 46 47 48bool 49AnalyserSettings::ReadSettings() 50{ 51 BAutolock _(fSettingsLock); 52 53 BDirectory rootDir; 54 fVolume.GetRootDirectory(&rootDir); 55 BPath path(&rootDir); 56 path.Append(kIndexServerDirectory); 57 path.Append(fName); 58 path.Append(kAnalyserStatusFile); 59 60 BFile file(path.Path(), B_READ_ONLY); 61 if (file.InitCheck() != B_OK) 62 return false; 63 64 uint32 value; 65 file.ReadAttr(kCatchUpEnabledAttr, B_UINT32_TYPE, 0, &value, 66 sizeof(uint32)); 67 fAnalyserSettings.catchUpEnabled = value != 0 ? true : false; 68 file.ReadAttr(kSyncPositionAttr, B_INT64_TYPE, 0, 69 &fAnalyserSettings.syncPosition, sizeof(int64)); 70 file.ReadAttr(kWatchingStartAttr, B_INT64_TYPE, 0, 71 &fAnalyserSettings.watchingStart, sizeof(int64)); 72 file.ReadAttr(kWatchingPositionAttr, B_INT64_TYPE, 0, 73 &fAnalyserSettings.watchingPosition, sizeof(int64)); 74 75 return true; 76} 77 78 79bool 80AnalyserSettings::WriteSettings() 81{ 82 BAutolock _(fSettingsLock); 83 84 BDirectory rootDir; 85 fVolume.GetRootDirectory(&rootDir); 86 BPath path(&rootDir); 87 path.Append(kIndexServerDirectory); 88 path.Append(fName); 89 if (create_directory(path.Path(), 777) != B_OK) 90 return false; 91 path.Append(kAnalyserStatusFile); 92 93 BFile file(path.Path(), B_READ_WRITE | B_CREATE_FILE | B_ERASE_FILE); 94 if (file.InitCheck() != B_OK) 95 return false; 96 97 uint32 value = fAnalyserSettings.catchUpEnabled ? 1 : 0; 98 file.WriteAttr(kCatchUpEnabledAttr, B_UINT32_TYPE, 0, &value, 99 sizeof(uint32)); 100 file.WriteAttr(kSyncPositionAttr, B_INT64_TYPE, 0, 101 &fAnalyserSettings.syncPosition, sizeof(int64)); 102 file.WriteAttr(kWatchingStartAttr, B_INT64_TYPE, 0, 103 &fAnalyserSettings.watchingStart, sizeof(int64)); 104 file.WriteAttr(kWatchingPositionAttr, B_INT64_TYPE, 0, 105 &fAnalyserSettings.watchingPosition, sizeof(int64)); 106 107 return true; 108} 109 110 111analyser_settings 112AnalyserSettings::RawSettings() 113{ 114 BAutolock _(fSettingsLock); 115 116 return fAnalyserSettings; 117} 118 119 120void 121AnalyserSettings::SetCatchUpEnabled(bool enabled) 122{ 123 BAutolock _(fSettingsLock); 124 125 fAnalyserSettings.catchUpEnabled = enabled; 126} 127 128 129void 130AnalyserSettings::SetSyncPosition(bigtime_t time) 131{ 132 BAutolock _(fSettingsLock); 133 134 fAnalyserSettings.syncPosition = time; 135} 136 137 138void 139AnalyserSettings::SetWatchingStart(bigtime_t time) 140{ 141 BAutolock _(fSettingsLock); 142 143 fAnalyserSettings.watchingStart = time; 144} 145 146 147void 148AnalyserSettings::SetWatchingPosition(bigtime_t time) 149{ 150 BAutolock _(fSettingsLock); 151 152 fAnalyserSettings.watchingPosition = time; 153} 154 155 156bool 157AnalyserSettings::CatchUpEnabled() 158{ 159 BAutolock _(fSettingsLock); 160 161 return fAnalyserSettings.catchUpEnabled; 162} 163 164 165bigtime_t 166AnalyserSettings::SyncPosition() 167{ 168 BAutolock _(fSettingsLock); 169 170 return fAnalyserSettings.syncPosition; 171} 172 173 174bigtime_t 175AnalyserSettings::WatchingStart() 176{ 177 BAutolock _(fSettingsLock); 178 179 return fAnalyserSettings.watchingStart; 180} 181 182 183bigtime_t 184AnalyserSettings::WatchingPosition() 185{ 186 BAutolock _(fSettingsLock); 187 188 return fAnalyserSettings.watchingPosition; 189} 190 191 192FileAnalyser::FileAnalyser(const BString& name, const BVolume& volume) 193 : 194 fVolume(volume), 195 fName(name) 196{ 197 198} 199 200 201void 202FileAnalyser::SetSettings(AnalyserSettings* settings) 203{ 204 ASSERT(fName == settings->Name() && fVolume == settings->Volume()); 205 206 fAnalyserSettings = settings; 207 ASSERT(fAnalyserSettings.Get()); 208 UpdateSettingsCache(); 209} 210 211 212AnalyserSettings* 213FileAnalyser::Settings() const 214{ 215 return fAnalyserSettings; 216} 217 218 219const analyser_settings& 220FileAnalyser::CachedSettings() const 221{ 222 return fCachedSettings; 223} 224 225 226void 227FileAnalyser::UpdateSettingsCache() 228{ 229 fCachedSettings = fAnalyserSettings->RawSettings(); 230} 231