ProcessorUtility.java

/*
 * SIP Communicator, the OpenSource Java VoIP and Instant Messaging client.
 *
 * Distributable under LGPL license.
 * See terms of license at gnu.org.
 */



package net.java.sip.communicator.impl.media;

//~--- non-JDK imports --------------------------------------------------------

import net.java.sip.communicator.util.*;

//~--- JDK imports ------------------------------------------------------------

import javax.media.*;

/**
 * A utility class that provides utility functions when working with processors.
 *
 * @author Emil Ivov
 * @author Ken Larson
 */
public class ProcessorUtility implements ControllerListener {
    private Logger logger = Logger.getLogger(ProcessorUtility.class);

    /**
     * The object that we use for syncing when waiting for a processor
     * to enter a specific state.
     */
    private Object  stateLock = new Object();
    private boolean failed    = false;

    /**
     * Default constructor, creates an instance of the of the Processor utility.
     */
    public ProcessorUtility() {}

    /**
     * Returns the object that we use for syncing when waiting for a processor
     * to enter a specific state.
     * @return Integer
     */
    private Object getStateLock() {
        return stateLock;
    }

    /**
     * Specifies whether the wait operation has failed or completed with
     * success.
     *
     * @param failed true if waiting has failed and false otherwise.
     */
    private void setFailed(boolean failed) {
        this.failed = failed;
    }

    /**
     * This method is called when an event is generated by a
     * <code>Controller</code> that this listener is registered with. We use
     * the event to notify all waiting on our lock and record success or
     * failure.
     *
     * @param ce The event generated.
     */
    public void controllerUpdate(ControllerEvent ce) {

        // If there was an error during configure or
        // realize, the processor will be closed
        if (ce instanceof ControllerClosedEvent) {
            if (ce instanceof ControllerErrorEvent) {
                logger.warn("ControllerErrorEvent: " + ce);
            } else {
                logger.debug("ControllerClosedEvent: " + ce);
            }

            setFailed(true);

            // All controller events, send a notification
            // to the waiting thread in waitForState method.
        }

        if (ce instanceof ControllerEvent) {
            synchronized (getStateLock()) {
                getStateLock().notifyAll();
            }
        }
    }

    /**
     * Waits until <tt>processor</tt> enters state and returns a boolean
     * indicating success or failure of the operation.
     *
     * @param processor Processor
     * @param state one of the Processor.XXXed sate vars
     * @return boolean true if the state has been reached and false otherwise
     */
    public synchronized boolean waitForState(Processor processor, int state)
    {
        processor.addControllerListener(this);
        setFailed(false);

        // Call the required method on the processor
        if (state == Processor.Configured) {
            processor.configure();
        } else if (state == Processor.Realized) {
            processor.realize();
        }

        // Wait until we get an event that confirms the
        // success of the method, or a failure event.
        // See StateListener inner class
        while ((processor.getState() < state) &&!failed) {
            synchronized (getStateLock()) {
                try {
                    getStateLock().wait();
                } catch (InterruptedException ie) {
                    return false;
                }
            }
        }

        return !failed;
    }
}


//~ Formatted by Jindent --- http://www.jindent.com