source: AE/installer2/src/net/oni2/aeinstaller/backend/mods/ModManager.java@ 636

Last change on this file since 636 was 636, checked in by alloc, 12 years ago

AEI2 0.93:

  • Primarily another bunch of refactorings
File size: 8.0 KB
Line 
1package net.oni2.aeinstaller.backend.mods;
2
3import java.io.File;
4import java.io.FileFilter;
5import java.io.FileInputStream;
6import java.io.FileNotFoundException;
7import java.io.FileOutputStream;
8import java.io.IOException;
9import java.util.Collection;
10import java.util.HashMap;
11import java.util.HashSet;
12import java.util.TreeMap;
13import java.util.TreeSet;
14import java.util.Vector;
15
16import com.thoughtworks.xstream.XStream;
17import com.thoughtworks.xstream.io.xml.StaxDriver;
18
19import net.oni2.aeinstaller.backend.Paths;
20import net.oni2.aeinstaller.backend.depot.DepotManager;
21import net.oni2.aeinstaller.backend.depot.model.NodeMod;
22import net.oni2.aeinstaller.backend.depot.model.TaxonomyTerm;
23import net.oni2.aeinstaller.backend.oni.Installer;
24
25/**
26 * @author Christian Illy
27 */
28public class ModManager {
29 private static ModManager instance = new ModManager();
30
31 private HashMap<String, Type> types = new HashMap<String, Type>();
32 private HashMap<Integer, Mod> mods = new HashMap<Integer, Mod>();
33 private HashMap<Integer, Mod> tools = new HashMap<Integer, Mod>();
34
35 private Vector<Integer> currentlyInstalled = new Vector<Integer>();
36
37 /**
38 * @param f
39 * Mod selection file
40 * @return Mod selection
41 */
42 @SuppressWarnings("unchecked")
43 public Vector<Integer> loadModSelection(File f) {
44 Vector<Integer> res = new Vector<Integer>();
45 try {
46 if (f.exists()) {
47 FileInputStream fis = new FileInputStream(f);
48 XStream xs = new XStream(new StaxDriver());
49 Object obj = xs.fromXML(fis);
50 if (obj instanceof Vector<?>)
51 res = (Vector<Integer>) obj;
52 fis.close();
53 }
54 } catch (FileNotFoundException e) {
55 e.printStackTrace();
56 } catch (IOException e) {
57 e.printStackTrace();
58 }
59 return res;
60 }
61
62 /**
63 * @param f
64 * Mod selection file
65 * @param mods
66 * Selected mods
67 */
68 public void saveModSelection(File f, TreeSet<Mod> mods) {
69 try {
70 Vector<Integer> installed = new Vector<Integer>();
71 for (Mod m : mods) {
72 installed.add(m.getPackageNumber());
73 }
74 FileOutputStream fos = new FileOutputStream(f);
75 XStream xs = new XStream(new StaxDriver());
76 xs.toXML(installed, fos);
77 fos.close();
78 } catch (FileNotFoundException e) {
79 e.printStackTrace();
80 } catch (IOException e) {
81 e.printStackTrace();
82 }
83 }
84
85 /**
86 * First initialization of ModManager
87 */
88 public void init() {
89 types = new HashMap<String, Type>();
90 mods = new HashMap<Integer, Mod>();
91
92 Type localType = new Type("-Local-", null);
93 types.put("-Local-", localType);
94
95 for (TaxonomyTerm tt : DepotManager.getInstance().getTypes()) {
96 types.put(tt.getName(), new Type(tt.getName(), tt));
97 }
98
99 HashMap<Integer, Mod> modFolders = new HashMap<Integer, Mod>();
100 if (Paths.getModsPath().exists()) {
101 for (File f : Paths.getModsPath().listFiles(new FileFilter() {
102 @Override
103 public boolean accept(File pathname) {
104 return pathname.isDirectory();
105 }
106 })) {
107 Mod m = new Mod(f);
108 modFolders.put(m.getPackageNumber(), m);
109 }
110 }
111
112 for (NodeMod nm : DepotManager.getInstance().getModPackageNodes()) {
113 if (nm.getUploads().size() == 1) {
114 Mod m = new Mod(nm);
115 if (nm.isTool())
116 tools.put(m.getPackageNumber(), m);
117 else
118 mods.put(m.getPackageNumber(), m);
119 modFolders.remove(m.getPackageNumber());
120 }
121 }
122
123 for (Mod m : modFolders.values()) {
124 if (!m.isMandatoryMod()) {
125 localType.addEntry(m);
126 m.getTypes().add(localType);
127 }
128 mods.put(m.getPackageNumber(), m);
129 }
130
131 currentlyInstalled = Installer.getInstalledMods();
132 if (currentlyInstalled == null)
133 currentlyInstalled = new Vector<Integer>();
134 }
135
136 /**
137 * @return Singleton instance
138 */
139 public static ModManager getInstance() {
140 return instance;
141 }
142
143 Type getTypeByName(String name) {
144 return types.get(name);
145 }
146
147 /**
148 * @return Collection of types which do have mods associated
149 */
150 public Collection<Type> getTypesWithContent() {
151 Vector<Type> res = new Vector<Type>();
152 for (Type t : types.values()) {
153 if (t.getEntries().size() > 0)
154 res.add(t);
155 }
156 return res;
157 }
158
159 /**
160 * @return Collection of mods valid on this platform and not mandatory
161 */
162 public Collection<Mod> getModsValidAndNotMandatory() {
163 Vector<Mod> res = new Vector<Mod>();
164 for (Mod m : mods.values())
165 if (m.isValidOnPlatform() && !m.isMandatoryMod())
166 res.add(m);
167 return res;
168 }
169
170 /**
171 * @return Mods which are always installed and valid on this platform
172 */
173 public TreeSet<Mod> getMandatoryMods() {
174 TreeSet<Mod> res = new TreeSet<Mod>();
175 for (Mod m : mods.values()) {
176 if (m.isValidOnPlatform() && m.isMandatoryMod())
177 res.add(m);
178 }
179 return res;
180 }
181
182 /**
183 * @return Mods which are already locally available
184 */
185 public TreeSet<Mod> getLocalAvailableMods() {
186 TreeSet<Mod> res = new TreeSet<Mod>();
187 for (Mod m : mods.values()) {
188 if (m.isLocalAvailable())
189 res.add(m);
190 }
191 return res;
192 }
193
194 /**
195 * @return Mods which can be updated
196 */
197 public TreeSet<Mod> getUpdatableMods() {
198 TreeSet<Mod> res = new TreeSet<Mod>();
199 for (Mod m : getLocalAvailableMods()) {
200 if (m.isNewerAvailable())
201 res.add(m);
202 }
203 return res;
204 }
205
206 /**
207 * @return Collection of tools valid on this platform and not mandatory
208 */
209 public TreeMap<String, Mod> getTools() {
210 TreeMap<String, Mod> res = new TreeMap<String, Mod>();
211 for (Mod m : tools.values())
212 if (m.isValidOnPlatform() && !m.isMandatoryMod())
213 res.put(m.getName(), m);
214 return res;
215 }
216
217 /**
218 * @return Tools which are always installed and valid on this platform
219 */
220 public TreeSet<Mod> getMandatoryTools() {
221 TreeSet<Mod> res = new TreeSet<Mod>();
222 for (Mod m : tools.values()) {
223 if (m.isValidOnPlatform() && m.isMandatoryMod())
224 res.add(m);
225 }
226 return res;
227 }
228
229 /**
230 * @return Tools which are already locally available
231 */
232 public TreeSet<Mod> getLocalAvailableTools() {
233 TreeSet<Mod> res = new TreeSet<Mod>();
234 for (Mod m : tools.values()) {
235 if (m.isLocalAvailable())
236 res.add(m);
237 }
238 return res;
239 }
240
241 /**
242 * @return Tools which can be updated
243 */
244 public TreeSet<Mod> getUpdatableTools() {
245 TreeSet<Mod> res = new TreeSet<Mod>();
246 for (Mod m : getLocalAvailableTools()) {
247 if (m.isNewerAvailable())
248 res.add(m);
249 }
250 return res;
251 }
252
253 /**
254 * @return Currently installed tools
255 */
256 public TreeSet<Mod> getInstalledTools() {
257 TreeSet<Mod> res = new TreeSet<Mod>();
258 for (int n : Installer.getInstalledTools()) {
259 res.add(getModByNumber(n));
260 }
261 return res;
262 }
263
264 /**
265 * Get a mod/tool by its package number
266 *
267 * @param number
268 * Package number
269 * @return Mod/tool or null
270 */
271 private Mod getModByNumber(int number) {
272 if (mods.containsKey(number))
273 return mods.get(number);
274 if (tools.containsKey(number))
275 return tools.get(number);
276 return null;
277 }
278
279 /**
280 * Check for unresolved dependencies within the given mods
281 *
282 * @param mods
283 * Mods to check
284 * @return Unmet dependencies
285 */
286 public HashMap<Mod, HashSet<Mod>> checkDependencies(TreeSet<Mod> mods) {
287 // TODO: Verify functionality (checkDependencies)
288 HashMap<Mod, HashSet<Mod>> res = new HashMap<Mod, HashSet<Mod>>();
289
290 for (Mod m : mods) {
291 for (int depNum : m.getDependencies()) {
292 Mod other = getModByNumber(depNum);
293 if (!mods.contains(other)) {
294 if (!res.containsKey(m))
295 res.put(m, new HashSet<Mod>());
296 res.get(m).add(other);
297 }
298 }
299 }
300
301 return res;
302 }
303
304 /**
305 * Check for incompabitilites between given mods
306 *
307 * @param mods
308 * Mods to check
309 * @return Incompatible mods
310 */
311 public HashMap<Mod, HashSet<Mod>> checkIncompabitilites(TreeSet<Mod> mods) {
312 // TODO: Verify functionality (checkIncompatibilities)
313 HashMap<Mod, HashSet<Mod>> res = new HashMap<Mod, HashSet<Mod>>();
314
315 for (Mod m : mods) {
316 for (int confNum : m.getIncompabitilities()) {
317 Mod other = getModByNumber(confNum);
318 if (mods.contains(other)) {
319 if (!res.containsKey(m))
320 res.put(m, new HashSet<Mod>());
321 res.get(m).add(other);
322 }
323 }
324 }
325
326 return res;
327 }
328
329 /**
330 * @param m
331 * Mod to check
332 * @return Is mod installed?
333 */
334 boolean isModInstalled(Mod m) {
335 return currentlyInstalled.contains(m.getPackageNumber());
336 }
337}
Note: See TracBrowser for help on using the repository browser.