telecomm/java/android/telecomm/ConnectionService.java - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2014 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package android.telecomm;

 import android.net.Uri;
 import android.os.Bundle;
 import android.telephony.DisconnectCause;

 import android.os.SystemClock;

 import java.util.Collection;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;

 /**
  * A {@link android.app.Service} that provides telephone connections to
  * processes running on an Android device.
  */
 public abstract class ConnectionService extends CallService {
     // Flag controlling whether PII is emitted into the logs
     private static final boolean PII_DEBUG = Log.isLoggable(android.util.Log.DEBUG);
     private static final Connection NULL_CONNECTION = new Connection() {};

     // Mappings from Connections to IDs as understood by the current CallService implementation
     private final Map<String, Connection> mConnectionById = new HashMap<>();
     private final Map<Connection, String> mIdByConnection = new HashMap<>();

     private final Connection.Listener mConnectionListener = new Connection.Listener() {
         @Override
         public void onStateChanged(Connection c, int state) {
             String id = mIdByConnection.get(c);
             Log.d(this, "Adapter set state %s %s", id, Connection.stateToString(state));
             switch (state) {
                 case Connection.State.ACTIVE:
                     getAdapter().setActive(id);
                     break;
                 case Connection.State.DIALING:
                     getAdapter().setDialing(id);
                     break;
                 case Connection.State.DISCONNECTED:
                     // Handled in onDisconnected()
                     break;
                 case Connection.State.HOLDING:
                     getAdapter().setOnHold(id);
                     break;
                 case Connection.State.NEW:
                     // Nothing to tell Telecomm
                     break;
                 case Connection.State.RINGING:
                     getAdapter().setRinging(id);
                     break;
             }
         }

         @Override
         public void onDisconnected(Connection c, int cause, String message) {
             String id = mIdByConnection.get(c);
             Log.d(this, "Adapter set disconnected %d %s", cause, message);
             getAdapter().setDisconnected(id, cause, message);
         }

         @Override
         public void onHandleChanged(Connection c, Uri newHandle) {
             // TODO: Unsupported yet
         }

         @Override
         public void onAudioStateChanged(Connection c, CallAudioState state) {
             // TODO: Unsupported yet
         }

         @Override
         public void onSignalChanged(Connection c, Bundle details) {
             // TODO: Unsupported yet
         }

         @Override
         public void onDestroyed(Connection c) {
             removeConnection(c);
         }

         @Override
         public void onRequestingRingback(Connection c, boolean ringback) {
             String id = mIdByConnection.get(c);
             Log.d(this, "Adapter onRingback %b", ringback);
             getAdapter().setRequestingRingback(id, ringback);
         }

         @Override
         public void onConferenceCapableChanged(Connection c, boolean isConferenceCapable) {
             String id = mIdByConnection.get(c);
             getAdapter().setCanConference(id, isConferenceCapable);
         }

         /** ${inheritDoc} */
         @Override
         public void onParentConnectionChanged(Connection c, Connection parent) {
             String id = mIdByConnection.get(c);
             String parentId = parent == null ? null : mIdByConnection.get(parent);
             getAdapter().setIsConferenced(id, parentId);
         }
     };

     @Override
     public final void isCompatibleWith(final CallInfo callInfo) {
         Log.d(this, "isCompatibleWith %s", callInfo);
         onFindSubscriptions(
                 callInfo.getHandle(),
                 new Response<Uri, Subscription>() {
                     @Override
                     public void onResult(Uri handle, Subscription... result) {
                         boolean isCompatible = result.length > 0;
                         Log.d(this, "adapter setIsCompatibleWith ");
                         getAdapter().setIsCompatibleWith(callInfo.getId(), isCompatible);
                     }

                     @Override
                     public void onError(Uri handle, int code, String msg) {
                         Log.w(this, "Error in onFindSubscriptions %s %d %s", handle, code, msg);
                         getAdapter().setIsCompatibleWith(callInfo.getId(), false);
                     }
                 }
         );
     }

     @Override
     public final void call(final CallInfo callInfo) {
         Log.d(this, "call %s", callInfo);
         onCreateConnections(
                 new ConnectionRequest(
                         callInfo.getId(),
                         callInfo.getHandle(),
                         callInfo.getExtras()),
                 new Response<ConnectionRequest, Connection>() {
                     @Override
                     public void onResult(ConnectionRequest request, Connection... result) {
                         if (result != null && result.length != 1) {
                             Log.d(this, "adapter handleFailedOutgoingCall %s", callInfo);
                             getAdapter().handleFailedOutgoingCall(
                                     request,
                                     DisconnectCause.ERROR_UNSPECIFIED,
                                     "Created " + result.length + " Connections, expected 1");
                             for (Connection c : result) {
                                 c.abort();
                             }
                         } else {
                             Log.d(this, "adapter handleSuccessfulOutgoingCall %s",
                                     callInfo.getId());
                             getAdapter().handleSuccessfulOutgoingCall(callInfo.getId());
                             addConnection(callInfo.getId(), result[0]);
                         }
                     }

                     @Override
                     public void onError(ConnectionRequest request, int code, String msg) {
                         getAdapter().handleFailedOutgoingCall(request, code, msg);
                     }
                 }
         );
     }

     @Override
     public final void abort(String callId) {
         Log.d(this, "abort %s", callId);
         findConnectionForAction(callId, "abort").abort();
     }

     @Override
     public final void setIncomingCallId(final String callId, Bundle extras) {
         Log.d(this, "setIncomingCallId %s %s", callId, extras);
         onCreateIncomingConnection(
                 new ConnectionRequest(
                         callId,
                         null,  // TODO: Can we obtain this from "extras"?
                         extras),
                 new Response<ConnectionRequest, Connection>() {
                     @Override
                     public void onResult(ConnectionRequest request, Connection... result) {
                         if (result != null && result.length != 1) {
                             Log.d(this, "adapter handleFailedOutgoingCall %s", callId);
                             getAdapter().handleFailedOutgoingCall(
                                     request,
                                     DisconnectCause.ERROR_UNSPECIFIED,
                                     "Created " + result.length + " Connections, expected 1");
                             for (Connection c : result) {
                                 c.abort();
                             }
                         } else {
                             addConnection(callId, result[0]);
                             Log.d(this, "adapter notifyIncomingCall %s", callId);
                             // TODO: Uri.EMPTY is because CallInfo crashes when Parceled with a
                             // null URI ... need to fix that at its cause!
                             getAdapter().notifyIncomingCall(new CallInfo(
                                     callId,
                                     connectionStateToCallState(result[0].getState()),
                                     request.getHandle() /* result[0].getHandle() == null
                                             ? Uri.EMPTY : result[0].getHandle() */));
                         }
                     }

                     @Override
                     public void onError(ConnectionRequest request, int code, String msg) {
                         Log.d(this, "adapter failed setIncomingCallId %s %d %s",
                                 request, code, msg);
                     }
                 }
         );
     }

     @Override
     public final void answer(String callId) {
         Log.d(this, "answer %s", callId);
         findConnectionForAction(callId, "answer").answer();
     }

     @Override
     public final void reject(String callId) {
         Log.d(this, "reject %s", callId);
         findConnectionForAction(callId, "reject").reject();
     }

     @Override
     public final void disconnect(String callId) {
         Log.d(this, "disconnect %s", callId);
         findConnectionForAction(callId, "disconnect").disconnect();
     }

     @Override
     public final void hold(String callId) {
         Log.d(this, "hold %s", callId);
         findConnectionForAction(callId, "hold").hold();
     }

     @Override
     public final void unhold(String callId) {
         Log.d(this, "unhold %s", callId);
         findConnectionForAction(callId, "unhold").unhold();
     }

     @Override
     public final void playDtmfTone(String callId, char digit) {
         Log.d(this, "playDtmfTone %s %c", callId, digit);
         findConnectionForAction(callId, "playDtmfTone").playDtmfTone(digit);
     }

     @Override
     public final void stopDtmfTone(String callId) {
         Log.d(this, "stopDtmfTone %s", callId);
         findConnectionForAction(callId, "stopDtmfTone").stopDtmfTone();
     }

     @Override
     public final void onAudioStateChanged(String callId, CallAudioState audioState) {
         Log.d(this, "onAudioStateChanged %s %s", callId, audioState);
         findConnectionForAction(callId, "onAudioStateChanged").setAudioState(audioState);
     }

     /** @hide */
     @Override
     public final void conference(final String conferenceCallId, String callId) {
         Log.d(this, "conference %s, %s", conferenceCallId, callId);

         Connection connection = findConnectionForAction(callId, "conference");
         if (connection == NULL_CONNECTION) {
             Log.w(this, "Connection missing in conference request %s.", callId);
             return;
         }

         onCreateConferenceConnection(conferenceCallId, connection,
                 new Response<String, Connection>() {
                     /** ${inheritDoc} */
                     @Override
                     public void onResult(String ignored, Connection... result) {
                         Log.d(this, "onCreateConference.Response %s", (Object[]) result);
                         if (result != null && result.length == 1) {
                             Connection conferenceConnection = result[0];
                             if (!mIdByConnection.containsKey(conferenceConnection)) {
                                 Log.v(this, "sending new conference call %s", conferenceCallId);
                                 getAdapter().addConferenceCall(conferenceCallId);
                                 addConnection(conferenceCallId, conferenceConnection);
                             }
                         }
                     }

                     /** ${inheritDoc} */
                     @Override
                     public void onError(String request, int code, String reason) {
                         // no-op
                     }
                 });
     }

     /** @hide */
     @Override
     public final void splitFromConference(String callId) {
         Log.d(this, "splitFromConference(%s)", callId);

         Connection connection = findConnectionForAction(callId, "splitFromConference");
         if (connection == NULL_CONNECTION) {
             Log.w(this, "Connection missing in conference request %s.", callId);
             return;
         }

         // TODO(santoscordon): Find existing conference call and invoke split(connection).
     }

     @Override
     public final void onPostDialContinue(String callId, boolean proceed) {
         Log.d(this, "onPostDialContinue(%s)", callId);

         Connection connection = findConnectionForAction(callId, "onPostDialContinue");
         if (connection == NULL_CONNECTION) {
             Log.w(this, "Connection missing in post-dial request %s.", callId);
             return;
         }
         connection.onPostDialContinue(proceed);
     }

     @Override
     public final void onPostDialWait(Connection conn, String remaining) {
         Log.d(this, "onPostDialWait(%s, %s)", conn, remaining);

         getAdapter().onPostDialWait(mIdByConnection.get(conn), remaining);
     }

     /**
      * Returns all connections currently associated with this connection service.
      */
     public Collection<Connection> getAllConnections() {
         return mConnectionById.values();
     }

     /**
      * Find a set of Subscriptions matching a given handle (e.g. phone number).
      *
      * @param handle A handle (e.g. phone number) with which to connect.
      * @param callback A callback for providing the result.
      */
     public void onFindSubscriptions(
             Uri handle,
             Response<Uri, Subscription> callback) {}

     /**
      * Create a Connection given a request.
      *
      * @param request Data encapsulating details of the desired Connection.
      * @param callback A callback for providing the result.
      */
     public void onCreateConnections(
             ConnectionRequest request,
             Response<ConnectionRequest, Connection> callback) {}

     /**
      * Returns a new or existing conference connection when the the user elects to convert the
      * specified connection into a conference call. The specified connection can be any connection
      * which had previously specified itself as conference-capable including both simple connections
      * and connections previously returned from this method.
      *
      * @param connection The connection from which the user opted to start a conference call.
      * @param token The token to be passed into the response callback.
      * @param callback The callback for providing the potentially-new conference connection.
      */
     public void onCreateConferenceConnection(
             String token,
             Connection connection,
             Response<String, Connection> callback) {}

     /**
      * Create a Connection to match an incoming connection notification.
      *
      * @param request Data encapsulating details of the desired Connection.
      * @param callback A callback for providing the result.
      */
     public void onCreateIncomingConnection(
             ConnectionRequest request,
             Response<ConnectionRequest, Connection> callback) {}

     /**
      * Notifies that a connection has been added to this connection service and sent to Telecomm.
      *
      * @param connection The connection which was added.
      */
     public void onConnectionAdded(Connection connection) {}

     /**
      * Notified that a connection has been removed from this connection service.
      *
      * @param connection The connection which was removed.
      */
     public void onConnectionRemoved(Connection connection) {}

     static String toLogSafePhoneNumber(String number) {
         // For unknown number, log empty string.
         if (number == null) {
             return "";
         }

         if (PII_DEBUG) {
             // When PII_DEBUG is true we emit PII.
             return number;
         }

         // Do exactly same thing as Uri#toSafeString() does, which will enable us to compare
         // sanitized phone numbers.
         StringBuilder builder = new StringBuilder();
         for (int i = 0; i < number.length(); i++) {
             char c = number.charAt(i);
             if (c == '-' || c == '@' || c == '.') {
                 builder.append(c);
             } else {
                 builder.append('x');
             }
         }
         return builder.toString();
     }

     private CallState connectionStateToCallState(int connectionState) {
         switch (connectionState) {
             case Connection.State.NEW:
                 return CallState.NEW;
             case Connection.State.RINGING:
                 return CallState.RINGING;
             case Connection.State.DIALING:
                 return CallState.DIALING;
             case Connection.State.ACTIVE:
                 return CallState.ACTIVE;
             case Connection.State.HOLDING:
                 return CallState.ON_HOLD;
             case Connection.State.DISCONNECTED:
                 return CallState.DISCONNECTED;
             default:
                 Log.wtf(this, "Unknown Connection.State %d", connectionState);
                 return CallState.NEW;
         }
     }

     private void addConnection(String callId, Connection connection) {
         mConnectionById.put(callId, connection);
         mIdByConnection.put(connection, callId);
         connection.addConnectionListener(mConnectionListener);
         onConnectionAdded(connection);
     }

     private void removeConnection(Connection connection) {
         connection.removeConnectionListener(mConnectionListener);
         mConnectionById.remove(mIdByConnection.get(connection));
         mIdByConnection.remove(connection);
         onConnectionRemoved(connection);
     }

     private Connection findConnectionForAction(String callId, String action) {
         if (mConnectionById.containsKey(callId)) {
             return mConnectionById.get(callId);
         }
         Log.w(this, "%s - Cannot find Connection %s", action, callId);
         return NULL_CONNECTION;
     }
 }
	/*
	* Copyright (C) 2014 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package android.telecomm;

	import android.net.Uri;
	import android.os.Bundle;
	import android.telephony.DisconnectCause;

	import android.os.SystemClock;

	import java.util.Collection;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.LinkedList;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;

	/**
	* A {@link android.app.Service} that provides telephone connections to
	* processes running on an Android device.
	*/
	public abstract class ConnectionService extends CallService {
	// Flag controlling whether PII is emitted into the logs
	private static final boolean PII_DEBUG = Log.isLoggable(android.util.Log.DEBUG);
	private static final Connection NULL_CONNECTION = new Connection() {};

	// Mappings from Connections to IDs as understood by the current CallService implementation
	private final Map<String, Connection> mConnectionById = new HashMap<>();
	private final Map<Connection, String> mIdByConnection = new HashMap<>();

	private final Connection.Listener mConnectionListener = new Connection.Listener() {
	@Override
	public void onStateChanged(Connection c, int state) {
	String id = mIdByConnection.get(c);
	Log.d(this, "Adapter set state %s %s", id, Connection.stateToString(state));
	switch (state) {
	case Connection.State.ACTIVE:
	getAdapter().setActive(id);
	break;
	case Connection.State.DIALING:
	getAdapter().setDialing(id);
	break;
	case Connection.State.DISCONNECTED:
	// Handled in onDisconnected()
	break;
	case Connection.State.HOLDING:
	getAdapter().setOnHold(id);
	break;
	case Connection.State.NEW:
	// Nothing to tell Telecomm
	break;
	case Connection.State.RINGING:
	getAdapter().setRinging(id);
	break;
	}
	}

	@Override
	public void onDisconnected(Connection c, int cause, String message) {
	String id = mIdByConnection.get(c);
	Log.d(this, "Adapter set disconnected %d %s", cause, message);
	getAdapter().setDisconnected(id, cause, message);
	}

	@Override
	public void onHandleChanged(Connection c, Uri newHandle) {
	// TODO: Unsupported yet
	}

	@Override
	public void onAudioStateChanged(Connection c, CallAudioState state) {
	// TODO: Unsupported yet
	}

	@Override
	public void onSignalChanged(Connection c, Bundle details) {
	// TODO: Unsupported yet
	}

	@Override
	public void onDestroyed(Connection c) {
	removeConnection(c);
	}

	@Override
	public void onRequestingRingback(Connection c, boolean ringback) {
	String id = mIdByConnection.get(c);
	Log.d(this, "Adapter onRingback %b", ringback);
	getAdapter().setRequestingRingback(id, ringback);
	}

	@Override
	public void onConferenceCapableChanged(Connection c, boolean isConferenceCapable) {
	String id = mIdByConnection.get(c);
	getAdapter().setCanConference(id, isConferenceCapable);
	}

	/** ${inheritDoc} */
	@Override
	public void onParentConnectionChanged(Connection c, Connection parent) {
	String id = mIdByConnection.get(c);
	String parentId = parent == null ? null : mIdByConnection.get(parent);
	getAdapter().setIsConferenced(id, parentId);
	}
	};

	@Override
	public final void isCompatibleWith(final CallInfo callInfo) {
	Log.d(this, "isCompatibleWith %s", callInfo);
	onFindSubscriptions(
	callInfo.getHandle(),
	new Response<Uri, Subscription>() {
	@Override
	public void onResult(Uri handle, Subscription... result) {
	boolean isCompatible = result.length > 0;
	Log.d(this, "adapter setIsCompatibleWith ");
	getAdapter().setIsCompatibleWith(callInfo.getId(), isCompatible);
	}

	@Override
	public void onError(Uri handle, int code, String msg) {
	Log.w(this, "Error in onFindSubscriptions %s %d %s", handle, code, msg);
	getAdapter().setIsCompatibleWith(callInfo.getId(), false);
	}
	}
	);
	}

	@Override
	public final void call(final CallInfo callInfo) {
	Log.d(this, "call %s", callInfo);
	onCreateConnections(
	new ConnectionRequest(
	callInfo.getId(),
	callInfo.getHandle(),
	callInfo.getExtras()),
	new Response<ConnectionRequest, Connection>() {
	@Override
	public void onResult(ConnectionRequest request, Connection... result) {
	if (result != null && result.length != 1) {
	Log.d(this, "adapter handleFailedOutgoingCall %s", callInfo);
	getAdapter().handleFailedOutgoingCall(
	request,
	DisconnectCause.ERROR_UNSPECIFIED,
	"Created " + result.length + " Connections, expected 1");
	for (Connection c : result) {
	c.abort();
	}
	} else {
	Log.d(this, "adapter handleSuccessfulOutgoingCall %s",
	callInfo.getId());
	getAdapter().handleSuccessfulOutgoingCall(callInfo.getId());
	addConnection(callInfo.getId(), result[0]);
	}
	}

	@Override
	public void onError(ConnectionRequest request, int code, String msg) {
	getAdapter().handleFailedOutgoingCall(request, code, msg);
	}
	}
	);
	}

	@Override
	public final void abort(String callId) {
	Log.d(this, "abort %s", callId);
	findConnectionForAction(callId, "abort").abort();
	}

	@Override
	public final void setIncomingCallId(final String callId, Bundle extras) {
	Log.d(this, "setIncomingCallId %s %s", callId, extras);
	onCreateIncomingConnection(
	new ConnectionRequest(
	callId,
	null, // TODO: Can we obtain this from "extras"?
	extras),
	new Response<ConnectionRequest, Connection>() {
	@Override
	public void onResult(ConnectionRequest request, Connection... result) {
	if (result != null && result.length != 1) {
	Log.d(this, "adapter handleFailedOutgoingCall %s", callId);
	getAdapter().handleFailedOutgoingCall(
	request,
	DisconnectCause.ERROR_UNSPECIFIED,
	"Created " + result.length + " Connections, expected 1");
	for (Connection c : result) {
	c.abort();
	}
	} else {
	addConnection(callId, result[0]);
	Log.d(this, "adapter notifyIncomingCall %s", callId);
	// TODO: Uri.EMPTY is because CallInfo crashes when Parceled with a
	// null URI ... need to fix that at its cause!
	getAdapter().notifyIncomingCall(new CallInfo(
	callId,
	connectionStateToCallState(result[0].getState()),
	request.getHandle() /* result[0].getHandle() == null
	? Uri.EMPTY : result[0].getHandle() */));
	}
	}

	@Override
	public void onError(ConnectionRequest request, int code, String msg) {
	Log.d(this, "adapter failed setIncomingCallId %s %d %s",
	request, code, msg);
	}
	}
	);
	}

	@Override
	public final void answer(String callId) {
	Log.d(this, "answer %s", callId);
	findConnectionForAction(callId, "answer").answer();
	}

	@Override
	public final void reject(String callId) {
	Log.d(this, "reject %s", callId);
	findConnectionForAction(callId, "reject").reject();
	}

	@Override
	public final void disconnect(String callId) {
	Log.d(this, "disconnect %s", callId);
	findConnectionForAction(callId, "disconnect").disconnect();
	}

	@Override
	public final void hold(String callId) {
	Log.d(this, "hold %s", callId);
	findConnectionForAction(callId, "hold").hold();
	}

	@Override
	public final void unhold(String callId) {
	Log.d(this, "unhold %s", callId);
	findConnectionForAction(callId, "unhold").unhold();
	}

	@Override
	public final void playDtmfTone(String callId, char digit) {
	Log.d(this, "playDtmfTone %s %c", callId, digit);
	findConnectionForAction(callId, "playDtmfTone").playDtmfTone(digit);
	}

	@Override
	public final void stopDtmfTone(String callId) {
	Log.d(this, "stopDtmfTone %s", callId);
	findConnectionForAction(callId, "stopDtmfTone").stopDtmfTone();
	}

	@Override
	public final void onAudioStateChanged(String callId, CallAudioState audioState) {
	Log.d(this, "onAudioStateChanged %s %s", callId, audioState);
	findConnectionForAction(callId, "onAudioStateChanged").setAudioState(audioState);
	}

	/** @hide */
	@Override
	public final void conference(final String conferenceCallId, String callId) {
	Log.d(this, "conference %s, %s", conferenceCallId, callId);

	Connection connection = findConnectionForAction(callId, "conference");
	if (connection == NULL_CONNECTION) {
	Log.w(this, "Connection missing in conference request %s.", callId);
	return;
	}

	onCreateConferenceConnection(conferenceCallId, connection,
	new Response<String, Connection>() {
	/** ${inheritDoc} */
	@Override
	public void onResult(String ignored, Connection... result) {
	Log.d(this, "onCreateConference.Response %s", (Object[]) result);
	if (result != null && result.length == 1) {
	Connection conferenceConnection = result[0];
	if (!mIdByConnection.containsKey(conferenceConnection)) {
	Log.v(this, "sending new conference call %s", conferenceCallId);
	getAdapter().addConferenceCall(conferenceCallId);
	addConnection(conferenceCallId, conferenceConnection);
	}
	}
	}

	/** ${inheritDoc} */
	@Override
	public void onError(String request, int code, String reason) {
	// no-op
	}
	});
	}

	/** @hide */
	@Override
	public final void splitFromConference(String callId) {
	Log.d(this, "splitFromConference(%s)", callId);

	Connection connection = findConnectionForAction(callId, "splitFromConference");
	if (connection == NULL_CONNECTION) {
	Log.w(this, "Connection missing in conference request %s.", callId);
	return;
	}

	// TODO(santoscordon): Find existing conference call and invoke split(connection).
	}

	@Override
	public final void onPostDialContinue(String callId, boolean proceed) {
	Log.d(this, "onPostDialContinue(%s)", callId);

	Connection connection = findConnectionForAction(callId, "onPostDialContinue");
	if (connection == NULL_CONNECTION) {
	Log.w(this, "Connection missing in post-dial request %s.", callId);
	return;
	}
	connection.onPostDialContinue(proceed);
	}

	@Override
	public final void onPostDialWait(Connection conn, String remaining) {
	Log.d(this, "onPostDialWait(%s, %s)", conn, remaining);

	getAdapter().onPostDialWait(mIdByConnection.get(conn), remaining);
	}

	/**
	* Returns all connections currently associated with this connection service.
	*/
	public Collection<Connection> getAllConnections() {
	return mConnectionById.values();
	}

	/**
	* Find a set of Subscriptions matching a given handle (e.g. phone number).
	*
	* @param handle A handle (e.g. phone number) with which to connect.
	* @param callback A callback for providing the result.
	*/
	public void onFindSubscriptions(
	Uri handle,
	Response<Uri, Subscription> callback) {}

	/**
	* Create a Connection given a request.
	*
	* @param request Data encapsulating details of the desired Connection.
	* @param callback A callback for providing the result.
	*/
	public void onCreateConnections(
	ConnectionRequest request,
	Response<ConnectionRequest, Connection> callback) {}

	/**
	* Returns a new or existing conference connection when the the user elects to convert the
	* specified connection into a conference call. The specified connection can be any connection
	* which had previously specified itself as conference-capable including both simple connections
	* and connections previously returned from this method.
	*
	* @param connection The connection from which the user opted to start a conference call.
	* @param token The token to be passed into the response callback.
	* @param callback The callback for providing the potentially-new conference connection.
	*/
	public void onCreateConferenceConnection(
	String token,
	Connection connection,
	Response<String, Connection> callback) {}

	/**
	* Create a Connection to match an incoming connection notification.
	*
	* @param request Data encapsulating details of the desired Connection.
	* @param callback A callback for providing the result.
	*/
	public void onCreateIncomingConnection(
	ConnectionRequest request,
	Response<ConnectionRequest, Connection> callback) {}

	/**
	* Notifies that a connection has been added to this connection service and sent to Telecomm.
	*
	* @param connection The connection which was added.
	*/
	public void onConnectionAdded(Connection connection) {}

	/**
	* Notified that a connection has been removed from this connection service.
	*
	* @param connection The connection which was removed.
	*/
	public void onConnectionRemoved(Connection connection) {}

	static String toLogSafePhoneNumber(String number) {
	// For unknown number, log empty string.
	if (number == null) {
	return "";
	}

	if (PII_DEBUG) {
	// When PII_DEBUG is true we emit PII.
	return number;
	}

	// Do exactly same thing as Uri#toSafeString() does, which will enable us to compare
	// sanitized phone numbers.
	StringBuilder builder = new StringBuilder();
	for (int i = 0; i < number.length(); i++) {
	char c = number.charAt(i);
	if (c == '-' \|\| c == '@' \|\| c == '.') {
	builder.append(c);
	} else {
	builder.append('x');
	}
	}
	return builder.toString();
	}

	private CallState connectionStateToCallState(int connectionState) {
	switch (connectionState) {
	case Connection.State.NEW:
	return CallState.NEW;
	case Connection.State.RINGING:
	return CallState.RINGING;
	case Connection.State.DIALING:
	return CallState.DIALING;
	case Connection.State.ACTIVE:
	return CallState.ACTIVE;
	case Connection.State.HOLDING:
	return CallState.ON_HOLD;
	case Connection.State.DISCONNECTED:
	return CallState.DISCONNECTED;
	default:
	Log.wtf(this, "Unknown Connection.State %d", connectionState);
	return CallState.NEW;
	}
	}

	private void addConnection(String callId, Connection connection) {
	mConnectionById.put(callId, connection);
	mIdByConnection.put(connection, callId);
	connection.addConnectionListener(mConnectionListener);
	onConnectionAdded(connection);
	}

	private void removeConnection(Connection connection) {
	connection.removeConnectionListener(mConnectionListener);
	mConnectionById.remove(mIdByConnection.get(connection));
	mIdByConnection.remove(connection);
	onConnectionRemoved(connection);
	}

	private Connection findConnectionForAction(String callId, String action) {
	if (mConnectionById.containsKey(callId)) {
	return mConnectionById.get(callId);
	}
	Log.w(this, "%s - Cannot find Connection %s", action, callId);
	return NULL_CONNECTION;
	}
	}