src/com/android/car/dialer/telecom/UiCallManager.java - platform/packages/apps/Car/Dialer - Git at Google

 /*
  * Copyright (C) 2015 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.car.dialer.telecom;

 import android.content.Context;
 import android.database.Cursor;
 import android.provider.CallLog;
 import android.telecom.Call;
 import android.telephony.TelephonyManager;
 import android.text.TextUtils;
 import android.util.Log;
 import android.view.KeyEvent;
 import com.android.car.dialer.ClassFactory;
 import com.android.car.dialer.R;

 import java.util.ArrayList;
 import java.util.Calendar;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.List;

 /**
  * The entry point for all interactions between UI and telecom.
  */
 public abstract class UiCallManager {
     private static String TAG = "Em.TelecomMgr";

     private static Object sInstanceLock = new Object();
     private static UiCallManager sInstance;

     private long mLastPlacedCallTimeMs = 0;

     // Rate limit how often you can place outgoing calls.
     private static final long MIN_TIME_BETWEEN_CALLS_MS = 3000;

     private static final List<Integer> sCallStateRank = new ArrayList<>();

     protected Context mContext;

     protected TelephonyManager mTelephonyManager;

     static {
         // States should be added from lowest rank to highest
         sCallStateRank.add(Call.STATE_DISCONNECTED);
         sCallStateRank.add(Call.STATE_DISCONNECTING);
         sCallStateRank.add(Call.STATE_NEW);
         sCallStateRank.add(Call.STATE_CONNECTING);
         sCallStateRank.add(Call.STATE_SELECT_PHONE_ACCOUNT);
         sCallStateRank.add(Call.STATE_HOLDING);
         sCallStateRank.add(Call.STATE_ACTIVE);
         sCallStateRank.add(Call.STATE_DIALING);
         sCallStateRank.add(Call.STATE_RINGING);
     }

     public static UiCallManager getInstance(Context context) {
         synchronized (sInstanceLock) {
             if (sInstance == null) {
                 if (Log.isLoggable(TAG, Log.DEBUG)) {
                     Log.d(TAG, "Creating an instance of CarTelecomManager");
                 }
                 sInstance = ClassFactory.getFactory().createCarTelecomManager();
                 sInstance.setUp(context.getApplicationContext());
             }
         }
         return sInstance;
     }

     protected UiCallManager() {}

     protected void setUp(Context context) {
         if (Log.isLoggable(TAG, Log.DEBUG)) {
             Log.d(TAG, "SetUp");
         }

         mContext = context;
         mTelephonyManager = (TelephonyManager) mContext.getSystemService(Context.TELEPHONY_SERVICE);
     }

     public abstract void tearDown();

     public abstract void addListener(CallListener listener);

     public abstract void removeListener(CallListener listener);

     protected abstract void placeCall(String number);

     public abstract void answerCall(UiCall call);

     public abstract void rejectCall(UiCall call, boolean rejectWithMessage, String textMessage);

     public abstract void disconnectCall(UiCall call);

     public abstract List<UiCall> getCalls();

     public abstract boolean getMuted();

     public abstract void setMuted(boolean muted);

     public abstract int getSupportedAudioRouteMask();

     public abstract int getAudioRoute();

     public abstract void setAudioRoute(int audioRoute);

     public abstract void holdCall(UiCall call);

     public abstract void unholdCall(UiCall call);

     public abstract void playDtmfTone(UiCall call, char digit);

     public abstract void stopDtmfTone(UiCall call);

     public abstract void postDialContinue(UiCall call, boolean proceed);

     public abstract void conference(UiCall call, UiCall otherCall);

     public abstract void splitFromConference(UiCall call);

     public static class CallListener {
         @SuppressWarnings("unused")
         public void dispatchPhoneKeyEvent(KeyEvent event) {}
         @SuppressWarnings("unused")
         public void onAudioStateChanged(boolean isMuted, int route, int supportedRouteMask) {}
         @SuppressWarnings("unused")
         public void onCallAdded(UiCall call) {}
         @SuppressWarnings("unused")
         public void onStateChanged(UiCall call, int state) {}
         @SuppressWarnings("unused")
         public void onCallUpdated(UiCall call) {}
         @SuppressWarnings("unused")
         public void onCallRemoved(UiCall call) {}
     }

     /** Returns a first call that matches at least one provided call state */
     public UiCall getCallWithState(int... callStates) {
         if (Log.isLoggable(TAG, Log.DEBUG)) {
             Log.d(TAG, "getCallWithState: " + callStates);
         }
         for (UiCall call : getCalls()) {
             for (int callState : callStates) {
                 if (call.getState() == callState) {
                     return call;
                 }
             }
         }
         return null;
     }

     public UiCall getPrimaryCall() {
         if (Log.isLoggable(TAG, Log.DEBUG)) {
             Log.d(TAG, "getPrimaryCall");
         }
         List<UiCall> calls = getCalls();
         if (calls.isEmpty()) {
             return null;
         }

         Collections.sort(calls, getCallComparator());
         UiCall uiCall = calls.get(0);
         if (uiCall.hasParent()) {
             return null;
         }
         return uiCall;
     }

     public UiCall getSecondaryCall() {
         if (Log.isLoggable(TAG, Log.DEBUG)) {
             Log.d(TAG, "getSecondaryCall");
         }
         List<UiCall> calls = getCalls();
         if (calls.size() < 2) {
             return null;
         }

         Collections.sort(calls, getCallComparator());
         UiCall uiCall = calls.get(1);
         if (uiCall.hasParent()) {
             return null;
         }
         return uiCall;
     }

     public static final int CAN_PLACE_CALL_RESULT_OK = 0;
     public static final int CAN_PLACE_CALL_RESULT_NETWORK_UNAVAILABLE = 1;
     public static final int CAN_PLACE_CALL_RESULT_HFP_UNAVAILABLE = 2;
     public static final int CAN_PLACE_CALL_RESULT_AIRPLANE_MODE = 3;

     public int getCanPlaceCallStatus(String number, boolean bluetoothRequired) {
         // TODO(b/26191392): figure out the logic for projected and embedded modes
         return CAN_PLACE_CALL_RESULT_OK;
     }

     public String getFailToPlaceCallMessage(int canPlaceCallResult) {
         switch (canPlaceCallResult) {
             case CAN_PLACE_CALL_RESULT_OK:
                 return "";
             case CAN_PLACE_CALL_RESULT_HFP_UNAVAILABLE:
                 return mContext.getString(R.string.error_no_hfp);
             case CAN_PLACE_CALL_RESULT_AIRPLANE_MODE:
                 return mContext.getString(R.string.error_airplane_mode);
             case CAN_PLACE_CALL_RESULT_NETWORK_UNAVAILABLE:
             default:
                 return mContext.getString(R.string.error_network_not_available);
         }
     }

     /** Places call only if there's no outgoing call right now */
     public void safePlaceCall(String number, boolean bluetoothRequired) {
         if (Log.isLoggable(TAG, Log.DEBUG)) {
             Log.d(TAG, "safePlaceCall: " + number);
         }

         int placeCallStatus = getCanPlaceCallStatus(number, bluetoothRequired);
         if (placeCallStatus != CAN_PLACE_CALL_RESULT_OK) {
             if (Log.isLoggable(TAG, Log.DEBUG)) {
                 Log.d(TAG, "Unable to place a call: " + placeCallStatus);
             }
             return;
         }

         UiCall outgoingCall = getCallWithState(
                 Call.STATE_CONNECTING, Call.STATE_NEW, Call.STATE_DIALING);
         if (outgoingCall == null) {
             long now = Calendar.getInstance().getTimeInMillis();
             if (now - mLastPlacedCallTimeMs > MIN_TIME_BETWEEN_CALLS_MS) {
                 placeCall(number);
                 mLastPlacedCallTimeMs = now;
             } else {
                 if (Log.isLoggable(TAG, Log.INFO)) {
                     Log.i(TAG, "You have to wait " + MIN_TIME_BETWEEN_CALLS_MS
                             + "ms between making calls");
                 }
             }
         }
     }

     public void callVoicemail() {
         if (Log.isLoggable(TAG, Log.DEBUG)) {
             Log.d(TAG, "callVoicemail");
         }

         String voicemailNumber = TelecomUtils.getVoicemailNumber(mContext);
         if (TextUtils.isEmpty(voicemailNumber)) {
             Log.w(TAG, "Unable to get voicemail number.");
             return;
         }
         safePlaceCall(voicemailNumber, false);
     }

     /**
      * Returns the call types for the given number of items in the cursor.
      * <p/>
      * It uses the next {@code count} rows in the cursor to extract the types.
      * <p/>
      * Its position in the cursor is unchanged by this function.
      */
     public int[] getCallTypes(Cursor cursor, int count) {
         if (Log.isLoggable(TAG, Log.DEBUG)) {
             Log.d(TAG, "getCallTypes: cursor: " + cursor + ", count: " + count);
         }

         int position = cursor.getPosition();
         int[] callTypes = new int[count];
         String voicemailNumber = mTelephonyManager.getVoiceMailNumber();
         int column;
         for (int index = 0; index < count; ++index) {
             column = cursor.getColumnIndex(CallLog.Calls.NUMBER);
             String phoneNumber = cursor.getString(column);
             if (phoneNumber != null && phoneNumber.equals(voicemailNumber)) {
                 callTypes[index] = PhoneLoader.VOICEMAIL_TYPE;
             } else {
                 column = cursor.getColumnIndex(CallLog.Calls.TYPE);
                 callTypes[index] = cursor.getInt(column);
             }
             cursor.moveToNext();
         }
         cursor.moveToPosition(position);
         return callTypes;
     }

     private static Comparator<UiCall> getCallComparator() {
         return new Comparator<UiCall>() {
             @Override
             public int compare(UiCall call, UiCall otherCall) {
                 if (call.hasParent() && !otherCall.hasParent()) {
                     return 1;
                 } else if (!call.hasParent() && otherCall.hasParent()) {
                     return -1;
                 }
                 int carCallRank = sCallStateRank.indexOf(call.getState());
                 int otherCarCallRank = sCallStateRank.indexOf(otherCall.getState());

                 return otherCarCallRank - carCallRank;
             }
         };
     }
 }
	/*
	* Copyright (C) 2015 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.car.dialer.telecom;

	import android.content.Context;
	import android.database.Cursor;
	import android.provider.CallLog;
	import android.telecom.Call;
	import android.telephony.TelephonyManager;
	import android.text.TextUtils;
	import android.util.Log;
	import android.view.KeyEvent;
	import com.android.car.dialer.ClassFactory;
	import com.android.car.dialer.R;

	import java.util.ArrayList;
	import java.util.Calendar;
	import java.util.Collections;
	import java.util.Comparator;
	import java.util.List;

	/**
	* The entry point for all interactions between UI and telecom.
	*/
	public abstract class UiCallManager {
	private static String TAG = "Em.TelecomMgr";

	private static Object sInstanceLock = new Object();
	private static UiCallManager sInstance;

	private long mLastPlacedCallTimeMs = 0;

	// Rate limit how often you can place outgoing calls.
	private static final long MIN_TIME_BETWEEN_CALLS_MS = 3000;

	private static final List<Integer> sCallStateRank = new ArrayList<>();

	protected Context mContext;

	protected TelephonyManager mTelephonyManager;

	static {
	// States should be added from lowest rank to highest
	sCallStateRank.add(Call.STATE_DISCONNECTED);
	sCallStateRank.add(Call.STATE_DISCONNECTING);
	sCallStateRank.add(Call.STATE_NEW);
	sCallStateRank.add(Call.STATE_CONNECTING);
	sCallStateRank.add(Call.STATE_SELECT_PHONE_ACCOUNT);
	sCallStateRank.add(Call.STATE_HOLDING);
	sCallStateRank.add(Call.STATE_ACTIVE);
	sCallStateRank.add(Call.STATE_DIALING);
	sCallStateRank.add(Call.STATE_RINGING);
	}

	public static UiCallManager getInstance(Context context) {
	synchronized (sInstanceLock) {
	if (sInstance == null) {
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "Creating an instance of CarTelecomManager");
	}
	sInstance = ClassFactory.getFactory().createCarTelecomManager();
	sInstance.setUp(context.getApplicationContext());
	}
	}
	return sInstance;
	}

	protected UiCallManager() {}

	protected void setUp(Context context) {
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "SetUp");
	}

	mContext = context;
	mTelephonyManager = (TelephonyManager) mContext.getSystemService(Context.TELEPHONY_SERVICE);
	}

	public abstract void tearDown();

	public abstract void addListener(CallListener listener);

	public abstract void removeListener(CallListener listener);

	protected abstract void placeCall(String number);

	public abstract void answerCall(UiCall call);

	public abstract void rejectCall(UiCall call, boolean rejectWithMessage, String textMessage);

	public abstract void disconnectCall(UiCall call);

	public abstract List<UiCall> getCalls();

	public abstract boolean getMuted();

	public abstract void setMuted(boolean muted);

	public abstract int getSupportedAudioRouteMask();

	public abstract int getAudioRoute();

	public abstract void setAudioRoute(int audioRoute);

	public abstract void holdCall(UiCall call);

	public abstract void unholdCall(UiCall call);

	public abstract void playDtmfTone(UiCall call, char digit);

	public abstract void stopDtmfTone(UiCall call);

	public abstract void postDialContinue(UiCall call, boolean proceed);

	public abstract void conference(UiCall call, UiCall otherCall);

	public abstract void splitFromConference(UiCall call);

	public static class CallListener {
	@SuppressWarnings("unused")
	public void dispatchPhoneKeyEvent(KeyEvent event) {}
	@SuppressWarnings("unused")
	public void onAudioStateChanged(boolean isMuted, int route, int supportedRouteMask) {}
	@SuppressWarnings("unused")
	public void onCallAdded(UiCall call) {}
	@SuppressWarnings("unused")
	public void onStateChanged(UiCall call, int state) {}
	@SuppressWarnings("unused")
	public void onCallUpdated(UiCall call) {}
	@SuppressWarnings("unused")
	public void onCallRemoved(UiCall call) {}
	}

	/** Returns a first call that matches at least one provided call state */
	public UiCall getCallWithState(int... callStates) {
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "getCallWithState: " + callStates);
	}
	for (UiCall call : getCalls()) {
	for (int callState : callStates) {
	if (call.getState() == callState) {
	return call;
	}
	}
	}
	return null;
	}

	public UiCall getPrimaryCall() {
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "getPrimaryCall");
	}
	List<UiCall> calls = getCalls();
	if (calls.isEmpty()) {
	return null;
	}

	Collections.sort(calls, getCallComparator());
	UiCall uiCall = calls.get(0);
	if (uiCall.hasParent()) {
	return null;
	}
	return uiCall;
	}

	public UiCall getSecondaryCall() {
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "getSecondaryCall");
	}
	List<UiCall> calls = getCalls();
	if (calls.size() < 2) {
	return null;
	}

	Collections.sort(calls, getCallComparator());
	UiCall uiCall = calls.get(1);
	if (uiCall.hasParent()) {
	return null;
	}
	return uiCall;
	}

	public static final int CAN_PLACE_CALL_RESULT_OK = 0;
	public static final int CAN_PLACE_CALL_RESULT_NETWORK_UNAVAILABLE = 1;
	public static final int CAN_PLACE_CALL_RESULT_HFP_UNAVAILABLE = 2;
	public static final int CAN_PLACE_CALL_RESULT_AIRPLANE_MODE = 3;

	public int getCanPlaceCallStatus(String number, boolean bluetoothRequired) {
	// TODO(b/26191392): figure out the logic for projected and embedded modes
	return CAN_PLACE_CALL_RESULT_OK;
	}

	public String getFailToPlaceCallMessage(int canPlaceCallResult) {
	switch (canPlaceCallResult) {
	case CAN_PLACE_CALL_RESULT_OK:
	return "";
	case CAN_PLACE_CALL_RESULT_HFP_UNAVAILABLE:
	return mContext.getString(R.string.error_no_hfp);
	case CAN_PLACE_CALL_RESULT_AIRPLANE_MODE:
	return mContext.getString(R.string.error_airplane_mode);
	case CAN_PLACE_CALL_RESULT_NETWORK_UNAVAILABLE:
	default:
	return mContext.getString(R.string.error_network_not_available);
	}
	}

	/** Places call only if there's no outgoing call right now */
	public void safePlaceCall(String number, boolean bluetoothRequired) {
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "safePlaceCall: " + number);
	}

	int placeCallStatus = getCanPlaceCallStatus(number, bluetoothRequired);
	if (placeCallStatus != CAN_PLACE_CALL_RESULT_OK) {
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "Unable to place a call: " + placeCallStatus);
	}
	return;
	}

	UiCall outgoingCall = getCallWithState(
	Call.STATE_CONNECTING, Call.STATE_NEW, Call.STATE_DIALING);
	if (outgoingCall == null) {
	long now = Calendar.getInstance().getTimeInMillis();
	if (now - mLastPlacedCallTimeMs > MIN_TIME_BETWEEN_CALLS_MS) {
	placeCall(number);
	mLastPlacedCallTimeMs = now;
	} else {
	if (Log.isLoggable(TAG, Log.INFO)) {
	Log.i(TAG, "You have to wait " + MIN_TIME_BETWEEN_CALLS_MS
	+ "ms between making calls");
	}
	}
	}
	}

	public void callVoicemail() {
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "callVoicemail");
	}

	String voicemailNumber = TelecomUtils.getVoicemailNumber(mContext);
	if (TextUtils.isEmpty(voicemailNumber)) {
	Log.w(TAG, "Unable to get voicemail number.");
	return;
	}
	safePlaceCall(voicemailNumber, false);
	}

	/**
	* Returns the call types for the given number of items in the cursor.
	* <p/>
	* It uses the next {@code count} rows in the cursor to extract the types.
	* <p/>
	* Its position in the cursor is unchanged by this function.
	*/
	public int[] getCallTypes(Cursor cursor, int count) {
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "getCallTypes: cursor: " + cursor + ", count: " + count);
	}

	int position = cursor.getPosition();
	int[] callTypes = new int[count];
	String voicemailNumber = mTelephonyManager.getVoiceMailNumber();
	int column;
	for (int index = 0; index < count; ++index) {
	column = cursor.getColumnIndex(CallLog.Calls.NUMBER);
	String phoneNumber = cursor.getString(column);
	if (phoneNumber != null && phoneNumber.equals(voicemailNumber)) {
	callTypes[index] = PhoneLoader.VOICEMAIL_TYPE;
	} else {
	column = cursor.getColumnIndex(CallLog.Calls.TYPE);
	callTypes[index] = cursor.getInt(column);
	}
	cursor.moveToNext();
	}
	cursor.moveToPosition(position);
	return callTypes;
	}

	private static Comparator<UiCall> getCallComparator() {
	return new Comparator<UiCall>() {
	@Override
	public int compare(UiCall call, UiCall otherCall) {
	if (call.hasParent() && !otherCall.hasParent()) {
	return 1;
	} else if (!call.hasParent() && otherCall.hasParent()) {
	return -1;
	}
	int carCallRank = sCallStateRank.indexOf(call.getState());
	int otherCarCallRank = sCallStateRank.indexOf(otherCall.getState());

	return otherCarCallRank - carCallRank;
	}
	};
	}
	}