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"),