| #!/usr/bin/env python3 |
| # |
| # Copyright 2016 - Google |
| # |
| # 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. |
| |
| import time |
| from queue import Empty |
| from acts_contrib.test_utils.tel.tel_defines import AUDIO_ROUTE_EARPIECE |
| from acts_contrib.test_utils.tel.tel_defines import INCALL_UI_DISPLAY_FOREGROUND |
| from acts_contrib.test_utils.tel.tel_defines import MAX_WAIT_TIME_VIDEO_SESSION_EVENT |
| from acts_contrib.test_utils.tel.tel_defines import MAX_WAIT_TIME_VOLTE_ENABLED |
| from acts_contrib.test_utils.tel.tel_defines import NETWORK_SERVICE_DATA |
| from acts_contrib.test_utils.tel.tel_defines import GEN_4G |
| from acts_contrib.test_utils.tel.tel_defines import RAT_IWLAN |
| from acts_contrib.test_utils.tel.tel_defines import VT_STATE_AUDIO_ONLY |
| from acts_contrib.test_utils.tel.tel_defines import VT_STATE_BIDIRECTIONAL |
| from acts_contrib.test_utils.tel.tel_defines import VT_STATE_BIDIRECTIONAL_PAUSED |
| from acts_contrib.test_utils.tel.tel_defines import VT_STATE_RX_ENABLED |
| from acts_contrib.test_utils.tel.tel_defines import VT_STATE_RX_PAUSED |
| from acts_contrib.test_utils.tel.tel_defines import VT_STATE_TX_ENABLED |
| from acts_contrib.test_utils.tel.tel_defines import VT_STATE_TX_PAUSED |
| from acts_contrib.test_utils.tel.tel_defines import VT_STATE_STATE_INVALID |
| from acts_contrib.test_utils.tel.tel_defines import VT_VIDEO_QUALITY_DEFAULT |
| from acts_contrib.test_utils.tel.tel_defines import WAIT_TIME_ANDROID_STATE_SETTLING |
| from acts_contrib.test_utils.tel.tel_defines import WAIT_TIME_IN_CALL |
| from acts_contrib.test_utils.tel.tel_defines import WFC_MODE_DISABLED |
| from acts_contrib.test_utils.tel.tel_defines import EventTelecomVideoCallSessionModifyRequestReceived |
| from acts_contrib.test_utils.tel.tel_defines import EventTelecomVideoCallSessionModifyResponseReceived |
| from acts_contrib.test_utils.tel.tel_defines import EVENT_VIDEO_SESSION_MODIFY_RESPONSE_RECEIVED |
| from acts_contrib.test_utils.tel.tel_defines import EVENT_VIDEO_SESSION_MODIFY_REQUEST_RECEIVED |
| from acts_contrib.test_utils.tel.tel_ims_utils import is_wfc_enabled |
| from acts_contrib.test_utils.tel.tel_ims_utils import toggle_volte |
| from acts_contrib.test_utils.tel.tel_ims_utils import set_wfc_mode_for_subscription |
| from acts_contrib.test_utils.tel.tel_ims_utils import wait_for_video_enabled |
| from acts_contrib.test_utils.tel.tel_phone_setup_utils import ensure_network_generation |
| from acts_contrib.test_utils.tel.tel_phone_setup_utils import phone_setup_iwlan_for_subscription |
| from acts_contrib.test_utils.tel.tel_phone_setup_utils import wait_for_network_generation |
| from acts_contrib.test_utils.tel.tel_subscription_utils import get_outgoing_voice_sub_id |
| from acts_contrib.test_utils.tel.tel_subscription_utils import get_incoming_voice_sub_id |
| from acts_contrib.test_utils.tel.tel_test_utils import get_network_rat |
| from acts_contrib.test_utils.tel.tel_voice_utils import call_setup_teardown_for_subscription |
| from acts_contrib.test_utils.tel.tel_voice_utils import initiate_call |
| from acts_contrib.test_utils.tel.tel_voice_utils import is_call_hd |
| from acts_contrib.test_utils.tel.tel_voice_utils import wait_and_answer_call_for_subscription |
| |
| |
| def phone_setup_video( |
| log, |
| ad, |
| wfc_mode=WFC_MODE_DISABLED, |
| is_airplane_mode=False, |
| wifi_ssid=None, |
| wifi_pwd=None): |
| """Setup phone default sub_id to make video call |
| |
| Args: |
| log: log object. |
| ad: android device object |
| wfc_mode: WFC mode to set to. |
| Valid mode includes: WFC_MODE_WIFI_ONLY, WFC_MODE_CELLULAR_PREFERRED, |
| WFC_MODE_WIFI_PREFERRED, WFC_MODE_DISABLED. |
| |
| Returns: |
| True if ad (default sub_id) is setup correctly and idle for video call. |
| """ |
| return phone_setup_video_for_subscription(log, ad, |
| get_outgoing_voice_sub_id(ad), |
| wfc_mode, |
| False, |
| wifi_ssid, |
| wifi_pwd) |
| |
| |
| def phone_setup_video_for_subscription(log, |
| ad, |
| sub_id, |
| wfc_mode=WFC_MODE_DISABLED, |
| is_airplane_mode=False, |
| wifi_ssid=None, |
| wifi_pwd=None): |
| """Setup phone sub_id to make video call |
| |
| Args: |
| log: log object. |
| ad: android device object |
| sub_id: ad's sub id. |
| wfc_mode: WFC mode to set to. Valid mode includes: |
| - WFC_MODE_WIFI_ONLY |
| - Wi-Fi will be connected if wifi_ssid is assigned. |
| - WFC_MODE_CELLULAR_PREFERRED |
| - Wi-Fi will be connected if wifi_ssid is assigned. |
| - WFC_MODE_WIFI_PREFERRED |
| - Wi-Fi will be connected if wifi_ssid is assigned. |
| - WFC_MODE_DISABLED |
| - Only WFC mode will be set to DISABLED. |
| - None |
| - Neither WFC mode nor Wi-Fi state will be changed. |
| is_airplane_mode: |
| - False: airplane mode disabled |
| - True: airplane mode enabled for ViWifi |
| wifi_ssid: SSID of Wi-Fi AP to connect for ViWifi |
| wifi_ssid: Password of Wi-Fi AP SSID for ViWifi |
| |
| Returns: |
| True if ad (sub_id) is setup correctly and idle for video call. |
| """ |
| if not ensure_network_generation( |
| log, ad, GEN_4G, voice_or_data=NETWORK_SERVICE_DATA): |
| log.error("{} voice not in LTE mode.".format(ad.serial)) |
| return False |
| |
| toggle_volte(log, ad, True) |
| |
| if wfc_mode == WFC_MODE_DISABLED: |
| if not set_wfc_mode_for_subscription(ad, wfc_mode, sub_id): |
| log.error("{} WFC mode failed to be set to {}.".format( |
| ad.serial, wfc_mode)) |
| return False |
| else: |
| if wfc_mode: |
| if not phone_setup_iwlan_for_subscription(log, ad, sub_id, |
| is_airplane_mode, wfc_mode, wifi_ssid, wifi_pwd): |
| log.error("Failed to set up phone on iwlan.") |
| return False |
| |
| return phone_idle_video_for_subscription(log, ad, sub_id) |
| |
| |
| def phone_idle_video(log, ad): |
| """Return if phone (default sub_id) is idle for video call. |
| |
| Args: |
| log: log object. |
| ad: android device object |
| |
| Returns: |
| True if ad is idle for video call. |
| """ |
| return phone_idle_video_for_subscription(log, ad, |
| get_outgoing_voice_sub_id(ad)) |
| |
| |
| def phone_idle_video_for_subscription(log, ad, sub_id): |
| """Return if phone (sub_id) is idle for video call. |
| |
| Args: |
| log: log object. |
| ad: android device object |
| sub_id: ad's sub id |
| |
| Returns: |
| True if ad (sub_id) is idle for video call. |
| """ |
| |
| if not wait_for_network_generation(log, ad, GEN_4G): |
| log.error("{} voice not in LTE mode.".format(ad.serial)) |
| return False |
| |
| if not wait_for_video_enabled(log, ad, MAX_WAIT_TIME_VOLTE_ENABLED): |
| log.error( |
| "{} failed to <report video calling enabled> within {}s.".format( |
| ad.serial, MAX_WAIT_TIME_VOLTE_ENABLED)) |
| return False |
| return True |
| |
| |
| def is_phone_in_call_video(log, ad): |
| """Return if ad is in a video call (in expected video state). |
| |
| Args: |
| log: log object. |
| ad: android device object |
| video_state: Expected Video call state. |
| This is optional, if it's None, |
| then TX_ENABLED/RX_ENABLED/BIDIRECTIONAL video call state will |
| return True. |
| |
| Returns: |
| True if ad (for sub_id) is in a video call (in expected video state). |
| """ |
| return is_phone_in_call_video_for_subscription( |
| log, ad, get_outgoing_voice_sub_id(ad)) |
| |
| |
| def is_phone_in_call_video_for_subscription(log, ad, sub_id, video_state=None): |
| """Return if ad (for sub_id) is in a video call (in expected video state). |
| Args: |
| log: log object. |
| ad: android device object |
| sub_id: device sub_id |
| video_state: Expected Video call state. |
| This is optional, if it's None, |
| then TX_ENABLED/RX_ENABLED/BIDIRECTIONAL video call state will |
| return True. |
| |
| Returns: |
| True if ad is in a video call (in expected video state). |
| """ |
| |
| if video_state is None: |
| log.info("Verify if {}(subid {}) in video call.".format( |
| ad.serial, sub_id)) |
| if not ad.droid.telecomIsInCall(): |
| log.error("{} not in call.".format(ad.serial)) |
| return False |
| call_list = ad.droid.telecomCallGetCallIds() |
| for call in call_list: |
| state = ad.droid.telecomCallVideoGetState(call) |
| if video_state is None: |
| if { |
| VT_STATE_AUDIO_ONLY: False, |
| VT_STATE_TX_ENABLED: True, |
| VT_STATE_TX_PAUSED: True, |
| VT_STATE_RX_ENABLED: True, |
| VT_STATE_RX_PAUSED: True, |
| VT_STATE_BIDIRECTIONAL: True, |
| VT_STATE_BIDIRECTIONAL_PAUSED: True, |
| VT_STATE_STATE_INVALID: False |
| }[state]: |
| return True |
| else: |
| if state == video_state: |
| return True |
| log.info("Non-Video-State: {}".format(state)) |
| log.error("Phone not in video call. Call list: {}".format(call_list)) |
| return False |
| |
| |
| def is_phone_in_call_viwifi_for_subscription(log, ad, sub_id, |
| video_state=None): |
| """Return if ad (for sub_id) is in a viwifi call (in expected video state). |
| Args: |
| log: log object. |
| ad: android device object |
| sub_id: device sub_id |
| video_state: Expected Video call state. |
| This is optional, if it's None, |
| then TX_ENABLED/RX_ENABLED/BIDIRECTIONAL video call state will |
| return True. |
| |
| Returns: |
| True if ad is in a video call (in expected video state). |
| """ |
| |
| if video_state is None: |
| log.info("Verify if {}(subid {}) in video call.".format( |
| ad.serial, sub_id)) |
| if not ad.droid.telecomIsInCall(): |
| log.error("{} not in call.".format(ad.serial)) |
| return False |
| nw_type = get_network_rat(log, ad, NETWORK_SERVICE_DATA) |
| if nw_type != RAT_IWLAN: |
| ad.log.error("Data rat on: %s. Expected: iwlan", nw_type) |
| return False |
| if not is_wfc_enabled(log, ad): |
| ad.log.error("WiFi Calling feature bit is False.") |
| return False |
| call_list = ad.droid.telecomCallGetCallIds() |
| for call in call_list: |
| state = ad.droid.telecomCallVideoGetState(call) |
| if video_state is None: |
| if { |
| VT_STATE_AUDIO_ONLY: False, |
| VT_STATE_TX_ENABLED: True, |
| VT_STATE_TX_PAUSED: True, |
| VT_STATE_RX_ENABLED: True, |
| VT_STATE_RX_PAUSED: True, |
| VT_STATE_BIDIRECTIONAL: True, |
| VT_STATE_BIDIRECTIONAL_PAUSED: True, |
| VT_STATE_STATE_INVALID: False |
| }[state]: |
| return True |
| else: |
| if state == video_state: |
| return True |
| ad.log.info("Non-Video-State: %s", state) |
| ad.log.error("Phone not in video call. Call list: %s", call_list) |
| return False |
| |
| |
| def is_phone_in_call_video_bidirectional(log, ad): |
| """Return if phone in bi-directional video call. |
| |
| Args: |
| log: log object. |
| ad: android device object |
| |
| Returns: |
| True if phone in bi-directional video call. |
| """ |
| return is_phone_in_call_video_bidirectional_for_subscription( |
| log, ad, get_outgoing_voice_sub_id(ad)) |
| |
| |
| def is_phone_in_call_video_bidirectional_for_subscription(log, ad, sub_id): |
| """Return if phone in bi-directional video call for subscription id. |
| |
| Args: |
| log: log object. |
| ad: android device object |
| sub_id: subscription id. |
| |
| Returns: |
| True if phone in bi-directional video call. |
| """ |
| log.info("Verify if {}(subid {}) in bi-directional video call.".format( |
| ad.serial, sub_id)) |
| return is_phone_in_call_video_for_subscription(log, ad, sub_id, |
| VT_STATE_BIDIRECTIONAL) |
| |
| |
| def is_phone_in_call_viwifi_bidirectional(log, ad): |
| """Return if phone in bi-directional viwifi call. |
| |
| Args: |
| log: log object. |
| ad: android device object |
| |
| Returns: |
| True if phone in bi-directional viwifi call. |
| """ |
| return is_phone_in_call_viwifi_bidirectional_for_subscription( |
| log, ad, get_outgoing_voice_sub_id(ad)) |
| |
| |
| def is_phone_in_call_viwifi_bidirectional_for_subscription(log, ad, sub_id): |
| """Return if phone in bi-directional viwifi call for subscription id. |
| |
| Args: |
| log: log object. |
| ad: android device object |
| sub_id: subscription id. |
| |
| Returns: |
| True if phone in bi-directional viwifi call. |
| """ |
| ad.log.info("Verify if subid %s in bi-directional video call.", sub_id) |
| return is_phone_in_call_viwifi_for_subscription(log, ad, sub_id, |
| VT_STATE_BIDIRECTIONAL) |
| |
| |
| def is_phone_in_call_video_tx_enabled(log, ad): |
| """Return if phone in tx_enabled video call. |
| |
| Args: |
| log: log object. |
| ad: android device object |
| |
| Returns: |
| True if phone in tx_enabled video call. |
| """ |
| return is_phone_in_call_video_tx_enabled_for_subscription( |
| log, ad, get_outgoing_voice_sub_id(ad)) |
| |
| |
| def is_phone_in_call_video_tx_enabled_for_subscription(log, ad, sub_id): |
| """Return if phone in tx_enabled video call for subscription id. |
| |
| Args: |
| log: log object. |
| ad: android device object |
| sub_id: subscription id. |
| |
| Returns: |
| True if phone in tx_enabled video call. |
| """ |
| log.info("Verify if {}(subid {}) in tx_enabled video call.".format( |
| ad.serial, sub_id)) |
| return is_phone_in_call_video_for_subscription(log, ad, sub_id, |
| VT_STATE_TX_ENABLED) |
| |
| |
| def is_phone_in_call_video_rx_enabled(log, ad): |
| """Return if phone in rx_enabled video call. |
| |
| Args: |
| log: log object. |
| ad: android device object |
| |
| Returns: |
| True if phone in rx_enabled video call. |
| """ |
| return is_phone_in_call_video_rx_enabled_for_subscription( |
| log, ad, get_outgoing_voice_sub_id(ad)) |
| |
| |
| def is_phone_in_call_video_rx_enabled_for_subscription(log, ad, sub_id): |
| """Return if phone in rx_enabled video call for subscription id. |
| |
| Args: |
| log: log object. |
| ad: android device object |
| sub_id: subscription id. |
| |
| Returns: |
| True if phone in rx_enabled video call. |
| """ |
| log.info("Verify if {}(subid {}) in rx_enabled video call.".format( |
| ad.serial, sub_id)) |
| return is_phone_in_call_video_for_subscription(log, ad, sub_id, |
| VT_STATE_RX_ENABLED) |
| |
| |
| def is_phone_in_call_voice_hd(log, ad): |
| """Return if phone in hd voice call. |
| |
| Args: |
| log: log object. |
| ad: android device object |
| |
| Returns: |
| True if phone in hd voice call. |
| """ |
| return is_phone_in_call_voice_hd_for_subscription( |
| log, ad, get_outgoing_voice_sub_id(ad)) |
| |
| |
| def is_phone_in_call_voice_hd_for_subscription(log, ad, sub_id): |
| """Return if phone in hd voice call for subscription id. |
| |
| Args: |
| log: log object. |
| ad: android device object |
| sub_id: subscription id. |
| |
| Returns: |
| True if phone in hd voice call. |
| """ |
| log.info("Verify if {}(subid {}) in hd voice call.".format( |
| ad.serial, sub_id)) |
| if not ad.droid.telecomIsInCall(): |
| log.error("{} not in call.".format(ad.serial)) |
| return False |
| for call in ad.droid.telecomCallGetCallIds(): |
| state = ad.droid.telecomCallVideoGetState(call) |
| if (state == VT_STATE_AUDIO_ONLY and is_call_hd(log, ad, call)): |
| return True |
| log.info("Non-HDAudio-State: {}, property: {}".format( |
| state, ad.droid.telecomCallGetProperties(call))) |
| return False |
| |
| |
| def initiate_video_call(log, ad_caller, callee_number): |
| """Make phone call from caller to callee. |
| |
| Args: |
| log: logging handle |
| ad_caller: Caller android device object. |
| callee_number: Callee phone number. |
| |
| Returns: |
| result: if phone call is placed successfully. |
| """ |
| return initiate_call(log, ad_caller, callee_number, video=True) |
| |
| |
| def wait_and_answer_video_call(log, |
| ad, |
| incoming_number=None, |
| video_state=VT_STATE_BIDIRECTIONAL, |
| incall_ui_display=INCALL_UI_DISPLAY_FOREGROUND): |
| """Wait for an incoming call on default voice subscription and |
| accepts the call. |
| |
| Args: |
| ad: android device object. |
| incoming_number: Expected incoming number. |
| Optional. Default is None |
| incall_ui_display: after answer the call, bring in-call UI to foreground or |
| background. Optional, default value is INCALL_UI_DISPLAY_FOREGROUND. |
| if = INCALL_UI_DISPLAY_FOREGROUND, bring in-call UI to foreground. |
| if = INCALL_UI_DISPLAY_BACKGROUND, bring in-call UI to background. |
| else, do nothing. |
| |
| Returns: |
| True: if incoming call is received and answered successfully. |
| False: for errors |
| """ |
| return wait_and_answer_video_call_for_subscription( |
| log, ad, get_outgoing_voice_sub_id(ad), incoming_number, video_state, |
| incall_ui_display) |
| |
| |
| def wait_and_answer_video_call_for_subscription( |
| log, |
| ad, |
| sub_id, |
| incoming_number=None, |
| video_state=VT_STATE_BIDIRECTIONAL, |
| incall_ui_display=INCALL_UI_DISPLAY_FOREGROUND): |
| """Wait for an incoming call on specified subscription and |
| accepts the call. |
| |
| Args: |
| ad: android device object. |
| sub_id: subscription ID |
| incoming_number: Expected incoming number. |
| Optional. Default is None |
| incall_ui_display: after answer the call, bring in-call UI to foreground or |
| background. Optional, default value is INCALL_UI_DISPLAY_FOREGROUND. |
| if = INCALL_UI_DISPLAY_FOREGROUND, bring in-call UI to foreground. |
| if = INCALL_UI_DISPLAY_BACKGROUND, bring in-call UI to background. |
| else, do nothing. |
| |
| Returns: |
| True: if incoming call is received and answered successfully. |
| False: for errors |
| """ |
| return wait_and_answer_call_for_subscription( |
| log, |
| ad, |
| sub_id, |
| incoming_number=None, |
| incall_ui_display=INCALL_UI_DISPLAY_FOREGROUND, |
| video_state=video_state) |
| |
| |
| def video_call_setup_teardown(log, |
| ad_caller, |
| ad_callee, |
| ad_hangup=None, |
| video_state=VT_STATE_BIDIRECTIONAL, |
| verify_caller_func=None, |
| verify_callee_func=None, |
| wait_time_in_call=WAIT_TIME_IN_CALL, |
| incall_ui_display=INCALL_UI_DISPLAY_FOREGROUND): |
| """ Call process, including make a phone call from caller, |
| accept from callee, and hang up. The call is on default subscription |
| |
| In call process, call from <droid_caller> to <droid_callee>, |
| accept the call, (optional)then hang up from <droid_hangup>. |
| |
| Args: |
| ad_caller: Caller Android Device Object. |
| ad_callee: Callee Android Device Object. |
| ad_hangup: Android Device Object end the phone call. |
| Optional. Default value is None, and phone call will continue. |
| video_state: video state for VT call. |
| Optional. Default value is VT_STATE_BIDIRECTIONAL |
| verify_caller_func: func_ptr to verify caller in correct mode |
| Optional. Default is None |
| verify_callee_func: func_ptr to verify callee in correct mode |
| Optional. Default is None |
| wait_time_in_call: wait time during call. |
| Optional. Default is WAIT_TIME_IN_CALL. |
| incall_ui_display: after answer the call, bring in-call UI to foreground or |
| background. Optional, default value is INCALL_UI_DISPLAY_FOREGROUND. |
| if = INCALL_UI_DISPLAY_FOREGROUND, bring in-call UI to foreground. |
| if = INCALL_UI_DISPLAY_BACKGROUND, bring in-call UI to background. |
| else, do nothing. |
| |
| Returns: |
| True if call process without any error. |
| False if error happened. |
| |
| """ |
| return video_call_setup_teardown_for_subscription( |
| log, ad_caller, ad_callee, get_outgoing_voice_sub_id(ad_caller), |
| get_incoming_voice_sub_id(ad_callee), ad_hangup, video_state, |
| verify_caller_func, verify_callee_func, wait_time_in_call, |
| incall_ui_display) |
| |
| |
| def video_call_setup_teardown_for_subscription( |
| log, |
| ad_caller, |
| ad_callee, |
| subid_caller, |
| subid_callee, |
| ad_hangup=None, |
| video_state=VT_STATE_BIDIRECTIONAL, |
| verify_caller_func=None, |
| verify_callee_func=None, |
| wait_time_in_call=WAIT_TIME_IN_CALL, |
| incall_ui_display=INCALL_UI_DISPLAY_FOREGROUND): |
| """ Call process, including make a phone call from caller, |
| accept from callee, and hang up. The call is on specified subscription |
| |
| In call process, call from <droid_caller> to <droid_callee>, |
| accept the call, (optional)then hang up from <droid_hangup>. |
| |
| Args: |
| ad_caller: Caller Android Device Object. |
| ad_callee: Callee Android Device Object. |
| subid_caller: Caller subscription ID |
| subid_callee: Callee subscription ID |
| ad_hangup: Android Device Object end the phone call. |
| Optional. Default value is None, and phone call will continue. |
| video_state: video state for VT call. |
| Optional. Default value is VT_STATE_BIDIRECTIONAL |
| verify_caller_func: func_ptr to verify caller in correct mode |
| Optional. Default is None |
| verify_callee_func: func_ptr to verify callee in correct mode |
| Optional. Default is None |
| wait_time_in_call: wait time during call. |
| Optional. Default is WAIT_TIME_IN_CALL. |
| incall_ui_display: after answer the call, bring in-call UI to foreground or |
| background. Optional, default value is INCALL_UI_DISPLAY_FOREGROUND. |
| if = INCALL_UI_DISPLAY_FOREGROUND, bring in-call UI to foreground. |
| if = INCALL_UI_DISPLAY_BACKGROUND, bring in-call UI to background. |
| else, do nothing. |
| |
| Returns: |
| True if call process without any error. |
| False if error happened. |
| |
| """ |
| return call_setup_teardown_for_subscription( |
| log, |
| ad_caller, |
| ad_callee, |
| subid_caller, |
| subid_callee, |
| ad_hangup=ad_hangup, |
| verify_caller_func=verify_caller_func, |
| verify_callee_func=verify_callee_func, |
| wait_time_in_call=wait_time_in_call, |
| incall_ui_display=incall_ui_display, |
| video_state=video_state) |
| |
| |
| def video_call_setup(log, |
| ad_caller, |
| ad_callee, |
| video_state=VT_STATE_BIDIRECTIONAL, |
| incall_ui_display=INCALL_UI_DISPLAY_FOREGROUND): |
| """ Call process, including make a phone call from caller, |
| accept from callee, and hang up. The call is on default subscription |
| |
| In call process, call from <droid_caller> to <droid_callee>, |
| accept the call, (optional)then hang up from <droid_hangup>. |
| |
| Args: |
| ad_caller: Caller Android Device Object. |
| ad_callee: Callee Android Device Object. |
| incall_ui_display: after answer the call, bring in-call UI to foreground or |
| background. Optional, default value is INCALL_UI_DISPLAY_FOREGROUND. |
| if = INCALL_UI_DISPLAY_FOREGROUND, bring in-call UI to foreground. |
| if = INCALL_UI_DISPLAY_BACKGROUND, bring in-call UI to background. |
| else, do nothing. |
| |
| Returns: |
| True if call process without any error. |
| False if error happened. |
| |
| """ |
| return video_call_setup_for_subscription( |
| log, ad_caller, ad_callee, get_outgoing_voice_sub_id(ad_caller), |
| get_incoming_voice_sub_id(ad_callee), video_state, incall_ui_display) |
| |
| |
| def video_call_setup_for_subscription( |
| log, |
| ad_caller, |
| ad_callee, |
| subid_caller, |
| subid_callee, |
| video_state=VT_STATE_BIDIRECTIONAL, |
| incall_ui_display=INCALL_UI_DISPLAY_FOREGROUND): |
| """ Call process, including make a phone call from caller, |
| accept from callee, and hang up. The call is on specified subscription |
| |
| In call process, call from <droid_caller> to <droid_callee>, |
| accept the call, (optional)then hang up from <droid_hangup>. |
| |
| Args: |
| ad_caller: Caller Android Device Object. |
| ad_callee: Callee Android Device Object. |
| subid_caller: Caller subscription ID |
| subid_callee: Callee subscription ID |
| ad_hangup: Android Device Object end the phone call. |
| Optional. Default value is None, and phone call will continue. |
| incall_ui_display: after answer the call, bring in-call UI to foreground or |
| background. Optional, default value is INCALL_UI_DISPLAY_FOREGROUND. |
| if = INCALL_UI_DISPLAY_FOREGROUND, bring in-call UI to foreground. |
| if = INCALL_UI_DISPLAY_BACKGROUND, bring in-call UI to background. |
| else, do nothing. |
| |
| Returns: |
| True if call process without any error. |
| False if error happened. |
| |
| """ |
| return call_setup_teardown_for_subscription( |
| log, |
| ad_caller, |
| ad_callee, |
| subid_caller, |
| subid_callee, |
| ad_hangup=None, |
| incall_ui_display=incall_ui_display, |
| video_state=video_state) |
| |
| |
| def video_call_modify_video(log, |
| ad_requester, |
| call_id_requester, |
| ad_responder, |
| call_id_responder, |
| video_state_request, |
| video_quality_request=VT_VIDEO_QUALITY_DEFAULT, |
| video_state_response=None, |
| video_quality_response=None, |
| verify_func_between_request_and_response=None): |
| """Modifies an ongoing call to change the video_call state |
| |
| Args: |
| log: logger object |
| ad_requester: android_device object of the requester |
| call_id_requester: the call_id of the call placing the modify request |
| ad_requester: android_device object of the responder |
| call_id_requester: the call_id of the call receiving the modify request |
| video_state_request: the requested video state |
| video_quality_request: the requested video quality, defaults to |
| QUALITY_DEFAULT |
| video_state_response: the responded video state or, or (default) |
| match the request if None |
| video_quality_response: the responded video quality, or (default) |
| match the request if None |
| |
| Returns: |
| A call_id corresponding to the first call in the state, or None |
| """ |
| |
| if not video_state_response: |
| video_state_response = video_state_request |
| if not video_quality_response: |
| video_quality_response = video_quality_request |
| |
| cur_video_state = ad_requester.droid.telecomCallVideoGetState( |
| call_id_requester) |
| |
| log.info("State change request from {} to {} requested".format( |
| cur_video_state, video_state_request)) |
| |
| if cur_video_state == video_state_request: |
| return True |
| |
| ad_responder.ed.clear_events( |
| EventTelecomVideoCallSessionModifyRequestReceived) |
| |
| ad_responder.droid.telecomCallVideoStartListeningForEvent( |
| call_id_responder, EVENT_VIDEO_SESSION_MODIFY_REQUEST_RECEIVED) |
| |
| ad_requester.droid.telecomCallVideoSendSessionModifyRequest( |
| call_id_requester, video_state_request, video_quality_request) |
| |
| try: |
| request_event = ad_responder.ed.pop_event( |
| EventTelecomVideoCallSessionModifyRequestReceived, |
| MAX_WAIT_TIME_VIDEO_SESSION_EVENT) |
| log.info(request_event) |
| except Empty: |
| log.error("Failed to receive SessionModifyRequest!") |
| return False |
| finally: |
| ad_responder.droid.telecomCallVideoStopListeningForEvent( |
| call_id_responder, EVENT_VIDEO_SESSION_MODIFY_REQUEST_RECEIVED) |
| |
| if (verify_func_between_request_and_response |
| and not verify_func_between_request_and_response()): |
| log.error("verify_func_between_request_and_response failed.") |
| return False |
| |
| # TODO: b/26291165 Replace with reducing the volume as we want |
| # to test route switching |
| ad_requester.droid.telecomCallSetAudioRoute(AUDIO_ROUTE_EARPIECE) |
| |
| ad_requester.droid.telecomCallVideoStartListeningForEvent( |
| call_id_requester, EVENT_VIDEO_SESSION_MODIFY_RESPONSE_RECEIVED) |
| |
| ad_responder.droid.telecomCallVideoSendSessionModifyResponse( |
| call_id_responder, video_state_response, video_quality_response) |
| |
| try: |
| response_event = ad_requester.ed.pop_event( |
| EventTelecomVideoCallSessionModifyResponseReceived, |
| MAX_WAIT_TIME_VIDEO_SESSION_EVENT) |
| log.info(response_event) |
| except Empty: |
| log.error("Failed to receive SessionModifyResponse!") |
| return False |
| finally: |
| ad_requester.droid.telecomCallVideoStopListeningForEvent( |
| call_id_requester, EVENT_VIDEO_SESSION_MODIFY_RESPONSE_RECEIVED) |
| |
| # TODO: b/26291165 Replace with reducing the volume as we want |
| # to test route switching |
| ad_responder.droid.telecomCallSetAudioRoute(AUDIO_ROUTE_EARPIECE) |
| |
| return True |
| |
| |
| def is_call_id_in_video_state(log, ad, call_id, video_state): |
| """Return is the call_id is in expected video_state |
| |
| Args: |
| log: logger object |
| ad: android_device object |
| call_id: call id |
| video_state: valid VIDEO_STATE |
| |
| Returns: |
| True is call_id in expected video_state; False if not. |
| """ |
| return video_state == ad.droid.telecomCallVideoGetState(call_id) |
| |
| |
| def get_call_id_in_video_state(log, ad, video_state): |
| """Gets the first call reporting a given video_state |
| from among the active calls |
| |
| Args: |
| log: logger object |
| ad: android_device object |
| video_state: valid VIDEO_STATE |
| |
| Returns: |
| A call_id corresponding to the first call in the state, or None |
| """ |
| |
| if not ad.droid.telecomIsInCall(): |
| log.error("{} not in call.".format(ad.serial)) |
| return None |
| for call in ad.droid.telecomCallGetCallIds(): |
| if is_call_id_in_video_state(log, ad, call, video_state): |
| return call |
| return None |
| |
| |
| def video_call_downgrade(log, |
| ad_requester, |
| call_id_requester, |
| ad_responder, |
| call_id_responder, |
| video_state_request=None, |
| video_quality_request=VT_VIDEO_QUALITY_DEFAULT): |
| """Downgrade Video call to video_state_request. |
| Send telecomCallVideoSendSessionModifyRequest from ad_requester. |
| Get video call state from ad_requester and ad_responder. |
| Verify video calls states are correct and downgrade succeed. |
| |
| Args: |
| log: logger object |
| ad_requester: android_device object of the requester |
| call_id_requester: the call_id of the call placing the modify request |
| ad_requester: android_device object of the responder |
| call_id_requester: the call_id of the call receiving the modify request |
| video_state_request: the requested downgrade video state |
| This parameter is optional. If this parameter is None: |
| if call_id_requester current is bi-directional, will downgrade to RX_ENABLED |
| if call_id_requester current is RX_ENABLED, will downgrade to AUDIO_ONLY |
| video_quality_request: the requested video quality, defaults to |
| QUALITY_DEFAULT |
| Returns: |
| True if downgrade succeed. |
| """ |
| if (call_id_requester is None) or (call_id_responder is None): |
| log.error("call_id_requester: {}, call_id_responder: {}".format( |
| call_id_requester, call_id_responder)) |
| return False |
| current_video_state_requester = ad_requester.droid.telecomCallVideoGetState( |
| call_id_requester) |
| if video_state_request is None: |
| if (current_video_state_requester == VT_STATE_BIDIRECTIONAL or |
| current_video_state_requester == VT_STATE_BIDIRECTIONAL_PAUSED |
| ): |
| video_state_request = VT_STATE_RX_ENABLED |
| elif (current_video_state_requester == VT_STATE_TX_ENABLED |
| or current_video_state_requester == VT_STATE_TX_PAUSED): |
| video_state_request = VT_STATE_AUDIO_ONLY |
| else: |
| log.error("Can Not Downgrade. ad: {}, current state {}".format( |
| ad_requester.serial, current_video_state_requester)) |
| return False |
| expected_video_state_responder = { |
| VT_STATE_AUDIO_ONLY: VT_STATE_AUDIO_ONLY, |
| VT_STATE_RX_ENABLED: VT_STATE_TX_ENABLED |
| }[video_state_request] |
| |
| ad_requester.droid.telecomCallVideoStartListeningForEvent( |
| call_id_requester, EVENT_VIDEO_SESSION_MODIFY_RESPONSE_RECEIVED) |
| |
| ad_requester.droid.telecomCallVideoSendSessionModifyRequest( |
| call_id_requester, video_state_request, video_quality_request) |
| |
| try: |
| response_event = ad_requester.ed.pop_event( |
| EventTelecomVideoCallSessionModifyResponseReceived, |
| MAX_WAIT_TIME_VIDEO_SESSION_EVENT) |
| log.info(response_event) |
| except Empty: |
| log.error("Failed to receive SessionModifyResponse!") |
| return False |
| finally: |
| ad_requester.droid.telecomCallVideoStopListeningForEvent( |
| call_id_requester, EVENT_VIDEO_SESSION_MODIFY_RESPONSE_RECEIVED) |
| |
| time.sleep(WAIT_TIME_ANDROID_STATE_SETTLING) |
| # TODO: b/26291165 Replace with reducing the volume as we want |
| # to test route switching |
| ad_requester.droid.telecomCallSetAudioRoute(AUDIO_ROUTE_EARPIECE) |
| ad_responder.droid.telecomCallSetAudioRoute(AUDIO_ROUTE_EARPIECE) |
| |
| time.sleep(WAIT_TIME_IN_CALL) |
| if video_state_request != ad_requester.droid.telecomCallVideoGetState( |
| call_id_requester): |
| log.error("requester not in correct state. expected:{}, current:{}" |
| .format(video_state_request, |
| ad_requester.droid.telecomCallVideoGetState( |
| call_id_requester))) |
| return False |
| if (expected_video_state_responder != |
| ad_responder.droid.telecomCallVideoGetState(call_id_responder)): |
| log.error( |
| "responder not in correct state. expected:{}, current:{}".format( |
| expected_video_state_responder, |
| ad_responder.droid.telecomCallVideoGetState( |
| call_id_responder))) |
| return False |
| |
| return True |
| |
| |
| def verify_video_call_in_expected_state(log, ad, call_id, call_video_state, |
| call_state): |
| """Return True if video call is in expected video state and call state. |
| |
| Args: |
| log: logger object |
| ad: android_device object |
| call_id: ad's call id |
| call_video_state: video state to validate. |
| call_state: call state to validate. |
| |
| Returns: |
| True if video call is in expected video state and call state. |
| """ |
| if not is_call_id_in_video_state(log, ad, call_id, call_video_state): |
| log.error("Call is not in expected {} state. Current state {}".format( |
| call_video_state, ad.droid.telecomCallVideoGetState(call_id))) |
| return False |
| if ad.droid.telecomCallGetCallState(call_id) != call_state: |
| log.error("Call is not in expected {} state. Current state {}".format( |
| call_state, ad.droid.telecomCallGetCallState(call_id))) |
| return False |
| return True |
