OpenMSPSynchroManager.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  *  Author : Philippe Delrieu
00023  *
00024  */
00025 
00026 package org.openmobileis.synchro.openmsp.client;
00027 
00028 import java.io.ByteArrayOutputStream;
00029 import java.io.IOException;
00030 import java.util.zip.GZIPOutputStream;
00031 
00032 import org.openmobileis.common.context.ApplicationContextManager;
00033 import org.openmobileis.common.context.Plateform;
00034 import org.openmobileis.common.intl.IntlResourceManager;
00035 import org.openmobileis.common.user.UserNotFoundException;
00036 import org.openmobileis.common.util.PropertiesManager;
00037 import org.openmobileis.common.util.PersistentPropertiesManager;
00038 import org.openmobileis.common.util.codec.GeneralCoder;
00039 import org.openmobileis.common.util.collection.Array;
00040 import org.openmobileis.common.util.exception.SynchroException;
00041 import org.openmobileis.common.util.log.LogManager;
00042 import org.openmobileis.database.fastobjectdb.synchro.client.SynchroListenerAddNotifier;
00043 import org.openmobileis.synchro.client.SynchroDescriptor;
00044 import org.openmobileis.synchro.client.SynchroProcessor;
00045 import org.openmobileis.synchro.openmsp.OpenMSPException;
00046 import org.openmobileis.synchro.openmsp.client.conduit.ConduitParameter;
00047 import org.openmobileis.synchro.openmsp.client.core.ListenerOrdonancer;
00048 import org.openmobileis.synchro.openmsp.client.core.OpenMSPSyncMessageFactory;
00049 import org.openmobileis.synchro.openmsp.protocol.Message;
00050 import org.openmobileis.synchro.openmsp.protocol.MessageFactory;
00051 import org.openmobileis.synchro.openmsp.protocol.Status;
00052 import org.openmobileis.synchro.security.auth.Credential;
00053 
00061 public class OpenMSPSynchroManager implements SynchroProcessor {
00062   public static final String OPENMSPPROCESSORNAME="OpenMSPSync";
00063 
00064   private static OpenMSPSynchroManager manager;
00065   private ListenerOrdonancer listenerOrdonancer;
00066   private ListenerOrdonancer moduleOrdonancer;
00067   private OpenMSPSyncMessageFactory messageFactory;
00068   private String lastSynchroLogin;
00069   private int globalSynchroStatut;
00070   private SynchroListenerAddNotifier addlistener;
00071   private OpenMSPSynchroProcessListener processListener;
00072 
00076   private OpenMSPSynchroManager() {
00077     super();
00078     this.listenerOrdonancer = new ListenerOrdonancer();
00079     this.moduleOrdonancer = new ListenerOrdonancer();
00080     this.messageFactory = new OpenMSPSyncMessageFactory();
00081   }
00082 
00083   public static OpenMSPSynchroManager getManager() {
00084     if (manager == null)  {
00085       synchronized (OpenMSPSynchroManager.class) {
00086         if (manager == null)  {
00087           manager = new OpenMSPSynchroManager();
00088           ApplicationContextManager.getManager().addManager(manager);
00089         }
00090       }
00091     }
00092     return manager;
00093   }
00094   
00095   public void setOpenMSPSynchroProcessListener(OpenMSPSynchroProcessListener listener)  {
00096         this.processListener = listener;
00097   }
00098 
00099   public void clearListeners(){
00100           this.listenerOrdonancer.clearListeners();
00101   }
00102 
00103   public String getProcessorName()  {
00104     return OpenMSPSynchroManager.OPENMSPPROCESSORNAME;
00105   }
00106 
00107   public void notifyFailure(String listernerName) {
00108     OpenMSPSyncListener listener = this.getListenerByName(listernerName);
00109     if (listener != null) {
00110       listener.notifySynchroFailure();
00111       listenerOrdonancer.notifySynchroError(listener.getSyncName());
00112       moduleOrdonancer.notifySynchroError(listener.getSyncName());
00113     }
00114     globalSynchroStatut = Status.STATUS_FAILED;
00115   }
00116 
00122   public OpenMSPSyncListener getListenerByName(String listenerName) {
00123     return listenerOrdonancer.getListenerByName(listenerName);
00124   }
00133   public OpenMSPSyncListener getModuleListenerByName(String listenerName) {
00134     return moduleOrdonancer.getListenerByName(listenerName);
00135   }
00136 
00137   public void doSynchro(Credential cred, SynchroDescriptor descriptor) throws SynchroException {
00138     globalSynchroStatut = Status.STATUS_SYNC_IN_PROGRESS;
00139     if (processListener != null) processListener.notifySynchroStart();
00140     this.lastSynchroLogin = cred.getPrincipal();
00141 
00142     String prgprop = PropertiesManager.getManager().getProperty("org.openmobileis.synchro.ui.progressbar");
00143     if ((prgprop != null) && (prgprop.equals("true")))  {
00144    }
00145 
00146     //save login
00147     PersistentPropertiesManager.getManager().saveProperty("OpenMSPSynchroManager", "login", this.lastSynchroLogin);
00148     ListenerOrdonancer currentOrdonnancer = this.listenerOrdonancer;
00149     currentOrdonnancer.beginSynchro();
00150     this.messageFactory.beginSynchro(cred, descriptor);
00151     Array listenerList = currentOrdonnancer.getNextListenerList();
00152     boolean moduleSynchro = false;
00153     if (listenerList.size() == 0)   {
00154       currentOrdonnancer.endSynchro();
00155       currentOrdonnancer = this.moduleOrdonancer;
00156       currentOrdonnancer.beginSynchro();
00157       listenerList = currentOrdonnancer.getNextListenerList();
00158       moduleSynchro = true;
00159     }
00160     try {
00161       while (listenerList.size() != 0)  {
00162         int listsize = listenerList.size();
00163         for (int i=0; i<listsize; i++)  {
00164           OpenMSPSyncListener listener = (OpenMSPSyncListener) listenerList.get(i);
00165           if (processListener != null) processListener.notifyListenerStartSync(listener.getSyncName());
00166           listener.startSync(cred, descriptor);
00167         }
00168         while (true) {
00169          if (processListener != null) processListener.notifyGenerateOpenMSPMessage();
00170          Message message = this.messageFactory.getOpenMSPMessage(listenerList);
00171           if (message.isEmpty()) {
00172             //get next listener phase.
00173             break;
00174           }
00175           String xmlString = message.encode();
00176           ConduitParameter[] parameters = new ConduitParameter[] {new ConduitParameter("openMISGroup", descriptor.getSynchroGroup())};
00177           if (processListener != null) processListener.notifyBeforeSendMessage();
00178           String reqResult = descriptor.getSynchroConduit().sendRequest(parameters, new String(compressAndEncodeRequest(xmlString)), descriptor.getServerURL());
00179           // third step : Process responses
00180           if (processListener != null) processListener.notifyReceiveMessageReturn();
00181           Message receivedMessage = MessageFactory.getFactory().getMessage(reqResult);
00182           String target = receivedMessage.getHeader().getTarget();
00183           if (processListener != null) processListener.notifyBeforeProcessMessageReturn();
00184           if (!target.equals(OpenMSPSyncMessageFactory.OpenMSPSOURCE)) {
00185             throw new OpenMSPException("Bad OpenMSP Sync Source in Server answer message. Synchro Abort.");
00186           } else {
00187             this.messageFactory.receiveOpenMSPMessage(listenerList, receivedMessage);
00188           }
00189           if (processListener != null) processListener.notifyAfterProcessMessageReturn();
00190         }
00191         for (int i=0; i<listsize; i++)  {
00192           OpenMSPSyncListener listener = (OpenMSPSyncListener) listenerList.get(i);
00193           if (processListener != null) processListener.notifyListenerEndSync(listener.getSyncName());
00194           listener.endSync();
00195         }
00196         listenerList = currentOrdonnancer.getNextListenerList();
00197         if (listenerList.size() == 0 && !moduleSynchro)   {
00198           currentOrdonnancer.endSynchro();
00199           currentOrdonnancer = this.moduleOrdonancer;
00200           currentOrdonnancer.beginSynchro();
00201           listenerList = currentOrdonnancer.getNextListenerList();
00202           moduleSynchro = true;
00203         }
00204       }
00205       if (processListener != null) processListener.notifyEndProcessListener();
00206        globalSynchroStatut = Status.STATUS_OK;
00207     } catch (UserNotFoundException ex)  {
00208       notifyFailureToListeners(listenerList);
00209       globalSynchroStatut = Status.STATUS_UNAUTHORIZED;
00210       if (processListener != null) processListener.notifySynchroFailure(Status.STATUS_UNAUTHORIZED);
00211       throw new OpenMSPException(ex);
00212     } catch (Throwable ex)  {
00213       notifyFailureToListeners(listenerList);
00214       if (processListener != null) processListener.notifySynchroFailure(Status.STATUS_FAILED);
00215       throw new OpenMSPException(ex);
00216     } finally {
00217       this.listenerOrdonancer.endSynchro();
00218       this.moduleOrdonancer.endSynchro();
00219       this.messageFactory.endSynchro();
00220       if (processListener != null) processListener.notifySynchroEnd();
00221     }
00222   }
00223 
00227   public void registerSynchroListenerAddNotifier(SynchroListenerAddNotifier listener) {
00228     addlistener = listener;
00229   }
00230 
00242   public void addListener(OpenMSPSyncListener listener, String[] depends) {
00243         // init listener.
00244         try     {
00245                 listener.initListener();
00246         }catch  (OpenMSPException ex)   {
00247                 LogManager.traceError(0, ex);
00248                 return;
00249         }
00250 
00251     if (addlistener != null) {
00252       addlistener.notifyAddListener(listener, depends);
00253       if (!addlistener.isBlocking())    {
00254         listenerOrdonancer.addListener(listener, depends);
00255       }
00256     } else  {
00257       listenerOrdonancer.addListener(listener, depends);
00258     }
00259   }
00260 
00261 
00262 
00272   public void addModuleListener(OpenMSPSyncListener listener, String[] depends) {
00273     moduleOrdonancer.addListener(listener, depends);
00274   }
00275 
00276   private void notifyFailureToListeners(Array listenerList) {
00277     for (int i=0; i<listenerList.size(); i++) {
00278       OpenMSPSyncListener listener = (OpenMSPSyncListener)listenerList.get(i);
00279       listener.notifySynchroFailure();
00280       listenerOrdonancer.notifySynchroError(listener.getSyncName());
00281       moduleOrdonancer.notifySynchroError(listener.getSyncName());
00282     }
00283     globalSynchroStatut = Status.STATUS_FAILED;
00284   }
00285 
00286   private byte[] compressAndEncodeRequest(String request) throws IOException {
00287     // compresse data
00288     byte[] compressedData = null;
00289     ByteArrayOutputStream byteStream = new ByteArrayOutputStream(512);
00290     GZIPOutputStream zipStream = new GZIPOutputStream(byteStream);
00291     try {
00292       zipStream.write(request.getBytes());
00293     } finally  {
00294       zipStream.close();
00295     }
00296     compressedData = byteStream.toByteArray();
00297 
00298     // encode compressed data
00299     byte[] returnData = GeneralCoder.encodeBase64(compressedData);
00300     return returnData;
00301   }
00302 
00303   public String getLastSynchroLogin() {
00304     if (this.lastSynchroLogin == null){
00305       this.lastSynchroLogin = PersistentPropertiesManager.getManager().getProperty("OpenMSPSynchroManager", "login");
00306 
00307     }
00308     return this.lastSynchroLogin;
00309   }
00310 
00319   public String getSynchroUserAgent(SynchroDescriptor descriptor) {
00320     String usera = PropertiesManager.getManager().getProperty("org.openmobileis.synchro.direct.useragent");
00321     if (usera == null)  {
00322       Plateform plateform = ApplicationContextManager.getManager().getApplicationContext().getPlateform();
00323       StringBuffer useragent = new StringBuffer("OpenMSPPlug-");
00324       useragent.append(plateform.getOpenMobileISMajorVersion()).append('.').append(plateform.getOpenMobileISMinorVersion()).append('-');
00325       useragent.append(plateform.getOS()).append('[').append(plateform.getOSVersion()).append("]-");
00326       String language = IntlResourceManager.getManager().getManagerLocaleString();
00327       useragent.append(language);
00328       String synctype = descriptor.getProperty("OpenMSPsynchrotype");
00329       if (synctype != null) {
00330         useragent.append('-').append(synctype);
00331       }
00332       usera = useragent.toString();
00333     }
00334     return usera;
00335   }
00336 
00337   public int getGlobalSynchroStatut() {
00338     return globalSynchroStatut;
00339   }
00340 
00341 }

Generated on Tue May 22 23:01:11 2007 for OpenMobileIS by  doxygen 1.5.1-p1