<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>Connection (Qpid ProtonJ2 Parent 1.0.0-M19 API)</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta name="description" content="declaration: package: org.apache.qpid.protonj2.engine, interface: Connection">
<meta name="generator" content="javadoc/ClassWriterImpl">
<link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
<script type="text/javascript" src="../../../../../script.js"></script>
</head>
<body class="class-declaration-page">
<script type="text/javascript">var evenRowColor = "even-row-color";
var oddRowColor = "odd-row-color";
var tableTab = "table-tab";
var activeTableTab = "active-table-tab";
</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<div class="flex-box">
<header role="banner" class="flex-header">
<nav role="navigation">
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="top-nav" id="navbar-top">
<div class="skip-nav"><a href="#skip-navbar-top" title="Skip navigation links">Skip navigation links</a></div>
<ul id="navbar-top-firstrow" class="nav-list" title="Navigation">
<li><a href="../../../../../index.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="nav-bar-cell1-rev">Class</li>
<li><a href="class-use/Connection.html">Use</a></li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../../help-doc.html#class">Help</a></li>
</ul>
</div>
<div class="sub-nav">
<div>
<ul class="sub-nav-list">
<li>Summary:&nbsp;</li>
<li>Nested&nbsp;|&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method-summary">Method</a></li>
</ul>
<ul class="sub-nav-list">
<li>Detail:&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method-detail">Method</a></li>
</ul>
</div>
</div>
<!-- ========= END OF TOP NAVBAR ========= -->
<span class="skip-nav" id="skip-navbar-top"></span></nav>
</header>
<div class="flex-content">
<main role="main">
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="sub-title"><span class="package-label-in-type">Package</span>&nbsp;<a href="package-summary.html">org.apache.qpid.protonj2.engine</a></div>
<h1 title="Interface Connection" class="title">Interface Connection</h1>
</div>
<section class="class-description" id="class-description">
<dl class="notes">
<dt>All Superinterfaces:</dt>
<dd><code><a href="Endpoint.html" title="interface in org.apache.qpid.protonj2.engine">Endpoint</a>&lt;<a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a>&gt;</code></dd>
</dl>
<dl class="notes">
<dt>All Known Implementing Classes:</dt>
<dd><code><a href="impl/ProtonConnection.html" title="class in org.apache.qpid.protonj2.engine.impl">ProtonConnection</a></code></dd>
</dl>
<hr>
<div class="type-signature"><span class="modifiers">public interface </span><span class="element-name type-name-label">Connection</span><span class="extends-implements">
extends <a href="Endpoint.html" title="interface in org.apache.qpid.protonj2.engine">Endpoint</a>&lt;<a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a>&gt;</span></div>
<div class="block">AMQP Connection state container</div>
</section>
<section class="summary">
<ul class="summary-list">
<!-- ========== METHOD SUMMARY =========== -->
<li>
<section class="method-summary" id="method-summary">
<h2>Method Summary</h2>
<div id="method-summary-table">
<div class="table-tabs" role="tablist" aria-orientation="horizontal"><button id="method-summary-table-tab0" role="tab" aria-selected="true" aria-controls="method-summary-table.tabpanel" tabindex="0" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table', 3)" class="active-table-tab">All Methods</button><button id="method-summary-table-tab2" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab2', 3)" class="table-tab">Instance Methods</button><button id="method-summary-table-tab3" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab3', 3)" class="table-tab">Abstract Methods</button></div>
<div id="method-summary-table.tabpanel" role="tabpanel">
<div class="summary-table three-column-summary" aria-labelledby="method-summary-table-tab0">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Method</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#getChannelMax()" class="member-name-link">getChannelMax</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#getContainerId()" class="member-name-link">getContainerId</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#getHostname()" class="member-name-link">getHostname</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#getIdleTimeout()" class="member-name-link">getIdleTimeout</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#getMaxFrameSize()" class="member-name-link">getMaxFrameSize</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#getParent()" class="member-name-link">getParent</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Gets the parent of this <a href="Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> which can be itself for <a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine"><code>Connection</code></a> instance.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#getRemoteContainerId()" class="member-name-link">getRemoteContainerId</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#getRemoteHostname()" class="member-name-link">getRemoteHostname</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#getRemoteIdleTimeout()" class="member-name-link">getRemoteIdleTimeout</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#getRemoteMaxFrameSize()" class="member-name-link">getRemoteMaxFrameSize</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="ConnectionState.html" title="enum in org.apache.qpid.protonj2.engine">ConnectionState</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#getRemoteState()" class="member-name-link">getRemoteState</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="ConnectionState.html" title="enum in org.apache.qpid.protonj2.engine">ConnectionState</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#getState()" class="member-name-link">getState</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#negotiate()" class="member-name-link">negotiate</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">If not already negotiated this method initiates the AMQP protocol negotiation phase of
 the connection process sending the <a href="../types/transport/AMQPHeader.html" title="class in org.apache.qpid.protonj2.types.transport"><code>AMQPHeader</code></a> to the remote peer.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#negotiate(org.apache.qpid.protonj2.engine.EventHandler)" class="member-name-link">negotiate</a><wbr>(<a href="EventHandler.html" title="interface in org.apache.qpid.protonj2.engine">EventHandler</a>&lt;<a href="../types/transport/AMQPHeader.html" title="class in org.apache.qpid.protonj2.types.transport">AMQPHeader</a>&gt;&nbsp;remoteAMQPHeaderHandler)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">If not already negotiated this method initiates the AMQP protocol negotiation phase of
 the connection process sending the <a href="../types/transport/AMQPHeader.html" title="class in org.apache.qpid.protonj2.types.transport"><code>AMQPHeader</code></a> to the remote peer.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#receiverOpenHandler(org.apache.qpid.protonj2.engine.EventHandler)" class="member-name-link">receiverOpenHandler</a><wbr>(<a href="EventHandler.html" title="interface in org.apache.qpid.protonj2.engine">EventHandler</a>&lt;<a href="Receiver.html" title="interface in org.apache.qpid.protonj2.engine">Receiver</a>&gt;&nbsp;remoteReceiverOpenEventHandler)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Sets a <a href="EventHandler.html" title="interface in org.apache.qpid.protonj2.engine"><code>EventHandler</code></a> for when an AMQP Attach frame is received from the remote peer for a receiving link.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#senderOpenHandler(org.apache.qpid.protonj2.engine.EventHandler)" class="member-name-link">senderOpenHandler</a><wbr>(<a href="EventHandler.html" title="interface in org.apache.qpid.protonj2.engine">EventHandler</a>&lt;<a href="Sender.html" title="interface in org.apache.qpid.protonj2.engine">Sender</a>&gt;&nbsp;remoteSenderOpenEventHandler)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Sets a <a href="EventHandler.html" title="interface in org.apache.qpid.protonj2.engine"><code>EventHandler</code></a> for when an AMQP Attach frame is received from the remote peer for a sending link.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#session()" class="member-name-link">session</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Creates a new Session linked to this Connection</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#sessionOpenHandler(org.apache.qpid.protonj2.engine.EventHandler)" class="member-name-link">sessionOpenHandler</a><wbr>(<a href="EventHandler.html" title="interface in org.apache.qpid.protonj2.engine">EventHandler</a>&lt;<a href="Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a>&gt;&nbsp;remoteSessionOpenEventHandler)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Sets a <a href="EventHandler.html" title="interface in org.apache.qpid.protonj2.engine"><code>EventHandler</code></a> for when an AMQP Begin frame is received from the remote peer.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#sessions()" class="member-name-link">sessions</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Returns an unmodifiable <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Set.html" title="class or interface in java.util" class="external-link"><code>Set</code></a> of Sessions that are tracked by the Connection.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#setChannelMax(int)" class="member-name-link">setChannelMax</a><wbr>(int&nbsp;channelMax)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Set the channel max value for this Connection.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#setContainerId(java.lang.String)" class="member-name-link">setContainerId</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;containerId)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Sets the Container Id to be used when opening this Connection.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#setHostname(java.lang.String)" class="member-name-link">setHostname</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;hostname)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Set the name of the host (either fully qualified or relative) to which this
 connection is connecting to.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#setIdleTimeout(long)" class="member-name-link">setIdleTimeout</a><wbr>(long&nbsp;idleTimeout)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Set the idle timeout value for this Connection.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#setMaxFrameSize(long)" class="member-name-link">setMaxFrameSize</a><wbr>(long&nbsp;maxFrameSize)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Sets the maximum frame size allowed for this connection, which is the largest single frame
 that the remote can send to this <a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine"><code>Connection</code></a> before it will close the connection with
 an error condition indicating the violation.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code>long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#tick(long)" class="member-name-link">tick</a><wbr>(long&nbsp;current)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Performs a tick operation on the connection which checks that Connection Idle timeout processing
 is run.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#tickAuto(java.util.concurrent.ScheduledExecutorService)" class="member-name-link">tickAuto</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/ScheduledExecutorService.html" title="class or interface in java.util.concurrent" class="external-link">ScheduledExecutorService</a>&nbsp;executor)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Convenience method which is the same as calling <a href="Engine.html#tickAuto(java.util.concurrent.ScheduledExecutorService)"><code>Engine.tickAuto(ScheduledExecutorService)</code></a>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#tickAuto(org.apache.qpid.protonj2.engine.Scheduler)" class="member-name-link">tickAuto</a><wbr>(<a href="Scheduler.html" title="interface in org.apache.qpid.protonj2.engine">Scheduler</a>&nbsp;scheduler)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Convenience method which is the same as calling <a href="Engine.html#tickAuto(org.apache.qpid.protonj2.engine.Scheduler)"><code>Engine.tickAuto(Scheduler)</code></a>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3"><code><a href="#transactionManagerOpenHandler(org.apache.qpid.protonj2.engine.EventHandler)" class="member-name-link">transactionManagerOpenHandler</a><wbr>(<a href="EventHandler.html" title="interface in org.apache.qpid.protonj2.engine">EventHandler</a>&lt;<a href="TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a>&gt;&nbsp;remoteTxnManagerOpenEventHandler)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab3">
<div class="block">Sets a <a href="EventHandler.html" title="interface in org.apache.qpid.protonj2.engine"><code>EventHandler</code></a> for when an AMQP Attach frame is received from the remote peer for a transaction
 coordination link.</div>
</div>
</div>
</div>
</div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-org.apache.qpid.protonj2.engine.Endpoint">Methods inherited from interface&nbsp;org.apache.qpid.protonj2.engine.<a href="Endpoint.html" title="interface in org.apache.qpid.protonj2.engine">Endpoint</a></h3>
<code><a href="Endpoint.html#close()">close</a>, <a href="Endpoint.html#closeHandler(org.apache.qpid.protonj2.engine.EventHandler)">closeHandler</a>, <a href="Endpoint.html#engineShutdownHandler(org.apache.qpid.protonj2.engine.EventHandler)">engineShutdownHandler</a>, <a href="Endpoint.html#getAttachments()">getAttachments</a>, <a href="Endpoint.html#getCondition()">getCondition</a>, <a href="Endpoint.html#getDesiredCapabilities()">getDesiredCapabilities</a>, <a href="Endpoint.html#getEngine()">getEngine</a>, <a href="Endpoint.html#getLinkedResource()">getLinkedResource</a>, <a href="Endpoint.html#getLinkedResource(java.lang.Class)">getLinkedResource</a>, <a href="Endpoint.html#getOfferedCapabilities()">getOfferedCapabilities</a>, <a href="Endpoint.html#getProperties()">getProperties</a>, <a href="Endpoint.html#getRemoteCondition()">getRemoteCondition</a>, <a href="Endpoint.html#getRemoteDesiredCapabilities()">getRemoteDesiredCapabilities</a>, <a href="Endpoint.html#getRemoteOfferedCapabilities()">getRemoteOfferedCapabilities</a>, <a href="Endpoint.html#getRemoteProperties()">getRemoteProperties</a>, <a href="Endpoint.html#isLocallyClosed()">isLocallyClosed</a>, <a href="Endpoint.html#isLocallyOpen()">isLocallyOpen</a>, <a href="Endpoint.html#isRemotelyClosed()">isRemotelyClosed</a>, <a href="Endpoint.html#isRemotelyOpen()">isRemotelyOpen</a>, <a href="Endpoint.html#localCloseHandler(org.apache.qpid.protonj2.engine.EventHandler)">localCloseHandler</a>, <a href="Endpoint.html#localOpenHandler(org.apache.qpid.protonj2.engine.EventHandler)">localOpenHandler</a>, <a href="Endpoint.html#open()">open</a>, <a href="Endpoint.html#openHandler(org.apache.qpid.protonj2.engine.EventHandler)">openHandler</a>, <a href="Endpoint.html#setCondition(org.apache.qpid.protonj2.types.transport.ErrorCondition)">setCondition</a>, <a href="Endpoint.html#setDesiredCapabilities(org.apache.qpid.protonj2.types.Symbol...)">setDesiredCapabilities</a>, <a href="Endpoint.html#setLinkedResource(java.lang.Object)">setLinkedResource</a>, <a href="Endpoint.html#setOfferedCapabilities(org.apache.qpid.protonj2.types.Symbol...)">setOfferedCapabilities</a>, <a href="Endpoint.html#setProperties(java.util.Map)">setProperties</a></code></div>
</section>
</li>
</ul>
</section>
<section class="details">
<ul class="details-list">
<!-- ============ METHOD DETAIL ========== -->
<li>
<section class="method-details" id="method-detail">
<h2>Method Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="negotiate()">
<h3>negotiate</h3>
<div class="member-signature"><span class="return-type"><a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></span>&nbsp;<span class="element-name">negotiate</span>()
              throws <span class="exceptions"><a href="exceptions/EngineStateException.html" title="class in org.apache.qpid.protonj2.engine.exceptions">EngineStateException</a></span></div>
<div class="block">If not already negotiated this method initiates the AMQP protocol negotiation phase of
 the connection process sending the <a href="../types/transport/AMQPHeader.html" title="class in org.apache.qpid.protonj2.types.transport"><code>AMQPHeader</code></a> to the remote peer.  For a client
 application this could mean requesting the server to indicate if it supports the version
 of the protocol this client speaks.  In rare cases a server could use this to preemptively
 send its AMQP header.

 Once a header is sent the remote should respond with the AMQP Header that indicates what
 protocol level it supports and if there is a mismatch the the engine will be failed with
 a error indicating the protocol support was not successfully negotiated.

 If the engine has a configured SASL layer then by starting the AMQP Header exchange this
 will implicitly first attempt the SASL authentication step of the connection process.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>this <a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine"><code>Connection</code></a> instance.</dd>
<dt>Throws:</dt>
<dd><code><a href="exceptions/EngineStateException.html" title="class in org.apache.qpid.protonj2.engine.exceptions">EngineStateException</a></code> - if the Engine state precludes accepting new input.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="negotiate(org.apache.qpid.protonj2.engine.EventHandler)">
<h3>negotiate</h3>
<div class="member-signature"><span class="return-type"><a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></span>&nbsp;<span class="element-name">negotiate</span><wbr><span class="parameters">(<a href="EventHandler.html" title="interface in org.apache.qpid.protonj2.engine">EventHandler</a>&lt;<a href="../types/transport/AMQPHeader.html" title="class in org.apache.qpid.protonj2.types.transport">AMQPHeader</a>&gt;&nbsp;remoteAMQPHeaderHandler)</span>
              throws <span class="exceptions"><a href="exceptions/EngineStateException.html" title="class in org.apache.qpid.protonj2.engine.exceptions">EngineStateException</a></span></div>
<div class="block">If not already negotiated this method initiates the AMQP protocol negotiation phase of
 the connection process sending the <a href="../types/transport/AMQPHeader.html" title="class in org.apache.qpid.protonj2.types.transport"><code>AMQPHeader</code></a> to the remote peer.  For a client
 application this could mean requesting the server to indicate if it supports the version
 of the protocol this client speaks.  In rare cases a server could use this to preemptively
 send its AMQP header.

 Once a header is sent the remote should respond with the AMQP Header that indicates what
 protocol level it supports and if there is a mismatch the the engine will be failed with
 a error indicating the protocol support was not successfully negotiated.

 If the engine has a configured SASL layer then by starting the AMQP Header exchange this
 will implicitly first attempt the SASL authentication step of the connection process.

 The provided remote AMQP Header handler will be called once the remote sends its AMQP Header to
 the either preemptively or as a response to offered AMQP Header from this peer, even if that has
 already happened prior to this call.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>remoteAMQPHeaderHandler</code> - Handler to be called when an AMQP Header response has arrived.</dd>
<dt>Returns:</dt>
<dd>this <a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine"><code>Connection</code></a> instance.</dd>
<dt>Throws:</dt>
<dd><code><a href="exceptions/EngineStateException.html" title="class in org.apache.qpid.protonj2.engine.exceptions">EngineStateException</a></code> - if the Engine state precludes accepting new input.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="tick(long)">
<h3>tick</h3>
<div class="member-signature"><span class="return-type">long</span>&nbsp;<span class="element-name">tick</span><wbr><span class="parameters">(long&nbsp;current)</span>
   throws <span class="exceptions"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/IllegalStateException.html" title="class or interface in java.lang" class="external-link">IllegalStateException</a>,
<a href="exceptions/EngineStateException.html" title="class in org.apache.qpid.protonj2.engine.exceptions">EngineStateException</a></span></div>
<div class="block">Performs a tick operation on the connection which checks that Connection Idle timeout processing
 is run.  This method is a convenience method that delegates the work to the <a href="Engine.html#tick(long)"><code>Engine.tick(long)</code></a>
 method.

 It is an error to call this method if <a href="#tickAuto(java.util.concurrent.ScheduledExecutorService)"><code>tickAuto(ScheduledExecutorService)</code></a> was called.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>current</code> - Current time value usually taken from <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/System.html#nanoTime()" title="class or interface in java.lang" class="external-link"><code>System.nanoTime()</code></a></dd>
<dt>Returns:</dt>
<dd>the absolute deadline in milliseconds to next call tick by/at, or 0 if there is none.</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/IllegalStateException.html" title="class or interface in java.lang" class="external-link">IllegalStateException</a></code> - if the <a href="Engine.html" title="interface in org.apache.qpid.protonj2.engine"><code>Engine</code></a> is already performing auto tick handling.</dd>
<dd><code><a href="exceptions/EngineStateException.html" title="class in org.apache.qpid.protonj2.engine.exceptions">EngineStateException</a></code> - if the Engine state precludes accepting new input.</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="Engine.html#tick(long)"><code>Engine.tick(long)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="tickAuto(java.util.concurrent.ScheduledExecutorService)">
<h3>tickAuto</h3>
<div class="member-signature"><span class="return-type"><a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></span>&nbsp;<span class="element-name">tickAuto</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/ScheduledExecutorService.html" title="class or interface in java.util.concurrent" class="external-link">ScheduledExecutorService</a>&nbsp;executor)</span></div>
<div class="block">Convenience method which is the same as calling <a href="Engine.html#tickAuto(java.util.concurrent.ScheduledExecutorService)"><code>Engine.tickAuto(ScheduledExecutorService)</code></a>.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>executor</code> - The single threaded execution context where all engine work takes place.</dd>
<dt>Returns:</dt>
<dd>this <a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine"><code>Connection</code></a> instance.</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/IllegalStateException.html" title="class or interface in java.lang" class="external-link">IllegalStateException</a></code> - if the <a href="Engine.html" title="interface in org.apache.qpid.protonj2.engine"><code>Engine</code></a> is already performing auto tick handling.</dd>
<dd><code><a href="exceptions/EngineStateException.html" title="class in org.apache.qpid.protonj2.engine.exceptions">EngineStateException</a></code> - if the Engine state precludes accepting new input.</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list-long">
<li><a href="Engine.html#tickAuto(java.util.concurrent.ScheduledExecutorService)"><code>Engine.tickAuto(ScheduledExecutorService)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="tickAuto(org.apache.qpid.protonj2.engine.Scheduler)">
<h3>tickAuto</h3>
<div class="member-signature"><span class="return-type"><a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></span>&nbsp;<span class="element-name">tickAuto</span><wbr><span class="parameters">(<a href="Scheduler.html" title="interface in org.apache.qpid.protonj2.engine">Scheduler</a>&nbsp;scheduler)</span>
             throws <span class="exceptions"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/IllegalStateException.html" title="class or interface in java.lang" class="external-link">IllegalStateException</a>,
<a href="exceptions/EngineStateException.html" title="class in org.apache.qpid.protonj2.engine.exceptions">EngineStateException</a></span></div>
<div class="block">Convenience method which is the same as calling <a href="Engine.html#tickAuto(org.apache.qpid.protonj2.engine.Scheduler)"><code>Engine.tickAuto(Scheduler)</code></a>.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>scheduler</code> - The single threaded execution context where all engine work takes place.</dd>
<dt>Returns:</dt>
<dd>this <a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine"><code>Connection</code></a> instance.</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/IllegalStateException.html" title="class or interface in java.lang" class="external-link">IllegalStateException</a></code> - if the <a href="Engine.html" title="interface in org.apache.qpid.protonj2.engine"><code>Engine</code></a> is already performing auto tick handling.</dd>
<dd><code><a href="exceptions/EngineStateException.html" title="class in org.apache.qpid.protonj2.engine.exceptions">EngineStateException</a></code> - if the Engine state precludes accepting new input.</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="Engine.html#tickAuto(org.apache.qpid.protonj2.engine.Scheduler)"><code>Engine.tickAuto(Scheduler)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getState()">
<h3>getState</h3>
<div class="member-signature"><span class="return-type"><a href="ConnectionState.html" title="enum in org.apache.qpid.protonj2.engine">ConnectionState</a></span>&nbsp;<span class="element-name">getState</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the local connection state only</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getParent()">
<h3>getParent</h3>
<div class="member-signature"><span class="return-type"><a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></span>&nbsp;<span class="element-name">getParent</span>()</div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="Endpoint.html#getParent()">Endpoint</a></code></span></div>
<div class="block">Gets the parent of this <a href="Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> which can be itself for <a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine"><code>Connection</code></a> instance.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="Endpoint.html#getParent()">getParent</a></code>&nbsp;in interface&nbsp;<code><a href="Endpoint.html" title="interface in org.apache.qpid.protonj2.engine">Endpoint</a>&lt;<a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a>&gt;</code></dd>
<dt>Returns:</dt>
<dd>this <a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine"><code>Connection</code></a> as it is the root of the <a href="Endpoint.html" title="interface in org.apache.qpid.protonj2.engine"><code>Endpoint</code></a> hierarchy.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getContainerId()">
<h3>getContainerId</h3>
<div class="member-signature"><span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getContainerId</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the Container ID assigned to this Connection</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setContainerId(java.lang.String)">
<h3>setContainerId</h3>
<div class="member-signature"><span class="return-type"><a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></span>&nbsp;<span class="element-name">setContainerId</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;containerId)</span>
                   throws <span class="exceptions"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/IllegalStateException.html" title="class or interface in java.lang" class="external-link">IllegalStateException</a></span></div>
<div class="block">Sets the Container Id to be used when opening this Connection.  The container Id can only
 be modified prior to a call to <a href="Endpoint.html#open()"><code>Endpoint.open()</code></a>, once the connection has been
 opened locally an error will be thrown if this method is called.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>containerId</code> - The Container Id used for this end of the Connection.</dd>
<dt>Returns:</dt>
<dd>this connection.</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/IllegalStateException.html" title="class or interface in java.lang" class="external-link">IllegalStateException</a></code> - if the Connection has already been opened.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setHostname(java.lang.String)">
<h3>setHostname</h3>
<div class="member-signature"><span class="return-type"><a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></span>&nbsp;<span class="element-name">setHostname</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;hostname)</span>
                throws <span class="exceptions"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/IllegalStateException.html" title="class or interface in java.lang" class="external-link">IllegalStateException</a></span></div>
<div class="block">Set the name of the host (either fully qualified or relative) to which this
 connection is connecting to.  This information may be used by the remote peer
 to determine the correct back-end service to connect the client to. This value
 will be sent in the Open performative.

 <b>Note that it is illegal to set the host name to a numeric IP
 address or include a port number.</b>

 The host name value can only be modified prior to a call to <a href="Endpoint.html#open()"><code>Endpoint.open()</code></a>,
 once the connection has been opened locally an error will be thrown if this method
 is called.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>hostname</code> - the RFC1035 compliant host name.</dd>
<dt>Returns:</dt>
<dd>this connection.</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/IllegalStateException.html" title="class or interface in java.lang" class="external-link">IllegalStateException</a></code> - if the Connection has already been opened.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getHostname()">
<h3>getHostname</h3>
<div class="member-signature"><span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getHostname</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>returns the host name assigned to this Connection.</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="#setHostname(java.lang.String)"><code>setHostname(java.lang.String)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setChannelMax(int)">
<h3>setChannelMax</h3>
<div class="member-signature"><span class="return-type"><a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></span>&nbsp;<span class="element-name">setChannelMax</span><wbr><span class="parameters">(int&nbsp;channelMax)</span>
                  throws <span class="exceptions"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/IllegalStateException.html" title="class or interface in java.lang" class="external-link">IllegalStateException</a></span></div>
<div class="block">Set the channel max value for this Connection.

 The channel max value can only be modified prior to a call to <a href="Endpoint.html#open()"><code>Endpoint.open()</code></a>,
 once the connection has been opened locally an error will be thrown if this method
 is called.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>channelMax</code> - The value to set for channel max when opening the connection.</dd>
<dt>Returns:</dt>
<dd>this connection.</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/IllegalStateException.html" title="class or interface in java.lang" class="external-link">IllegalStateException</a></code> - if the Connection has already been opened.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getChannelMax()">
<h3>getChannelMax</h3>
<div class="member-signature"><span class="return-type">int</span>&nbsp;<span class="element-name">getChannelMax</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the currently configured channel max for this <a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine"><code>Connection</code></a></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setMaxFrameSize(long)">
<h3>setMaxFrameSize</h3>
<div class="member-signature"><span class="return-type"><a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></span>&nbsp;<span class="element-name">setMaxFrameSize</span><wbr><span class="parameters">(long&nbsp;maxFrameSize)</span>
                    throws <span class="exceptions"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/IllegalStateException.html" title="class or interface in java.lang" class="external-link">IllegalStateException</a></span></div>
<div class="block">Sets the maximum frame size allowed for this connection, which is the largest single frame
 that the remote can send to this <a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine"><code>Connection</code></a> before it will close the connection with
 an error condition indicating the violation.

 The legal range for this value is defined as (512 - 2^32-1) bytes.

 The max frame size value can only be modified prior to a call to <a href="Endpoint.html#open()"><code>Endpoint.open()</code></a>,
 once the connection has been opened locally an error will be thrown if this method
 is called.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>maxFrameSize</code> - The maximum number of bytes allowed for a single</dd>
<dt>Returns:</dt>
<dd>this connection.</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/IllegalStateException.html" title="class or interface in java.lang" class="external-link">IllegalStateException</a></code> - if the Connection has already been opened.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getMaxFrameSize()">
<h3>getMaxFrameSize</h3>
<div class="member-signature"><span class="return-type">long</span>&nbsp;<span class="element-name">getMaxFrameSize</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the currently configured max frame size this connection will accept.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setIdleTimeout(long)">
<h3>setIdleTimeout</h3>
<div class="member-signature"><span class="return-type"><a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></span>&nbsp;<span class="element-name">setIdleTimeout</span><wbr><span class="parameters">(long&nbsp;idleTimeout)</span>
                   throws <span class="exceptions"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/IllegalStateException.html" title="class or interface in java.lang" class="external-link">IllegalStateException</a></span></div>
<div class="block">Set the idle timeout value for this Connection.

 The idle timeout value can only be modified prior to a call to <a href="Endpoint.html#open()"><code>Endpoint.open()</code></a>,
 once the connection has been opened locally an error will be thrown if this method
 is called.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>idleTimeout</code> - The value to set for the idle timeout when opening the connection.</dd>
<dt>Returns:</dt>
<dd>this connection.</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/IllegalStateException.html" title="class or interface in java.lang" class="external-link">IllegalStateException</a></code> - if the Connection has already been opened.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getIdleTimeout()">
<h3>getIdleTimeout</h3>
<div class="member-signature"><span class="return-type">long</span>&nbsp;<span class="element-name">getIdleTimeout</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the currently configured idle timeout for this <a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine"><code>Connection</code></a></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="session()">
<h3>session</h3>
<div class="member-signature"><span class="return-type"><a href="Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a></span>&nbsp;<span class="element-name">session</span>()
         throws <span class="exceptions"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/IllegalStateException.html" title="class or interface in java.lang" class="external-link">IllegalStateException</a></span></div>
<div class="block">Creates a new Session linked to this Connection</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>a newly created <a href="Session.html" title="interface in org.apache.qpid.protonj2.engine"><code>Session</code></a> linked to this <a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine"><code>Connection</code></a>.</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/IllegalStateException.html" title="class or interface in java.lang" class="external-link">IllegalStateException</a></code> - if the <a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine"><code>Connection</code></a> has already been closed.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="sessions()">
<h3>sessions</h3>
<div class="member-signature"><span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;<a href="Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a>&gt;</span>&nbsp;<span class="element-name">sessions</span>()</div>
<div class="block">Returns an unmodifiable <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Set.html" title="class or interface in java.util" class="external-link"><code>Set</code></a> of Sessions that are tracked by the Connection.

 The <a href="Session.html" title="interface in org.apache.qpid.protonj2.engine"><code>Session</code></a> instances returned from this method will be locally or remotely open or
 both which gives the caller full view of the complete set of known <a href="Session.html" title="interface in org.apache.qpid.protonj2.engine"><code>Session</code></a> instances.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>an unmodifiable <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Set.html" title="class or interface in java.util" class="external-link"><code>Set</code></a> of Sessions tracked by this Connection.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getRemoteContainerId()">
<h3>getRemoteContainerId</h3>
<div class="member-signature"><span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getRemoteContainerId</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the Container Id assigned to the remote end of the Connection.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getRemoteHostname()">
<h3>getRemoteHostname</h3>
<div class="member-signature"><span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getRemoteHostname</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the host name assigned to the remote end of this Connection.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getRemoteIdleTimeout()">
<h3>getRemoteIdleTimeout</h3>
<div class="member-signature"><span class="return-type">long</span>&nbsp;<span class="element-name">getRemoteIdleTimeout</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the idle timeout value provided by the remote end of this Connection.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getRemoteMaxFrameSize()">
<h3>getRemoteMaxFrameSize</h3>
<div class="member-signature"><span class="return-type">long</span>&nbsp;<span class="element-name">getRemoteMaxFrameSize</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the remote set max frame size limit.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getRemoteState()">
<h3>getRemoteState</h3>
<div class="member-signature"><span class="return-type"><a href="ConnectionState.html" title="enum in org.apache.qpid.protonj2.engine">ConnectionState</a></span>&nbsp;<span class="element-name">getRemoteState</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the remote state (as last communicated)</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="sessionOpenHandler(org.apache.qpid.protonj2.engine.EventHandler)">
<h3>sessionOpenHandler</h3>
<div class="member-signature"><span class="return-type"><a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></span>&nbsp;<span class="element-name">sessionOpenHandler</span><wbr><span class="parameters">(<a href="EventHandler.html" title="interface in org.apache.qpid.protonj2.engine">EventHandler</a>&lt;<a href="Session.html" title="interface in org.apache.qpid.protonj2.engine">Session</a>&gt;&nbsp;remoteSessionOpenEventHandler)</span></div>
<div class="block">Sets a <a href="EventHandler.html" title="interface in org.apache.qpid.protonj2.engine"><code>EventHandler</code></a> for when an AMQP Begin frame is received from the remote peer.

 Used to process remotely initiated Sessions. Locally initiated sessions have their own EventHandler
 invoked instead.  This method is Typically used by servers to listen for remote Session creation.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>remoteSessionOpenEventHandler</code> - the EventHandler that will be signaled when a session is remotely opened.</dd>
<dt>Returns:</dt>
<dd>this connection</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="senderOpenHandler(org.apache.qpid.protonj2.engine.EventHandler)">
<h3>senderOpenHandler</h3>
<div class="member-signature"><span class="return-type"><a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></span>&nbsp;<span class="element-name">senderOpenHandler</span><wbr><span class="parameters">(<a href="EventHandler.html" title="interface in org.apache.qpid.protonj2.engine">EventHandler</a>&lt;<a href="Sender.html" title="interface in org.apache.qpid.protonj2.engine">Sender</a>&gt;&nbsp;remoteSenderOpenEventHandler)</span></div>
<div class="block">Sets a <a href="EventHandler.html" title="interface in org.apache.qpid.protonj2.engine"><code>EventHandler</code></a> for when an AMQP Attach frame is received from the remote peer for a sending link.

 Used to process remotely initiated sending link.  Locally initiated links have their own EventHandler
 invoked instead.  This method is Typically used by servers to listen for remote Receiver creation.
 If an event handler for remote sender open is registered on the Session that the link is owned by then
 that handler will be invoked instead of this one.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>remoteSenderOpenEventHandler</code> - the EventHandler that will be signaled when a sender link is remotely opened.</dd>
<dt>Returns:</dt>
<dd>this connection</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="receiverOpenHandler(org.apache.qpid.protonj2.engine.EventHandler)">
<h3>receiverOpenHandler</h3>
<div class="member-signature"><span class="return-type"><a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></span>&nbsp;<span class="element-name">receiverOpenHandler</span><wbr><span class="parameters">(<a href="EventHandler.html" title="interface in org.apache.qpid.protonj2.engine">EventHandler</a>&lt;<a href="Receiver.html" title="interface in org.apache.qpid.protonj2.engine">Receiver</a>&gt;&nbsp;remoteReceiverOpenEventHandler)</span></div>
<div class="block">Sets a <a href="EventHandler.html" title="interface in org.apache.qpid.protonj2.engine"><code>EventHandler</code></a> for when an AMQP Attach frame is received from the remote peer for a receiving link.

 Used to process remotely initiated receiving link.  Locally initiated links have their own EventHandler
 invoked instead.  This method is Typically used by servers to listen for remote Sender creation.
 If an event handler for remote receiver open is registered on the Session that the link is owned by then
 that handler will be invoked instead of this one.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>remoteReceiverOpenEventHandler</code> - the EventHandler that will be signaled when a receiver link is remotely opened.</dd>
<dt>Returns:</dt>
<dd>this connection</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="transactionManagerOpenHandler(org.apache.qpid.protonj2.engine.EventHandler)">
<h3>transactionManagerOpenHandler</h3>
<div class="member-signature"><span class="return-type"><a href="Connection.html" title="interface in org.apache.qpid.protonj2.engine">Connection</a></span>&nbsp;<span class="element-name">transactionManagerOpenHandler</span><wbr><span class="parameters">(<a href="EventHandler.html" title="interface in org.apache.qpid.protonj2.engine">EventHandler</a>&lt;<a href="TransactionManager.html" title="interface in org.apache.qpid.protonj2.engine">TransactionManager</a>&gt;&nbsp;remoteTxnManagerOpenEventHandler)</span></div>
<div class="block">Sets a <a href="EventHandler.html" title="interface in org.apache.qpid.protonj2.engine"><code>EventHandler</code></a> for when an AMQP Attach frame is received from the remote peer for a transaction
 coordination link.

 Used to process remotely initiated transaction manager link.  Locally initiated links have their own EventHandler
 invoked instead.  This method is Typically used by servers to listen for remote <a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</code></a>
 creation.  If an event handler for remote <a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</code></a> open is registered on the Session that the
 link is owned by then that handler will be invoked instead of this one.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>remoteTxnManagerOpenEventHandler</code> - the EventHandler that will be signaled when a <a href="TransactionController.html" title="interface in org.apache.qpid.protonj2.engine"><code>TransactionController</code></a> link is remotely opened.</dd>
<dt>Returns:</dt>
<dd>this connection</dd>
</dl>
</section>
</li>
</ul>
</section>
</li>
</ul>
</section>
<!-- ========= END OF CLASS DATA ========= -->
</main>
<footer role="contentinfo">
<hr>
<p class="legal-copy"><small>Copyright &#169; 2024 <a href="https://www.apache.org/">The Apache Software Foundation</a>. All rights reserved.</small></p>
</footer>
</div>
</div>
</body>
</html>
