Main Page | Packages | Class Hierarchy | Class List | Directories | File List | Class Members | Related Pages

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.embedded;
00029 
00030 import java.io.File;
00031 import java.io.FileNotFoundException;
00032 import java.io.FileReader;
00033 import java.io.IOException;
00034 import java.util.Collection;
00035 import java.util.Enumeration;
00036 import java.util.Hashtable;
00037 
00038 import org.openmobileis.common.util.PropertiesManager;
00039 import org.openmobileis.common.util.collection.Array;
00040 import org.openmobileis.common.util.collection.tree.DependTree;
00041 import org.openmobileis.common.util.exception.ServiceException;
00042 import org.openmobileis.common.util.log.LogManager;
00043 import org.openmobileis.database.fastobjectdb.synchro.client.SynchroFastObjectDBManager;
00044 import org.openmobileis.modules.profiles.embedded.core.DependProfileModule;
00045 import org.openmobileis.modules.profiles.embedded.core.DependProfileRubric;
00046 import org.openmobileis.modules.profiles.embedded.core.ProfileParser;
00047 import org.openmobileis.modules.profiles.embedded.core.ProfileRubricSynchroListener;
00048 import org.openmobileis.modules.profiles.embedded.core.ProfileSynchroListenerAddNotifier;
00049 import org.openmobileis.services.common.ServiceManager;
00050 import org.openmobileis.synchro.openmsp.client.OpenMSPSyncListener;
00051 import org.openmobileis.synchro.openmsp.client.OpenMSPSynchroManager;
00052 import org.xmlpull.v1.XmlPullParserException;
00053 
00063 public class ProfileManager {
00064 
00065         private static ProfileManager manager;
00066         private String profilFile;
00067         private Hashtable profilRubrics = null;
00068         private Hashtable profilModules = null;
00069   ProfileSynchroListenerAddNotifier profileSyncListenerNotifier = new ProfileSynchroListenerAddNotifier();
00070           
00071         private ProfileManager() {
00072                 profilFile = PropertiesManager.getManager().getProperty("org.openmobileis.profil.file");
00073                 if (profilFile==null) {
00074                   profilFile = System.getProperty("user.dir")+File.separator+"WEB-INF"+File.separator+"conf"+File.separator+"properties"+File.separator+"profildata.xml";
00075     }
00076     profilRubrics = new Hashtable(20);
00077     profilModules = new Hashtable(10);
00078     
00079     profileSyncListenerNotifier = new ProfileSynchroListenerAddNotifier();
00080         }
00081         
00082         public static ProfileManager getManager() {
00083                 if (manager == null)  {
00084                         synchronized(org.openmobileis.modules.profiles.embedded.ProfileManager.class) {
00085                                 if (manager == null)  {
00086                                         manager = new ProfileManager();
00087           try {
00088             manager.initManager();
00089           } catch (Throwable ex)  {
00090             LogManager.traceError(0, ex);
00091           }
00092                                 }
00093                         }
00094                 }
00095                 return manager;
00096         }
00097         
00098         public Collection getProfilRubrics() {
00099                 return profilRubrics.values();
00100         }
00101         
00102         public Collection getProfilModules() {
00103                 return profilModules.values();
00104         }
00105   
00106   public ProfileRubric getRubric(String rubricName) {
00107     return (ProfileRubric)profilRubrics.get(rubricName);
00108   }
00109  
00110   public ProfileModule getModule(String moduleName)  {
00111     return (ProfileModule)profilModules.get(moduleName);
00112   }
00113   
00114   public void addRubric(ProfileRubric rubric)  {
00115     profilRubrics.put(rubric.getName(), rubric);
00116   }
00117   
00118   public void addModule(ProfileModule module)  {
00119     profilModules.put(module.getName(), module);
00120   }
00121   
00122   private void initManager() throws ServiceException   {
00123     try {
00124      this.parseFile();  
00125       
00126       //init synchro db
00127       
00128         OpenMSPSynchroManager.getManager().registerSynchroListenerAddNotifier(profileSyncListenerNotifier);
00129         profileSyncListenerNotifier.setBlocking(true);
00130         try {
00131           SynchroFastObjectDBManager.getCurrentFODB(); //init synchro db to be use as default db
00132         } finally {
00133           profileSyncListenerNotifier.setBlocking(false);
00134         }
00135       } catch (Throwable ex)  {
00136         throw new ServiceException(ex);
00137       }
00138     }
00139   public void loadProfile() throws ServiceException   {
00140     try {
00141    
00142       
00143       //determine module loading order
00144       DependTree moduledepend = new DependTree();
00145       Enumeration  enume =profilModules.elements();
00146       while (enume.hasMoreElements())  {
00147         ProfileModule module = (ProfileModule)enume.nextElement() ;
00148         Array moduleDependList = module.getDependModuleList();
00149         Array moduleNameDependList = new Array();
00150         int depsize = moduleDependList.size();
00151         boolean error = false;
00152         for (int j=0; j<depsize; j++) {
00153           //verify dependance module version
00154           DependProfileModule dep = (DependProfileModule)moduleDependList.get(j);
00155           ProfileModule depModule = this.getModule(dep.getModuleName());
00156           if ((depModule!= null) && (depModule.getVersion() == null || depModule.getVersion().equals(dep.getModuleVersion())))  {
00157             moduleNameDependList.add(dep.getModuleName());
00158           } else  {
00159             LogManager.traceError(0, "Can't load module :"+module.getName()+" Missing depend's module:"+dep.getModuleName()+" or version:"+dep.getModuleVersion());
00160             error = true;
00161             break;
00162           }
00163         }
00164         if (error) continue;
00165         String[] smodulenamedeplist = new String[moduleNameDependList.size()];
00166         moduleNameDependList.toArray(smodulenamedeplist);
00167         moduledepend.addObject(module.getName(), module, smodulenamedeplist);                  
00168       }
00169       
00170       //load each module in rigth order
00171       moduledepend.resetPhaseList();     
00172       Array moduleList = moduledepend.getNextPhaseObjectList();
00173       while (moduleList.size() != 0)  {
00174         int modsize = moduleList.size();
00175         for (int i=0; i<modsize; i++)  {
00176           ProfileModule module = (ProfileModule) moduleList.get(i);
00177           try {
00178             Array moduledeplist = module.getDependModuleList();
00179             String[] smoduledeplist = new String[moduledeplist.size()];
00180             int depsize = moduledeplist.size();
00181             for (int j=0; j<depsize; j++) {
00182               DependProfileModule dep = (DependProfileModule)moduledeplist.get(j);
00183               smoduledeplist[j] = dep.getModuleName();
00184             }
00185           this.loadModule(module, smoduledeplist);
00186           } catch (Throwable ex)  {
00187             LogManager.traceError(0, "Error during rubric loading :"+module.getName()+" Exception:"+ex.getClass()+" Message :"+ex.getMessage());
00188             LogManager.traceError(0, ex);
00189           }
00190         }
00191         moduleList = moduledepend.getNextPhaseObjectList();
00192       } 
00193       
00194       //load remainding synchro listener that has not been loaded by the profil.
00195       Enumeration syncenum = profileSyncListenerNotifier.listenerlist.elements();
00196       while (syncenum.hasMoreElements())  {
00197         OpenMSPSyncListener toloadlistener = (OpenMSPSyncListener)syncenum.nextElement();
00198         String[] syncdepends = (String[])profileSyncListenerNotifier.dependlist.get(toloadlistener.getSyncName());
00199         OpenMSPSynchroManager.getManager().addListener(toloadlistener, syncdepends);
00200       }
00201       profileSyncListenerNotifier.listenerlist.clear();
00202       profileSyncListenerNotifier.dependlist.clear();
00203       
00204     } catch (Throwable ex)  {
00205       LogManager.traceError(0, "Error during loading profile file :"+ex.getMessage());
00206       throw new ServiceException(ex);
00207     }
00208     
00209   }
00210   
00211   private void loadModule(ProfileModule module, String[] moduleDependList) throws ServiceException  {
00212     Array rublist = module.getModuleRubric();
00213     //determine rubric loading order
00214     DependTree rubricDependTree = new DependTree();
00215     for (int k=0; k<rublist.size(); k++)  {
00216       DependProfileRubric rubric = (DependProfileRubric)rublist.get(k);
00217       rubricDependTree.addObject(rubric.getRubricName(), rubric, rubric.getRubricDepends());          
00218     }
00219     
00220     //construct base listener depend list based on depend module.
00221     Array synclistenerdependlist = new Array();
00222     for (int i=0; i<moduleDependList.length; i++) {
00223       ProfileModule depmodule = this.getModule(moduleDependList[i]);
00224       Array deprublist = depmodule.getModuleRubric();
00225       for (int k=0; k<deprublist.size(); k++)  {
00226         DependProfileRubric deprubric = (DependProfileRubric)deprublist.get(k);
00227         ProfileRubric rubric = this.getRubric(deprubric.getRubricName());
00228         Array synclistlist = rubric.getSynchroListenerList();
00229         for (int j=0; j<synclistlist.size(); j++) {
00230           ProfileRubricSynchroListener synclistener = (ProfileRubricSynchroListener)synclistlist.get(j);
00231           synclistenerdependlist.add(synclistener.name);
00232         }
00233       }
00234         
00235     }
00236     
00237     //block synchro listener loading and load it with profile depend info.
00238     rubricDependTree.resetPhaseList();     
00239     Array rubricList = rubricDependTree.getNextPhaseObjectList();
00240     while (rubricList.size() != 0)  {
00241       int rubsize = rubricList.size();
00242       for (int i=0; i<rubsize; i++)  {
00243         DependProfileRubric deprubric = (DependProfileRubric) rubricList.get(i);
00244         ProfileRubric rubric = this.getRubric(deprubric.getRubricName());
00245         try {
00246           // add synchro listerner of depend rubric to depend from module list
00247           Array rubsynclistenerdependlist = (Array)synclistenerdependlist.clone();
00248           String rubricdependlist[] = deprubric.getRubricDepends();
00249           if (rubricdependlist != null){
00250             for (int k=0; k<rubricdependlist.length; k++) {
00251               ProfileRubric deprub = this.getRubric(rubricdependlist[k]);
00252               Array synclistlist = deprub.getSynchroListenerList();
00253               for (int j=0; j<synclistlist.size(); j++) {
00254                 ProfileRubricSynchroListener synclistener = (ProfileRubricSynchroListener)synclistlist.get(j);
00255                 rubsynclistenerdependlist.add(synclistener.name);
00256               }
00257             }
00258           }
00259 
00260           //load rubric as in ServiceManagerand block listener loading
00261           profileSyncListenerNotifier.setBlocking(true);
00262           try {
00263             ServiceManager.getManager().loadRubricLoader(rubric.getLoader());
00264           } finally {
00265             profileSyncListenerNotifier.setBlocking(false);
00266           }
00267           
00268           //load synchro listener
00269           Array synchroListenerList = rubric.getSynchroListenerList();
00270           //contruct rubric synchro lister loading order list
00271           DependTree syncDependTree = new DependTree();
00272           for (int k=0; k<synchroListenerList.size(); k++)  {
00273             ProfileRubricSynchroListener synclistener = (ProfileRubricSynchroListener)synchroListenerList.get(k);
00274             syncDependTree.addObject(synclistener.name, synclistener, synclistener.dependsList);
00275           }
00276           
00277           //load rubric listener with its depend list. Depend list = module sync list + rubric depend sync list + sync depend list
00278           syncDependTree.resetPhaseList();     
00279           Array syncList = syncDependTree.getNextPhaseObjectList();
00280           while (syncList.size() != 0)  {
00281             int syncsize = syncList.size();
00282             for (int j=0; j<syncsize; j++)  {
00283               ProfileRubricSynchroListener listener = (ProfileRubricSynchroListener)syncList.get(j);
00284               //add sync listener depend list.
00285               Array syncrubsynclistenerdependlist = (Array)rubsynclistenerdependlist.clone(); 
00286               String[] depends = listener.dependsList;
00287               if (depends != null)  {
00288                 for (int k=0; k<depends.length; k++)  {
00289                   syncrubsynclistenerdependlist.add(depends[k]);
00290                 }
00291               }
00292               //load sync listener.
00293               String[] cursyncdeplist = new String[syncrubsynclistenerdependlist.size()];
00294               syncrubsynclistenerdependlist.toArray(cursyncdeplist);
00295               String name = listener.name;
00296               OpenMSPSyncListener toloadlistener = (OpenMSPSyncListener)profileSyncListenerNotifier.listenerlist.get(name);
00297               if (toloadlistener != null) {
00298                 OpenMSPSynchroManager.getManager().addListener(toloadlistener, cursyncdeplist);
00299                 profileSyncListenerNotifier.listenerlist.remove(toloadlistener.getSyncName());
00300                 profileSyncListenerNotifier.dependlist.remove(toloadlistener.getSyncName());       
00301              } else  {
00302                 LogManager.traceError(0, "Error during rubric loading "+rubric.getName()+". Synchro listener not found :"+name+". Listener not loaded");
00303               }
00304             }
00305             syncList = syncDependTree.getNextPhaseObjectList();
00306            
00307           }   
00308           
00309         } catch (Throwable ex)  {
00310           LogManager.traceError(0, "Error during rubric loading :"+rubric.getName()+" Exception:"+ex.getClass()+" Message :"+ex.getMessage());
00311           LogManager.traceError(0, ex);
00312         }
00313       }
00314       rubricList = rubricDependTree.getNextPhaseObjectList();
00315     }
00316   }
00317         
00318         private void parseFile () throws IOException, FileNotFoundException,XmlPullParserException {
00319                         FileReader reader = new FileReader(this.profilFile);
00320                         ProfileParser parser = new ProfileParser(reader);
00321                         parser.parse();                 
00322         }
00323 
00324   public ProfileSynchroListenerAddNotifier getProfileSyncListenerNotifier() {
00325     return profileSyncListenerNotifier;
00326   }
00327 
00328   public void setProfileSyncListenerNotifier(ProfileSynchroListenerAddNotifier profileSyncListenerNotifier) {
00329     this.profileSyncListenerNotifier = profileSyncListenerNotifier;
00330   }
00331 }

Generated on Mon Jul 10 10:29:32 2006 for OpenMobileIS by  doxygen 1.4.4