ProfileManager.java

00001 /*
00002  * OpenMobileIS - a free Java(TM) Framework for mobile applications Java(TM)
00003  * Copyright (C) 2004-2006 Philippe Delrieu
00004  * All rights reserved.
00005  * Contact: pdelrieu@openmobileis.org
00006  *
00007  * This library is free software; you can redistribute it and/or
00008  * modify it under the terms of the GNU Lesser General Public
00009  * License as published by the Free Software Foundation; either
00010  * version 2.1 of the License, or any later version.
00011  *
00012  * This library is distributed in the hope that it will be useful,
00013  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00014  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00015  * Lesser General Public License for more details.
00016  *
00017  * You should have received a copy of the GNU Lesser General Public
00018  * License along with this library; if not, write to the Free Software
00019  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
00020  * USA
00021  *
00022  *  
00023  *  Modifications :
00024  *  2006 Creation P.Delrieu
00025  * 
00026  */
00027 
00028 package org.openmobileis.modules.profiles.old;
00029 
00030 import java.io.File;
00031 import java.io.FileNotFoundException;
00032 import java.io.FileOutputStream;
00033 import java.io.FileReader;
00034 import java.io.FileWriter;
00035 import java.io.IOException;
00036 import java.util.Collection;
00037 import java.util.Enumeration;
00038 import java.util.Hashtable;
00039 
00040 import org.openmobileis.common.util.PropertiesManager;
00041 import org.openmobileis.common.util.collection.Array;
00042 import org.openmobileis.common.util.collection.tree.DependTree;
00043 import org.openmobileis.common.util.exception.ServiceException;
00044 import org.openmobileis.common.util.log.LogManager;
00045 import org.openmobileis.database.fastobjectdb.synchro.client.SynchroFastObjectDBManager;
00046 import org.openmobileis.modules.profiles.old.embedded.core.DependProfileModule;
00047 import org.openmobileis.modules.profiles.old.embedded.core.DependProfileRubric;
00048 import org.openmobileis.modules.profiles.old.embedded.core.ProfileParser;
00049 import org.openmobileis.modules.profiles.old.embedded.core.ProfileRubricSynchroListener;
00050 import org.openmobileis.modules.profiles.old.embedded.core.ProfileSynchroListenerAddNotifier;
00051 import org.openmobileis.services.common.ServiceManager;
00052 import org.openmobileis.synchro.openmsp.client.OpenMSPSyncListener;
00053 import org.openmobileis.synchro.openmsp.client.OpenMSPSynchroManager;
00054 import org.xmlpull.v1.XmlPullParserException;
00055 
00065 public class ProfileManager {
00066 
00067   private static ProfileManager manager;
00068 
00069   private String profilFile;
00070 
00071   private Hashtable profilRubrics = null;
00072 
00073   private Hashtable profilModules = null;
00074 
00075   ProfileSynchroListenerAddNotifier profileSyncListenerNotifier = new ProfileSynchroListenerAddNotifier();
00076 
00077   private ProfileManager() {
00078     profilFile = PropertiesManager.getManager().getProperty("org.openmobileis.profil.file");
00079     if (profilFile == null) {
00080       profilFile = System.getProperty("user.dir") + File.separator + "WEB-INF" + File.separator + "conf" + File.separator + "properties" + File.separator
00081           + "profildata.xml";
00082     }
00083     profilRubrics = new Hashtable(20);
00084     profilModules = new Hashtable(10);
00085 
00086     profileSyncListenerNotifier = new ProfileSynchroListenerAddNotifier();
00087   }
00088 
00089   public static ProfileManager getManager() {
00090     if (manager == null) {
00091       synchronized (org.openmobileis.modules.profiles.old.ProfileManager.class) {
00092         if (manager == null) {
00093           manager = new ProfileManager();
00094           try {
00095             manager.initManager();
00096           } catch (Throwable ex) {
00097             LogManager.traceError(0, ex);
00098           }
00099         }
00100       }
00101     }
00102     return manager;
00103   }
00104 
00105   public void saveProfilFile(String fileData) throws ServiceException {
00106     try {
00107       FileWriter out = new FileWriter(this.profilFile);
00108       try {
00109         out.write(fileData.toCharArray());
00110         out.flush();
00111       } finally {
00112         out.close();
00113       }
00114       profilRubrics.clear();
00115       profilModules.clear();
00116       this.parseFile();
00117     } catch (Throwable ex)  {
00118       throw new ServiceException(ex);
00119     }
00120   }
00121 
00122   public Collection getProfilRubrics() {
00123     return profilRubrics.values();
00124   }
00125 
00126   public Collection getProfilModules() {
00127     return profilModules.values();
00128   }
00129 
00130   public ProfileRubric getRubric(String rubricName) {
00131     return (ProfileRubric) profilRubrics.get(rubricName);
00132   }
00133 
00134   public ProfileModule getModule(String moduleName) {
00135     return (ProfileModule) profilModules.get(moduleName);
00136   }
00137 
00138   public void addRubric(ProfileRubric rubric) {
00139     profilRubrics.put(rubric.getName(), rubric);
00140   }
00141 
00142   public void addModule(ProfileModule module) {
00143     profilModules.put(module.getName(), module);
00144   }
00145 
00146   private void initManager() throws ServiceException {
00147     try {
00148       this.parseFile();
00149 
00150       //init synchro db
00151 
00152       OpenMSPSynchroManager.getManager().registerSynchroListenerAddNotifier(profileSyncListenerNotifier);
00153       profileSyncListenerNotifier.setBlocking(true);
00154       try {
00155         SynchroFastObjectDBManager.getCurrentFODB(); //init synchro db to be use as default db
00156       } finally {
00157         profileSyncListenerNotifier.setBlocking(false);
00158       }
00159     } catch (Throwable ex) {
00160       throw new ServiceException(ex);
00161     }
00162   }
00163 
00164   public void loadProfile() throws ServiceException {
00165     try {
00166       //determine module loading order
00167       DependTree moduledepend = new DependTree();
00168       Enumeration enume = profilModules.elements();
00169       while (enume.hasMoreElements()) {
00170         ProfileModule module = (ProfileModule) enume.nextElement();
00171         Array moduleDependList = module.getDependModuleList();
00172         Array moduleNameDependList = new Array();
00173         int depsize = moduleDependList.size();
00174         boolean error = false;
00175         for (int j = 0; j < depsize; j++) {
00176           //verify dependance module version
00177           DependProfileModule dep = (DependProfileModule) moduleDependList.get(j);
00178           ProfileModule depModule = this.getModule(dep.getModuleName());
00179           if ((depModule != null) && (depModule.getVersion() == null || depModule.getVersion().equals(dep.getModuleVersion()))) {
00180             moduleNameDependList.add(dep.getModuleName());
00181           } else {
00182             LogManager.traceError(0, "Can't load module :" + module.getName() + " Missing depend's module:" + dep.getModuleName() + " or version:"
00183                 + dep.getModuleVersion());
00184             error = true;
00185             break;
00186           }
00187         }
00188         if (error)
00189           continue;
00190         String[] smodulenamedeplist = new String[moduleNameDependList.size()];
00191         moduleNameDependList.toArray(smodulenamedeplist);
00192         moduledepend.addObject(module.getName(), module, smodulenamedeplist);
00193       }
00194 
00195       //load each module in rigth order
00196       moduledepend.resetPhaseList();
00197       Array moduleList = moduledepend.getNextPhaseObjectList();
00198       while (moduleList.size() != 0) {
00199         int modsize = moduleList.size();
00200         for (int i = 0; i < modsize; i++) {
00201           ProfileModule module = (ProfileModule) moduleList.get(i);
00202           try {
00203             Array moduledeplist = module.getDependModuleList();
00204             String[] smoduledeplist = new String[moduledeplist.size()];
00205             int depsize = moduledeplist.size();
00206             for (int j = 0; j < depsize; j++) {
00207               DependProfileModule dep = (DependProfileModule) moduledeplist.get(j);
00208               smoduledeplist[j] = dep.getModuleName();
00209             }
00210             this.loadModule(module, smoduledeplist);
00211           } catch (Throwable ex) {
00212             LogManager.traceError(0, "Error during rubric loading :" + module.getName() + " Exception:" + ex.getClass() + " Message :" + ex.getMessage());
00213             LogManager.traceError(0, ex);
00214           }
00215         }
00216         moduleList = moduledepend.getNextPhaseObjectList();
00217       }
00218 
00219       //load remainding synchro listener that has not been loaded by the profil.
00220       Enumeration syncenum = profileSyncListenerNotifier.listenerlist.elements();
00221       while (syncenum.hasMoreElements()) {
00222         OpenMSPSyncListener toloadlistener = (OpenMSPSyncListener) syncenum.nextElement();
00223         String[] syncdepends = (String[]) profileSyncListenerNotifier.dependlist.get(toloadlistener.getSyncName());
00224         OpenMSPSynchroManager.getManager().addListener(toloadlistener, syncdepends);
00225       }
00226       profileSyncListenerNotifier.listenerlist.clear();
00227       profileSyncListenerNotifier.dependlist.clear();
00228 
00229     } catch (Throwable ex) {
00230       LogManager.traceError(0, "Error during loading profile file :" + ex.getMessage());
00231       throw new ServiceException(ex);
00232     }
00233 
00234   }
00235 
00236   private void loadModule(ProfileModule module, String[] moduleDependList) throws ServiceException {
00237     Array rublist = module.getModuleRubric();
00238     //determine rubric loading order
00239     DependTree rubricDependTree = new DependTree();
00240     for (int k = 0; k < rublist.size(); k++) {
00241       DependProfileRubric rubric = (DependProfileRubric) rublist.get(k);
00242       rubricDependTree.addObject(rubric.getRubricName(), rubric, rubric.getRubricDepends());
00243     }
00244 
00245     //construct base listener depend list based on depend module.
00246     Array synclistenerdependlist = new Array();
00247     for (int i = 0; i < moduleDependList.length; i++) {
00248       ProfileModule depmodule = this.getModule(moduleDependList[i]);
00249       Array deprublist = depmodule.getModuleRubric();
00250       for (int k = 0; k < deprublist.size(); k++) {
00251         DependProfileRubric deprubric = (DependProfileRubric) deprublist.get(k);
00252         ProfileRubric rubric = this.getRubric(deprubric.getRubricName());
00253         Array synclistlist = rubric.getSynchroListenerList();
00254         for (int j = 0; j < synclistlist.size(); j++) {
00255           ProfileRubricSynchroListener synclistener = (ProfileRubricSynchroListener) synclistlist.get(j);
00256           synclistenerdependlist.add(synclistener.name);
00257         }
00258       }
00259 
00260     }
00261 
00262     //block synchro listener loading and load it with profile depend info.
00263     rubricDependTree.resetPhaseList();
00264     Array rubricList = rubricDependTree.getNextPhaseObjectList();
00265     while (rubricList.size() != 0) {
00266       int rubsize = rubricList.size();
00267       for (int i = 0; i < rubsize; i++) {
00268         DependProfileRubric deprubric = (DependProfileRubric) rubricList.get(i);
00269         ProfileRubric rubric = this.getRubric(deprubric.getRubricName());
00270         try {
00271           // add synchro listerner of depend rubric to depend from module list
00272           Array rubsynclistenerdependlist = (Array) synclistenerdependlist.clone();
00273           String rubricdependlist[] = deprubric.getRubricDepends();
00274           if (rubricdependlist != null) {
00275             for (int k = 0; k < rubricdependlist.length; k++) {
00276               ProfileRubric deprub = this.getRubric(rubricdependlist[k]);
00277               Array synclistlist = deprub.getSynchroListenerList();
00278               for (int j = 0; j < synclistlist.size(); j++) {
00279                 ProfileRubricSynchroListener synclistener = (ProfileRubricSynchroListener) synclistlist.get(j);
00280                 rubsynclistenerdependlist.add(synclistener.name);
00281               }
00282             }
00283           }
00284 
00285           //load rubric as in ServiceManagerand block listener loading
00286           profileSyncListenerNotifier.setBlocking(true);
00287           try {
00288             ServiceManager.getManager().loadRubricLoader(rubric.getLoader());
00289           } finally {
00290             profileSyncListenerNotifier.setBlocking(false);
00291           }
00292 
00293           //load synchro listener
00294           Array synchroListenerList = rubric.getSynchroListenerList();
00295           //contruct rubric synchro lister loading order list
00296           DependTree syncDependTree = new DependTree();
00297           for (int k = 0; k < synchroListenerList.size(); k++) {
00298             ProfileRubricSynchroListener synclistener = (ProfileRubricSynchroListener) synchroListenerList.get(k);
00299             syncDependTree.addObject(synclistener.name, synclistener, synclistener.dependsList);
00300           }
00301 
00302           //load rubric listener with its depend list. Depend list = module sync list + rubric depend sync list + sync depend list
00303           syncDependTree.resetPhaseList();
00304           Array syncList = syncDependTree.getNextPhaseObjectList();
00305           while (syncList.size() != 0) {
00306             int syncsize = syncList.size();
00307             for (int j = 0; j < syncsize; j++) {
00308               ProfileRubricSynchroListener listener = (ProfileRubricSynchroListener) syncList.get(j);
00309               //add sync listener depend list.
00310               Array syncrubsynclistenerdependlist = (Array) rubsynclistenerdependlist.clone();
00311               String[] depends = listener.dependsList;
00312               if (depends != null) {
00313                 for (int k = 0; k < depends.length; k++) {
00314                   syncrubsynclistenerdependlist.add(depends[k]);
00315                 }
00316               }
00317               //load sync listener.
00318               String[] cursyncdeplist = new String[syncrubsynclistenerdependlist.size()];
00319               syncrubsynclistenerdependlist.toArray(cursyncdeplist);
00320               String name = listener.name;
00321               OpenMSPSyncListener toloadlistener = (OpenMSPSyncListener) profileSyncListenerNotifier.listenerlist.get(name);
00322               if (toloadlistener != null) {
00323                 OpenMSPSynchroManager.getManager().addListener(toloadlistener, cursyncdeplist);
00324                 profileSyncListenerNotifier.listenerlist.remove(toloadlistener.getSyncName());
00325                 profileSyncListenerNotifier.dependlist.remove(toloadlistener.getSyncName());
00326               } else {
00327                 LogManager.traceError(0, "Error during rubric loading " + rubric.getName() + ". Synchro listener not found :" + name + ". Listener not loaded");
00328               }
00329             }
00330             syncList = syncDependTree.getNextPhaseObjectList();
00331 
00332           }
00333 
00334         } catch (Throwable ex) {
00335           LogManager.traceError(0, "Error during rubric loading :" + rubric.getName() + " Exception:" + ex.getClass() + " Message :" + ex.getMessage());
00336           LogManager.traceError(0, ex);
00337         }
00338       }
00339       rubricList = rubricDependTree.getNextPhaseObjectList();
00340     }
00341   }
00342 
00343   private void parseFile() throws IOException, FileNotFoundException, XmlPullParserException {
00344     FileReader reader = new FileReader(this.profilFile);
00345     ProfileParser parser = new ProfileParser(reader);
00346     parser.parse();
00347   }
00348 
00349   public ProfileSynchroListenerAddNotifier getProfileSyncListenerNotifier() {
00350     return profileSyncListenerNotifier;
00351   }
00352 
00353   public void setProfileSyncListenerNotifier(ProfileSynchroListenerAddNotifier profileSyncListenerNotifier) {
00354     this.profileSyncListenerNotifier = profileSyncListenerNotifier;
00355   }
00356 }

Generated on Mon Dec 4 11:03:29 2006 for OpenMobileIS by  doxygen 1.5.1-p1