Application.java - imity-client

‹r2

r16

Source path: svn/ trunk/ src/ com/ imity/ Application.java

1436
1437

/*
 * Application.java
 */

package com.imity;

import com.exploringxml.xml.*;
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
import javax.bluetooth.*;

import javax.microedition.io.*;
import java.io.*;
import java.util.*;
import de.enough.polish.util.*;
//import javax.wireless.messaging.MessageConnection;
//import javax.wireless.messaging.MessageListener;

import javax.microedition.midlet.MIDletStateChangeException;
import de.enough.polish.util.Locale;
import de.enough.polish.ui.*;

//import de.enough.polish.blackberry.ui.*;

//#ifdef polish.debugEnabled
	import de.enough.polish.util.Debug;
//#endif
	

/**
 *
 * @author shim
 */
  
public class Application {
    
    private Application() {
        AccountNumber = 0;
    }
    
    public static Application getInstance() { 
        if (_instance == null) { 
                _instance = new Application();
                _instance.initialize();
        }
        return _instance;
    }
    
    public String DebugStr = "";
    
    // Shared UUID by server and client
    public static final UUID RFCOMM_UUID = new UUID(0x0003);  
    public static final UUID IMITY_UUID = new UUID("3000010008000000805F9B34FB49D4EE",false);  
    public String localAddress = "";
    public static int MaxDiscoveries = 2;
    public Hashtable Discoveries;
    public ImityObjects Bookmarks;
    public ImityObjects WorldObjects;
    public ImityObjects LocalObjects;
    public ImityObjects Notifications;
    public Hashtable FriendDevices;
    public Hashtable PersonDevices;
    public boolean isDemo = false;
    
    public ObexService obexService = null;

    public ImityLogger Logger;
   
    private int scanWaitTime = 1000;
    private Person LocalPerson = null;
    
    
    //#ifdef config.ConnectToLocalhost:defined

    private static String ServerUrl = "http://emulator.imity.com:3000/api/spp"; 
    public static String ServerDomainName = "emulator.imity.com"; 
    private static String LoginUrl = "http://emulator.imity.com:3000/api/login"; 

    //#else

    private static String ServerUrl = "http://my.imity.com/api/spp"; 
    public static String ServerDomainName = "my.imity.com"; 
    private static String LoginUrl = "http://my.imity.com/api/login"; 

    //#endif

    public ImityMidlet SPM;

    public static final int firstChildOccur[] = {1};
    
    public static final String RECORDSTORE_SPP = "sp_spp";
    public static final String RECORDSTORE_LOCALOBJECTS = "sp_local";
    public static final String RECORDSTORE_ACCOUNT = "sp_account";
    public static final String RECORDSTORE_NOTICES = "sp_notices";
    public static final String RECORDSTORE_NOTICE_OBJECTS = "sp_notice_objects";
    public static final String RECORDSTORE_BYTE_COUNT = "sp_byte_count";
    public static final long timeDiffRecent = 1000 * 40; //40 sec
    public static final long timeDiffLong = 1000 * 60 * 2; //2 min
    public static final int AUTOUPLOAD_INTERVAL_MINS = 5;

    private static Application _instance;
    private int AccountNumber;
    
    public boolean serviceSearchRunning = false;
    public boolean submittingData = false;
    public boolean scanning = false;
    public long nextAutoUpload = 0;

    public String Encoding = "";
    public String SessionId = "";
    public String State = "1";
    public long bytes_this_session = 0; 
    public long bytes_since_login = 0; 
    
    private void initialize() {
        
        submittingData = false;
        nextAutoUpload = System.currentTimeMillis() + (1000 * 60 * Application.AUTOUPLOAD_INTERVAL_MINS);
   
            
        try {
		    
            Bookmarks = new ImityObjects();
            Discoveries = new Hashtable();
            WorldObjects = new ImityObjects();
            LocalObjects = new ImityObjects();
            Notifications = new ImityObjects();
            FriendDevices = new Hashtable();
            PersonDevices = new Hashtable();
            Logger = ImityLogger.getInstance();
	    

            localAddress = LocalDevice.getLocalDevice().getBluetoothAddress();
            Logger.imityStart();
            if (LocalDevice.getLocalDevice().getDiscoverable() != DiscoveryAgent.GIAC) {
                LocalDevice.getLocalDevice().setDiscoverable(DiscoveryAgent.GIAC);
            }
   		
            //load local objects
            //


            Hashtable lor = RecordStoreUtil.readData(Application.RECORDSTORE_ACCOUNT);

            String acc_string = "";
            for (Enumeration e = lor.elements(); e.hasMoreElements();) {
                acc_string = (String)e.nextElement();
            }

            try {
                String[] AccData = TextUtil.split(acc_string,';'); 
                AccountNumber = Integer.parseInt(AccData[0]);
                SessionId = AccData[1];
            } catch (Exception ex) {
            }

           
            lor = RecordStoreUtil.readData(Application.RECORDSTORE_LOCALOBJECTS);

            for (Enumeration e = lor.elements(); e.hasMoreElements();) {
                try {
                    String rsStr = "<lo>" + (String)e.nextElement() + "</lo>";
                    //appendString("-rs-str:" + rsStr);
                    ImityObjects io = Application.DeSerializeLocalData(rsStr);
                    
                    for (Enumeration e2 = io.elements(); e2.hasMoreElements();) {
                        SpimeObject spo = (SpimeObject)e2.nextElement();
                        if (spo.getClassId() > 0) {
                            LocalObjects.put(spo.getId(),spo);
                            //appendString("-lo-d-:" + spo.getId() + " ");
                        }

                    }
                    
                } catch (Exception ex) {
                    appendString("DeSerialization exception while processing local objects recordstore:" + ex);
                }
                
            }
           
            
            lor = RecordStoreUtil.readData(Application.RECORDSTORE_NOTICE_OBJECTS);

            for (Enumeration e = lor.elements(); e.hasMoreElements();) {
                try {
                    String rsStr = "<lo>" + (String)e.nextElement() + "</lo>";
                    //appendString("-rs-str:" + rsStr);
                    ImityObjects io = Application.DeSerializeLocalData(rsStr);
                    
                    for (Enumeration e2 = io.elements(); e2.hasMoreElements();) {
                        SpimeObject spo = (SpimeObject)e2.nextElement();
                        if (spo.getClassId() > 0) {
                            WorldObjects.put(spo.getId(),spo);
                            appendString("-put-local-notice-obj-into-worl-:" + spo.getId() + " ");
                        }

                    }
                    
                } catch (Exception ex) {
                    appendString("DeSerialization exception while processing notice objects recordstore:" + ex);
                }
                
            }
           
            refreshFriendDevices();


            Hashtable nos = RecordStoreUtil.readData(Application.RECORDSTORE_NOTICES);

            for (Enumeration e = nos.elements(); e.hasMoreElements();) {
                String rsStr = "<nos>" + (String)e.nextElement() + "</nos>";
                try {
                    //appendString("-rs-str:" + rsStr);
                    ImityObjects io = Application.DeSerializeNotifications(rsStr);
                    
                    for (Enumeration e2 = io.elements(); e2.hasMoreElements();) {
                        Notice no = (Notice)e2.nextElement();
                        if (no != null) {
                            Notifications.put(no.getId(),no);
                            appendString("-notice-on-:" + no.NoticeSpid + " ");
                        }
                    }

                } catch (Exception ex) {
                    appendString("DS-ex-NOS");
                }
            }
            
            String bytes_as_string = RecordStoreUtil.readString(Application.RECORDSTORE_BYTE_COUNT);
            if (bytes_as_string != null) {
                bytes_since_login = Long.parseLong(bytes_as_string);
            }
            
          
	        //obexService = new ObexService(this);
	        //obexService.startService();
        }
        catch (Exception ex) {
            appendString("Exception: " + ex.toString() + ":" + ex.getMessage());
        }
  
    }    
     
    public void shutDown() {
	    obexService.shutDown();
    	//obexService.stopService();
    }
    
    public void startScanJob() {

	    startScanJob(null);
    }
   
    public void forceScanJob(ImityMidlet spm) {
     	if (SPM == null) SPM = spm;
  
        Timer timer = new Timer();
        timer.schedule(new ForcedScanDevicesTask(this,spm),10);
    
    }
   
    public void startScanJob(ImityMidlet spm) {
	  
    	if (SPM == null) SPM = spm;
  
        Timer timer = new Timer();
        timer.schedule(new ScanDevicesTask(this,spm),scanWaitTime);

        if ((scanWaitTime == 6000) && (SPM != null)) SPM.autoSubmitData();

        
    	if (scanWaitTime < 30000) scanWaitTime += 5000;
	    //appendString("-s-ds-");
    }
        
     
    
    public void scanForDevices() {
        scanForDevices(false);
    }
    public void scanForDevices(boolean isForced) {
    	ImityDiscoveryListener spdl = new ImityDiscoveryListener(this);
        spdl.isForced = isForced;
    }

    
    public void scanForDevices(ImityMidlet spm) {
        scanForDevices(spm, false); 
    }
    
    public void scanForDevices(ImityMidlet spm,boolean isForced) {
    	ImityDiscoveryListener spdl = new ImityDiscoveryListener(this, spm);
        spdl.isForced = isForced;
    }
    
    public Bookmark bookmark() {
      
        /* test */
        /*
        this.addDeviceInfo(new BluetoothDevice("MAC1","TEST NAME 1"));
        this.addDeviceInfo(new BluetoothDevice("MAC2","TEST NAME 2"));
      
        ((BluetoothDevice)(Devices.get("MAC1"))).ImityServiceUrl = "proto://MAC1/1234";
        ((BluetoothDevice)(Devices.get("MAC2"))).ImityServiceUrl = "proto://MAC2/1234";
        */
         /* test end */
        
        
        Bookmark bm = new Bookmark(WorldObjects);
        
        return bm;
        //Bookmarks.put(bm.Tag,bm);
        
    }
    
    
    public void appendString(String str) {
        //SET TO TRUE
        appendString(str, true);
    }
    
    public void appendString(String str, boolean ignore) {
        if (!ignore) {
            DebugStr += str;

            if (null != SPM) {
                Form df = SPM.get_DebugForm();
            }
        }
    }

   public void clearAllRecords() {
        RecordStoreUtil.clearData(Application.RECORDSTORE_SPP);
   }
    
   public final static String readData(StreamConnection conn) {
    
    InputStream input = null;
    byte[] data = null;  
    
    try {       	      	
      input = conn.openInputStream();
      
      // Probably want to throw an exception if length is not greater then 0
      int length = input.read();       
      data= new byte[length];
      length = 0;

      // Assemble data
      while (length != data.length) {     
        int ch = input.read(data, length, data.length - length);
        if (ch == -1) {
          throw new IOException("Can't read data");
        }
        length += ch;
      }      

    } catch (IOException e) {
      System.err.println(e);
    } finally {        
    	
      // close input stream	
      if (input != null) {
        try {
          input.close();
        } catch (IOException e) {
        }
      } 
    }
    return new String(data);       
  }    

  void addDeviceInfo(BluetoothDevice bd) {
  
  	addDeviceInfo(bd, null);
  }
  
  void addDeviceInfo(BluetoothDevice bd, ImityMidlet spm) {
  
      boolean changes = false;
        
      //Check that bd is phone or computer
      if ((bd.getMajorClass() != 256 && bd.getMajorClass() != 512)) {
      //
      //Check that bd is phone
      //if (bd.getMajorClass() != 512) {
          return;
      }
      
      try {
	  
          if (WorldObjects.containsKey(bd.getId())) {

		
              BluetoothDevice bdd = (BluetoothDevice)WorldObjects.get(bd.getId());
              
              //appendString("-R-" + bd.BluetoothAddress + "\r\n");
	          if (bdd.FriendlyName.equals("") && !bd.FriendlyName.equals("")) {
	      	    bdd.FriendlyName = bd.FriendlyName;
                bdd.setLogged(false);
                changes = true;
	          } 
              
              if (bdd.getMajorClass() == 0 && bd.getMajorClass() > 0) {
                bdd.setMajorClass(bd.getMajorClass());
              }
              if (bdd.getMinorClass() == 0 && bd.getMinorClass() > 0) {
                bdd.setMinorClass(bd.getMajorClass());
              }


              bdd.setDiscoveryDate(bd.getDiscoveryDate());

              if (!bdd.inProximity())
              {          
                  bdd.setInProximity(true);
                  Logger.bluetoothDeviceArrive(bdd.getId());
              }

              
              
              //Devices.remove(bd.BluetoothAddress);
              //appendString("-r-" + bd.BluetoothAddress + "\r\n");
          } else 
          {
		  
            WorldObjects.put(bd.getId(),bd);
            bd.setInProximity(true);
            Logger.bluetoothDeviceArrive(bd.getId());
            
	        //appendString("-ToWorld-" + bd.BluetoothAddress + "\r\n");
	        if (null != spm) {

		        SpimeChoiceItem dvli;
                   
                if (bd.isFriend()) {
                        
/*                } else
	            if (bd.hasUnreadMessages()) {  
		            //#style messageListItem
		            dvli = new SpimeChoiceItem(bd.getId(),bd.FriendlyName,null,Choice.IMPLICIT);
		            dvli.addCommand(spm.get_showMessages());

            	    spm.ObjectList.add(dvli);
		        } else if (bd.hasImityService()) {  
		            //#style shoutpodListItem
		            dvli = new SpimeChoiceItem(bd.getId(),bd.FriendlyName,null,Choice.IMPLICIT);
		            dvli.addCommand(spm.get_showMessages());

            	    spm.ObjectList.add(dvli); */
		        } else {
	                if (bd.inProximity() && !bd.getDisplayName().equals("")) {
		                //#style deviceListItemUpdating
		                dvli = new SpimeChoiceItem(bd.getId(),bd.getDisplayName(),null,Choice.IMPLICIT);
            	        spm.ObjectList.add(dvli);
                    }
		        }
                
	       }
	    
          }

          if ((null != spm) && (changes)) spm.refreshObjectList();

      } catch (Exception ex) {
        appendString("AddDeviceInfo Exception: " + ex.toString() + ":" + ex.getMessage());
      }
      
  } 

  public void deleteDataRecordStores() {
      try {
        RecordStoreUtil.clearData(Application.RECORDSTORE_SPP);
        RecordStoreUtil.clearData(Application.RECORDSTORE_LOCALOBJECTS);
        RecordStoreUtil.clearData(Application.RECORDSTORE_ACCOUNT);
        RecordStoreUtil.clearData(Application.RECORDSTORE_NOTICES);
        RecordStoreUtil.clearData(Application.RECORDSTORE_NOTICE_OBJECTS);
      } catch (Exception ex) {} 
  }

  public void saveNotifications() {
   
      try {
        String nos = Notifications.toImityElementsString(true,-1); 
        
        RecordStoreUtil.clearData(Application.RECORDSTORE_NOTICES);
        RecordStoreUtil.clearData(Application.RECORDSTORE_NOTICE_OBJECTS);
        if (nos != null) {
            RecordStoreUtil.writeData(Application.RECORDSTORE_NOTICES, nos);
        }
        
        String n_objects = "";
        for (Enumeration e = Notifications.elements(); e.hasMoreElements();) {
            Notice n = (Notice)e.nextElement();
            try {
                SpimeObject spo = (SpimeObject)WorldObjects.get(n.NoticeSpid);

                if (spo != null) {
                    n_objects += spo.toXmlElementString();
                    //appendString("putting object:" + spo.getId() + " into notice cache");
                }
               
                
            } catch (Exception ex) {}
        }
        
        //appendString("notice_objects_cache:" + n_objects);

        if (!n_objects.equals("")) {
                
            RecordStoreUtil.writeData(Application.RECORDSTORE_NOTICE_OBJECTS, n_objects);
        }
        
      } catch (Exception ex) {
        appendString("-nos-saveDataException: " + ex);
      }

  }

  public void saveDataToRecordStore() {
        
      try {

        saveNotifications();
        String spp = makeImityElements(false); 
        String lspp = LocalObjects.toImityElementsString(true, -1);
        
        if (spp != null) {
            RecordStoreUtil.writeData(Application.RECORDSTORE_SPP, spp);
        }

        RecordStoreUtil.clearData(Application.RECORDSTORE_LOCALOBJECTS);
        if (lspp != null) {
            RecordStoreUtil.writeData(Application.RECORDSTORE_LOCALOBJECTS, lspp);
        }
        RecordStoreUtil.clearData(Application.RECORDSTORE_BYTE_COUNT);
        if (bytes_since_login != 0) {
            RecordStoreUtil.writeString(Application.RECORDSTORE_BYTE_COUNT, Long.toString(bytes_since_login));
        }

        
      } catch (Exception ex) {
        appendString("saveDataException: " + ex);
      }
        
  }

  public String makeImityDataPackage() {
    String contents = "";
    
    String elementStr = makeImityElements();
    
    if (elementStr != null) contents += elementStr;
        
    /* 
    Hashtable h = RecordStoreUtil.readData(Application.RECORDSTORE_SPP);
    for (Enumeration e = h.elements(); e.hasMoreElements();) {
      contents += (String)e.nextElement(); 
    } 
    */
   

    return makeImityPackage(contents);

  }
  
  public String makeImityPackage(String contents) {
      String imityPackage = null;
      try {

	      long localTime = System.currentTimeMillis();
	      String transactionId = generateUid();
	      imityPackage = "<spp sessid=\"" + SessionId + "\" state=\"" + State + "\" cltrid=\"" + transactionId + "\" aid=\"" + getAccountId() + "\" lt=\"" + localTime + "\" a=\"" + localDeviceId() + "\">";
          
          imityPackage += contents;

	      imityPackage += "</spp>";
	      
	      String testString = "<spp sessid=\"" + SessionId + "\" state=\"" + State + "\" cltrid=\"" + transactionId + "\" aid=\"" + getAccountId() + "\" lt=\"" + localTime + "\" a=\"" + localDeviceId() + "\">";
	      testString += "";
	      testString += "</spp>";
	      
	      if (imityPackage.equals(testString)) {
	        return null;
		  }
	
      } catch (Exception ex) {
        appendString("-make-spp-exception-: " + ex);
      }
      
      return "<?xml version=\"1.0\" encoding=\"" + Application.getInstance().Encoding + "\"?>\n" + imityPackage;

  }

  public String makeImityElements(boolean includeLocalObjects) {
      String shoutpodElements = "";
      try {
	    ImityObjects spo = WorldObjects.clone();
        shoutpodElements += Bookmarks.toImityElementsString();
        if (includeLocalObjects) shoutpodElements += LocalObjects.toImityElementsString();
        shoutpodElements += Logger.toString();
        shoutpodElements += spo.toImityElementsString(false,4); //ignore person spime
      } catch (Exception ex) {
        appendString("-make-spp-e-exception-:" + ex);
      }
        
      if (shoutpodElements.equals("")) return null;
      return shoutpodElements;
    
  }
  
  public String makeImityElements() {
    return makeImityElements(true);
  }


  /*
  public void submitDataToFile() {
      
      long cTime = System.currentTimeMillis();
      String imityPackage = makeImityDataPackage();
         
      String ret = "";

      if (imityPackage != null) {
        //There is data to send
	
        //Special build that dumps a file instead of uploading
        //ret = HttpUtil.HttpPostPackage(this.ServerUrl,HttpUtil.URLencode(imityPackage));
        
        FileUtil fu = new FileUtil(); 

        fu.saveTextFile(imityPackage);
        
        ret = "0";
            
	    // Should do some updates to world here if info is received from services.
      } else {
	    //Show no data to send alert
        ret = "-102:No data to send";
      }
      
      
      if (ret.equals("0")) {
        //Update logged flag on devices
        Logger.deleteEntriesBefore(cTime);
        Bookmarks.setAllLogged();
        WorldObjects.setAllLogged();
        LocalObjects.setAllLogged();

        RecordStoreUtil.clearData(Application.RECORDSTORE_SPP);
      }
      
      appendString("Submit returned:" + ret + "\r\n");
      
  }
  */
  
  public void submitDataToServer() {
    submitDataToServer("",true);  
  }
  
  public void submitDataToServer(String dataPackage,boolean retryOnFail) {
      
      long cTime = System.currentTimeMillis();

      
      String imityPackage = dataPackage;
      
      if (imityPackage.equals("")) imityPackage = makeImityDataPackage();
      //appendString("-before sending:" + imityPackage);
         
      String ret = "";

      if (imityPackage != null) {
        //There is data to send
	    //appendString("-pdata:" + imityPackage + "-");
        ret = HttpUtil.HttpPostPackage(this.ServerUrl,HttpUtil.URLencode(imityPackage));
        //appendString("-rdata:" + ret + "-");
	    // Should do some updates to world here if info is received from services.
      } else {
	    //Show no data to send alert
        ret = "<spp a=\"local\" c=\"800\"/>";
      }
      
      int retCode = 800;
      
      Hashtable retData = processServerSpp(ret);
      
      if (retData.containsKey("returnCode")) retCode = Integer.parseInt((String)retData.get("returnCode"));
     
      
      if (retCode == 200) {
        //Update logged flag on devices
        
        Logger.deleteEntriesBefore(cTime);
        Bookmarks.setAllLogged();
        WorldObjects.setAllLogged();
        LocalObjects.setAllLogged();

        RecordStoreUtil.clearData(Application.RECORDSTORE_SPP);

        State = "1";

      } else if (retCode == 401) { 
        if (SPM != null) { 
            SPM.alertAndLogout("Invalid Session","Your session id is no longer valid. You will have to logout.");
        }
      } else if (retryOnFail) {
        try {

            appendString("Submit returned:(" + retCode + "). Retry in 5s");
            Thread.sleep(5000);

            appendString("-Retrying-");
            submitDataToServer(imityPackage,false);
        } catch (Exception ex) {}
        return;

      }
      
     
      
      appendString("Submit returned:(" + retCode + ")");

      if (retCode == 800) {
        appendString("ret:" + ret);
        State = "0";
      }
      
      /* if (!scanning) forceScanJob(SPM); */
  }
  
  public int sendSpimeObject(String RecipientSpid, SpimeObject so) {
	  try {

	  	ObexClient oc = new ObexClient(this);	     
       
        String btaddr_to_send_to = "";
        String recipient_spid = "";
        if (WorldObjects.containsKey(RecipientSpid)) {
            Person p = (Person)WorldObjects.get(RecipientSpid);
            if (!p.isNear()) return -1;
            btaddr_to_send_to = p.isNearAddress;
            recipient_spid = p.getId();
        }
 
        if (LocalObjects.containsKey(RecipientSpid)) {
            Friend f = (Friend)LocalObjects.get(RecipientSpid);
            if (!f.isNear()) return -1;
            btaddr_to_send_to = f.isNearAddress;
            recipient_spid = f.PersonRef;
        }
        
        if (so.getClassId() == 3) {

            //This is a message
            Message m = (Message)so;
            m.ReceiverPersonSpid = recipient_spid;
            m.SenderPersonSpid = getLocalPerson().getId();
	        BluetoothDevice btd = new BluetoothDevice(localAddress,"",0,0);

        }
        
	    BluetoothDevice btd = new BluetoothDevice(btaddr_to_send_to,"",0,0);
        
		if (WorldObjects.containsKey(btd.getId())) {
	  		oc.sendSpimeObject((BluetoothDevice)WorldObjects.get(btd.getId()),so);
		}
	  } catch (Exception ex) {
	  	appendString("sendSpimeObject Exception: " + ex + "\r\n");
		return -1;
	  }

	  return 0;
  }

  public void notifyNewObject(String soid) {
  
    try {
	  SpimeObject so = (SpimeObject)WorldObjects.get(soid);

	  /* If we are running in a midlet lets act */
	  if (null != SPM) {
        SPM.NotifyNewObject();
	  }

    } catch (Exception ex) {
    }

  }


  public void notifyObjectNotSent(BluetoothDevice btdToSendTo, SpimeObject spoToSend) {
      if (null != SPM) {
        /*
	  	if (spoToSend.getClassId() == 3) {
			try {
                    
                if (SPM.activeSoid == btdToSendTo.getId()) {
						SPM.AddErrorMessageToMessageForm(btdToSendTo.getDisplayName(), ((Message)spoToSend).Text);
                } else {
                        //Should at error to the shout messages dialog once I have it in place
                }
			
			} catch (Exception ex) {
				appendString("Could not append new message to MessageForm");
			}
		}
        */

        SPM.autoSubmitData();
	  }
  }

 public static ImityObjects DeSerializeNotifications(String xmlStr) {
 
     ImityObjects io = new ImityObjects();
         
	 try {
	 	Node root = new Xparse().parse(xmlStr);	  
		Node lo = root.find("nos", firstChildOccur);
	    if (lo == null) return io;


        for (int x = 0; x < lo.contents.length(); x++) {
            try {
                int occur[] = {(x + 1)};
                Node nextNode = lo.find("no", occur);
                
                if (nextNode != null) {
                    Notice n = Notice.DeSerialize(nextNode);
                    io.put(n.getId(),n);
                }
                
            } catch (Exception ex) {
                
                Application.getInstance().appendString("-a-DS-nos-ex:" + ex);
        
            }
            
        }

        
	 } catch (Exception ex) { }
	 
     return io;


 }

 public static ImityObjects DeSerializeLocalData(String xmlStr) {
    
     //Application.getInstance().appendString("parse:" + xmlStr);
     ImityObjects io = new ImityObjects();
         
	 try {
	 	Node root = new Xparse().parse(xmlStr);	  
		Node lo = root.find("lo", firstChildOccur);
	    if (lo == null) return io;

        for (int x = 0; x < lo.contents.length(); x++) {
            try {
                int occur[] = {(x + 1)};
                Node nextNode = lo.find("o", occur);
                String classId = "" + nextNode.attributes.get("classId");
                
                if (classId.equals("5")) {
                    Friend f = Friend.DeSerialize(nextNode);
                    io.put(f.getId(),f);
                }
                if (classId.equals("4")) {
                    //Application.getInstance().appendString("We got a person");
                    Person p = Person.DeSerialize(nextNode);
                    io.put(p.getId(),p);
                    
                    //Application.getInstance().appendString("person deserialized");
                }
                if (classId.equals("1")) {
                    BluetoothDevice b = BluetoothDevice.DeSerialize(nextNode);
                    io.put(b.getId(),b);
                }
                
            } catch (Exception ex) {
                
                Application.getInstance().appendString("-a-DS-lo-ex:" + ex);
        
            }
            
        }

        
	 } catch (Exception ex) { }
	 
     return io;

 }
  
  public static SpimeObject DeSerializeSpimeData(String xmlStr) {
  
	 try {
	 	Node root = new Xparse().parse(xmlStr);	  
		Node o = root.find("o", firstChildOccur);
	    if (o == null) return null;
		
		    int classId = Integer.parseInt((String)o.attributes.get("classId"));
	 
	        if (classId == 1) return BluetoothDevice.DeSerialize(o);
	        if (classId == 3) return Message.DeSerialize(o);
	        if (classId == 5) return Friend.DeSerialize(o);

	 } catch (Exception ex) { }
	 
     return null;
  }

  public void LogWorldObjects() {
  
    /* Should create log entries for upload in recordstore or upload directly if there is a
     * proxy service available?
     *
     * Also update objects that have not been discovered for a while. Eg a bluetooth devices not
     * discovered within 60 sec should not have a ImityServiceUrl etc.
     * */

    // loop though world objects
   
    //appendString("-lwo-");
    boolean changes = false; 
   
    Hashtable objectsToRemove = new Hashtable();
    
    try {
    
	    for (Enumeration e = WorldObjects.elements() ; e.hasMoreElements() ;) {
	           
	            SpimeObject so = (SpimeObject)e.nextElement();
	    
	            if (so.getClassId() == 1) {
	                BluetoothDevice btd = (BluetoothDevice)so;

                  if (btd.inProximity()) {
                  
  	                if (((btd.getDiscoveryDate() + timeDiffRecent) < System.currentTimeMillis()) && (btd.hasImityService())) {
	                      //appendString("Resetting SPUrl on: " + btd.getId());
	                      btd.ImityServiceUrl = "";
	                      changes = true;
	                  }
	                  if ((btd.getDiscoveryDate() + timeDiffLong) < System.currentTimeMillis() ) {
	                      //appendString("Removing btd: " + btd.getId());
	                      //objectsToRemove.put(btd.getId(),btd.getId());

                        btd.setInProximity(false);

                        Logger.bluetoothDeviceLeave(btd.getId());
	                      changes = true;
	                  }
	                
	                }
	                
	            }
	    }
        /*
        for (Enumeration e = objectsToRemove.elements(); e.hasMoreElements() ;) {
            String cKey = (String)e.nextElement();

            WorldObjects.remove(cKey);
        }
        */
        
  
    } catch (Exception ex) {
        appendString("LogWorld Exception: " + ex);
    }
  
    /* 
    Bookmark bm = bookmark();
    Bookmarks.put(bm.getId(),bm);
    */

    if (changes &&  SPM != null) {
            
        //appendString("-lwo-refresh-");
        SPM.refreshObjectList();
    }

   
  }


  public String login(String login, String pwd) {

      if (login.equals("debug")) {
        AccountNumber = 666;

        RecordStoreUtil.clearData(Application.RECORDSTORE_ACCOUNT);
        RecordStoreUtil.writeData(Application.RECORDSTORE_ACCOUNT,"" + AccountNumber + ";DEBUGSESSION");
        bytes_since_login = 0;  
        RecordStoreUtil.clearData(Application.RECORDSTORE_BYTE_COUNT);
        RecordStoreUtil.writeString(Application.RECORDSTORE_BYTE_COUNT, Long.toString(bytes_since_login));
          
          
 
        return null;
      }
        
      /* send account package to login url and parse response*/

      String contents = "<login><l><![CDATA[" + login + "]]></l><p><![CDATA[" + pwd + "]]></p></login>";
      String imityPackage = makeImityPackage(contents);

         
      String ret = "";

      if (imityPackage != null) {
        //There is data to send
	
        ret = HttpUtil.HttpPostPackage(Application.LoginUrl,HttpUtil.URLencode(imityPackage));
	
	    // Should do some updates to world here if info is received from services.
      } else {
	    //Show no data to send alert
        ret = "-102:No data to send";
        return ret;
      }
      
      //appendString("login ret raw:" + ret + "\r\n");
      
      int retCode = -1;
      int accountNumber = -1;


      Hashtable retData = processServerSpp(ret);
      
      if (retData.containsKey("returnCode")) retCode = Integer.parseInt((String)retData.get("returnCode"));
      if (retData.containsKey("accountNumber")) accountNumber = Integer.parseInt((String)retData.get("accountNumber"));
      if (retData.containsKey("sessionId")) SessionId = (String)retData.get("sessionId");
      
      //appendString("login returned:" + retCode + "\r\n");
      if (retCode == 200 && accountNumber > 0) {
        //set accountId and person and create/update recordstore Application.RECORDSTORE_ACCOUNT

        RecordStoreUtil.clearData(Application.RECORDSTORE_ACCOUNT);
        RecordStoreUtil.writeData(Application.RECORDSTORE_ACCOUNT,"" + accountNumber + ";" + SessionId);
        bytes_since_login = 0;  
        saveDataToRecordStore();
                    
        return null;
      } else if (retCode == 203) {
          return "Bad username or password";
      } else if (!retData.containsKey("returnCode")) {
          return "Could not connect to server";
      }
      AccountNumber = -1; 
      return "There was a problem logging in. Please try again";
  }

  public Hashtable processServerSpp(String sppStr) {
    Hashtable retData = new Hashtable();
 
     /* parsing response from server*/
	  try {
        //appendString("-startparse-");
	    Node root = new Xparse().parse(sppStr);	  
            

        //appendString("-spp-parse-:" + sppStr);
        Node spp = root.find("spp", firstChildOccur);
	    if (spp != null) {

            //appendString("-c-attrib-");
		        retData.put("returnCode",(String)spp.attributes.get("c"));
            
            //appendString("-account-node-");
            Node account = spp.find("account", firstChildOccur);
            if (account != null) {
                //appendString("-number-attrib-");
                retData.put("accountNumber", (String)account.attributes.get("number"));

                AccountNumber = Integer.parseInt((String)retData.get("accountNumber"));
            }

            try {
                String sessionId = (String)spp.attributes.get("sessid");
                retData.put("sessionId",sessionId);
            } catch (Exception ex) {
            
            }

            Node spoNode = spp.find("spo", firstChildOccur);
       
            if (spoNode != null) {
            
	            for (int x = 0; x < spoNode.contents.length(); x++) {
	                try {
	                    int occur[] = {(x + 1)};
	                    Node nextNode = spoNode.find("o", occur);
	                    String classId = "" + nextNode.attributes.get("classId");
                        
                        String isDead = "0";
                        try { 
	                        isDead = "" + nextNode.attributes.get("d");
                        } catch (Exception ex) {
                            appendString("-is-dead-ex:" + ex);
                        }

	                    if (classId.equals("4")) {
	                        Person person = Person.DeSerialize(nextNode);

                            person.setLastUpdated(System.currentTimeMillis());
                            if (person.UID.equals("" + AccountNumber))
                            {                
                                LocalObjects.put(person.getId(),person);
                            } else {

                                //appendString("-ds-p-add:" + person.toXmlElementString() + "-");
                                //Check for Local Friends who should be updated

                                Friend f = findFriendByPersonRef(person.getId());

                                if (f != null) {
                                    f.setLastUpdated(System.currentTimeMillis());
                                    f.Name.setValue(person.Name);
                                    f.FriendName.setValue(person.Name);
                                    f.Weblog.setValue(person.Weblog);
                                    f.Tagline.setValue(person.Tagline);
                                    f.About.setValue(person.About);
                                    f.ImageUrl.setValue(person.ImageUrl);
                                    f.Devices = person.Devices.clone();
                                    f.Journal.setValue(person.Journal);
                                    //f.setPublicTags(person.getPublicTagString());
                                    //f.setPublicNotes(person.getPublicNotes().clone());
                                    
                                }
                                   
                                WorldObjects.put(person.getId(),person); 

                                if (isDead.equals("1")) {
                                    appendString("remove person " + person.getId());
                                    WorldObjects.remove(person.getId());
                                }  
                                
                            }
                            
	                    }
	                    if (classId.equals("5")) {
	                        Friend friend = Friend.DeSerialize(nextNode);
                            friend.setLastUpdated(System.currentTimeMillis());
	                        LocalObjects.put(friend.getId(),friend);

                            if (isDead.equals("1")) {
                                appendString("remove friend " + friend.getId());
                                WorldObjects.remove(friend.getId());
                            }  

	                    }
                        if (classId.equals("1")) {
                            BluetoothDevice btd = BluetoothDevice.DeSerialize(nextNode);
                           
                            if (WorldObjects.containsKey(btd.getId())) {
                                
                                BluetoothDevice btdWorld = (BluetoothDevice)WorldObjects.get(btd.getId());
                                btdWorld.setLastUpdated(System.currentTimeMillis());
                                btdWorld.Journal.setValue(btd.Journal);
                                btdWorld.setPublicTags(btd.getPublicTagString());
                                btdWorld.setPublicNotes(btd.getPublicNotes().clone());
                                btdWorld.PublicName = btd.PublicName;
                                btdWorld.PublicNameWhen = btd.PublicNameWhen;
                                btdWorld.PublicNameWho = btd.PublicNameWho;
                                 
                                
                            }

                            /* I dont do dead bit checks on devices since they should never be dead
                             * and since the only time they are cached are if one has setup notices on them */
                        }
	                    
	                } catch (Exception ex) {
	                    
	                    Application.getInstance().appendString("-spo-l-DS-d-ex:" + ex);
	            
	                }    
	                
	            }
 
            }

            //notices

	        for (int x = 0; x < spp.contents.length(); x++) {
	            try {
	                int occur[] = {(x + 1)};
	                Node nextNode = spp.find("no", occur);
                    if (nextNode != null) {
                        Notice no = Notice.DeSerialize(nextNode);
                        Notifications.put(no.getId(),no);
                    }
	            } catch (Exception ex) {
	                Application.getInstance().appendString("-nos-l-DS-d-ex:" + ex);
                }
            }
                       
        } else {
            //appendString("-no-spp-element-");
        }

	  } catch (Exception ex) {
        appendString("-login-response-exception:" + ex);
        return new Hashtable();
    }
     
    refreshFriendDevices();
 
    saveNotifications();
    Logger.checkForNotices();

   
    if (null != SPM) {
        SPM.notifyUpdates();
    }
    return retData;   
  }

  
  public boolean hasAccountId() {
      // TODO: Deal with pre signup accounts....
    if (AccountNumber > 0) return true;
    return false;
  }

  public String getAccountId() {
    if (AccountNumber > 0) return "" + AccountNumber;
    return null;
  }


  public void refreshFriendDevices() {
    /*name should be changed to profileStatusUpdate of something similar*/

          
    FriendDevices.clear();
    PersonDevices.clear();
          
    for (Enumeration e = LocalObjects.elements(); e.hasMoreElements();) {
        try {
            SpimeObject spo = (SpimeObject)e.nextElement();
        
            if (spo.getClassId() == 5) {
                Friend f = (Friend)spo;
                try {
                    BluetoothDevice btd = new BluetoothDevice(f.FirstAddr.toString(), "", 1, 1);
                    //appendString("-fd-p:" + btd.getId() + "-" + f.getId());
                    FriendDevices.put(btd.getId(),f.getId());
                } catch (Exception ex) {}  
                
                for (Enumeration d = f.Devices.elements(); d.hasMoreElements();) {
                    try {    
                        BluetoothDevice obtd = (BluetoothDevice)d.nextElement();
                        //appendString("-fd-p:" + btd.getId() + "-" + f.getId());
                        FriendDevices.put(obtd.getId(),f.getId());
                    } catch (Exception ex) {}
                }

                f.checkForUnreadMessages();
                
            }
        } catch (Exception ex) {
            appendString("-rf-fd-ex: " + ex);
        }
    }

    for (Enumeration e = WorldObjects.elements(); e.hasMoreElements();) {
        try {
            SpimeObject spo = (SpimeObject)e.nextElement();
        
            if (spo.getClassId() == 4) {
                Person p = (Person)spo;
                try {
                    BluetoothDevice btd = new BluetoothDevice(p.FirstAddr.toString(), "", 1, 1);
                    //appendString("-fd-p:" + btd.getId() + "-" + f.getId());
                    PersonDevices.put(btd.getId(),p.getId());
                } catch (Exception ex) {} 
                
                for (Enumeration d = p.Devices.elements(); d.hasMoreElements();) {
                    try {
                        BluetoothDevice obtd = (BluetoothDevice)d.nextElement();
                        //appendString("-fd-p:" + btd.getId() + "-" + p.getId());
                        PersonDevices.put(obtd.getId(),p.getId());
                    } catch (Exception ex) {
                    }
                }

                p.checkForUnreadMessages();
                
            }
        } catch (Exception ex) {
            appendString("-rf-fd-ex: " + ex);
        }
    }
 
    
  }

  public String generateUid() {

      int upperlimit = 100;
      int lowerlimit = 0;
      Random r = new Random();           
      int nr = (r.nextInt() >>> 1) % (upperlimit +1 - lowerlimit) + lowerlimit;
      
      return "" + nr + localAddress + System.currentTimeMillis();
      
  }


  public String localDeviceId() {

    //#ifdef config.ConnectToLocalhost:defined
        return "fakemac"; //Application.fake_id
    //#else
        BluetoothDevice btd = new BluetoothDevice(localAddress, "",1,1);
        return btd.getId();
    //#endif
  }

  public static int classIdFromSpid(String spid) {
    int ret = 0;
    
    try {
        String[] aStr = TextUtil.split(spid,'/');    
        
        ret = Integer.parseInt(aStr[2]);
        
    } catch (Exception ex) {
    }
        
    return ret;
  }

  public Friend findFriendByPersonRef(String spid) {
    
          try {
                  
              for (Enumeration e = LocalObjects.elements(); e.hasMoreElements(); ) {
                SpimeObject spo = (SpimeObject)e.nextElement();

                if (spo.getClassId() == 5) {
                    Friend f = (Friend)spo;
                    if (f.PersonRef.equals(spid)) return f;
                }
              }
          } catch (Exception ex) {
          }

          return null;
  }

  public SpimeObject getSpimeObject(String spid) {

        SpimeObject spo = null;
        if (LocalObjects.containsKey(spid)) {
            spo = (SpimeObject)LocalObjects.get(spid);
        } else if (WorldObjects.containsKey(spid)) {
            spo = (SpimeObject)WorldObjects.get(spid);            
        }

        return spo;
 
  }
 
  public Person getPersonFromDeviceSpid(String spid) {
  
    try {
        //appendString("-look for person on:" + spid + "-");
        if (PersonDevices.containsKey(spid)) {
            //appendString("-person exist as device:" + PersonDevices.get(spid) + "-");
            return (Person)WorldObjects.get(PersonDevices.get(spid)); 
        }
    } catch (Exception ex) {
        appendString("-agpds-ex-"); 
    } 

    return null;
    
  }
  
 
  public Person getLocalPerson() {
      try {
	      if (LocalPerson == null) {
	          
		      for (SpimePriorityEnumeration e = LocalObjects.prioritizedElements(); e.hasMoreElements();) {
		
		          SpimeObject s = (SpimeObject)e.nextElement();
		        
		          if (s.getClassId() == 4) {
	                LocalPerson = (Person)s;
	                return LocalPerson;
		          }
		      }
	
	          return null;
	
	      } 
      
      } catch (Exception ex) {
        appendString("-getLocalPerson-ex:" + ex + "-");
      }
	
      return LocalPerson;
  }

  public int getScreenWidth() {
    if (SPM != null) {
        return SPM.ScreenWidth;
    } else { return 220; } 
    
  }

  public void removeNotificationsByNoticeSpid(String noticeSpid) {
    try {
        for (Enumeration e = Notifications.elements(); e.hasMoreElements();) {
            Notice n = (Notice)e.nextElement();
            if (n.NoticeSpid.equals(noticeSpid)) {
                n.Ack = 1;
                n.setLogged(false);
                WorldObjects.put(n.getId(),n);
                Notifications.remove(n.getId());
                return;
            }
        }
    } catch (Exception ex) {
        
    }
  }
  
  public void ComputeTrafficStats(long accumulate_bytes) {
      bytes_since_login += accumulate_bytes;
      bytes_this_session += accumulate_bytes;
  }

Show details Hide details

Change log

r11 by claus.dahl on Feb 07, 2007 Diff

error screens - bandwidth logging

Go to:

Project members, sign in to write a code review

Older revisions

r2 by claus.dahl on Feb 05, 2007 Diff

first drop

All revisions of this file

File info

Size: 47195 bytes, 1437 lines

View raw file