contactitemcollection.java

来自「moblie syncml mail javame」· Java 代码 · 共 779 行 · 第 1/2 页

    
    
    private void notifyListener(int eventCode) {
        // notify the listener
        if (listener != null) {
            ContactItemCollectionEvent event =
                    new ContactItemCollectionEvent();
            event.setEventCode(
                    ContactItemCollectionEvent.EVENT_CODE_SORT_CONTACTITEM_LIST);
            listener.update(event);
        }
    }
    
    
    /**
     * filter the contactitems vector with the current contactFilter
     */
    private void filter() throws NoMatchingContactsException  {
        
        Log.info("collection filter()");
        
        filteredVector = filter.filter(contactItems, getFilteredVector());
        
        // notify the listener
        if (listener != null) {
            ContactItemCollectionEvent event =
                    new ContactItemCollectionEvent();
            event.setEventCode(
                    ContactItemCollectionEvent.EVENT_CODE_FILTER_CONTACTITEM_LIST);
            listener.update(event);
        }
    }
    
    
    /**
     * update notification handler. event are received and parsed to choose
     * what to do.
     */
    public void update(ContactManagerEvent event) {
       /*
        
         Log.debug("* * * * * * * * * * * * * * * * * * * * * * Update event!\n "
                +"\t\t CODE: " + event.getEventCode();
        */
        switch (event.getEventCode()) {
            
            case ContactManagerEvent.EVENT_CODE_ADD_CONTACT:
                insert(new ContactItem(event.getContact()));
                //append(new ContactItem(event.getContact()));
                break;
            case ContactManagerEvent.EVENT_CODE_DELETE_CONTACT:
                deleteFromContact(event.getContact());
                break;
            case ContactManagerEvent.EVENT_CODE_UPDATE_CONTACT:
                updateFromContact(event.getContact());
                break;
            case ContactManagerEvent.EVENT_CODE_RESET_CONTACT_LIST:
                initCollection();
                break;
            default: //and EVENT_CODE_NONE
                break;
        }
        
    }
    
    /**
     * update the contactItem with the given contact
     */
    private boolean updateFromContact(Contact contact) {
        boolean found = false;
        Enumeration e = contactItems.elements();
        while (e.hasMoreElements()) {
            ContactItem item = (ContactItem)e.nextElement();
            if (item.getContact().getContactId() == contact.getContactId()) {
                item.setContact(contact);
                found = true;
                toBeFiltered = true;
                // notify the listener
                if (listener != null) {
                    ContactItemCollectionEvent event =
                            new ContactItemCollectionEvent();
                    event.setEventCode(
                            ContactItemCollectionEvent.EVENT_CODE_UPDATE_CONTACTITEM);
                    event.setContactItem(item);
                    listener.update(event);
                }
                break;
            }
        }
        return found;
    }
    
    
    /**
     * add the given contact to the contactItemList. If the address refers to an
     * existent contactitem, the contactitem is updated with the state given by
     * the address, otherwise the contactItem is created and added to the list
     *
     * @param address the address from wich we create the contactItem
     * @return true if the contactItem has been found, false if not
     */
    
    public boolean addAddress(Address address) {
        Log.info("adding address " + address.getVisibleName() + " to message list");
        Enumeration e = contactItems.elements();
        String email = address.getEmail();
        boolean found=false;
        ContactItem item=null;
        // starting from bottom because this is often called with the needed
        // at the end of the list!
        for (int i = contactItems.size()-1; i>=0; i--){
            item = (ContactItem)contactItems.elementAt(i);
            Contact c = item.getContact();
            
            if (email.equals(c.getDefaultEmail())) {
                item.setSelectedEmailIndex(Contact.DEFAULT_EMAIL);
                found = true;
                break;
                
            } else if (email.equals(c.getEmail_2())) {
                item.setSelectedEmailIndex(Contact.SECONDARY_EMAIL);
                found = true;
                break;
                
            } else if (email.equals(c.getEmail_3())) {
                item.setSelectedEmailIndex(Contact.TERTIARY_EMAIL);
                found = true;
                break;
            }
        }
        if (found) {
            Log.info("address found at item " + item.getContact().getVisibleName());
            item.setState(address.getType());
            if (listener != null) {
                ContactItemCollectionEvent event =
                        new ContactItemCollectionEvent();
                event.setEventCode(
                        ContactItemCollectionEvent.EVENT_CODE_UPDATE_CONTACTITEM);
                event.setContactItem(item);
                listener.update(event);
            }
        } else {
            // contact not found
            Log.info("address not found, creating it");
            
            ContactItem ci;
            
            try {
                ci = new ContactItem(new Contact(address));
                ci.setState(Address.TO);
                insert(ci);
                if (listener != null) {
                    ContactItemCollectionEvent event =
                            new ContactItemCollectionEvent();
                    event.setEventCode(
                            ContactItemCollectionEvent.EVENT_CODE_ADD_CONTACTITEM);
                    event.setContactItem(item);
                    listener.update(event);
                }
            } catch (ContactManagerException ex) {
                ex.printStackTrace();
            }
        }
        
        
        return found;
    }
    
    /**
     * delete the contactitem containing the given contact
     *
     * @return true if contact has been found and deleted, false otherwise
     */
    private boolean deleteFromContact(Contact contact) {
        boolean found = false;
        for (int i = 0; i< contactItems.size(); i++) {
            ContactItem item = (ContactItem)contactItems.elementAt(i);
            if (item.getContact().getContactId() == contact.getContactId()) {
                found =true;
                contactItems.removeElementAt(i);
                getFilteredVector().removeElement(item);
                // notify the listener
                if (listener != null) {
                    ContactItemCollectionEvent event =
                            new ContactItemCollectionEvent();
                    event.setEventCode(
                            ContactItemCollectionEvent.EVENT_CODE_DELETE_CONTACTITEM);
                    event.setContactItem(item);
                    listener.update(event);
                }
                break;
            }
        }
        
        return found;
    }
    
    
    /**
     * return the current filteredvector, or create it if needed (it is created
     * as a reference to contactitems vector)
     * used to have a single filteredvector and to avoid null pointers
     */
    private Vector getFilteredVector() {
        
        if (filteredVector == null) {
            filteredVector = contactItems;
        }
        return filteredVector;
    }
    
    
    
    /**
     * set the toBeFiltered property.
     * @param toBeFiltered if true set the property to true,  if false set the
     * property to false.
     */
    public void setToBeFiltered(boolean toBeFiltered) {
        this.toBeFiltered = toBeFiltered;
    }
    
    
    
    
    /**
     * @return the current comparator
     */
    public ContactItemComparator getComparator() {
//        return comparator;
        return null;
    }
    
    
    
    /**
     * insert the contactItem to the right position in the contactItem list
     * if a sort is necessary, it's performed before adding the contactItem
     */
    
    
    private void insert(ContactItem contactItem) {
        
        
        int position = getPosition(contactItem, contactItems);
        contactItems.insertElementAt(contactItem, position);
        Log.info("inserting contact item " + contactItem.getContact().getVisibleName() + " at position " + position);
        
        setToBeFiltered(true);
        if (listener != null) {
            ContactItemCollectionEvent event =
                    new ContactItemCollectionEvent();
            event.setEventCode(
                    ContactItemCollectionEvent.EVENT_CODE_ADD_CONTACTITEM);
            event.setContactItem(contactItem);
            listener.update(event);
        }
    }
    
    /**
     * @return the right position where to insert the contactitem
     */
    
    private int getPosition(ContactItem c, Vector vector) {
        
        int start = 0;
        int end =  vector.size();
        //  if (end < 0) end = 0;
        ContactItem middle;
        
        while (start!=end) {
            middle = (ContactItem) vector.elementAt( (start  + end)/2 );
            if (alphabeticalComparator.compare(c,middle) <= 0) {
                end = (start + end) /2;
            } else {
                if (start == ( (start + end) / 2)) {
                    start ++;
                } else {
                    start = (start + end) /2;
                }
            }
        }
        return start;
    }
    
    
    /**
     * set the ContactItemCollectionListener that needs to be notified when
     * a contactitem is added / removed or edited
     * @param listener the listener or null to remove it
     */
    public void setListener(ContactItemCollectionListener listener) {
        this.listener = listener;
    }
    
    /**
     * @return the current ContactItemCollectionListener or null if no listener
     * has been set
     */
    public ContactItemCollectionListener getListener() {
        return listener;
    }
    
    
    public ContactItemFilter getFilter() {
        return filter;
    }
    
    /**
     * @return true if collection is to be filtered
     */
    public boolean isToBeFiltered() {
        return toBeFiltered;
    }
    
    /**
     * insert a given ContactItem into the collection
     */
    private void insertItem(ContactItem contactItem, ContactItemComparator comparator) {
        
        
        int start = 0;
        int end =  contactItems.size();
        //  if (end < 0) end = 0;
        ContactItem middle;
        
        while (start!=end) {
            middle = (ContactItem) contactItems.elementAt( (start  + end)/2 );
            if (comparator.compare(contactItem,middle) <= 0) {
                end = (start + end) /2;
            } else {
                if (start == ( (start + end) / 2)) {
                    start ++;
                } else {
                    start = (start + end) /2;
                }
            }
        }
        Log.info("inserting " + contactItem.getContact().getVisibleName() + " at position " + start);
        contactItems.insertElementAt(contactItem, start);
    }
    
    void partialSort(int start, int end, int mode) {
        Log.info("partial sorting from " + start + " to " + end);
        Vector v = new Vector(end-start);
        
        ContactItemComparator comp = alphabeticalComparator;
        
        if (mode == BY_STATE) {
            comp = stateComparator;
        }
        
        for (int i = start; i < end; i++) {
            
            v.addElement(contactItems.elementAt(start));
            contactItems.removeElementAt(start);
        }
        Enumeration e = v.elements();
        while (e.hasMoreElements()) {
            ContactItem ci = (ContactItem) e.nextElement();
            
            int pos = getPosition(ci, contactItems);
            
            Log.info("repositioning element " + ci.getContact().getVisibleName()
            + " at position " + pos);
            
            contactItems.insertElementAt(ci, pos);
        }
    }
    
    /**
     * return a vector containing all contactitems in state Address.TO,
     * Address.CC  or Address.BCC without applying the current filter.
     */
    Vector getSelectedItems() {
        //5 is a reasonable number of recipients
        Vector selected = new Vector(5);
        Enumeration e = contactItems.elements();
        while (e.hasMoreElements()) {
            ContactItem c = (ContactItem)e.nextElement();
            if (c.getState() != ContactItem.ADDRESS_STATE_NONE) {
                selected.addElement(c);
            }
        }
        return selected;
        
    }
}