| /* |
| * 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.telecom; |
| |
| import android.net.Uri; |
| import android.os.Bundle; |
| import android.os.IBinder; |
| import android.os.IBinder.DeathRecipient; |
| import android.os.RemoteException; |
| |
| import com.android.internal.telecom.IConnectionService; |
| import com.android.internal.telecom.IConnectionServiceAdapter; |
| import com.android.internal.telecom.IVideoProvider; |
| import com.android.internal.telecom.RemoteServiceCallback; |
| |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.List; |
| import java.util.UUID; |
| |
| /** |
| * Remote connection service which other connection services can use to place calls on their behalf. |
| * |
| * @hide |
| */ |
| final class RemoteConnectionService { |
| |
| // Note: Casting null to avoid ambiguous constructor reference. |
| private static final RemoteConnection NULL_CONNECTION = |
| new RemoteConnection("NULL", null, (ConnectionRequest) null); |
| |
| private static final RemoteConference NULL_CONFERENCE = |
| new RemoteConference("NULL", null); |
| |
| private final IConnectionServiceAdapter mServantDelegate = new IConnectionServiceAdapter() { |
| @Override |
| public void handleCreateConnectionComplete( |
| String id, |
| ConnectionRequest request, |
| ParcelableConnection parcel) { |
| RemoteConnection connection = |
| findConnectionForAction(id, "handleCreateConnectionSuccessful"); |
| if (connection != NULL_CONNECTION && mPendingConnections.contains(connection)) { |
| mPendingConnections.remove(connection); |
| // Unconditionally initialize the connection ... |
| connection.setConnectionCapabilities(parcel.getConnectionCapabilities()); |
| if (parcel.getHandle() != null |
| || parcel.getState() != Connection.STATE_DISCONNECTED) { |
| connection.setAddress(parcel.getHandle(), parcel.getHandlePresentation()); |
| } |
| if (parcel.getCallerDisplayName() != null |
| || parcel.getState() != Connection.STATE_DISCONNECTED) { |
| connection.setCallerDisplayName( |
| parcel.getCallerDisplayName(), |
| parcel.getCallerDisplayNamePresentation()); |
| } |
| // Set state after handle so that the client can identify the connection. |
| if (parcel.getState() == Connection.STATE_DISCONNECTED) { |
| connection.setDisconnected(parcel.getDisconnectCause()); |
| } else { |
| connection.setState(parcel.getState()); |
| } |
| List<RemoteConnection> conferenceable = new ArrayList<>(); |
| for (String confId : parcel.getConferenceableConnectionIds()) { |
| if (mConnectionById.containsKey(confId)) { |
| conferenceable.add(mConnectionById.get(confId)); |
| } |
| } |
| connection.setConferenceableConnections(conferenceable); |
| connection.setVideoState(parcel.getVideoState()); |
| if (connection.getState() == Connection.STATE_DISCONNECTED) { |
| // ... then, if it was created in a disconnected state, that indicates |
| // failure on the providing end, so immediately mark it destroyed |
| connection.setDestroyed(); |
| } |
| } |
| } |
| |
| @Override |
| public void setActive(String callId) { |
| if (mConnectionById.containsKey(callId)) { |
| findConnectionForAction(callId, "setActive") |
| .setState(Connection.STATE_ACTIVE); |
| } else { |
| findConferenceForAction(callId, "setActive") |
| .setState(Connection.STATE_ACTIVE); |
| } |
| } |
| |
| @Override |
| public void setRinging(String callId) { |
| findConnectionForAction(callId, "setRinging") |
| .setState(Connection.STATE_RINGING); |
| } |
| |
| @Override |
| public void setDialing(String callId) { |
| findConnectionForAction(callId, "setDialing") |
| .setState(Connection.STATE_DIALING); |
| } |
| |
| @Override |
| public void setDisconnected(String callId, DisconnectCause disconnectCause) { |
| if (mConnectionById.containsKey(callId)) { |
| findConnectionForAction(callId, "setDisconnected") |
| .setDisconnected(disconnectCause); |
| } else { |
| findConferenceForAction(callId, "setDisconnected") |
| .setDisconnected(disconnectCause); |
| } |
| } |
| |
| @Override |
| public void setOnHold(String callId) { |
| if (mConnectionById.containsKey(callId)) { |
| findConnectionForAction(callId, "setOnHold") |
| .setState(Connection.STATE_HOLDING); |
| } else { |
| findConferenceForAction(callId, "setOnHold") |
| .setState(Connection.STATE_HOLDING); |
| } |
| } |
| |
| @Override |
| public void setRingbackRequested(String callId, boolean ringing) { |
| findConnectionForAction(callId, "setRingbackRequested") |
| .setRingbackRequested(ringing); |
| } |
| |
| @Override |
| public void setConnectionCapabilities(String callId, int connectionCapabilities) { |
| if (mConnectionById.containsKey(callId)) { |
| findConnectionForAction(callId, "setConnectionCapabilities") |
| .setConnectionCapabilities(connectionCapabilities); |
| } else { |
| findConferenceForAction(callId, "setConnectionCapabilities") |
| .setConnectionCapabilities(connectionCapabilities); |
| } |
| } |
| |
| @Override |
| public void setIsConferenced(String callId, String conferenceCallId) { |
| // Note: callId should not be null; conferenceCallId may be null |
| RemoteConnection connection = |
| findConnectionForAction(callId, "setIsConferenced"); |
| if (connection != NULL_CONNECTION) { |
| if (conferenceCallId == null) { |
| // 'connection' is being split from its conference |
| if (connection.getConference() != null) { |
| connection.getConference().removeConnection(connection); |
| } |
| } else { |
| RemoteConference conference = |
| findConferenceForAction(conferenceCallId, "setIsConferenced"); |
| if (conference != NULL_CONFERENCE) { |
| conference.addConnection(connection); |
| } |
| } |
| } |
| } |
| |
| @Override |
| public void setConferenceMergeFailed(String callId) { |
| // Nothing to do here. |
| // The event has already been handled and there is no state to update |
| // in the underlying connection or conference objects |
| } |
| |
| @Override |
| public void addConferenceCall( |
| final String callId, |
| ParcelableConference parcel) { |
| RemoteConference conference = new RemoteConference(callId, |
| mOutgoingConnectionServiceRpc); |
| |
| for (String id : parcel.getConnectionIds()) { |
| RemoteConnection c = mConnectionById.get(id); |
| if (c != null) { |
| conference.addConnection(c); |
| } |
| } |
| |
| if (conference.getConnections().size() == 0) { |
| // A conference was created, but none of its connections are ones that have been |
| // created by, and therefore being tracked by, this remote connection service. It |
| // is of no interest to us. |
| return; |
| } |
| |
| conference.setState(parcel.getState()); |
| conference.setConnectionCapabilities(parcel.getConnectionCapabilities()); |
| mConferenceById.put(callId, conference); |
| conference.registerCallback(new RemoteConference.Callback() { |
| @Override |
| public void onDestroyed(RemoteConference c) { |
| mConferenceById.remove(callId); |
| maybeDisconnectAdapter(); |
| } |
| }); |
| |
| mOurConnectionServiceImpl.addRemoteConference(conference); |
| } |
| |
| @Override |
| public void removeCall(String callId) { |
| if (mConnectionById.containsKey(callId)) { |
| findConnectionForAction(callId, "removeCall") |
| .setDestroyed(); |
| } else { |
| findConferenceForAction(callId, "removeCall") |
| .setDestroyed(); |
| } |
| } |
| |
| @Override |
| public void onPostDialWait(String callId, String remaining) { |
| findConnectionForAction(callId, "onPostDialWait") |
| .setPostDialWait(remaining); |
| } |
| |
| @Override |
| public void onPostDialChar(String callId, char nextChar) { |
| findConnectionForAction(callId, "onPostDialChar") |
| .onPostDialChar(nextChar); |
| } |
| |
| @Override |
| public void queryRemoteConnectionServices(RemoteServiceCallback callback) { |
| // Not supported from remote connection service. |
| } |
| |
| @Override |
| public void setVideoProvider(String callId, IVideoProvider videoProvider) { |
| RemoteConnection.VideoProvider remoteVideoProvider = null; |
| if (videoProvider != null) { |
| remoteVideoProvider = new RemoteConnection.VideoProvider(videoProvider); |
| } |
| findConnectionForAction(callId, "setVideoProvider") |
| .setVideoProvider(remoteVideoProvider); |
| } |
| |
| @Override |
| public void setVideoState(String callId, int videoState) { |
| findConnectionForAction(callId, "setVideoState") |
| .setVideoState(videoState); |
| } |
| |
| @Override |
| public void setIsVoipAudioMode(String callId, boolean isVoip) { |
| findConnectionForAction(callId, "setIsVoipAudioMode") |
| .setIsVoipAudioMode(isVoip); |
| } |
| |
| @Override |
| public void setStatusHints(String callId, StatusHints statusHints) { |
| findConnectionForAction(callId, "setStatusHints") |
| .setStatusHints(statusHints); |
| } |
| |
| @Override |
| public void setAddress(String callId, Uri address, int presentation) { |
| findConnectionForAction(callId, "setAddress") |
| .setAddress(address, presentation); |
| } |
| |
| @Override |
| public void setCallerDisplayName(String callId, String callerDisplayName, |
| int presentation) { |
| findConnectionForAction(callId, "setCallerDisplayName") |
| .setCallerDisplayName(callerDisplayName, presentation); |
| } |
| |
| @Override |
| public IBinder asBinder() { |
| throw new UnsupportedOperationException(); |
| } |
| |
| @Override |
| public final void setConferenceableConnections( |
| String callId, List<String> conferenceableConnectionIds) { |
| List<RemoteConnection> conferenceable = new ArrayList<>(); |
| for (String id : conferenceableConnectionIds) { |
| if (mConnectionById.containsKey(id)) { |
| conferenceable.add(mConnectionById.get(id)); |
| } |
| } |
| |
| if (hasConnection(callId)) { |
| findConnectionForAction(callId, "setConferenceableConnections") |
| .setConferenceableConnections(conferenceable); |
| } else { |
| findConferenceForAction(callId, "setConferenceableConnections") |
| .setConferenceableConnections(conferenceable); |
| } |
| } |
| |
| @Override |
| public void addExistingConnection(String callId, ParcelableConnection connection) { |
| // TODO: add contents of this method |
| RemoteConnection remoteConnction = new RemoteConnection(callId, |
| mOutgoingConnectionServiceRpc, connection); |
| |
| mOurConnectionServiceImpl.addRemoteExistingConnection(remoteConnction); |
| } |
| |
| @Override |
| public void setExtras(String callId, Bundle extras) { |
| if (mConnectionById.containsKey(callId)) { |
| findConnectionForAction(callId, "setExtras") |
| .setExtras(extras); |
| } else { |
| findConferenceForAction(callId, "setExtras") |
| .setExtras(extras); |
| } |
| } |
| |
| @Override |
| public void onConnectionEvent(String callId, String event, Bundle extras) { |
| if (mConnectionById.containsKey(callId)) { |
| findConnectionForAction(callId, "onConnectionEvent").onConnectionEvent(event, |
| extras); |
| } |
| } |
| }; |
| |
| private final ConnectionServiceAdapterServant mServant = |
| new ConnectionServiceAdapterServant(mServantDelegate); |
| |
| private final DeathRecipient mDeathRecipient = new DeathRecipient() { |
| @Override |
| public void binderDied() { |
| for (RemoteConnection c : mConnectionById.values()) { |
| c.setDestroyed(); |
| } |
| for (RemoteConference c : mConferenceById.values()) { |
| c.setDestroyed(); |
| } |
| mConnectionById.clear(); |
| mConferenceById.clear(); |
| mPendingConnections.clear(); |
| mOutgoingConnectionServiceRpc.asBinder().unlinkToDeath(mDeathRecipient, 0); |
| } |
| }; |
| |
| private final IConnectionService mOutgoingConnectionServiceRpc; |
| private final ConnectionService mOurConnectionServiceImpl; |
| private final Map<String, RemoteConnection> mConnectionById = new HashMap<>(); |
| private final Map<String, RemoteConference> mConferenceById = new HashMap<>(); |
| private final Set<RemoteConnection> mPendingConnections = new HashSet<>(); |
| |
| RemoteConnectionService( |
| IConnectionService outgoingConnectionServiceRpc, |
| ConnectionService ourConnectionServiceImpl) throws RemoteException { |
| mOutgoingConnectionServiceRpc = outgoingConnectionServiceRpc; |
| mOutgoingConnectionServiceRpc.asBinder().linkToDeath(mDeathRecipient, 0); |
| mOurConnectionServiceImpl = ourConnectionServiceImpl; |
| } |
| |
| @Override |
| public String toString() { |
| return "[RemoteCS - " + mOutgoingConnectionServiceRpc.asBinder().toString() + "]"; |
| } |
| |
| final RemoteConnection createRemoteConnection( |
| PhoneAccountHandle connectionManagerPhoneAccount, |
| ConnectionRequest request, |
| boolean isIncoming) { |
| final String id = UUID.randomUUID().toString(); |
| final ConnectionRequest newRequest = new ConnectionRequest( |
| request.getAccountHandle(), |
| request.getAddress(), |
| request.getExtras(), |
| request.getVideoState()); |
| try { |
| if (mConnectionById.isEmpty()) { |
| mOutgoingConnectionServiceRpc.addConnectionServiceAdapter(mServant.getStub()); |
| } |
| RemoteConnection connection = |
| new RemoteConnection(id, mOutgoingConnectionServiceRpc, newRequest); |
| mPendingConnections.add(connection); |
| mConnectionById.put(id, connection); |
| mOutgoingConnectionServiceRpc.createConnection( |
| connectionManagerPhoneAccount, |
| id, |
| newRequest, |
| isIncoming, |
| false /* isUnknownCall */); |
| connection.registerCallback(new RemoteConnection.Callback() { |
| @Override |
| public void onDestroyed(RemoteConnection connection) { |
| mConnectionById.remove(id); |
| maybeDisconnectAdapter(); |
| } |
| }); |
| return connection; |
| } catch (RemoteException e) { |
| return RemoteConnection.failure( |
| new DisconnectCause(DisconnectCause.ERROR, e.toString())); |
| } |
| } |
| |
| private boolean hasConnection(String callId) { |
| return mConnectionById.containsKey(callId); |
| } |
| |
| private RemoteConnection 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; |
| } |
| |
| private RemoteConference findConferenceForAction( |
| String callId, String action) { |
| if (mConferenceById.containsKey(callId)) { |
| return mConferenceById.get(callId); |
| } |
| Log.w(this, "%s - Cannot find Conference %s", action, callId); |
| return NULL_CONFERENCE; |
| } |
| |
| private void maybeDisconnectAdapter() { |
| if (mConnectionById.isEmpty() && mConferenceById.isEmpty()) { |
| try { |
| mOutgoingConnectionServiceRpc.removeConnectionServiceAdapter(mServant.getStub()); |
| } catch (RemoteException e) { |
| } |
| } |
| } |
| } |