コード例 #1
0
  /**
   * Implements {@link PacketListener}. Notifies this instance that a specific {@link Packet} (which
   * this instance has already expressed interest into by returning <tt>true</tt> from {@link
   * #accept(Packet)}) has been received.
   *
   * @param packet the <tt>Packet</tt> which has been received and which this instance is given a
   *     chance to process
   */
  public void processPacket(Packet packet) {
    /*
     * As we do elsewhere, acknowledge the receipt of the Packet first and
     * then go about our business with it.
     */
    IQ iq = (IQ) packet;

    if (iq.getType() == IQ.Type.SET)
      protocolProvider.getConnection().sendPacket(IQ.createResultIQ(iq));

    /*
     * Now that the acknowledging is out of the way, do go about our
     * business with the Packet.
     */
    ColibriConferenceIQ conferenceIQ = (ColibriConferenceIQ) iq;
    boolean interrupted = false;

    try {
      processColibriConferenceIQ(conferenceIQ);
    } catch (Throwable t) {
      logger.error(
          "An error occurred during the processing of a " + packet.getClass().getName() + " packet",
          t);

      if (t instanceof InterruptedException) {
        /*
         * We cleared the interrupted state of the current Thread by
         * catching the InterruptedException. However, we do not really
         * care whether the current Thread has been interrupted - we
         * caught the InterruptedException because we want to swallow
         * any Throwable. Consequently, we should better restore the
         * interrupted state.
         */
        interrupted = true;
      } else if (t instanceof ThreadDeath) throw (ThreadDeath) t;
    }
    if (interrupted) Thread.currentThread().interrupt();
  }
コード例 #2
0
/**
 * Implements <tt>OperationSetVideoBridge</tt> for Jabber.
 *
 * @author Yana Stamcheva
 * @author Lyubomir Marinov
 */
public class OperationSetVideoBridgeImpl
    implements OperationSetVideoBridge,
        PacketFilter,
        PacketListener,
        RegistrationStateChangeListener {
  /**
   * The <tt>Logger</tt> used by the <tt>OperationSetVideoBridgeImpl</tt> class and its instances
   * for logging output.
   */
  private static final Logger logger = Logger.getLogger(OperationSetVideoBridgeImpl.class);

  /**
   * The <tt>ProtocolProviderService</tt> implementation which initialized this instance, owns it
   * and is often referred to as its parent.
   */
  private final ProtocolProviderServiceJabberImpl protocolProvider;

  /**
   * Creates an instance of <tt>OperationSetVideoBridgeImpl</tt> by specifying the parent
   * <tt>ProtocolProviderService</tt> announcing this operation set.
   *
   * @param protocolProvider the parent Jabber protocol provider
   */
  public OperationSetVideoBridgeImpl(ProtocolProviderServiceJabberImpl protocolProvider) {
    this.protocolProvider = protocolProvider;
    this.protocolProvider.addRegistrationStateChangeListener(this);
  }

  /**
   * Implements {@link PacketFilter}. Determines whether this instance is interested in a specific
   * {@link Packet}. <tt>OperationSetVideoBridgeImpl</tt> returns <tt>true</tt> if the specified
   * <tt>packet</tt> is a {@link ColibriConferenceIQ}; otherwise, <tt>false</tt>.
   *
   * @param packet the <tt>Packet</tt> to be determined whether this instance is interested in it
   * @return <tt>true</tt> if the specified <tt>packet</tt> is a <tt>ColibriConferenceIQ</tt>;
   *     otherwise, <tt>false</tt>
   */
  public boolean accept(Packet packet) {
    return (packet instanceof ColibriConferenceIQ);
  }

  /**
   * Creates a conference call with the specified callees as call peers via a video bridge provided
   * by the parent Jabber provider.
   *
   * @param callees the list of addresses that we should call
   * @return the newly created conference call containing all CallPeers
   * @throws OperationFailedException if establishing the conference call fails
   * @throws OperationNotSupportedException if the provider does not have any conferencing features.
   */
  public Call createConfCall(String[] callees)
      throws OperationFailedException, OperationNotSupportedException {
    return protocolProvider
        .getOperationSet(OperationSetTelephonyConferencing.class)
        .createConfCall(callees, new MediaAwareCallConference(true));
  }

  /**
   * Invites the callee represented by the specified uri to an already existing call using a video
   * bridge provided by the parent Jabber provider. The difference between this method and
   * createConfCall is that inviteCalleeToCall allows a user to add new peers to an already
   * established conference.
   *
   * @param uri the callee to invite to an existing conf call.
   * @param call the call that we should invite the callee to.
   * @return the CallPeer object corresponding to the callee represented by the specified uri.
   * @throws OperationFailedException if inviting the specified callee to the specified call fails
   * @throws OperationNotSupportedException if allowing additional callees to a pre-established call
   *     is not supported.
   */
  public CallPeer inviteCalleeToCall(String uri, Call call)
      throws OperationFailedException, OperationNotSupportedException {
    return protocolProvider
        .getOperationSet(OperationSetTelephonyConferencing.class)
        .inviteCalleeToCall(uri, call);
  }

  /**
   * Indicates if there's an active video bridge available at this moment. The Jabber provider may
   * announce support for video bridge, but it should not be used for calling until it becomes
   * actually active.
   *
   * @return <tt>true</tt> to indicate that there's currently an active available video bridge,
   *     <tt>false</tt> - otherwise
   */
  public boolean isActive() {
    String jitsiVideobridge = protocolProvider.getJitsiVideobridge();

    return ((jitsiVideobridge != null) && (jitsiVideobridge.length() > 0));
  }

  /**
   * Notifies this instance that a specific <tt>ColibriConferenceIQ</tt> has been received.
   *
   * @param conferenceIQ the <tt>ColibriConferenceIQ</tt> which has been received
   */
  private void processColibriConferenceIQ(ColibriConferenceIQ conferenceIQ) {
    /*
     * The application is not a Jitsi Videobridge server, it is a client.
     * Consequently, the specified ColibriConferenceIQ is sent to it in
     * relation to the part of the application's functionality which makes
     * requests to a Jitsi Videobridge server i.e. CallJabberImpl.
     *
     * Additionally, the method processColibriConferenceIQ is presently tasked
     * with processing ColibriConferenceIQ requests only. They are SET IQs
     * sent by the Jitsi Videobridge server to notify the application about
     * updates in the states of (colibri) conferences organized by the
     * application.
     */
    if (IQ.Type.SET.equals(conferenceIQ.getType()) && conferenceIQ.getID() != null) {
      OperationSetBasicTelephony<?> basicTelephony =
          protocolProvider.getOperationSet(OperationSetBasicTelephony.class);

      if (basicTelephony != null) {
        Iterator<? extends Call> i = basicTelephony.getActiveCalls();

        while (i.hasNext()) {
          Call call = i.next();

          if (call instanceof CallJabberImpl) {
            CallJabberImpl callJabberImpl = (CallJabberImpl) call;
            MediaAwareCallConference conference = callJabberImpl.getConference();

            if ((conference != null) && conference.isJitsiVideobridge()) {
              /*
               * TODO We may want to disallow rogue CallJabberImpl
               * instances which may throw an exception to prevent
               * the conferenceIQ from reaching the CallJabberImpl
               * instance which it was meant for.
               */
              if (callJabberImpl.processColibriConferenceIQ(conferenceIQ)) break;
            }
          }
        }
      }
    }
  }

  /**
   * Implements {@link PacketListener}. Notifies this instance that a specific {@link Packet} (which
   * this instance has already expressed interest into by returning <tt>true</tt> from {@link
   * #accept(Packet)}) has been received.
   *
   * @param packet the <tt>Packet</tt> which has been received and which this instance is given a
   *     chance to process
   */
  public void processPacket(Packet packet) {
    /*
     * As we do elsewhere, acknowledge the receipt of the Packet first and
     * then go about our business with it.
     */
    IQ iq = (IQ) packet;

    if (iq.getType() == IQ.Type.SET)
      protocolProvider.getConnection().sendPacket(IQ.createResultIQ(iq));

    /*
     * Now that the acknowledging is out of the way, do go about our
     * business with the Packet.
     */
    ColibriConferenceIQ conferenceIQ = (ColibriConferenceIQ) iq;
    boolean interrupted = false;

    try {
      processColibriConferenceIQ(conferenceIQ);
    } catch (Throwable t) {
      logger.error(
          "An error occurred during the processing of a " + packet.getClass().getName() + " packet",
          t);

      if (t instanceof InterruptedException) {
        /*
         * We cleared the interrupted state of the current Thread by
         * catching the InterruptedException. However, we do not really
         * care whether the current Thread has been interrupted - we
         * caught the InterruptedException because we want to swallow
         * any Throwable. Consequently, we should better restore the
         * interrupted state.
         */
        interrupted = true;
      } else if (t instanceof ThreadDeath) throw (ThreadDeath) t;
    }
    if (interrupted) Thread.currentThread().interrupt();
  }

  /**
   * {@inheritDoc}
   *
   * <p>Implements {@link RegistrationStateChangeListener}. Notifies this instance that there has
   * been a change in the <tt>RegistrationState</tt> of {@link #protocolProvider}. Subscribes this
   * instance to {@link ColibriConferenceIQ}s as soon as <tt>protocolProvider</tt> is registered and
   * unsubscribes it as soon as <tt>protocolProvider</tt> is unregistered.
   */
  public void registrationStateChanged(RegistrationStateChangeEvent ev) {
    RegistrationState registrationState = ev.getNewState();

    if (RegistrationState.REGISTERED.equals(registrationState)) {
      protocolProvider.getConnection().addPacketListener(this, this);
    } else if (RegistrationState.UNREGISTERED.equals(registrationState)) {
      XMPPConnection connection = protocolProvider.getConnection();

      if (connection != null) connection.removePacketListener(this);
    }
  }
}