Esempio n. 1
0
  /**
   * Permanently removes locally stored message history for the metacontact, remove any recent
   * contacts if any.
   */
  public void eraseLocallyStoredHistory(MetaContact contact) throws IOException {
    List<ComparableEvtObj> toRemove = null;
    synchronized (recentMessages) {
      toRemove = new ArrayList<ComparableEvtObj>();
      Iterator<Contact> iter = contact.getContacts();
      while (iter.hasNext()) {
        Contact item = iter.next();
        String id = item.getAddress();
        ProtocolProviderService provider = item.getProtocolProvider();

        for (ComparableEvtObj msc : recentMessages) {
          if (msc.getProtocolProviderService().equals(provider)
              && msc.getContactAddress().equals(id)) {
            toRemove.add(msc);
          }
        }
      }

      recentMessages.removeAll(toRemove);
    }
    if (recentQuery != null) {
      for (ComparableEvtObj msc : toRemove) {
        recentQuery.fireContactRemoved(msc);
      }
    }
  }
Esempio n. 2
0
  /** @param aProperties the updated properties. */
  @SuppressWarnings("rawtypes")
  final void setProperties(final Dictionary aProperties) {
    final Map<String, String> newProps = new HashMap<String, String>();

    Enumeration keys = aProperties.keys();
    while (keys.hasMoreElements()) {
      final String key = (String) keys.nextElement();
      if (!KNOWN_KEYS.contains(key) && !IGNORED_KEYS.contains(key)) {
        LOG.log(Level.WARNING, "Unknown/unsupported profile key: " + key);
        continue;
      }

      final String value = aProperties.get(key).toString();
      newProps.put(key, value.trim());
    }

    // Verify whether all known keys are defined...
    final List<String> checkedKeys = new ArrayList<String>(KNOWN_KEYS);
    checkedKeys.removeAll(newProps.keySet());
    if (!checkedKeys.isEmpty()) {
      throw new IllegalArgumentException(
          "Profile settings not complete! Missing keys are: " + checkedKeys.toString());
    }

    this.properties.putAll(newProps);

    LOG.log(
        Level.INFO,
        "New device profile settings applied for {1} ({0}) ...", //
        new Object[] {getType(), getDescription()});
  }
 /** removeAll removes all elements from the given collection */
 public void testRemoveAll() {
   List full = populatedArray(3);
   Vector v = new Vector();
   v.add(one);
   v.add(two);
   full.removeAll(v);
   assertEquals(1, full.size());
 }
Esempio n. 4
0
  /**
   * A provider has been removed.
   *
   * @param provider the ProtocolProviderService that has been unregistered.
   */
  void handleProviderRemoved(ProtocolProviderService provider) {
    // lets remove the recent messages for this provider, and update
    // with recent messages for the available providers
    synchronized (recentMessages) {
      if (provider != null) {
        List<ComparableEvtObj> removedItems = new ArrayList<ComparableEvtObj>();
        for (ComparableEvtObj msc : recentMessages) {
          if (msc.getProtocolProviderService().equals(provider)) removedItems.add(msc);
        }

        recentMessages.removeAll(removedItems);
        if (!recentMessages.isEmpty())
          oldestRecentMessage = recentMessages.get(recentMessages.size() - 1).getTimestamp();
        else oldestRecentMessage = null;

        if (recentQuery != null) {
          for (ComparableEvtObj msc : removedItems) {
            recentQuery.fireContactRemoved(msc);
          }
        }
      }

      // handleProviderRemoved can be invoked due to stopped
      // history service, if this is the case we do not want to
      // update messages
      if (!this.messageHistoryService.isHistoryLoggingEnabled()) return;

      // lets do the same as we enable provider
      // for all registered providers and finally fire events
      List<ComparableEvtObj> contactsToAdd = new ArrayList<ComparableEvtObj>();
      for (ProtocolProviderService pps : messageHistoryService.getCurrentlyAvailableProviders()) {
        contactsToAdd.addAll(getCachedRecentMessages(pps, true));
      }

      addNewRecentMessages(contactsToAdd);
    }
  }
  public User getUser(Principal principal, Properties properties) throws IOException {
    User res = null;

    {
      AbstractUserAuthorizor.DefaultUser user = null; // user created by this

      // Set 'user':
      {
        User u = super.getUser(principal, properties); // get user returned from nested resource

        if (u == null) {
          user = new AbstractUserAuthorizor.DefaultUser();

          // Set principal:
          {
            String userName = PrincipalUtil.getNameStripped(principal);
            Principal userPrincipal = new SimplePrincipal(userName);
            user.setPrincipal(userPrincipal);
          }
        } else {
          user = new AbstractUserAuthorizor.DefaultUser(u);
        }
      }

      // Override group principals:
      {
        List<Principal> l = expandGroupPrincipals(user); // new list of group-principals
        user.setGroupPrincipals(l); // overwrite the original group principals
      }

      // Override user roles:
      {
        List<String> userRoles = new ArrayList<String>();

        // Add basic user roles:
        {
          List<String> l = user.getUserRoles();
          if (l != null) {
            userRoles.addAll(l);
          }
        }

        // Add special, additional user roles:
        {
          List<String> l = getIncludeUserRolesFromConfig(principal);
          if (l != null) {
            userRoles.addAll(l); // add!
          }
        }

        // Expand all user roles:
        {
          userRoles =
              ApplicationUserRoles.expandUserRoles(
                  userRoles); // expanded user-roles, sorted, duplicates removed!
        }

        // Remove special, excluded user roles:
        {
          List<String> l = getExcludeUserRolesFromConfig(principal);
          if (l != null) {
            l =
                ApplicationUserRoles.expandUserRoles(
                    l); // expanded user-roles, sorted, duplicates removed!
            userRoles.removeAll(l); // remove!
          }
        }

        user.setUserRoles(userRoles); // overwrite the original user roles
      }

      // Override full name:
      {
        Principal userPrincipal = user.getPrincipal();
        String fullName = getUserPresentationNameFromConfig(userPrincipal);
        if (fullName != null) {
          fullName = fullName.trim();

          if (fullName.length() > 0) {
            user.setFullName(fullName);
          }
        }
      }

      res = user;
    }

    return res;
  }
Esempio n. 6
0
  public void tick() {
    timeLeft--;

    if (widthArrow < 0) {
      widthArrow *= -1;
      tipWidthArrow *= -1;

      xPositionsArrow =
          new int[] {
            xArrow + -widthArrow / 2,
            xArrow + widthArrow / 2 - tipWidthArrow,
            xArrow + widthArrow / 2 - tipWidthArrow,
            xArrow + widthArrow / 2,
            xArrow + widthArrow / 2 - tipWidthArrow,
            xArrow + widthArrow / 2 - tipWidthArrow,
            xArrow + -widthArrow / 2
          };
      yPositionsArrow =
          new int[] {
            yArrow + -heightArrow / 4,
            yArrow + -heightArrow / 4,
            yArrow + -heightArrow / 2,
            yArrow + 0,
            yArrow + heightArrow / 2,
            yArrow + heightArrow / 4,
            yArrow + heightArrow / 4
          };
    }

    if (timeLeft == 0) {
      mario.dieTime();
    }

    xCamO = xCam;
    yCamO = yCam;

    if (startTime > 0) {
      startTime++;
    }

    float targetXCam = mario.x - 160;

    xCam = targetXCam;

    if (xCam < 0) xCam = 0;
    if (xCam > level.getWidth() * 16 - 320) xCam = level.getWidth() * 16 - 320;

    /*      if (recorder != null)
    {
    recorder.addTick(mario.getKeyMask());
    }

    if (replayer!=null)
    {
    mario.setKeys(replayer.nextTick());
    }*/

    fireballsOnScreen = 0;

    for (Sprite sprite : sprites) {
      if (sprite != mario) {
        float xd = sprite.x - xCam;
        float yd = sprite.y - yCam;
        if (xd < -64 || xd > 320 + 64 || yd < -64 || yd > 240 + 64) {
          removeSprite(sprite);
        } else {
          if (sprite instanceof Fireball) {
            fireballsOnScreen++;
          }
        }
      }
    }

    if (paused) {
      for (Sprite sprite : sprites) {
        if (sprite == mario) {
          sprite.tick();
        } else {
          sprite.tickNoMove();
        }
      }
    } else {

      tick++;
      level.tick();

      boolean hasShotCannon = false;
      int xCannon = 0;

      for (int x = (int) xCam / 16 - 1; x <= (int) (xCam + layer.width) / 16 + 1; x++)
        for (int y = (int) yCam / 16 - 1; y <= (int) (yCam + layer.height) / 16 + 1; y++) {
          int dir = 0;

          if (x * 16 + 8 > mario.x + 16) dir = -1;
          if (x * 16 + 8 < mario.x - 16) dir = 1;

          SpriteTemplate st = level.getSpriteTemplate(x, y);

          if (st != null) {
            if (st.lastVisibleTick != tick - 1) {
              if (st.sprite == null || !sprites.contains(st.sprite)) {
                st.spawn(this, x, y, dir);
              }
            }

            st.lastVisibleTick = tick;
          }

          if (dir != 0) {
            byte b = level.getBlock(x, y);
            if (((Level.TILE_BEHAVIORS[b & 0xff]) & Level.BIT_ANIMATED) > 0) {
              if ((b % 16) / 4 == 3 && b / 16 == 0) {
                if ((tick - x * 2) % 100 == 0) {
                  xCannon = x;
                  for (int i = 0; i < 8; i++) {
                    addSprite(
                        new Sparkle(
                            x * 16 + 8,
                            y * 16 + (int) (Math.random() * 16),
                            (float) Math.random() * dir,
                            0,
                            0,
                            1,
                            5));
                  }
                  addSprite(new BulletBill(this, x * 16 + 8 + dir * 8, y * 16 + 15, dir));
                  hasShotCannon = true;
                }
              }
            }
          }
        }

      if (hasShotCannon) {
        sound.play(
            Art.samples[Art.SAMPLE_CANNON_FIRE],
            new FixedSoundSource(xCannon * 16, yCam + 120),
            1,
            1,
            1);
      }

      for (Sprite sprite : sprites) {
        sprite.tick();
      }

      for (Sprite sprite : sprites) {
        sprite.collideCheck();
      }

      for (Shell shell : shellsToCheck) {
        for (Sprite sprite : sprites) {
          if (sprite != shell && !shell.dead) {
            if (sprite.shellCollideCheck(shell)) {
              if (mario.carried == shell && !shell.dead) {
                mario.carried = null;
                shell.die();
              }
            }
          }
        }
      }
      shellsToCheck.clear();

      for (Fireball fireball : fireballsToCheck) {
        for (Sprite sprite : sprites) {
          if (sprite != fireball && !fireball.dead) {
            if (sprite.fireballCollideCheck(fireball)) {
              fireball.die();
            }
          }
        }
      }
      fireballsToCheck.clear();
    }

    sprites.addAll(0, spritesToAdd);
    sprites.removeAll(spritesToRemove);
    spritesToAdd.clear();
    spritesToRemove.clear();

    // TODO: THIS IS TEST FLIP
    //        if(keys[Mario.KEY_UP] && tick%2 == 0)
    //        	level.startFlipping = true;

    //        if(level.canFlip)
    //        	flip();
  }
Esempio n. 7
0
  /**
   * Handles new events.
   *
   * @param obj the event object
   * @param provider the provider
   * @param id the id of the source of the event
   */
  private void handle(EventObject obj, ProtocolProviderService provider, String id) {
    // check if provider - contact exist update message content
    synchronized (recentMessages) {
      ComparableEvtObj existingMsc = null;
      for (ComparableEvtObj msc : recentMessages) {
        if (msc.getProtocolProviderService().equals(provider)
            && msc.getContactAddress().equals(id)) {
          // update
          msc.update(obj);
          updateRecentMessageToHistory(msc);

          existingMsc = msc;
        }
      }

      if (existingMsc != null) {
        Collections.sort(recentMessages);
        oldestRecentMessage = recentMessages.get(recentMessages.size() - 1).getTimestamp();

        if (recentQuery != null) {
          recentQuery.updateContact(existingMsc, existingMsc.getEventObject());
          recentQuery.fireContactChanged(existingMsc);
        }

        return;
      }

      // if missing create source contact
      // and update recent messages, trim and sort
      MessageSourceContact newSourceContact =
          new MessageSourceContact(obj, MessageSourceService.this);
      newSourceContact.initDetails(obj);
      // we have already checked for duplicate
      ComparableEvtObj newMsg = new ComparableEvtObj(obj);
      recentMessages.add(newMsg);

      Collections.sort(recentMessages);
      oldestRecentMessage = recentMessages.get(recentMessages.size() - 1).getTimestamp();

      // trim
      List<ComparableEvtObj> removedItems = null;
      if (recentMessages.size() > numberOfMessages) {
        removedItems =
            new ArrayList<ComparableEvtObj>(
                recentMessages.subList(numberOfMessages, recentMessages.size()));

        recentMessages.removeAll(removedItems);
      }

      // save
      saveRecentMessageToHistory(newMsg);

      // no query nothing to fire
      if (recentQuery == null) return;

      // now fire
      if (removedItems != null) {
        for (ComparableEvtObj msc : removedItems) {
          recentQuery.fireContactRemoved(msc);
        }
      }

      recentQuery.addQueryResult(newSourceContact);
    }
  }
Esempio n. 8
0
  /**
   * Add the ComparableEvtObj, newly added will fire new, for existing fire update and when trimming
   * the list to desired length fire remove for those that were removed
   *
   * @param contactsToAdd
   */
  private void addNewRecentMessages(List<ComparableEvtObj> contactsToAdd) {
    // now find object to fire new, and object to fire remove
    // let us find duplicates and fire update
    List<ComparableEvtObj> duplicates = new ArrayList<ComparableEvtObj>();
    for (ComparableEvtObj msgToAdd : contactsToAdd) {
      if (recentMessages.contains(msgToAdd)) {
        duplicates.add(msgToAdd);

        // save update
        updateRecentMessageToHistory(msgToAdd);
      }
    }
    recentMessages.removeAll(duplicates);

    // now contacts to add has no duplicates, add them all
    boolean changed = recentMessages.addAll(contactsToAdd);

    if (changed) {
      Collections.sort(recentMessages);

      if (recentQuery != null) {
        for (ComparableEvtObj obj : duplicates)
          recentQuery.updateContact(obj, obj.getEventObject());
      }
    }

    if (!recentMessages.isEmpty())
      oldestRecentMessage = recentMessages.get(recentMessages.size() - 1).getTimestamp();

    // trim
    List<ComparableEvtObj> removedItems = null;
    if (recentMessages.size() > numberOfMessages) {
      removedItems =
          new ArrayList<ComparableEvtObj>(
              recentMessages.subList(numberOfMessages, recentMessages.size()));

      recentMessages.removeAll(removedItems);
    }

    if (recentQuery != null) {
      // now fire, removed for all that were in the list
      // and now are removed after trim
      if (removedItems != null) {
        for (ComparableEvtObj msc : removedItems) {
          if (!contactsToAdd.contains(msc)) recentQuery.fireContactRemoved(msc);
        }
      }

      // fire new for all that were added, and not removed after trim
      for (ComparableEvtObj msc : contactsToAdd) {
        if ((removedItems == null || !removedItems.contains(msc)) && !duplicates.contains(msc)) {
          MessageSourceContact newSourceContact =
              new MessageSourceContact(msc.getEventObject(), MessageSourceService.this);
          newSourceContact.initDetails(msc.getEventObject());

          recentQuery.addQueryResult(newSourceContact);
        }
      }

      // if recent messages were changed, indexes have change lets
      // fire event for the last element which will reorder the whole
      // group if needed.
      if (changed) recentQuery.fireContactChanged(recentMessages.get(recentMessages.size() - 1));
    }
  }
Esempio n. 9
0
  /**
   * Sets the new view and sends a VIEW_CHANGE event up and down the stack. If the view is a
   * MergeView (subclass of View), then digest will be non-null and has to be set before installing
   * the view.
   */
  public void installView(View new_view, Digest digest) {
    ViewId vid = new_view.getVid();
    List<Address> mbrs = new_view.getMembers();
    ltime =
        Math.max(
            vid.getId(),
            ltime); // compute the logical time, regardless of whether the view is accepted

    // Discards view with id lower than or equal to our own. Will be installed without check if it
    // is the first view
    if (view != null) {
      ViewId view_id = view.getViewId();
      int rc = vid.compareToIDs(view_id);
      if (rc <= 0) {
        if (log.isWarnEnabled()
            && rc < 0
            && log_view_warnings) { // only scream if view is smaller, silently discard same views
          log.warn(
              local_addr
                  + ": received view < current view;"
                  + " discarding it (current vid: "
                  + view_id
                  + ", new vid: "
                  + vid
                  + ')');
        }
        return;
      }
    }

    /* Check for self-inclusion: if I'm not part of the new membership, I just discard it.
    This ensures that messages sent in view V1 are only received by members of V1 */
    if (!mbrs.contains(local_addr)) {
      if (log.isWarnEnabled() && log_view_warnings)
        log.warn(local_addr + ": not member of view " + new_view.getViewId() + "; discarding it");
      return;
    }

    if (digest != null) {
      if (new_view instanceof MergeView) mergeDigest(digest);
      else setDigest(digest);
    }

    if (log.isDebugEnabled()) log.debug(local_addr + ": installing view " + new_view);

    Event view_event;
    synchronized (members) {
      view = new View(new_view.getVid(), new_view.getMembers());
      view_event = new Event(Event.VIEW_CHANGE, new_view);

      // Set the membership. Take into account joining members
      if (!mbrs.isEmpty()) {
        members.set(mbrs);
        tmp_members.set(members);
        joining.removeAll(mbrs); // remove all members in mbrs from joining
        // remove all elements from 'leaving' that are not in 'mbrs'
        leaving.retainAll(mbrs);

        tmp_members.add(joining); // add members that haven't yet shown up in the membership
        tmp_members.remove(
            leaving); // remove members that haven't yet been removed from the membership

        // add to prev_members
        for (Address addr : mbrs) {
          if (!prev_members.contains(addr)) prev_members.add(addr);
        }
      }

      Address coord = determineCoordinator();
      if (coord != null && coord.equals(local_addr) && !haveCoordinatorRole()) {
        becomeCoordinator();
      } else {
        if (haveCoordinatorRole() && !local_addr.equals(coord)) {
          becomeParticipant();
          merge_ack_collector.reset(null); // we don't need this one anymore
        }
      }
    }

    // - Changed order of passing view up and down (http://jira.jboss.com/jira/browse/JGRP-347)
    // - Changed it back (bela Sept 4 2007): http://jira.jboss.com/jira/browse/JGRP-564
    // - Moved sending up view_event out of the synchronized block (bela Nov 2011)
    down_prot.down(view_event); // needed e.g. by failure detector or UDP
    up_prot.up(view_event);

    List<Address> tmp_mbrs = new_view.getMembers();
    ack_collector.retainAll(tmp_mbrs);
    merge_ack_collector.retainAll(tmp_mbrs);

    if (new_view instanceof MergeView) merger.forceCancelMerge();

    if (stats) {
      num_views++;
      prev_views.add(new Tuple<View, Long>(new_view, System.currentTimeMillis()));
    }
  }
Esempio n. 10
0
  /**
   * Broadcasts the new view and digest, and waits for acks from all members in the list given as
   * argument. If the list is null, we take the members who are part of new_view
   */
  public void castViewChange(
      View new_view, Digest digest, JoinRsp jr, Collection<Address> newMembers) {
    if (log.isTraceEnabled())
      log.trace(local_addr + ": mcasting view " + new_view + " (" + new_view.size() + " mbrs)\n");

    // Send down a local TMP_VIEW event. This is needed by certain layers (e.g. NAKACK) to compute
    // correct digest
    // in case client's next request (e.g. getState()) reaches us *before* our own view change
    // multicast.
    // Check NAKACK's TMP_VIEW handling for details
    down_prot.up(new Event(Event.TMP_VIEW, new_view));
    down_prot.down(new Event(Event.TMP_VIEW, new_view));

    List<Address> ackMembers = new ArrayList<Address>(new_view.getMembers());
    if (newMembers != null && !newMembers.isEmpty()) ackMembers.removeAll(newMembers);

    Message view_change_msg = new Message(); // bcast to all members
    GmsHeader hdr = new GmsHeader(GmsHeader.VIEW, new_view);
    hdr.my_digest = digest;
    view_change_msg.putHeader(this.id, hdr);

    // If we're the only member the VIEW is broadcast to, let's simply install the view directly,
    // without
    // sending the VIEW multicast ! Or else N-1 members drop the multicast anyway...
    if (local_addr != null && ackMembers.size() == 1 && ackMembers.get(0).equals(local_addr)) {
      // we need to add the message to the retransmit window (e.g. in NAKACK), so (1) it can be
      // retransmitted and
      // (2) we increment the seqno (otherwise, we'd return an incorrect digest)
      down_prot.down(new Event(Event.ADD_TO_XMIT_TABLE, view_change_msg));
      impl.handleViewChange(new_view, digest);
    } else {
      if (!ackMembers.isEmpty()) ack_collector.reset(ackMembers);

      down_prot.down(new Event(Event.MSG, view_change_msg));
      try {
        if (!ackMembers.isEmpty()) {
          ack_collector.waitForAllAcks(view_ack_collection_timeout);
          if (log.isTraceEnabled())
            log.trace(
                local_addr
                    + ": received all "
                    + ack_collector.expectedAcks()
                    + " ACKs from members for view "
                    + new_view.getVid());
        }
      } catch (TimeoutException e) {
        if (log_collect_msgs && log.isWarnEnabled()) {
          log.warn(
              local_addr
                  + ": failed to collect all ACKs (expected="
                  + ack_collector.expectedAcks()
                  + ") for view "
                  + new_view.getViewId()
                  + " after "
                  + view_ack_collection_timeout
                  + "ms, missing ACKs from "
                  + ack_collector.printMissing());
        }
      }
    }

    if (jr != null && (newMembers != null && !newMembers.isEmpty())) {
      ack_collector.reset(new ArrayList<Address>(newMembers));
      for (Address joiner : newMembers) {
        sendJoinResponse(jr, joiner);
      }
      try {
        ack_collector.waitForAllAcks(view_ack_collection_timeout);
        if (log.isTraceEnabled())
          log.trace(
              local_addr
                  + ": received all ACKs ("
                  + ack_collector.expectedAcks()
                  + ") from joiners for view "
                  + new_view.getVid());
      } catch (TimeoutException e) {
        if (log_collect_msgs && log.isWarnEnabled()) {
          log.warn(
              local_addr
                  + ": failed to collect all ACKs (expected="
                  + ack_collector.expectedAcks()
                  + ") for unicast view "
                  + new_view
                  + " after "
                  + view_ack_collection_timeout
                  + "ms, missing ACKs from "
                  + ack_collector.printMissing());
        }
      }
    }
  }
Esempio n. 11
0
  protected void fixVCalendar(boolean fromServer) {
    // set iCal 4 global X-CALENDARSERVER-ACCESS from CLASS
    if (fromServer) {
      setPropertyValue("X-CALENDARSERVER-ACCESS", getCalendarServerAccess());
    }

    // iCal 4 global X-CALENDARSERVER-ACCESS
    String calendarServerAccess = getPropertyValue("X-CALENDARSERVER-ACCESS");
    String now = ExchangeSession.getZuluDateFormat().format(new Date());

    // fix method from iPhone
    if (!fromServer && getPropertyValue("METHOD") == null) {
      setPropertyValue("METHOD", "PUBLISH");
    }

    // rename TZID for maximum iCal/iPhone compatibility
    String tzid = null;
    if (fromServer) {
      // get current tzid
      VObject vObject = vTimezone;
      if (vObject != null) {
        String currentTzid = vObject.getPropertyValue("TZID");
        // fix TZID with \n (Exchange 2010 bug)
        if (currentTzid != null && currentTzid.endsWith("\n")) {
          currentTzid = currentTzid.substring(0, currentTzid.length() - 1);
          vObject.setPropertyValue("TZID", currentTzid);
        }
        if (currentTzid != null && currentTzid.indexOf(' ') >= 0) {
          try {
            tzid = ResourceBundle.getBundle("timezones").getString(currentTzid);
            vObject.setPropertyValue("TZID", tzid);
          } catch (MissingResourceException e) {
            LOGGER.debug("Timezone " + currentTzid + " not found in rename table");
          }
        }
      }
    }

    if (!fromServer) {
      fixTimezone();
    }

    // iterate over vObjects
    for (VObject vObject : vObjects) {
      if ("VEVENT".equals(vObject.type)) {
        if (calendarServerAccess != null) {
          vObject.setPropertyValue("CLASS", getEventClass(calendarServerAccess));
          // iCal 3, get X-CALENDARSERVER-ACCESS from local VEVENT
        } else if (vObject.getPropertyValue("X-CALENDARSERVER-ACCESS") != null) {
          vObject.setPropertyValue(
              "CLASS", getEventClass(vObject.getPropertyValue("X-CALENDARSERVER-ACCESS")));
        }
        if (fromServer) {
          // remove organizer line for event without attendees for iPhone
          if (vObject.getProperty("ATTENDEE") == null) {
            vObject.setPropertyValue("ORGANIZER", null);
          }
          // detect allday and update date properties
          if (isCdoAllDay(vObject)) {
            setClientAllday(vObject.getProperty("DTSTART"));
            setClientAllday(vObject.getProperty("DTEND"));
            setClientAllday(vObject.getProperty("RECURRENCE-ID"));
          }
          String cdoBusyStatus = vObject.getPropertyValue("X-MICROSOFT-CDO-BUSYSTATUS");
          if (cdoBusyStatus != null) {
            vObject.setPropertyValue(
                "TRANSP", !"FREE".equals(cdoBusyStatus) ? "OPAQUE" : "TRANSPARENT");
          }

          // Apple iCal doesn't understand this key, and it's entourage
          // specific (i.e. not needed by any caldav client): strip it out
          vObject.removeProperty("X-ENTOURAGE_UUID");

          splitExDate(vObject);

          // remove empty properties
          if ("".equals(vObject.getPropertyValue("LOCATION"))) {
            vObject.removeProperty("LOCATION");
          }
          if ("".equals(vObject.getPropertyValue("DESCRIPTION"))) {
            vObject.removeProperty("DESCRIPTION");
          }
          if ("".equals(vObject.getPropertyValue("CLASS"))) {
            vObject.removeProperty("CLASS");
          }
          // rename TZID
          if (tzid != null) {
            VProperty dtStart = vObject.getProperty("DTSTART");
            if (dtStart != null && dtStart.getParam("TZID") != null) {
              dtStart.setParam("TZID", tzid);
            }
            VProperty dtEnd = vObject.getProperty("DTEND");
            if (dtEnd != null && dtStart.getParam("TZID") != null) {
              dtEnd.setParam("TZID", tzid);
            }
            VProperty reccurrenceId = vObject.getProperty("RECURRENCE-ID");
            if (reccurrenceId != null && reccurrenceId.getParam("TZID") != null) {
              reccurrenceId.setParam("TZID", tzid);
            }
          }
          // remove unsupported attachment reference
          if (vObject.getProperty("ATTACH") != null) {
            List<String> toRemoveValues = null;
            List<String> values = vObject.getProperty("ATTACH").getValues();
            for (String value : values) {
              if (value.indexOf("CID:") >= 0) {
                if (toRemoveValues == null) {
                  toRemoveValues = new ArrayList<String>();
                }
                toRemoveValues.add(value);
              }
            }
            if (toRemoveValues != null) {
              values.removeAll(toRemoveValues);
              if (values.size() == 0) {
                vObject.removeProperty("ATTACH");
              }
            }
          }
        } else {
          // add organizer line to all events created in Exchange for active sync
          String organizer = getEmailValue(vObject.getProperty("ORGANIZER"));
          if (organizer == null) {
            vObject.setPropertyValue("ORGANIZER", "MAILTO:" + email);
          } else if (!email.equalsIgnoreCase(organizer)
              && vObject.getProperty("X-MICROSOFT-CDO-REPLYTIME") == null) {
            vObject.setPropertyValue("X-MICROSOFT-CDO-REPLYTIME", now);
          }
          // set OWA allday flag
          vObject.setPropertyValue(
              "X-MICROSOFT-CDO-ALLDAYEVENT", isAllDay(vObject) ? "TRUE" : "FALSE");
          vObject.setPropertyValue(
              "X-MICROSOFT-CDO-BUSYSTATUS",
              !"TRANSPARENT".equals(vObject.getPropertyValue("TRANSP")) ? "BUSY" : "FREE");

          if (isAllDay(vObject)) {
            // convert date values to outlook compatible values
            setServerAllday(vObject.getProperty("DTSTART"));
            setServerAllday(vObject.getProperty("DTEND"));
          } else {
            fixTzid(vObject.getProperty("DTSTART"));
            fixTzid(vObject.getProperty("DTEND"));
          }
        }

        fixAttendees(vObject, fromServer);

        fixAlarm(vObject, fromServer);
      }
    }
  }