1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
|
/*
* 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 com.android.services.telephony;
import android.content.Context;
import android.content.res.Resources;
import android.os.Bundle;
import android.telecom.Conference;
import android.telecom.Connection;
import android.telecom.PhoneAccountHandle;
import android.telephony.CarrierConfigManager;
import com.android.internal.telephony.Call;
import com.android.internal.telephony.CallStateException;
import com.android.phone.PhoneGlobals;
import com.android.phone.common.R;
import java.util.List;
/**
* CDMA-based conference call.
*/
public class CdmaConference extends Conference {
private int mCapabilities;
public CdmaConference(PhoneAccountHandle phoneAccount) {
super(phoneAccount);
setActive();
}
public void updateCapabilities(int capabilities) {
capabilities |= Connection.CAPABILITY_MUTE | Connection.CAPABILITY_GENERIC_CONFERENCE;
setConnectionCapabilities(capabilities);
}
/**
* Invoked when the Conference and all it's {@link Connection}s should be disconnected.
*/
@Override
public void onDisconnect() {
Call call = getOriginalCall();
if (call != null) {
Log.d(this, "Found multiparty call to hangup for conference.");
try {
call.hangup();
} catch (CallStateException e) {
Log.e(this, e, "Exception thrown trying to hangup conference");
}
}
}
@Override
public void onSeparate(Connection connection) {
Log.e(this, new Exception(), "Separate not supported for CDMA conference call.");
}
@Override
public void onHold() {
Log.e(this, new Exception(), "Hold not supported for CDMA conference call.");
}
/**
* Invoked when the conference should be moved from hold to active.
*/
@Override
public void onUnhold() {
Log.e(this, new Exception(), "Unhold not supported for CDMA conference call.");
}
@Override
public void onMerge() {
Log.i(this, "Merging CDMA conference call.");
// Can only merge once
mCapabilities &= ~Connection.CAPABILITY_MERGE_CONFERENCE;
// Once merged, swap is enabled.
if (isSwapSupportedAfterMerge()){
mCapabilities |= Connection.CAPABILITY_SWAP_CONFERENCE;
}
updateCapabilities(mCapabilities);
sendFlash();
}
@Override
public void onPlayDtmfTone(char c) {
final CdmaConnection connection = getFirstConnection();
if (connection != null) {
connection.onPlayDtmfTone(c);
} else {
Log.w(this, "No CDMA connection found while trying to play dtmf tone.");
}
}
@Override
public void onStopDtmfTone() {
final CdmaConnection connection = getFirstConnection();
if (connection != null) {
connection.onStopDtmfTone();
} else {
Log.w(this, "No CDMA connection found while trying to stop dtmf tone.");
}
}
@Override
public void onSwap() {
Log.i(this, "Swapping CDMA conference call.");
sendFlash();
}
private void sendFlash() {
Call call = getOriginalCall();
if (call != null) {
try {
// For CDMA calls, this just sends a flash command.
call.getPhone().switchHoldingAndActive();
} catch (CallStateException e) {
Log.e(this, e, "Error while trying to send flash command.");
}
}
}
private Call getMultipartyCallForConnection(Connection connection) {
com.android.internal.telephony.Connection radioConnection =
getOriginalConnection(connection);
if (radioConnection != null) {
Call call = radioConnection.getCall();
if (call != null && call.isMultiparty()) {
return call;
}
}
return null;
}
private Call getOriginalCall() {
List<Connection> connections = getConnections();
if (!connections.isEmpty()) {
com.android.internal.telephony.Connection originalConnection =
getOriginalConnection(connections.get(0));
if (originalConnection != null) {
return originalConnection.getCall();
}
}
return null;
}
/**
* Return whether network support swap after merge conference call.
*
* @return true to support, false not support.
*/
private final boolean isSwapSupportedAfterMerge()
{
boolean supportSwapAfterMerge = true;
Context context = PhoneGlobals.getInstance();
if (context != null) {
CarrierConfigManager configManager = (CarrierConfigManager) context.getSystemService(
Context.CARRIER_CONFIG_SERVICE);
Bundle b = configManager.getConfig();
if (b != null) {
supportSwapAfterMerge = b.getBoolean(CarrierConfigManager.BOOL_SUPPORT_SWAP_AFTER_MERGE);
Log.d(this, "Current network support swap after call merged capability is "
+ supportSwapAfterMerge);
}
}
return supportSwapAfterMerge;
}
private com.android.internal.telephony.Connection getOriginalConnection(Connection connection) {
if (connection instanceof CdmaConnection) {
return ((CdmaConnection) connection).getOriginalConnection();
} else {
Log.e(this, null, "Non CDMA connection found in a CDMA conference");
return null;
}
}
private CdmaConnection getFirstConnection() {
final List<Connection> connections = getConnections();
if (connections.isEmpty()) {
return null;
}
return (CdmaConnection) connections.get(0);
}
}
|
