Home | History | Annotate | Download | only in connserv 
      1 /*
      2  * Copyright (C) 2016 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 package com.android.bluetooth.hfpclient.connserv;
     17 
     18 import android.bluetooth.BluetoothDevice;
     19 import android.bluetooth.BluetoothHeadsetClient;
     20 import android.bluetooth.BluetoothHeadsetClientCall;
     21 import android.bluetooth.BluetoothProfile;
     22 import android.content.Context;
     23 import android.net.Uri;
     24 import android.telecom.Connection;
     25 import android.telecom.DisconnectCause;
     26 import android.telecom.PhoneAccount;
     27 import android.telecom.TelecomManager;
     28 import android.util.Log;
     29 
     30 import java.util.UUID;
     31 
     32 public class HfpClientConnection extends Connection {
     33     private static final String TAG = "HfpClientConnection";
     34     private static final boolean DBG = false;
     35 
     36     private final Context mContext;
     37     private final BluetoothDevice mDevice;
     38     private BluetoothHeadsetClient mHeadsetProfile;
     39 
     40     private BluetoothHeadsetClientCall mCurrentCall;
     41     private boolean mClosed;
     42     private boolean mClosing = false;
     43     private boolean mLocalDisconnect;
     44     private boolean mClientHasEcc;
     45     private boolean mAdded;
     46 
     47     // Constructor to be used when there's an existing call (such as that created on the AG or
     48     // when connection happens and we see calls for the first time).
     49     public HfpClientConnection(Context context, BluetoothDevice device,
     50             BluetoothHeadsetClient client, BluetoothHeadsetClientCall call) {
     51         mDevice = device;
     52         mContext = context;
     53         mHeadsetProfile = client;
     54 
     55         if (call == null) {
     56             throw new IllegalStateException("Call is null");
     57         }
     58 
     59         mCurrentCall = call;
     60         handleCallChanged();
     61         finishInitializing();
     62     }
     63 
     64     // Constructor to be used when a call is intiated on the HF. The call handle is obtained by
     65     // using the dial() command.
     66     public HfpClientConnection(Context context, BluetoothDevice device,
     67             BluetoothHeadsetClient client, Uri number) {
     68         mDevice = device;
     69         mContext = context;
     70         mHeadsetProfile = client;
     71 
     72         if (mHeadsetProfile == null) {
     73             throw new IllegalStateException("HeadsetProfile is null, returning");
     74         }
     75 
     76         mCurrentCall = mHeadsetProfile.dial(
     77             mDevice, number.getSchemeSpecificPart());
     78         if (mCurrentCall == null) {
     79             close(DisconnectCause.ERROR);
     80             Log.e(TAG, "Failed to create the call, dial failed.");
     81             return;
     82         }
     83 
     84         setInitializing();
     85         setDialing();
     86         finishInitializing();
     87     }
     88 
     89     void finishInitializing() {
     90         mClientHasEcc = HfpClientConnectionService.hasHfpClientEcc(mHeadsetProfile, mDevice);
     91         setAudioModeIsVoip(false);
     92         Uri number = Uri.fromParts(PhoneAccount.SCHEME_TEL, mCurrentCall.getNumber(), null);
     93         setAddress(number, TelecomManager.PRESENTATION_ALLOWED);
     94         setConnectionCapabilities(CAPABILITY_SUPPORT_HOLD | CAPABILITY_MUTE |
     95                 CAPABILITY_SEPARATE_FROM_CONFERENCE | CAPABILITY_DISCONNECT_FROM_CONFERENCE |
     96                 (getState() == STATE_ACTIVE || getState() == STATE_HOLDING ? CAPABILITY_HOLD : 0));
     97     }
     98 
     99     public UUID getUUID() {
    100         return mCurrentCall.getUUID();
    101     }
    102 
    103     public void onHfpDisconnected() {
    104         mHeadsetProfile = null;
    105         close(DisconnectCause.ERROR);
    106     }
    107 
    108     public void onAdded() {
    109         mAdded = true;
    110     }
    111 
    112     public BluetoothHeadsetClientCall getCall() {
    113         return mCurrentCall;
    114     }
    115 
    116     public boolean inConference() {
    117         return mAdded && mCurrentCall != null && mCurrentCall.isMultiParty() &&
    118                 getState() != Connection.STATE_DISCONNECTED;
    119     }
    120 
    121     public void enterPrivateMode() {
    122         mHeadsetProfile.enterPrivateMode(mDevice, mCurrentCall.getId());
    123         setActive();
    124     }
    125 
    126     public void updateCall(BluetoothHeadsetClientCall call) {
    127         if (call == null) {
    128             Log.e(TAG, "Updating call to a null value.");
    129             return;
    130         }
    131         mCurrentCall = call;
    132     }
    133 
    134     public void handleCallChanged() {
    135         HfpClientConference conference = (HfpClientConference) getConference();
    136         int state = mCurrentCall.getState();
    137 
    138         if (DBG) {
    139             Log.d(TAG, "Got call state change to " + state);
    140         }
    141         switch (state) {
    142             case BluetoothHeadsetClientCall.CALL_STATE_ACTIVE:
    143                 setActive();
    144                 if (conference != null) {
    145                     conference.setActive();
    146                 }
    147                 break;
    148             case BluetoothHeadsetClientCall.CALL_STATE_HELD_BY_RESPONSE_AND_HOLD:
    149             case BluetoothHeadsetClientCall.CALL_STATE_HELD:
    150                 setOnHold();
    151                 if (conference != null) {
    152                     conference.setOnHold();
    153                 }
    154                 break;
    155             case BluetoothHeadsetClientCall.CALL_STATE_DIALING:
    156             case BluetoothHeadsetClientCall.CALL_STATE_ALERTING:
    157                 setDialing();
    158                 break;
    159             case BluetoothHeadsetClientCall.CALL_STATE_INCOMING:
    160             case BluetoothHeadsetClientCall.CALL_STATE_WAITING:
    161                 setRinging();
    162                 break;
    163             case BluetoothHeadsetClientCall.CALL_STATE_TERMINATED:
    164                 // TODO Use more specific causes
    165                 close(mLocalDisconnect ? DisconnectCause.LOCAL : DisconnectCause.REMOTE);
    166                 break;
    167             default:
    168                 Log.wtf(TAG, "Unexpected phone state " + state);
    169         }
    170     }
    171 
    172     public synchronized void close(int cause) {
    173         if (DBG) {
    174             Log.d(TAG, "Closing call " + mCurrentCall + "state: " + mClosed);
    175         }
    176         if (mClosed) {
    177             return;
    178         }
    179         Log.d(TAG, "Setting " + mCurrentCall + " to disconnected " + getTelecomCallId());
    180         setDisconnected(new DisconnectCause(cause));
    181 
    182         mClosed = true;
    183         mCurrentCall = null;
    184 
    185         destroy();
    186     }
    187 
    188     public synchronized boolean isClosing() {
    189         return mClosing;
    190     }
    191 
    192     public synchronized BluetoothDevice getDevice() {
    193         return mDevice;
    194     }
    195 
    196     @Override
    197     public synchronized void onPlayDtmfTone(char c) {
    198         if (DBG) {
    199             Log.d(TAG, "onPlayDtmfTone " + c + " " + mCurrentCall);
    200         }
    201         if (!mClosed) {
    202             mHeadsetProfile.sendDTMF(mDevice, (byte) c);
    203         }
    204     }
    205 
    206     @Override
    207     public synchronized void onDisconnect() {
    208         if (DBG) {
    209             Log.d(TAG, "onDisconnect call: " + mCurrentCall + " state: " + mClosed);
    210         }
    211         // The call is not closed so we should send a terminate here.
    212         if (!mClosed) {
    213             mHeadsetProfile.terminateCall(mDevice, mCurrentCall);
    214             mLocalDisconnect = true;
    215             mClosing = true;
    216         }
    217     }
    218 
    219     @Override
    220     public void onAbort() {
    221         if (DBG) {
    222             Log.d(TAG, "onAbort " + mCurrentCall);
    223         }
    224         onDisconnect();
    225     }
    226 
    227     @Override
    228     public synchronized void onHold() {
    229         if (DBG) {
    230             Log.d(TAG, "onHold " + mCurrentCall);
    231         }
    232         if (!mClosed) {
    233             mHeadsetProfile.holdCall(mDevice);
    234         }
    235     }
    236 
    237     @Override
    238     public synchronized void onUnhold() {
    239         if (getConnectionService().getAllConnections().size() > 1) {
    240             Log.w(TAG, "Ignoring unhold; call hold on the foreground call");
    241             return;
    242         }
    243         if (DBG) {
    244             Log.d(TAG, "onUnhold " + mCurrentCall);
    245         }
    246         if (!mClosed) {
    247             mHeadsetProfile.acceptCall(mDevice, BluetoothHeadsetClient.CALL_ACCEPT_HOLD);
    248         }
    249     }
    250 
    251     @Override
    252     public synchronized void onAnswer() {
    253         if (DBG) {
    254             Log.d(TAG, "onAnswer " + mCurrentCall);
    255         }
    256         if (!mClosed) {
    257             mHeadsetProfile.acceptCall(mDevice, BluetoothHeadsetClient.CALL_ACCEPT_NONE);
    258         }
    259     }
    260 
    261     @Override
    262     public synchronized void onReject() {
    263         if (DBG) {
    264             Log.d(TAG, "onReject " + mCurrentCall);
    265         }
    266         if (!mClosed) {
    267             mHeadsetProfile.rejectCall(mDevice);
    268         }
    269     }
    270 
    271     @Override
    272     public boolean equals(Object o) {
    273         if (!(o instanceof HfpClientConnection)) {
    274             return false;
    275         }
    276         Uri otherAddr = ((HfpClientConnection) o).getAddress();
    277         return getAddress() == otherAddr || otherAddr != null && otherAddr.equals(getAddress());
    278     }
    279 
    280     @Override
    281     public String toString() {
    282         return "HfpClientConnection{" + getAddress() + "," + stateToString(getState()) + "," +
    283                 mCurrentCall + "}";
    284     }
    285 }
    286