diff --git a/src/org/ice4j/StackProperties.java b/src/org/ice4j/StackProperties.java index 0e88692..14060ef 100644 --- a/src/org/ice4j/StackProperties.java +++ b/src/org/ice4j/StackProperties.java @@ -114,6 +114,8 @@ public class StackProperties = "org.ice4j.TERMINATION_DELAY"; /** + * THIS PROPERTY IS CURRENTLY UNUSED. IF YOU WANT TO SPEED UP NOMINATIONS + * THEN CONSIDER SPEEDING UP TRANSACTION FAILURE FOR THE TIME BEING. * The maximum number of milliseconds that we should wait for a check list * to complete before nominating one of its valid pairs (unless there are * none in which case we may have to wait until one appears or the whole diff --git a/src/org/ice4j/ice/CandidatePair.java b/src/org/ice4j/ice/CandidatePair.java index 855c8e4..fd3d77a 100644 --- a/src/org/ice4j/ice/CandidatePair.java +++ b/src/org/ice4j/ice/CandidatePair.java @@ -235,7 +235,7 @@ public class CandidatePair * {@link CandidatePairState#IN_PROGRESS} or a non-null for any * other state would cause an {@link IllegalArgumentException} to be thrown. * - * @param state the state that this candidate pair is to enter. + * @param newState the state that this candidate pair is to enter. * @param tranID the {@link TransactionID} that we are using for the * connectivity check in case we are entering the In-Progress * state and null otherwise. @@ -243,13 +243,14 @@ public class CandidatePair * @throws IllegalArgumentException if state is {@link CandidatePairState * #IN_PROGRESS} and tranID is null. */ - private synchronized void setState(CandidatePairState state, + private synchronized void setState(CandidatePairState newState, TransactionID tranID) throws IllegalArgumentException { - this.state = state; + CandidatePairState oldState = this.state; + this.state = newState; - if(state != CandidatePairState.IN_PROGRESS) + if(newState != CandidatePairState.IN_PROGRESS) { if (tranID != null) throw new IllegalArgumentException( @@ -266,6 +267,9 @@ public class CandidatePair this.connCheckTranID = tranID; + getParentComponent().getParentStream().firePairPropertyChange( + this, IceMediaStream.PROPERTY_PAIR_STATE_CHANGED, + oldState, newState); } /** @@ -523,6 +527,8 @@ public class CandidatePair public void nominate() { this.isNominated = true; + getParentComponent().getParentStream().firePairPropertyChange(this, + IceMediaStream.PROPERTY_PAIR_NOMINATED, false, true); } /** @@ -556,5 +562,7 @@ public class CandidatePair protected void validate() { this.isValid = true; + getParentComponent().getParentStream().firePairPropertyChange(this, + IceMediaStream.PROPERTY_PAIR_VALIDATED, false, true); } } diff --git a/src/org/ice4j/ice/CheckList.java b/src/org/ice4j/ice/CheckList.java index ff619cb..e899d84 100644 --- a/src/org/ice4j/ice/CheckList.java +++ b/src/org/ice4j/ice/CheckList.java @@ -186,7 +186,7 @@ public class CheckList * @return true if this list is active and false * otherwise. */ - protected synchronized boolean isActive() + public synchronized boolean isActive() { for (CandidatePair pair : this) { @@ -196,6 +196,25 @@ public class CheckList return false; } + /** + * Determines whether all checks in this CheckList have ended one + * way or another. + * + * @return true if all checks for pairs in this list have either + * succeeded or failed (but non are are currently waiting or in progress) + * or false otherwise.. + */ + public synchronized boolean allChecksCompleted() + { + for (CandidatePair pair : this) + { + if (pair.getState() != CandidatePairState.SUCCEEDED + && pair.getState() != CandidatePairState.FAILED) + return false; + } + return true; + } + /** * Determines whether this CheckList can be considered frozen. * RFC 5245 says: a check list with all pairs Frozen is called a frozen @@ -204,7 +223,7 @@ public class CheckList * @return true if all pairs in this list are frozen and * false otherwise. */ - protected synchronized boolean isFrozen() + public synchronized boolean isFrozen() { for (CandidatePair pair : this) { @@ -462,4 +481,16 @@ public class CheckList l.propertyChange(evt); } } + + /** + * Returns a reference to the {@link IceMediaStream} that created and that + * maintains this check list. + * + * @return a reference to the {@link IceMediaStream} that this list belongs + * to. + */ + public IceMediaStream getParentStream() + { + return parentStream; + } } diff --git a/src/org/ice4j/ice/ConnectivityCheckClient.java b/src/org/ice4j/ice/ConnectivityCheckClient.java index bedc305..2ed9fb4 100644 --- a/src/org/ice4j/ice/ConnectivityCheckClient.java +++ b/src/org/ice4j/ice/ConnectivityCheckClient.java @@ -372,14 +372,14 @@ class ConnectivityCheckClient validRemoteCandidate); } - if(! validPair.isValid()) - parentAgent.validatePair(validPair); - //The agent sets the state of the pair that *generated* the check to //Succeeded. Note that, the pair which *generated* the check may be //different than the valid pair constructed above checkedPair.setStateSucceeded(); + if(! validPair.isValid()) + parentAgent.validatePair(validPair); + //The agent changes the states for all other Frozen pairs for the //same media stream and same foundation to Waiting. IceMediaStream parentStream = checkedPair.getParentComponent() @@ -406,7 +406,8 @@ class ConnectivityCheckClient { for(CandidatePair pair : checkList) { - if (parentStream.validListContainsFoundation(pair.getFoundation()) + if (parentStream.validListContainsFoundation( + pair.getFoundation()) && pair.getState() == CandidatePairState.FROZEN) { pair.setStateWaiting(); diff --git a/src/org/ice4j/ice/DefaultNominator.java b/src/org/ice4j/ice/DefaultNominator.java index 466ad5c..16f374a 100644 --- a/src/org/ice4j/ice/DefaultNominator.java +++ b/src/org/ice4j/ice/DefaultNominator.java @@ -61,24 +61,74 @@ public class DefaultNominator for(IceMediaStream stream : streams) { - stream.addStreamChangeListener(this); + stream.addPairChangeListener(this); stream.getCheckList().addStateChangeListener(this); } } - if (!parentAgent.isControlling()) + if (!parentAgent.isControlling() //CONTROLLED agents cannot nominate + || strategy == NominationStrategy.NONE) { - //CONTROLLED agents cannot nominate pairs return; } + if(strategy == NominationStrategy.NOMINATE_FIRST_VALID) + strategyNominateFirstValid(evt); + else if (strategy == NominationStrategy.NOMINATE_HIGHEST_PRIO) + strategyNominateHighestPrio(evt); + + } + + /** + * Implements a basic nomination strategy that consists in nominating the + * first pair that has become valid for a check list. + * + * @param evt the {@link PropertyChangeEvent} containing the pair which + * has been validated. + */ + private void strategyNominateFirstValid(PropertyChangeEvent evt) + { if(IceMediaStream.PROPERTY_PAIR_VALIDATED.equals(evt.getPropertyName())) { - CandidatePair validPair = (CandidatePair)evt.getNewValue(); + CandidatePair validPair = (CandidatePair)evt.getSource(); parentAgent.nominate(validPair); } } + /** + * Implements a nomination strategy that allows checks for several (or all) + * pairs in a check list to conclude before nominating the one with the + * highest priority. + * + * @param evt the {@link PropertyChangeEvent} containing the new state and + * the source {@link CheckList}. + */ + private void strategyNominateHighestPrio(PropertyChangeEvent evt) + { + String propName = evt.getPropertyName(); + if(IceMediaStream.PROPERTY_PAIR_VALIDATED.equals(propName) + || (IceMediaStream.PROPERTY_PAIR_STATE_CHANGED.equals(propName) + && ((CandidatePairState)evt.getNewValue()) + == CandidatePairState.FAILED)) + { + CandidatePair validPair = (CandidatePair)evt.getSource(); + Component parentComponent = validPair.getParentComponent(); + IceMediaStream parentStream = parentComponent.getParentStream(); + CheckList parentCheckList = parentStream.getCheckList(); + + if(!parentCheckList.allChecksCompleted()) + return; + + List components = parentStream.getComponents(); + + for(Component component : components) + { + CandidatePair pair = parentStream.getValidPair(component); + if(pair != null) + parentAgent.nominate(pair); + } + } + } /** * The {@link NominationStrategy} that this nominator should use when diff --git a/src/org/ice4j/ice/IceMediaStream.java b/src/org/ice4j/ice/IceMediaStream.java index 851b890..d88849a 100644 --- a/src/org/ice4j/ice/IceMediaStream.java +++ b/src/org/ice4j/ice/IceMediaStream.java @@ -76,6 +76,18 @@ public class IceMediaStream */ public static final String PROPERTY_PAIR_VALIDATED = "PairValidated"; + /** + * The property name that we use when delivering events notifying listeners + * that a pair has changed states.. + */ + public static final String PROPERTY_PAIR_STATE_CHANGED = "PairStateChanged"; + + /** + * The property name that we use when delivering events notifying listeners + * of newly nominated pairs. + */ + public static final String PROPERTY_PAIR_NOMINATED = "PairNominated"; + /** * Contains {@link PropertyChangeListener}s registered with this {@link * Agent} and following the various events it may be generating. @@ -173,7 +185,7 @@ public class IceMediaStream * @return the Component with the specified id or * null if no such component exists in this stream. */ - public Component getComponnet(int id) + public Component getComponent(int id) { synchronized(components) { @@ -570,12 +582,11 @@ public class IceMediaStream { synchronized (validList) { - pair.validate(); if(!validList.contains(pair)) validList.add(pair); } - fireStateChange(PROPERTY_PAIR_VALIDATED, pair, pair); + pair.validate(); } /** @@ -671,11 +682,14 @@ public class IceMediaStream } /** - * Adds l to the list of listeners registered for property changes. + * Adds l to the list of listeners registered for property changes + * if {@link CandidatePair}s. We add such listeners in the stream, rather + * than having them in the candidate pair itself, because we don't want all + * pairs to keep lists of references to the same listeners. * * @param l the listener to register. */ - public void addStreamChangeListener(PropertyChangeListener l) + public void addPairChangeListener(PropertyChangeListener l) { synchronized(streamListeners) { @@ -690,7 +704,7 @@ public class IceMediaStream * * @param l the listener to remove. */ - public void removeStateChangeListener(PropertyChangeListener l) + public void removePairStateChangeListener(PropertyChangeListener l) { synchronized(streamListeners) { @@ -702,13 +716,15 @@ public class IceMediaStream * Creates a new {@link PropertyChangeEvent} and delivers it to all * currently registered state listeners. * - * @param propertyName the name of the event we'd like to fire. + * @param source the {@link CandidatePair} whose property has just changed. + * @param propertyName the name of the property that changed. * @param oldValue the old value of the property that changed. * @param newValue the new value of the property that changed. */ - private void fireStateChange(String propertyName, - Object oldValue, - Object newValue) + protected void firePairPropertyChange(CandidatePair source, + String propertyName, + Object oldValue, + Object newValue) { List listenersCopy; @@ -719,7 +735,7 @@ public class IceMediaStream } PropertyChangeEvent evt = new PropertyChangeEvent( - this, PROPERTY_PAIR_VALIDATED, oldValue, newValue); + source, PROPERTY_PAIR_VALIDATED, oldValue, newValue); for(PropertyChangeListener l : listenersCopy) { diff --git a/src/org/ice4j/ice/NominationStrategy.java b/src/org/ice4j/ice/NominationStrategy.java index 0672caf..61fd43e 100644 --- a/src/org/ice4j/ice/NominationStrategy.java +++ b/src/org/ice4j/ice/NominationStrategy.java @@ -6,7 +6,6 @@ */ package org.ice4j.ice; -import org.ice4j.*; /** * Contains the nomination strategies currently supported by this @@ -35,10 +34,7 @@ public enum NominationStrategy /** * The strategy consists in nominating the highest priority valid pair once - * all checks in a list have completed, or after the nomination timer has - * fired for that check list, whichever happens first. The value of the - * nomination timer (in ms) is defined by the {@link StackProperties# - * NOMINATION_TIMER} property. + * all checks in a list have completed. */ NOMINATE_HIGHEST_PRIO("NominateHighestPriority"),