ModularXmppClientToServerConnectionInternal.java

  1. /**
  2.  *
  3.  * Copyright 2020-2021 Florian Schmaus
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  17. package org.jivesoftware.smack.c2s.internal;

  18. import java.io.IOException;
  19. import java.nio.channels.ClosedChannelException;
  20. import java.nio.channels.SelectableChannel;
  21. import java.nio.channels.SelectionKey;
  22. import java.util.ListIterator;
  23. import java.util.Queue;

  24. import org.jivesoftware.smack.SmackException;
  25. import org.jivesoftware.smack.SmackException.NoResponseException;
  26. import org.jivesoftware.smack.SmackException.NotConnectedException;
  27. import org.jivesoftware.smack.SmackReactor;
  28. import org.jivesoftware.smack.SmackReactor.ChannelSelectedCallback;
  29. import org.jivesoftware.smack.XMPPException;
  30. import org.jivesoftware.smack.XMPPException.FailedNonzaException;
  31. import org.jivesoftware.smack.XmppInputOutputFilter;
  32. import org.jivesoftware.smack.c2s.ModularXmppClientToServerConnection;
  33. import org.jivesoftware.smack.c2s.XmppClientToServerTransport;
  34. import org.jivesoftware.smack.debugger.SmackDebugger;
  35. import org.jivesoftware.smack.fsm.ConnectionStateEvent;
  36. import org.jivesoftware.smack.internal.SmackTlsContext;
  37. import org.jivesoftware.smack.packet.Nonza;
  38. import org.jivesoftware.smack.packet.TopLevelStreamElement;
  39. import org.jivesoftware.smack.packet.XmlEnvironment;
  40. import org.jivesoftware.smack.util.Consumer;
  41. import org.jivesoftware.smack.util.PacketParserUtils;
  42. import org.jivesoftware.smack.util.Supplier;
  43. import org.jivesoftware.smack.xml.XmlPullParser;
  44. import org.jivesoftware.smack.xml.XmlPullParserException;

  45. public abstract class ModularXmppClientToServerConnectionInternal {

  46.     private final SmackReactor reactor;

  47.     public final ModularXmppClientToServerConnection connection;

  48.     public final SmackDebugger smackDebugger;

  49.     public final Queue<TopLevelStreamElement> outgoingElementsQueue;

  50.     public ModularXmppClientToServerConnectionInternal(ModularXmppClientToServerConnection connection, SmackReactor reactor,
  51.                     SmackDebugger smackDebugger, Queue<TopLevelStreamElement> outgoingElementsQueue) {
  52.         this.connection = connection;
  53.         this.reactor = reactor;
  54.         this.smackDebugger = smackDebugger;
  55.         this.outgoingElementsQueue = outgoingElementsQueue;
  56.     }

  57.     public SelectionKey registerWithSelector(SelectableChannel channel, int ops, ChannelSelectedCallback callback)
  58.                     throws ClosedChannelException {
  59.         return reactor.registerWithSelector(channel, ops, callback);
  60.     }

  61.     public void setInterestOps(SelectionKey selectionKey, int interestOps) {
  62.         reactor.setInterestOps(selectionKey, interestOps);
  63.     }

  64.     public final void withSmackDebugger(Consumer<SmackDebugger> smackDebuggerConsumer) {
  65.         if (smackDebugger == null) {
  66.             return;
  67.         }

  68.         smackDebuggerConsumer.accept(smackDebugger);
  69.     }

  70.     public abstract XmlEnvironment getOutgoingStreamXmlEnvironment();

  71.     // TODO: The incomingElement parameter was previously of type TopLevelStreamElement, but I believe it has to be
  72.     // of type string. But would this also work for BOSH or WebSocket?
  73.     public abstract void parseAndProcessElement(String wrappedCompleteIncomingElement);

  74.     public abstract void notifyConnectionError(Exception e);

  75.     public final String onStreamOpen(String streamOpen) {
  76.         XmlPullParser streamOpenParser;
  77.         try {
  78.             streamOpenParser = PacketParserUtils.getParserFor(streamOpen);
  79.         } catch (XmlPullParserException | IOException e) {
  80.             // Should never happen.
  81.             throw new AssertionError(e);
  82.         }
  83.         String streamClose = onStreamOpen(streamOpenParser);
  84.         return streamClose;
  85.     }

  86.     public abstract String onStreamOpen(XmlPullParser parser);

  87.     public abstract void onStreamClosed();

  88.     public abstract void fireFirstLevelElementSendListeners(TopLevelStreamElement element);

  89.     public abstract void invokeConnectionStateMachineListener(ConnectionStateEvent connectionStateEvent);

  90.     public abstract void addXmppInputOutputFilter(XmppInputOutputFilter xmppInputOutputFilter);

  91.     public abstract ListIterator<XmppInputOutputFilter> getXmppInputOutputFilterBeginIterator();

  92.     public abstract ListIterator<XmppInputOutputFilter> getXmppInputOutputFilterEndIterator();

  93.     public abstract void waitForFeaturesReceived(String waitFor) throws InterruptedException, SmackException, XMPPException;

  94.     public abstract void newStreamOpenWaitForFeaturesSequence(String waitFor) throws InterruptedException,
  95.                     NoResponseException, NotConnectedException, SmackException, XMPPException;

  96.     public abstract SmackTlsContext getSmackTlsContext();

  97.     public abstract <SN extends Nonza, FN extends Nonza> SN sendAndWaitForResponse(Nonza nonza,
  98.                     Class<SN> successNonzaClass, Class<FN> failedNonzaClass)
  99.                     throws NoResponseException, NotConnectedException, FailedNonzaException, InterruptedException;

  100.     public abstract void asyncGo(Runnable runnable);

  101.     public abstract void waitForConditionOrThrowConnectionException(Supplier<Boolean> condition, String waitFor) throws InterruptedException, SmackException, XMPPException;

  102.     public abstract void notifyWaitingThreads();

  103.     public abstract void setCompressionEnabled(boolean compressionEnabled);

  104.     /**
  105.      * Set the active transport (TCP, BOSH, WebSocket, …) to be used for the XMPP connection. Also marks the connection
  106.      * as connected.
  107.      *
  108.      * @param xmppTransport the active transport.
  109.      */
  110.     public abstract void setTransport(XmppClientToServerTransport xmppTransport);
  111. }