Lines Matching refs:conference
191 private final Map<String, Conference> mConferenceById = new ConcurrentHashMap<>();
192 private final Map<Conference, String> mIdByConference = new ConcurrentHashMap<>();
199 private Conference sNullConference;
493 public void conference(String callId1, String callId2, Session.Info sessionInfo) {
989 conference(callId1, callId2);
1155 private final Conference.Listener mConferenceListener = new Conference.Listener() {
1157 public void onStateChanged(Conference conference, int oldState, int newState) {
1158 String id = mIdByConference.get(conference);
1173 public void onDisconnected(Conference conference, DisconnectCause disconnectCause) {
1174 String id = mIdByConference.get(conference);
1179 public void onConnectionAdded(Conference conference, Connection connection) {
1183 public void onConnectionRemoved(Conference conference, Connection connection) {
1188 Conference conference, List<Connection> conferenceableConnections) {
1190 mIdByConference.get(conference),
1195 public void onDestroyed(Conference conference) {
1196 removeConference(conference);
1201 Conference conference,
1203 String id = mIdByConference.get(conference);
1204 Log.d(this, "call capabilities: conference: %s",
1211 Conference conference,
1213 String id = mIdByConference.get(conference);
1214 Log.d(this, "call capabilities: conference: %s",
1220 public void onVideoStateChanged(Conference c, int videoState) {
1227 public void onVideoProviderChanged(Conference c, Connection.VideoProvider videoProvider) {
1235 public void onStatusHintsChanged(Conference conference, StatusHints statusHints) {
1236 String id = mIdByConference.get(conference);
1243 public void onExtrasChanged(Conference c, Bundle extras) {
1251 public void onExtrasRemoved(Conference c, List<String> keys) {
1387 public void onConferenceChanged(Connection connection, Conference conference) {
1391 if (conference != null) {
1392 conferenceId = mIdByConference.get(conference);
1711 private void conference(String callId1, String callId2) {
1712 Log.d(this, "conference %s, %s", callId1, callId2);
1714 // Attempt to get second connection or conference.
1715 Connection connection2 = findConnectionForAction(callId2, "conference");
1716 Conference conference2 = getNullConference();
1718 conference2 = findConferenceForAction(callId2, "conference");
1720 Log.w(this, "Connection2 or Conference2 missing in conference request %s.",
1726 // Attempt to get first connection or conference and perform merge.
1727 Connection connection1 = findConnectionForAction(callId1, "conference");
1729 Conference conference1 = findConferenceForAction(callId1, "addConnection");
1732 "Connection1 or Conference1 missing in conference request %s.",
1735 // Call 1 is a conference.
1737 // Call 2 is a connection so merge via call 1 (conference).
1740 // Call 2 is ALSO a conference; this should never happen.
1741 Log.wtf(this, "There can only be one conference and an attempt was made to " +
1749 // Call 2 is a conference, so merge via call 2.
1763 Log.w(this, "Connection missing in conference request %s.", callId);
1767 Conference conference = connection.getConference();
1768 if (conference != null) {
1769 conference.onSeparate(connection);
1775 Conference conference = findConferenceForAction(callId, "mergeConference");
1776 if (conference != null) {
1777 conference.onMerge();
1783 Conference conference = findConferenceForAction(callId, "swapConference");
1784 if (conference != null) {
1785 conference.onSwap();
1835 * Notifies a {@link Connection} or {@link Conference} of a change to the extras from Telecom.
1860 Log.w(this, "startRtt called on a conference.");
1869 Log.w(this, "stopRtt called on a conference.");
1879 Log.w(this, "handleRttUpgradeResponse called on a conference.");
1965 * {@link RemoteConnection}s should be merged into a conference call.
1967 * If the conference request is successful, the method {@link #onRemoteConferenceAdded} will
1970 * @param remoteConnection1 The first of the remote connections to conference.
1971 * @param remoteConnection2 The second of the remote connections to conference.
1980 * Adds a new conference call. When a conference call is created either as a result of an
1982 * an instance of {@link Conference} by invoking this method. A conference call provided by this
1983 * method will persist until {@link Conference#destroy} is invoked on the conference instance.
1985 * @param conference The new conference object.
1987 public final void addConference(Conference conference) {
1988 Log.d(this, "addConference: conference=%s", conference);
1990 String id = addConferenceInternal(conference);
1993 for (Connection connection : conference.getConnections()) {
1998 conference.setTelecomCallId(id);
2000 conference.getPhoneAccountHandle(),
2001 conference.getState(),
2002 conference.getConnectionCapabilities(),
2003 conference.getConnectionProperties(),
2005 conference.getVideoProvider() == null ?
2006 null : conference.getVideoProvider().getInterface(),
2007 conference.getVideoState(),
2008 conference.getConnectTimeMillis(),
2009 conference.getConnectionStartElapsedRealTime(),
2010 conference.getStatusHints(),
2011 conference.getExtras());
2014 mAdapter.setVideoProvider(id, conference.getVideoProvider());
2015 mAdapter.setVideoState(id, conference.getVideoState());
2018 for (Connection connection : conference.getConnections()) {
2024 onConferenceAdded(conference);
2037 addExistingConnection(phoneAccountHandle, connection, null /* conference */);
2056 * @param conference The parent conference of the new connection.
2060 Connection connection, Conference conference) {
2066 if (conference != null) {
2067 conferenceId = mIdByConference.get(conference);
2107 * Returns all the active {@code Conference}s for which this {@code ConnectionService}
2110 * @return A collection of {@code Conference}s created by this {@code ConnectionService}.
2112 public final Collection<Conference> getAllConferences() {
2183 * Trigger recalculate functinality for conference calls. This is used when a Telephony
2184 * Connection is part of a conference controller but is not yet added to Connection
2185 * Service and hence cannot be added to the conference call.
2348 * Conference two specified connections. Invoked when the user has made a request to merge the
2349 * specified connections into a conference call. In response, the connection service should
2350 * create an instance of {@link Conference} and pass it into {@link #addConference}.
2352 * @param connection1 A connection to merge into a conference call.
2353 * @param connection2 A connection to merge into a conference call.
2370 * Called when a conference is added.
2373 public void onConferenceAdded(Conference conference) {}
2376 * Called when a conference is removed.
2379 public void onConferenceRemoved(Conference conference) {}
2382 * Indicates that a remote conference has been created for existing {@link RemoteConnection}s.
2384 * representation of the conference call and send it to telecom using {@link #addConference}.
2389 * @param conference The remote conference call.
2391 public void onRemoteConferenceAdded(RemoteConference conference) {}
2416 public boolean containsConference(Conference conference) {
2417 return mIdByConference.containsKey(conference);
2489 private String addConferenceInternal(Conference conference) {
2491 if (conference.getExtras() != null && conference.getExtras()
2493 originalId = conference.getExtras().getString(Connection.EXTRA_ORIGINAL_CONNECTION_ID);
2495 conference.getTelecomCallId(),
2498 if (mIdByConference.containsKey(conference)) {
2499 Log.w(this, "Re-adding an existing conference: %s.", conference);
2500 } else if (conference != null) {
2505 mConferenceById.put(id, conference);
2506 mIdByConference.put(conference, id);
2507 conference.addListener(mConferenceListener);
2514 private void removeConference(Conference conference) {
2515 if (mIdByConference.containsKey(conference)) {
2516 conference.removeListener(mConferenceListener);
2518 String id = mIdByConference.get(conference);
2520 mIdByConference.remove(conference);
2523 onConferenceRemoved(conference);
2542 private Conference findConferenceForAction(String conferenceId, String action) {
2546 Log.w(this, "%s - Cannot find conference %s", action, conferenceId);
2562 * Builds a list of {@link Connection} and {@link Conference} IDs based on the list of
2566 * @return List of string conference and call Ids.
2571 // Only allow Connection and Conference conferenceables.
2577 } else if (c instanceof Conference) {
2578 Conference conference = (Conference) c;
2579 if (mIdByConference.containsKey(conference)) {
2580 ids.add(mIdByConference.get(conference));
2588 private Conference getNullConference() {
2590 sNullConference = new Conference(null) {};
2598 // only operate on top-level calls. Conference calls will be removed on their own.
2603 for (Conference conference : mIdByConference.keySet()) {
2604 conference.onDisconnect();
