1#!/usr/bin/env python3 2# 3# Copyright 2021 - Google 4# 5# Licensed under the Apache License, Version 2.0 (the "License"); 6# you may not use this file except in compliance with the License. 7# You may obtain a copy of the License at 8# 9# http://www.apache.org/licenses/LICENSE-2.0 10# 11# Unless required by applicable law or agreed to in writing, software 12# distributed under the License is distributed on an "AS IS" BASIS, 13# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14# See the License for the specific language governing permissions and 15# limitations under the License. 16 17import re 18import time 19from queue import Empty 20from acts import signals 21from acts.utils import rand_ascii_str 22from acts.libs.utils.multithread import multithread_func 23from acts.libs.utils.multithread import run_multithread_func 24from acts_contrib.test_utils.tel.tel_defines import EventCallStateChanged 25from acts_contrib.test_utils.tel.tel_defines import EventMmsSentFailure 26from acts_contrib.test_utils.tel.tel_defines import EventMmsSentSuccess 27from acts_contrib.test_utils.tel.tel_defines import EventMmsDownloaded 28from acts_contrib.test_utils.tel.tel_defines import EventSmsDeliverFailure 29from acts_contrib.test_utils.tel.tel_defines import EventSmsDeliverSuccess 30from acts_contrib.test_utils.tel.tel_defines import EventSmsReceived 31from acts_contrib.test_utils.tel.tel_defines import EventSmsSentFailure 32from acts_contrib.test_utils.tel.tel_defines import EventSmsSentSuccess 33from acts_contrib.test_utils.tel.tel_defines import INCALL_UI_DISPLAY_BACKGROUND 34from acts_contrib.test_utils.tel.tel_defines import INCALL_UI_DISPLAY_FOREGROUND 35from acts_contrib.test_utils.tel.tel_defines import MAX_WAIT_TIME_MMS_RECEIVE 36from acts_contrib.test_utils.tel.tel_defines import MAX_WAIT_TIME_SMS_RECEIVE 37from acts_contrib.test_utils.tel.tel_defines import MAX_WAIT_TIME_SMS_RECEIVE_IN_COLLISION 38from acts_contrib.test_utils.tel.tel_defines import MAX_WAIT_TIME_SMS_SENT_SUCCESS_IN_COLLISION 39from acts_contrib.test_utils.tel.tel_defines import SMS_OVER_WIFI_PROVIDERS 40from acts_contrib.test_utils.tel.tel_defines import WAIT_TIME_ANDROID_STATE_SETTLING 41from acts_contrib.test_utils.tel.tel_defines import WAIT_TIME_IN_CALL 42from acts_contrib.test_utils.tel.tel_defines import VT_STATE_BIDIRECTIONAL 43from acts_contrib.test_utils.tel.tel_defines import WFC_MODE_DISABLED 44from acts_contrib.test_utils.tel.tel_phone_setup_utils import phone_setup_on_rat 45from acts_contrib.test_utils.tel.tel_subscription_utils import get_incoming_message_sub_id 46from acts_contrib.test_utils.tel.tel_subscription_utils import get_outgoing_message_sub_id 47from acts_contrib.test_utils.tel.tel_subscription_utils import get_subid_from_slot_index 48from acts_contrib.test_utils.tel.tel_subscription_utils import get_subid_on_same_network_of_host_ad 49from acts_contrib.test_utils.tel.tel_subscription_utils import set_subid_for_message 50from acts_contrib.test_utils.tel.tel_test_utils import CallResult 51from acts_contrib.test_utils.tel.tel_test_utils import TelResultWrapper 52from acts_contrib.test_utils.tel.tel_test_utils import check_phone_number_match 53from acts_contrib.test_utils.tel.tel_test_utils import get_device_epoch_time 54from acts_contrib.test_utils.tel.tel_test_utils import toggle_airplane_mode 55from acts_contrib.test_utils.tel.tel_voice_utils import call_setup_teardown 56from acts_contrib.test_utils.tel.tel_voice_utils import hangup_call 57from acts_contrib.test_utils.tel.tel_voice_utils import is_phone_in_call 58from acts_contrib.test_utils.tel.tel_voice_utils import last_call_drop_reason 59from acts_contrib.test_utils.tel.tel_voice_utils import is_phone_in_call_on_rat 60from acts_contrib.test_utils.tel.tel_voice_utils import wait_and_answer_call_for_subscription 61from acts_contrib.test_utils.tel.tel_voice_utils import wait_for_in_call_active 62from acts_contrib.test_utils.tel.tel_voice_utils import wait_for_call_end 63from acts_contrib.test_utils.tel.tel_voice_utils import wait_for_call_offhook_for_subscription 64from acts_contrib.test_utils.tel.tel_video_utils import is_phone_in_call_video_bidirectional 65from acts_contrib.test_utils.tel.tel_video_utils import video_call_setup_teardown 66from acts_contrib.test_utils.tel.tel_video_utils import phone_idle_video 67from acts_contrib.test_utils.tel.tel_wifi_utils import ensure_wifi_connected 68 69 70def send_message_with_random_message_body( 71 log, ad_mo, ad_mt, msg_type='sms', long_msg=False, mms_expected_result=True): 72 """Test SMS/MMS between two phones. 73 Returns: 74 True if success. 75 False if failed. 76 """ 77 message_lengths = (50, 160, 180) 78 79 if long_msg: 80 message_lengths = (800, 1600) 81 message_lengths_of_jp_carriers = (800, 1530) 82 sender_message_sub_id = get_outgoing_message_sub_id(ad_mo) 83 sender_mcc = ad_mo.telephony["subscription"][sender_message_sub_id]["mcc"] 84 if str(sender_mcc) in ["440", "441"]: 85 message_lengths = message_lengths_of_jp_carriers 86 87 if msg_type == 'sms': 88 for length in message_lengths: 89 message_array = [rand_ascii_str(length)] 90 if not sms_send_receive_verify(log, ad_mo, ad_mt, message_array): 91 ad_mo.log.error("SMS of length %s test failed", length) 92 return False 93 else: 94 ad_mo.log.info("SMS of length %s test succeeded", length) 95 log.info("SMS test of length %s characters succeeded.", 96 message_lengths) 97 elif msg_type == 'mms': 98 is_roaming = False 99 for ad in [ad_mo, ad_mt]: 100 ad.sms_over_wifi = False 101 # verizon supports sms over wifi. will add more carriers later 102 for sub in ad.telephony["subscription"].values(): 103 if sub["operator"] in SMS_OVER_WIFI_PROVIDERS: 104 ad.sms_over_wifi = True 105 106 if getattr(ad, 'roaming', False): 107 is_roaming = True 108 109 if is_roaming: 110 # roaming device does not allow message of length 180 111 message_lengths = (50, 160) 112 113 for length in message_lengths: 114 message_array = [("Test Message", rand_ascii_str(length), None)] 115 result = True 116 if not mms_send_receive_verify( 117 log, 118 ad_mo, 119 ad_mt, 120 message_array, 121 expected_result=mms_expected_result): 122 123 if mms_expected_result is True: 124 if ad_mo.droid.telecomIsInCall() or ad_mt.droid.telecomIsInCall(): 125 if not mms_receive_verify_after_call_hangup( 126 log, ad_mo, ad_mt, message_array): 127 result = False 128 else: 129 result = False 130 131 if not result: 132 log.error("MMS of body length %s test failed", length) 133 return False 134 else: 135 log.info("MMS of body length %s test succeeded", length) 136 log.info("MMS test of body lengths %s succeeded", message_lengths) 137 return True 138 139def message_test( 140 log, 141 ad_mo, 142 ad_mt, 143 mo_rat='general', 144 mt_rat='general', 145 msg_type='sms', 146 long_msg=False, 147 mms_expected_result=True, 148 msg_in_call=False, 149 video_or_voice='voice', 150 is_airplane_mode=False, 151 wfc_mode=None, 152 wifi_ssid=None, 153 wifi_pwd=None): 154 155 mo_phone_setup_argv = ( 156 log, ad_mo, 'general', None, False, None, None, None, None, 'sms') 157 mt_phone_setup_argv = ( 158 log, ad_mt, 'general', None, False, None, None, None, None, 'sms') 159 verify_caller_func = None 160 verify_callee_func = None 161 162 if mo_rat: 163 mo_phone_setup_argv = ( 164 log, 165 ad_mo, 166 mo_rat, 167 None, 168 is_airplane_mode, 169 wfc_mode, 170 wifi_ssid, 171 wifi_pwd, 172 None, 173 'sms') 174 verify_caller_func = is_phone_in_call_on_rat( 175 log, ad_mo, rat=mo_rat, only_return_fn=True) 176 177 if mt_rat: 178 mt_phone_setup_argv = ( 179 log, 180 ad_mt, 181 mt_rat, 182 None, 183 is_airplane_mode, 184 wfc_mode, 185 wifi_ssid, 186 wifi_pwd, 187 None, 188 'sms') 189 verify_callee_func = is_phone_in_call_on_rat( 190 log, ad_mo, rat=mt_rat, only_return_fn=True) 191 192 tasks = [(phone_setup_on_rat, mo_phone_setup_argv), 193 (phone_setup_on_rat, mt_phone_setup_argv)] 194 if not multithread_func(log, tasks): 195 log.error("Phone Failed to Set Up Properly.") 196 return False 197 time.sleep(WAIT_TIME_ANDROID_STATE_SETTLING) 198 199 if wifi_ssid: 200 if not wfc_mode or wfc_mode == WFC_MODE_DISABLED: 201 tasks = [(ensure_wifi_connected, (log, ad_mo, wifi_ssid, wifi_pwd)), 202 (ensure_wifi_connected, (log, ad_mt, wifi_ssid, wifi_pwd))] 203 if not multithread_func(log, tasks): 204 log.error("Failed to connected to Wi-Fi.") 205 return False 206 207 if msg_in_call: 208 if video_or_voice == 'voice': 209 if not call_setup_teardown( 210 log, 211 ad_mo, 212 ad_mt, 213 ad_hangup=None, 214 verify_caller_func=verify_caller_func, 215 verify_callee_func=verify_callee_func): 216 log.error("Failed to setup a voice call") 217 return False 218 elif video_or_voice == 'video': 219 tasks = [ 220 (phone_idle_video, (log, ad_mo)), 221 (phone_idle_video, (log, ad_mt))] 222 if not multithread_func(log, tasks): 223 log.error("Phone Failed to Set Up Properly.") 224 return False 225 time.sleep(WAIT_TIME_ANDROID_STATE_SETTLING) 226 if not video_call_setup_teardown( 227 log, 228 ad_mo, 229 ad_mt, 230 None, 231 video_state=VT_STATE_BIDIRECTIONAL, 232 verify_caller_func=is_phone_in_call_video_bidirectional, 233 verify_callee_func=is_phone_in_call_video_bidirectional): 234 log.error("Failed to setup a video call") 235 return False 236 237 result = True 238 if not send_message_with_random_message_body( 239 log, ad_mo, ad_mt, msg_type, long_msg, mms_expected_result): 240 log.error("Test failed.") 241 result = False 242 243 if msg_in_call: 244 if not hangup_call(log, ad_mo): 245 ad_mo.log.info("Failed to hang up call!") 246 result = False 247 248 return result 249 250def sms_send_receive_verify(log, 251 ad_tx, 252 ad_rx, 253 array_message, 254 max_wait_time=MAX_WAIT_TIME_SMS_RECEIVE, 255 expected_result=True, 256 slot_id_rx=None): 257 """Send SMS, receive SMS, and verify content and sender's number. 258 259 Send (several) SMS from droid_tx to droid_rx. 260 Verify SMS is sent, delivered and received. 261 Verify received content and sender's number are correct. 262 263 Args: 264 log: Log object. 265 ad_tx: Sender's Android Device Object 266 ad_rx: Receiver's Android Device Object 267 array_message: the array of message to send/receive 268 slot_id_rx: the slot on the Receiver's android device (0/1) 269 """ 270 subid_tx = get_outgoing_message_sub_id(ad_tx) 271 if slot_id_rx is None: 272 subid_rx = get_incoming_message_sub_id(ad_rx) 273 else: 274 subid_rx = get_subid_from_slot_index(log, ad_rx, slot_id_rx) 275 276 result = sms_send_receive_verify_for_subscription( 277 log, ad_tx, ad_rx, subid_tx, subid_rx, array_message, max_wait_time) 278 if result != expected_result: 279 log_messaging_screen_shot(ad_tx, test_name="sms_tx") 280 log_messaging_screen_shot(ad_rx, test_name="sms_rx") 281 return result == expected_result 282 283def sms_send_receive_verify_for_subscription( 284 log, 285 ad_tx, 286 ad_rx, 287 subid_tx, 288 subid_rx, 289 array_message, 290 max_wait_time=MAX_WAIT_TIME_SMS_RECEIVE): 291 """Send SMS, receive SMS, and verify content and sender's number. 292 293 Send (several) SMS from droid_tx to droid_rx. 294 Verify SMS is sent, delivered and received. 295 Verify received content and sender's number are correct. 296 297 Args: 298 log: Log object. 299 ad_tx: Sender's Android Device Object.. 300 ad_rx: Receiver's Android Device Object. 301 subid_tx: Sender's subscription ID to be used for SMS 302 subid_rx: Receiver's subscription ID to be used for SMS 303 array_message: the array of message to send/receive 304 """ 305 phonenumber_tx = ad_tx.telephony['subscription'][subid_tx]['phone_num'] 306 phonenumber_rx = ad_rx.telephony['subscription'][subid_rx]['phone_num'] 307 308 for ad in (ad_tx, ad_rx): 309 if not getattr(ad, "messaging_droid", None): 310 ad.messaging_droid, ad.messaging_ed = ad.get_droid() 311 ad.messaging_ed.start() 312 else: 313 try: 314 if not ad.messaging_droid.is_live: 315 ad.messaging_droid, ad.messaging_ed = ad.get_droid() 316 ad.messaging_ed.start() 317 else: 318 ad.messaging_ed.clear_all_events() 319 ad.messaging_droid.logI( 320 "Start sms_send_receive_verify_for_subscription test") 321 except Exception: 322 ad.log.info("Create new sl4a session for messaging") 323 ad.messaging_droid, ad.messaging_ed = ad.get_droid() 324 ad.messaging_ed.start() 325 326 for text in array_message: 327 length = len(text) 328 ad_tx.log.info("Sending SMS from %s to %s, len: %s, content: %s.", 329 phonenumber_tx, phonenumber_rx, length, text) 330 try: 331 ad_rx.messaging_ed.clear_events(EventSmsReceived) 332 ad_tx.messaging_ed.clear_events(EventSmsSentSuccess) 333 ad_tx.messaging_ed.clear_events(EventSmsSentFailure) 334 ad_rx.messaging_droid.smsStartTrackingIncomingSmsMessage() 335 time.sleep(1) #sleep 100ms after starting event tracking 336 ad_tx.messaging_droid.logI("Sending SMS of length %s" % length) 337 ad_rx.messaging_droid.logI("Expecting SMS of length %s" % length) 338 ad_tx.messaging_droid.smsSendTextMessage(phonenumber_rx, text, 339 True) 340 try: 341 events = ad_tx.messaging_ed.pop_events( 342 "(%s|%s|%s|%s)" % 343 (EventSmsSentSuccess, EventSmsSentFailure, 344 EventSmsDeliverSuccess, 345 EventSmsDeliverFailure), max_wait_time) 346 for event in events: 347 ad_tx.log.info("Got event %s", event["name"]) 348 if event["name"] == EventSmsSentFailure or event["name"] == EventSmsDeliverFailure: 349 if event.get("data") and event["data"].get("Reason"): 350 ad_tx.log.error("%s with reason: %s", 351 event["name"], 352 event["data"]["Reason"]) 353 return False 354 elif event["name"] == EventSmsSentSuccess or event["name"] == EventSmsDeliverSuccess: 355 break 356 except Empty: 357 ad_tx.log.error("No %s or %s event for SMS of length %s.", 358 EventSmsSentSuccess, EventSmsSentFailure, 359 length) 360 return False 361 362 if not wait_for_matching_sms( 363 log, 364 ad_rx, 365 phonenumber_tx, 366 text, 367 max_wait_time, 368 allow_multi_part_long_sms=True): 369 ad_rx.log.error("No matching received SMS of length %s.", 370 length) 371 return False 372 except Exception as e: 373 log.error("Exception error %s", e) 374 raise 375 finally: 376 ad_rx.messaging_droid.smsStopTrackingIncomingSmsMessage() 377 return True 378 379def sms_in_collision_send_receive_verify( 380 log, 381 ad_rx, 382 ad_rx2, 383 ad_tx, 384 ad_tx2, 385 array_message, 386 array_message2, 387 max_wait_time=MAX_WAIT_TIME_SMS_RECEIVE_IN_COLLISION): 388 """Send 2 SMS', receive both SMS', and verify content and sender's number of 389 each SMS. 390 391 Send 2 SMS'. One from ad_tx to ad_rx and the other from ad_tx2 to ad_rx2. 392 When ad_rx is identical to ad_rx2, the scenario of SMS' in collision can 393 be tested. 394 Verify both SMS' are sent, delivered and received. 395 Verify received content and sender's number of each SMS is correct. 396 397 Args: 398 log: Log object. 399 ad_tx: Sender's Android Device Object.. 400 ad_rx: Receiver's Android Device Object. 401 ad_tx2: 2nd sender's Android Device Object.. 402 ad_rx2: 2nd receiver's Android Device Object. 403 array_message: the array of message to send/receive from ad_tx to ad_rx 404 array_message2: the array of message to send/receive from ad_tx2 to 405 ad_rx2 406 max_wait_time: Max time to wait for reception of SMS 407 """ 408 rx_sub_id = get_outgoing_message_sub_id(ad_rx) 409 rx2_sub_id = get_outgoing_message_sub_id(ad_rx2) 410 411 _, tx_sub_id, _ = get_subid_on_same_network_of_host_ad( 412 [ad_rx, ad_tx, ad_tx2], 413 host_sub_id=rx_sub_id) 414 set_subid_for_message(ad_tx, tx_sub_id) 415 416 _, _, tx2_sub_id = get_subid_on_same_network_of_host_ad( 417 [ad_rx2, ad_tx, ad_tx2], 418 host_sub_id=rx2_sub_id) 419 set_subid_for_message(ad_tx2, tx2_sub_id) 420 421 if not sms_in_collision_send_receive_verify_for_subscription( 422 log, 423 ad_tx, 424 ad_tx2, 425 ad_rx, 426 ad_rx2, 427 tx_sub_id, 428 tx2_sub_id, 429 rx_sub_id, 430 rx_sub_id, 431 array_message, 432 array_message2, 433 max_wait_time): 434 log_messaging_screen_shot( 435 ad_rx, test_name="sms rx subid: %s" % rx_sub_id) 436 log_messaging_screen_shot( 437 ad_rx2, test_name="sms rx2 subid: %s" % rx2_sub_id) 438 log_messaging_screen_shot( 439 ad_tx, test_name="sms tx subid: %s" % tx_sub_id) 440 log_messaging_screen_shot( 441 ad_tx2, test_name="sms tx subid: %s" % tx2_sub_id) 442 return False 443 return True 444 445def sms_in_collision_send_receive_verify_for_subscription( 446 log, 447 ad_tx, 448 ad_tx2, 449 ad_rx, 450 ad_rx2, 451 subid_tx, 452 subid_tx2, 453 subid_rx, 454 subid_rx2, 455 array_message, 456 array_message2, 457 max_wait_time=MAX_WAIT_TIME_SMS_RECEIVE_IN_COLLISION): 458 """Send 2 SMS', receive both SMS', and verify content and sender's number of 459 each SMS. 460 461 Send 2 SMS'. One from ad_tx to ad_rx and the other from ad_tx2 to ad_rx2. 462 When ad_rx is identical to ad_rx2, the scenario of SMS' in collision can 463 be tested. 464 Verify both SMS' are sent, delivered and received. 465 Verify received content and sender's number of each SMS is correct. 466 467 Args: 468 log: Log object. 469 ad_tx: Sender's Android Device Object.. 470 ad_rx: Receiver's Android Device Object. 471 ad_tx2: 2nd sender's Android Device Object.. 472 ad_rx2: 2nd receiver's Android Device Object. 473 subid_tx: Sub ID of ad_tx as default Sub ID for outgoing SMS 474 subid_tx2: Sub ID of ad_tx2 as default Sub ID for outgoing SMS 475 subid_rx: Sub ID of ad_rx as default Sub ID for incoming SMS 476 subid_rx2: Sub ID of ad_rx2 as default Sub ID for incoming SMS 477 array_message: the array of message to send/receive from ad_tx to ad_rx 478 array_message2: the array of message to send/receive from ad_tx2 to 479 ad_rx2 480 max_wait_time: Max time to wait for reception of SMS 481 """ 482 483 phonenumber_tx = ad_tx.telephony['subscription'][subid_tx]['phone_num'] 484 phonenumber_tx2 = ad_tx2.telephony['subscription'][subid_tx2]['phone_num'] 485 phonenumber_rx = ad_rx.telephony['subscription'][subid_rx]['phone_num'] 486 phonenumber_rx2 = ad_rx2.telephony['subscription'][subid_rx2]['phone_num'] 487 488 for ad in (ad_tx, ad_tx2, ad_rx, ad_rx2): 489 ad.send_keycode("BACK") 490 if not getattr(ad, "messaging_droid", None): 491 ad.messaging_droid, ad.messaging_ed = ad.get_droid() 492 ad.messaging_ed.start() 493 else: 494 try: 495 if not ad.messaging_droid.is_live: 496 ad.messaging_droid, ad.messaging_ed = ad.get_droid() 497 ad.messaging_ed.start() 498 else: 499 ad.messaging_ed.clear_all_events() 500 ad.messaging_droid.logI( 501 "Start sms_send_receive_verify_for_subscription test") 502 except Exception: 503 ad.log.info("Create new sl4a session for messaging") 504 ad.messaging_droid, ad.messaging_ed = ad.get_droid() 505 ad.messaging_ed.start() 506 507 for text, text2 in zip(array_message, array_message2): 508 length = len(text) 509 length2 = len(text2) 510 ad_tx.log.info("Sending SMS from %s to %s, len: %s, content: %s.", 511 phonenumber_tx, phonenumber_rx, length, text) 512 ad_tx2.log.info("Sending SMS from %s to %s, len: %s, content: %s.", 513 phonenumber_tx2, phonenumber_rx2, length2, text2) 514 515 try: 516 ad_rx.messaging_ed.clear_events(EventSmsReceived) 517 ad_rx2.messaging_ed.clear_events(EventSmsReceived) 518 ad_tx.messaging_ed.clear_events(EventSmsSentSuccess) 519 ad_tx.messaging_ed.clear_events(EventSmsSentFailure) 520 ad_tx2.messaging_ed.clear_events(EventSmsSentSuccess) 521 ad_tx2.messaging_ed.clear_events(EventSmsSentFailure) 522 ad_rx.messaging_droid.smsStartTrackingIncomingSmsMessage() 523 if ad_rx2 != ad_rx: 524 ad_rx2.messaging_droid.smsStartTrackingIncomingSmsMessage() 525 time.sleep(1) 526 ad_tx.messaging_droid.logI("Sending SMS of length %s" % length) 527 ad_tx2.messaging_droid.logI("Sending SMS of length %s" % length2) 528 ad_rx.messaging_droid.logI( 529 "Expecting SMS of length %s from %s" % (length, ad_tx.serial)) 530 ad_rx2.messaging_droid.logI( 531 "Expecting SMS of length %s from %s" % (length2, ad_tx2.serial)) 532 533 tasks = [ 534 (ad_tx.messaging_droid.smsSendTextMessage, 535 (phonenumber_rx, text, True)), 536 (ad_tx2.messaging_droid.smsSendTextMessage, 537 (phonenumber_rx2, text2, True))] 538 multithread_func(log, tasks) 539 try: 540 tasks = [ 541 (ad_tx.messaging_ed.pop_events, ("(%s|%s|%s|%s)" % ( 542 EventSmsSentSuccess, 543 EventSmsSentFailure, 544 EventSmsDeliverSuccess, 545 EventSmsDeliverFailure), max_wait_time)), 546 (ad_tx2.messaging_ed.pop_events, ("(%s|%s|%s|%s)" % ( 547 EventSmsSentSuccess, 548 EventSmsSentFailure, 549 EventSmsDeliverSuccess, 550 EventSmsDeliverFailure), max_wait_time)) 551 ] 552 results = run_multithread_func(log, tasks) 553 res = True 554 _ad = ad_tx 555 for ad, events in [(ad_tx, results[0]),(ad_tx2, results[1])]: 556 _ad = ad 557 for event in events: 558 ad.log.info("Got event %s", event["name"]) 559 if event["name"] == EventSmsSentFailure or \ 560 event["name"] == EventSmsDeliverFailure: 561 if event.get("data") and event["data"].get("Reason"): 562 ad.log.error("%s with reason: %s", 563 event["name"], 564 event["data"]["Reason"]) 565 res = False 566 elif event["name"] == EventSmsSentSuccess or \ 567 event["name"] == EventSmsDeliverSuccess: 568 break 569 if not res: 570 return False 571 except Empty: 572 _ad.log.error("No %s or %s event for SMS of length %s.", 573 EventSmsSentSuccess, EventSmsSentFailure, 574 length) 575 return False 576 if ad_rx == ad_rx2: 577 if not wait_for_matching_mt_sms_in_collision( 578 log, 579 ad_rx, 580 phonenumber_tx, 581 phonenumber_tx2, 582 text, 583 text2, 584 max_wait_time=MAX_WAIT_TIME_SMS_RECEIVE_IN_COLLISION): 585 586 ad_rx.log.error( 587 "No matching received SMS of length %s from %s.", 588 length, 589 ad_rx.serial) 590 return False 591 else: 592 if not wait_for_matching_mt_sms_in_collision_with_mo_sms( 593 log, 594 ad_rx, 595 ad_rx2, 596 phonenumber_tx, 597 phonenumber_tx2, 598 text, 599 text2, 600 max_wait_time=MAX_WAIT_TIME_SMS_RECEIVE_IN_COLLISION): 601 return False 602 except Exception as e: 603 log.error("Exception error %s", e) 604 raise 605 finally: 606 ad_rx.messaging_droid.smsStopTrackingIncomingSmsMessage() 607 ad_rx2.messaging_droid.smsStopTrackingIncomingSmsMessage() 608 return True 609 610def sms_rx_power_off_multiple_send_receive_verify( 611 log, 612 ad_rx, 613 ad_tx, 614 ad_tx2, 615 array_message_length, 616 array_message2_length, 617 num_array_message, 618 num_array_message2, 619 max_wait_time=MAX_WAIT_TIME_SMS_RECEIVE_IN_COLLISION): 620 621 rx_sub_id = get_outgoing_message_sub_id(ad_rx) 622 623 _, tx_sub_id, _ = get_subid_on_same_network_of_host_ad( 624 [ad_rx, ad_tx, ad_tx2], 625 host_sub_id=rx_sub_id) 626 set_subid_for_message(ad_tx, tx_sub_id) 627 628 _, _, tx2_sub_id = get_subid_on_same_network_of_host_ad( 629 [ad_rx, ad_tx, ad_tx2], 630 host_sub_id=rx_sub_id) 631 set_subid_for_message(ad_tx2, tx2_sub_id) 632 633 if not sms_rx_power_off_multiple_send_receive_verify_for_subscription( 634 log, 635 ad_tx, 636 ad_tx2, 637 ad_rx, 638 tx_sub_id, 639 tx2_sub_id, 640 rx_sub_id, 641 rx_sub_id, 642 array_message_length, 643 array_message2_length, 644 num_array_message, 645 num_array_message2): 646 log_messaging_screen_shot( 647 ad_rx, test_name="sms rx subid: %s" % rx_sub_id) 648 log_messaging_screen_shot( 649 ad_tx, test_name="sms tx subid: %s" % tx_sub_id) 650 log_messaging_screen_shot( 651 ad_tx2, test_name="sms tx subid: %s" % tx2_sub_id) 652 return False 653 return True 654 655def sms_rx_power_off_multiple_send_receive_verify_for_subscription( 656 log, 657 ad_tx, 658 ad_tx2, 659 ad_rx, 660 subid_tx, 661 subid_tx2, 662 subid_rx, 663 subid_rx2, 664 array_message_length, 665 array_message2_length, 666 num_array_message, 667 num_array_message2, 668 max_wait_time=MAX_WAIT_TIME_SMS_RECEIVE_IN_COLLISION): 669 670 phonenumber_tx = ad_tx.telephony['subscription'][subid_tx]['phone_num'] 671 phonenumber_tx2 = ad_tx2.telephony['subscription'][subid_tx2]['phone_num'] 672 phonenumber_rx = ad_rx.telephony['subscription'][subid_rx]['phone_num'] 673 phonenumber_rx2 = ad_rx.telephony['subscription'][subid_rx2]['phone_num'] 674 675 if not toggle_airplane_mode(log, ad_rx, True): 676 ad_rx.log.error("Failed to enable Airplane Mode") 677 return False 678 ad_rx.stop_services() 679 ad_rx.log.info("Rebooting......") 680 ad_rx.adb.reboot() 681 682 message_dict = {phonenumber_tx: [], phonenumber_tx2: []} 683 for index in range(max(num_array_message, num_array_message2)): 684 array_message = [rand_ascii_str(array_message_length)] 685 array_message2 = [rand_ascii_str(array_message2_length)] 686 for text, text2 in zip(array_message, array_message2): 687 message_dict[phonenumber_tx].append(text) 688 message_dict[phonenumber_tx2].append(text2) 689 length = len(text) 690 length2 = len(text2) 691 692 ad_tx.log.info("Sending SMS from %s to %s, len: %s, content: %s.", 693 phonenumber_tx, phonenumber_rx, length, text) 694 ad_tx2.log.info("Sending SMS from %s to %s, len: %s, content: %s.", 695 phonenumber_tx2, phonenumber_rx2, length2, text2) 696 697 try: 698 for ad in (ad_tx, ad_tx2): 699 ad.send_keycode("BACK") 700 if not getattr(ad, "messaging_droid", None): 701 ad.messaging_droid, ad.messaging_ed = ad.get_droid() 702 ad.messaging_ed.start() 703 else: 704 try: 705 if not ad.messaging_droid.is_live: 706 ad.messaging_droid, ad.messaging_ed = \ 707 ad.get_droid() 708 ad.messaging_ed.start() 709 else: 710 ad.messaging_ed.clear_all_events() 711 ad.messaging_droid.logI( 712 "Start sms_send_receive_verify_for_subscription" 713 " test") 714 except Exception: 715 ad.log.info("Create new sl4a session for messaging") 716 ad.messaging_droid, ad.messaging_ed = ad.get_droid() 717 ad.messaging_ed.start() 718 719 ad_tx.messaging_ed.clear_events(EventSmsSentSuccess) 720 ad_tx.messaging_ed.clear_events(EventSmsSentFailure) 721 ad_tx2.messaging_ed.clear_events(EventSmsSentSuccess) 722 ad_tx2.messaging_ed.clear_events(EventSmsSentFailure) 723 724 if index < num_array_message and index < num_array_message2: 725 ad_tx.messaging_droid.logI( 726 "Sending SMS of length %s" % length) 727 ad_tx2.messaging_droid.logI( 728 "Sending SMS of length %s" % length2) 729 tasks = [ 730 (ad_tx.messaging_droid.smsSendTextMessage, 731 (phonenumber_rx, text, True)), 732 (ad_tx2.messaging_droid.smsSendTextMessage, 733 (phonenumber_rx2, text2, True))] 734 multithread_func(log, tasks) 735 else: 736 if index < num_array_message: 737 ad_tx.messaging_droid.logI( 738 "Sending SMS of length %s" % length) 739 ad_tx.messaging_droid.smsSendTextMessage( 740 phonenumber_rx, text, True) 741 if index < num_array_message2: 742 ad_tx2.messaging_droid.logI( 743 "Sending SMS of length %s" % length2) 744 ad_tx2.messaging_droid.smsSendTextMessage( 745 phonenumber_rx2, text2, True) 746 747 try: 748 if index < num_array_message and index < num_array_message2: 749 tasks = [ 750 (ad_tx.messaging_ed.pop_events, ("(%s|%s|%s|%s)" % ( 751 EventSmsSentSuccess, 752 EventSmsSentFailure, 753 EventSmsDeliverSuccess, 754 EventSmsDeliverFailure), 755 max_wait_time)), 756 (ad_tx2.messaging_ed.pop_events, ("(%s|%s|%s|%s)" % ( 757 EventSmsSentSuccess, 758 EventSmsSentFailure, 759 EventSmsDeliverSuccess, 760 EventSmsDeliverFailure), 761 max_wait_time)) 762 ] 763 results = run_multithread_func(log, tasks) 764 res = True 765 _ad = ad_tx 766 for ad, events in [ 767 (ad_tx, results[0]), (ad_tx2, results[1])]: 768 _ad = ad 769 for event in events: 770 ad.log.info("Got event %s", event["name"]) 771 if event["name"] == EventSmsSentFailure or \ 772 event["name"] == EventSmsDeliverFailure: 773 if event.get("data") and \ 774 event["data"].get("Reason"): 775 ad.log.error("%s with reason: %s", 776 event["name"], 777 event["data"]["Reason"]) 778 res = False 779 elif event["name"] == EventSmsSentSuccess or \ 780 event["name"] == EventSmsDeliverSuccess: 781 break 782 if not res: 783 return False 784 else: 785 if index < num_array_message: 786 result = ad_tx.messaging_ed.pop_events( 787 "(%s|%s|%s|%s)" % ( 788 EventSmsSentSuccess, 789 EventSmsSentFailure, 790 EventSmsDeliverSuccess, 791 EventSmsDeliverFailure), 792 max_wait_time) 793 res = True 794 _ad = ad_tx 795 for ad, events in [(ad_tx, result)]: 796 _ad = ad 797 for event in events: 798 ad.log.info("Got event %s", event["name"]) 799 if event["name"] == EventSmsSentFailure or \ 800 event["name"] == EventSmsDeliverFailure: 801 if event.get("data") and \ 802 event["data"].get("Reason"): 803 ad.log.error( 804 "%s with reason: %s", 805 event["name"], 806 event["data"]["Reason"]) 807 res = False 808 elif event["name"] == EventSmsSentSuccess \ 809 or event["name"] == EventSmsDeliverSuccess: 810 break 811 if not res: 812 return False 813 if index < num_array_message2: 814 result = ad_tx2.messaging_ed.pop_events( 815 "(%s|%s|%s|%s)" % ( 816 EventSmsSentSuccess, 817 EventSmsSentFailure, 818 EventSmsDeliverSuccess, 819 EventSmsDeliverFailure), 820 max_wait_time) 821 res = True 822 _ad = ad_tx2 823 for ad, events in [(ad_tx2, result)]: 824 _ad = ad 825 for event in events: 826 ad.log.info("Got event %s", event["name"]) 827 if event["name"] == EventSmsSentFailure or \ 828 event["name"] == EventSmsDeliverFailure: 829 if event.get("data") and \ 830 event["data"].get("Reason"): 831 ad.log.error( 832 "%s with reason: %s", 833 event["name"], 834 event["data"]["Reason"]) 835 res = False 836 elif event["name"] == EventSmsSentSuccess \ 837 or event["name"] == EventSmsDeliverSuccess: 838 break 839 if not res: 840 return False 841 842 843 except Empty: 844 _ad.log.error("No %s or %s event for SMS of length %s.", 845 EventSmsSentSuccess, EventSmsSentFailure, 846 length) 847 return False 848 849 except Exception as e: 850 log.error("Exception error %s", e) 851 raise 852 853 ad_rx.wait_for_boot_completion() 854 ad_rx.root_adb() 855 ad_rx.start_services(skip_setup_wizard=False) 856 857 output = ad_rx.adb.logcat("-t 1") 858 match = re.search(r"\d+-\d+\s\d+:\d+:\d+.\d+", output) 859 if match: 860 ad_rx.test_log_begin_time = match.group(0) 861 862 ad_rx.messaging_droid, ad_rx.messaging_ed = ad_rx.get_droid() 863 ad_rx.messaging_ed.start() 864 ad_rx.messaging_droid.smsStartTrackingIncomingSmsMessage() 865 time.sleep(1) #sleep 100ms after starting event tracking 866 867 if not toggle_airplane_mode(log, ad_rx, False): 868 ad_rx.log.error("Failed to disable Airplane Mode") 869 return False 870 871 res = True 872 try: 873 if not wait_for_matching_multiple_sms(log, 874 ad_rx, 875 phonenumber_tx, 876 phonenumber_tx2, 877 messages=message_dict, 878 max_wait_time=max_wait_time): 879 res = False 880 except Exception as e: 881 log.error("Exception error %s", e) 882 raise 883 finally: 884 ad_rx.messaging_droid.smsStopTrackingIncomingSmsMessage() 885 886 return res 887 888def is_sms_match(event, phonenumber_tx, text): 889 """Return True if 'text' equals to event['data']['Text'] 890 and phone number match. 891 892 Args: 893 event: Event object to verify. 894 phonenumber_tx: phone number for sender. 895 text: text string to verify. 896 897 Returns: 898 Return True if 'text' equals to event['data']['Text'] 899 and phone number match. 900 """ 901 return (check_phone_number_match(event['data']['Sender'], phonenumber_tx) 902 and event['data']['Text'].strip() == text) 903 904def is_sms_partial_match(event, phonenumber_tx, text): 905 """Return True if 'text' starts with event['data']['Text'] 906 and phone number match. 907 908 Args: 909 event: Event object to verify. 910 phonenumber_tx: phone number for sender. 911 text: text string to verify. 912 913 Returns: 914 Return True if 'text' starts with event['data']['Text'] 915 and phone number match. 916 """ 917 event_text = event['data']['Text'].strip() 918 if event_text.startswith("("): 919 event_text = event_text.split(")")[-1] 920 return (check_phone_number_match(event['data']['Sender'], phonenumber_tx) 921 and text.startswith(event_text)) 922 923def is_sms_in_collision_match( 924 event, phonenumber_tx, phonenumber_tx2, text, text2): 925 event_text = event['data']['Text'].strip() 926 if event_text.startswith("("): 927 event_text = event_text.split(")")[-1] 928 929 for phonenumber, txt in [[phonenumber_tx, text], [phonenumber_tx2, text2]]: 930 if check_phone_number_match( 931 event['data']['Sender'], phonenumber) and txt.startswith(event_text): 932 return True 933 return False 934 935def is_sms_in_collision_partial_match( 936 event, phonenumber_tx, phonenumber_tx2, text, text2): 937 for phonenumber, txt in [[phonenumber_tx, text], [phonenumber_tx2, text2]]: 938 if check_phone_number_match( 939 event['data']['Sender'], phonenumber) and \ 940 event['data']['Text'].strip() == txt: 941 return True 942 return False 943 944def is_sms_match_among_multiple_sms( 945 event, phonenumber_tx, phonenumber_tx2, texts=[], texts2=[]): 946 for txt in texts: 947 if check_phone_number_match( 948 event['data']['Sender'], phonenumber_tx) and \ 949 event['data']['Text'].strip() == txt: 950 return True 951 952 for txt in texts2: 953 if check_phone_number_match( 954 event['data']['Sender'], phonenumber_tx2) and \ 955 event['data']['Text'].strip() == txt: 956 return True 957 958 return False 959 960def is_sms_partial_match_among_multiple_sms( 961 event, phonenumber_tx, phonenumber_tx2, texts=[], texts2=[]): 962 event_text = event['data']['Text'].strip() 963 if event_text.startswith("("): 964 event_text = event_text.split(")")[-1] 965 966 for txt in texts: 967 if check_phone_number_match( 968 event['data']['Sender'], phonenumber_tx) and \ 969 txt.startswith(event_text): 970 return True 971 972 for txt in texts2: 973 if check_phone_number_match( 974 event['data']['Sender'], phonenumber_tx2) and \ 975 txt.startswith(event_text): 976 return True 977 978 return False 979 980def wait_for_matching_sms(log, 981 ad_rx, 982 phonenumber_tx, 983 text, 984 max_wait_time=MAX_WAIT_TIME_SMS_RECEIVE, 985 allow_multi_part_long_sms=True): 986 """Wait for matching incoming SMS. 987 988 Args: 989 log: Log object. 990 ad_rx: Receiver's Android Device Object 991 phonenumber_tx: Sender's phone number. 992 text: SMS content string. 993 allow_multi_part_long_sms: is long SMS allowed to be received as 994 multiple short SMS. This is optional, default value is True. 995 996 Returns: 997 True if matching incoming SMS is received. 998 """ 999 if not allow_multi_part_long_sms: 1000 try: 1001 ad_rx.messaging_ed.wait_for_event(EventSmsReceived, is_sms_match, 1002 max_wait_time, phonenumber_tx, 1003 text) 1004 ad_rx.log.info("Got event %s", EventSmsReceived) 1005 return True 1006 except Empty: 1007 ad_rx.log.error("No matched SMS received event.") 1008 return False 1009 else: 1010 try: 1011 received_sms = '' 1012 remaining_text = text 1013 while (remaining_text != ''): 1014 event = ad_rx.messaging_ed.wait_for_event( 1015 EventSmsReceived, is_sms_partial_match, max_wait_time, 1016 phonenumber_tx, remaining_text) 1017 event_text = event['data']['Text'].split(")")[-1].strip() 1018 event_text_length = len(event_text) 1019 ad_rx.log.info("Got event %s of text length %s from %s", 1020 EventSmsReceived, event_text_length, 1021 phonenumber_tx) 1022 remaining_text = remaining_text[event_text_length:] 1023 received_sms += event_text 1024 ad_rx.log.info("Received SMS of length %s", len(received_sms)) 1025 return True 1026 except Empty: 1027 ad_rx.log.error( 1028 "Missing SMS received event of text length %s from %s", 1029 len(remaining_text), phonenumber_tx) 1030 if received_sms != '': 1031 ad_rx.log.error( 1032 "Only received partial matched SMS of length %s", 1033 len(received_sms)) 1034 return False 1035 1036def wait_for_matching_mt_sms_in_collision(log, 1037 ad_rx, 1038 phonenumber_tx, 1039 phonenumber_tx2, 1040 text, 1041 text2, 1042 allow_multi_part_long_sms=True, 1043 max_wait_time=MAX_WAIT_TIME_SMS_RECEIVE_IN_COLLISION): 1044 1045 if not allow_multi_part_long_sms: 1046 try: 1047 ad_rx.messaging_ed.wait_for_event( 1048 EventSmsReceived, 1049 is_sms_in_collision_match, 1050 max_wait_time, 1051 phonenumber_tx, 1052 phonenumber_tx2, 1053 text, 1054 text2) 1055 ad_rx.log.info("Got event %s", EventSmsReceived) 1056 return True 1057 except Empty: 1058 ad_rx.log.error("No matched SMS received event.") 1059 return False 1060 else: 1061 try: 1062 received_sms = '' 1063 received_sms2 = '' 1064 remaining_text = text 1065 remaining_text2 = text2 1066 while (remaining_text != '' or remaining_text2 != ''): 1067 event = ad_rx.messaging_ed.wait_for_event( 1068 EventSmsReceived, 1069 is_sms_in_collision_partial_match, 1070 max_wait_time, 1071 phonenumber_tx, 1072 phonenumber_tx2, 1073 remaining_text, 1074 remaining_text2) 1075 event_text = event['data']['Text'].split(")")[-1].strip() 1076 event_text_length = len(event_text) 1077 1078 if event_text in remaining_text: 1079 ad_rx.log.info("Got event %s of text length %s from %s", 1080 EventSmsReceived, event_text_length, 1081 phonenumber_tx) 1082 remaining_text = remaining_text[event_text_length:] 1083 received_sms += event_text 1084 elif event_text in remaining_text2: 1085 ad_rx.log.info("Got event %s of text length %s from %s", 1086 EventSmsReceived, event_text_length, 1087 phonenumber_tx2) 1088 remaining_text2 = remaining_text2[event_text_length:] 1089 received_sms2 += event_text 1090 1091 ad_rx.log.info("Received SMS of length %s", len(received_sms)) 1092 ad_rx.log.info("Received SMS of length %s", len(received_sms2)) 1093 return True 1094 except Empty: 1095 ad_rx.log.error( 1096 "Missing SMS received event.") 1097 if received_sms != '': 1098 ad_rx.log.error( 1099 "Only received partial matched SMS of length %s from %s", 1100 len(received_sms), phonenumber_tx) 1101 if received_sms2 != '': 1102 ad_rx.log.error( 1103 "Only received partial matched SMS of length %s from %s", 1104 len(received_sms2), phonenumber_tx2) 1105 return False 1106 1107def wait_for_matching_mt_sms_in_collision_with_mo_sms(log, 1108 ad_rx, 1109 ad_rx2, 1110 phonenumber_tx, 1111 phonenumber_tx2, 1112 text, 1113 text2, 1114 allow_multi_part_long_sms=True, 1115 max_wait_time=MAX_WAIT_TIME_SMS_RECEIVE_IN_COLLISION): 1116 1117 if not allow_multi_part_long_sms: 1118 result = True 1119 try: 1120 ad_rx.messaging_ed.wait_for_call_offhook_event( 1121 EventSmsReceived, 1122 is_sms_match, 1123 max_wait_time, 1124 phonenumber_tx, 1125 text) 1126 ad_rx.log.info("Got event %s", EventSmsReceived) 1127 except Empty: 1128 ad_rx.log.error("No matched SMS received event.") 1129 result = False 1130 1131 try: 1132 ad_rx2.messaging_ed.wait_for_call_offhook_event( 1133 EventSmsReceived, 1134 is_sms_match, 1135 max_wait_time, 1136 phonenumber_tx2, 1137 text2) 1138 ad_rx2.log.info("Got event %s", EventSmsReceived) 1139 except Empty: 1140 ad_rx2.log.error("No matched SMS received event.") 1141 result = False 1142 1143 return result 1144 else: 1145 result = True 1146 try: 1147 received_sms = '' 1148 remaining_text = text 1149 while remaining_text != '': 1150 event = ad_rx.messaging_ed.wait_for_event( 1151 EventSmsReceived, is_sms_partial_match, max_wait_time, 1152 phonenumber_tx, remaining_text) 1153 event_text = event['data']['Text'].split(")")[-1].strip() 1154 event_text_length = len(event_text) 1155 1156 if event_text in remaining_text: 1157 ad_rx.log.info("Got event %s of text length %s from %s", 1158 EventSmsReceived, event_text_length, 1159 phonenumber_tx) 1160 remaining_text = remaining_text[event_text_length:] 1161 received_sms += event_text 1162 1163 ad_rx.log.info("Received SMS of length %s", len(received_sms)) 1164 except Empty: 1165 ad_rx.log.error( 1166 "Missing SMS received event.") 1167 if received_sms != '': 1168 ad_rx.log.error( 1169 "Only received partial matched SMS of length %s from %s", 1170 len(received_sms), phonenumber_tx) 1171 result = False 1172 1173 try: 1174 received_sms2 = '' 1175 remaining_text2 = text2 1176 while remaining_text2 != '': 1177 event2 = ad_rx2.messaging_ed.wait_for_event( 1178 EventSmsReceived, is_sms_partial_match, max_wait_time, 1179 phonenumber_tx2, remaining_text2) 1180 event_text2 = event2['data']['Text'].split(")")[-1].strip() 1181 event_text_length2 = len(event_text2) 1182 1183 if event_text2 in remaining_text2: 1184 ad_rx2.log.info("Got event %s of text length %s from %s", 1185 EventSmsReceived, event_text_length2, 1186 phonenumber_tx2) 1187 remaining_text2 = remaining_text2[event_text_length2:] 1188 received_sms2 += event_text2 1189 1190 ad_rx2.log.info("Received SMS of length %s", len(received_sms2)) 1191 except Empty: 1192 ad_rx2.log.error( 1193 "Missing SMS received event.") 1194 if received_sms2 != '': 1195 ad_rx2.log.error( 1196 "Only received partial matched SMS of length %s from %s", 1197 len(received_sms2), phonenumber_tx2) 1198 result = False 1199 1200 return result 1201 1202def wait_for_matching_multiple_sms(log, 1203 ad_rx, 1204 phonenumber_tx, 1205 phonenumber_tx2, 1206 messages={}, 1207 allow_multi_part_long_sms=True, 1208 max_wait_time=MAX_WAIT_TIME_SMS_RECEIVE): 1209 1210 if not allow_multi_part_long_sms: 1211 try: 1212 ad_rx.messaging_ed.wait_for_event( 1213 EventSmsReceived, 1214 is_sms_match_among_multiple_sms, 1215 max_wait_time, 1216 phonenumber_tx, 1217 phonenumber_tx2, 1218 messages[phonenumber_tx], 1219 messages[phonenumber_tx2]) 1220 ad_rx.log.info("Got event %s", EventSmsReceived) 1221 return True 1222 except Empty: 1223 ad_rx.log.error("No matched SMS received event.") 1224 return False 1225 else: 1226 all_msgs = [] 1227 for tx, msgs in messages.items(): 1228 for msg in msgs: 1229 all_msgs.append([tx, msg, msg, '']) 1230 1231 all_msgs_copy = all_msgs.copy() 1232 1233 try: 1234 while (all_msgs != []): 1235 event = ad_rx.messaging_ed.wait_for_event( 1236 EventSmsReceived, 1237 is_sms_partial_match_among_multiple_sms, 1238 max_wait_time, 1239 phonenumber_tx, 1240 phonenumber_tx2, 1241 messages[phonenumber_tx], 1242 messages[phonenumber_tx2]) 1243 event_text = event['data']['Text'].split(")")[-1].strip() 1244 event_text_length = len(event_text) 1245 1246 for msg in all_msgs_copy: 1247 if event_text in msg[2]: 1248 ad_rx.log.info("Got event %s of text length %s from %s", 1249 EventSmsReceived, event_text_length, 1250 msg[0]) 1251 msg[2] = msg[2][event_text_length:] 1252 msg[3] += event_text 1253 1254 if msg[2] == "": 1255 all_msgs.remove(msg) 1256 1257 ad_rx.log.info("Received all SMS' sent when power-off.") 1258 except Empty: 1259 ad_rx.log.error( 1260 "Missing SMS received event.") 1261 1262 for msg in all_msgs_copy: 1263 if msg[3] != '': 1264 ad_rx.log.error( 1265 "Only received partial matched SMS of length %s from %s", 1266 len(msg[3]), msg[0]) 1267 return False 1268 1269 return True 1270 1271def wait_for_sending_sms(ad_tx, max_wait_time=MAX_WAIT_TIME_SMS_RECEIVE): 1272 try: 1273 events = ad_tx.messaging_ed.pop_events( 1274 "(%s|%s|%s|%s)" % 1275 (EventSmsSentSuccess, EventSmsSentFailure, 1276 EventSmsDeliverSuccess, 1277 EventSmsDeliverFailure), max_wait_time) 1278 for event in events: 1279 ad_tx.log.info("Got event %s", event["name"]) 1280 if event["name"] == EventSmsSentFailure or \ 1281 event["name"] == EventSmsDeliverFailure: 1282 if event.get("data") and event["data"].get("Reason"): 1283 ad_tx.log.error("%s with reason: %s", 1284 event["name"], 1285 event["data"]["Reason"]) 1286 return False 1287 elif event["name"] == EventSmsSentSuccess or \ 1288 event["name"] == EventSmsDeliverSuccess: 1289 return True 1290 except Empty: 1291 ad_tx.log.error("No %s or %s event for SMS.", 1292 EventSmsSentSuccess, EventSmsSentFailure) 1293 return False 1294 1295def voice_call_in_collision_with_mt_sms_msim( 1296 log, 1297 ad_primary, 1298 ad_sms, 1299 ad_voice, 1300 sms_subid_ad_primary, 1301 sms_subid_ad_sms, 1302 voice_subid_ad_primary, 1303 voice_subid_ad_voice, 1304 array_message, 1305 ad_hangup=None, 1306 verify_caller_func=None, 1307 verify_callee_func=None, 1308 call_direction="mo", 1309 wait_time_in_call=WAIT_TIME_IN_CALL, 1310 incall_ui_display=INCALL_UI_DISPLAY_FOREGROUND, 1311 dialing_number_length=None, 1312 video_state=None): 1313 1314 ad_tx = ad_sms 1315 ad_rx = ad_primary 1316 subid_tx = sms_subid_ad_sms 1317 subid_rx = sms_subid_ad_primary 1318 1319 if call_direction == "mo": 1320 ad_caller = ad_primary 1321 ad_callee = ad_voice 1322 subid_caller = voice_subid_ad_primary 1323 subid_callee = voice_subid_ad_voice 1324 elif call_direction == "mt": 1325 ad_callee = ad_primary 1326 ad_caller = ad_voice 1327 subid_callee = voice_subid_ad_primary 1328 subid_caller = voice_subid_ad_voice 1329 1330 1331 phonenumber_tx = ad_tx.telephony['subscription'][subid_tx]['phone_num'] 1332 phonenumber_rx = ad_rx.telephony['subscription'][subid_rx]['phone_num'] 1333 1334 tel_result_wrapper = TelResultWrapper(CallResult('SUCCESS')) 1335 1336 for ad in (ad_tx, ad_rx): 1337 ad.send_keycode("BACK") 1338 if not getattr(ad, "messaging_droid", None): 1339 ad.messaging_droid, ad.messaging_ed = ad.get_droid() 1340 ad.messaging_ed.start() 1341 else: 1342 try: 1343 if not ad.messaging_droid.is_live: 1344 ad.messaging_droid, ad.messaging_ed = ad.get_droid() 1345 ad.messaging_ed.start() 1346 else: 1347 ad.messaging_ed.clear_all_events() 1348 except Exception: 1349 ad.log.info("Create new sl4a session for messaging") 1350 ad.messaging_droid, ad.messaging_ed = ad.get_droid() 1351 ad.messaging_ed.start() 1352 1353 if not verify_caller_func: 1354 verify_caller_func = is_phone_in_call 1355 if not verify_callee_func: 1356 verify_callee_func = is_phone_in_call 1357 1358 caller_number = ad_caller.telephony['subscription'][subid_caller][ 1359 'phone_num'] 1360 callee_number = ad_callee.telephony['subscription'][subid_callee][ 1361 'phone_num'] 1362 if dialing_number_length: 1363 skip_test = False 1364 trunc_position = 0 - int(dialing_number_length) 1365 try: 1366 caller_area_code = caller_number[:trunc_position] 1367 callee_area_code = callee_number[:trunc_position] 1368 callee_dial_number = callee_number[trunc_position:] 1369 except: 1370 skip_test = True 1371 if caller_area_code != callee_area_code: 1372 skip_test = True 1373 if skip_test: 1374 msg = "Cannot make call from %s to %s by %s digits" % ( 1375 caller_number, callee_number, dialing_number_length) 1376 ad_caller.log.info(msg) 1377 raise signals.TestSkip(msg) 1378 else: 1379 callee_number = callee_dial_number 1380 1381 msg = "Call from %s to %s" % (caller_number, callee_number) 1382 if video_state: 1383 msg = "Video %s" % msg 1384 video = True 1385 else: 1386 video = False 1387 if ad_hangup: 1388 msg = "%s for duration of %s seconds" % (msg, wait_time_in_call) 1389 ad_caller.log.info(msg) 1390 1391 for ad in (ad_caller, ad_callee): 1392 call_ids = ad.droid.telecomCallGetCallIds() 1393 setattr(ad, "call_ids", call_ids) 1394 if call_ids: 1395 ad.log.info("Pre-exist CallId %s before making call", call_ids) 1396 1397 ad_caller.ed.clear_events(EventCallStateChanged) 1398 call_begin_time = get_device_epoch_time(ad) 1399 ad_caller.droid.telephonyStartTrackingCallStateForSubscription(subid_caller) 1400 1401 for text in array_message: 1402 length = len(text) 1403 ad_tx.log.info("Sending SMS from %s to %s, len: %s, content: %s.", 1404 phonenumber_tx, phonenumber_rx, length, text) 1405 try: 1406 ad_rx.messaging_ed.clear_events(EventSmsReceived) 1407 ad_tx.messaging_ed.clear_events(EventSmsSentSuccess) 1408 ad_tx.messaging_ed.clear_events(EventSmsSentFailure) 1409 ad_rx.messaging_droid.smsStartTrackingIncomingSmsMessage() 1410 time.sleep(1) #sleep 100ms after starting event tracking 1411 ad_tx.messaging_droid.logI("Sending SMS of length %s" % length) 1412 ad_rx.messaging_droid.logI("Expecting SMS of length %s" % length) 1413 ad_caller.log.info("Make a phone call to %s", callee_number) 1414 1415 tasks = [ 1416 (ad_tx.messaging_droid.smsSendTextMessage, 1417 (phonenumber_rx, text, True)), 1418 (ad_caller.droid.telecomCallNumber, 1419 (callee_number, video))] 1420 1421 run_multithread_func(log, tasks) 1422 1423 try: 1424 # Verify OFFHOOK state 1425 if not wait_for_call_offhook_for_subscription( 1426 log, 1427 ad_caller, 1428 subid_caller, 1429 event_tracking_started=True): 1430 ad_caller.log.info( 1431 "sub_id %s not in call offhook state", subid_caller) 1432 last_call_drop_reason(ad_caller, begin_time=call_begin_time) 1433 1434 ad_caller.log.error("Initiate call failed.") 1435 tel_result_wrapper.result_value = CallResult( 1436 'INITIATE_FAILED') 1437 return tel_result_wrapper 1438 else: 1439 ad_caller.log.info("Caller initate call successfully") 1440 finally: 1441 ad_caller.droid.telephonyStopTrackingCallStateChangeForSubscription( 1442 subid_caller) 1443 if incall_ui_display == INCALL_UI_DISPLAY_FOREGROUND: 1444 ad_caller.droid.telecomShowInCallScreen() 1445 elif incall_ui_display == INCALL_UI_DISPLAY_BACKGROUND: 1446 ad_caller.droid.showHomeScreen() 1447 1448 if not wait_and_answer_call_for_subscription( 1449 log, 1450 ad_callee, 1451 subid_callee, 1452 incoming_number=caller_number, 1453 caller=ad_caller, 1454 incall_ui_display=incall_ui_display, 1455 video_state=video_state): 1456 ad_callee.log.error("Answer call fail.") 1457 tel_result_wrapper.result_value = CallResult( 1458 'NO_RING_EVENT_OR_ANSWER_FAILED') 1459 return tel_result_wrapper 1460 else: 1461 ad_callee.log.info("Callee answered the call successfully") 1462 1463 for ad, call_func in zip([ad_caller, ad_callee], 1464 [verify_caller_func, verify_callee_func]): 1465 call_ids = ad.droid.telecomCallGetCallIds() 1466 new_call_ids = set(call_ids) - set(ad.call_ids) 1467 if not new_call_ids: 1468 ad.log.error( 1469 "No new call ids are found after call establishment") 1470 ad.log.error("telecomCallGetCallIds returns %s", 1471 ad.droid.telecomCallGetCallIds()) 1472 tel_result_wrapper.result_value = CallResult( 1473 'NO_CALL_ID_FOUND') 1474 for new_call_id in new_call_ids: 1475 if not wait_for_in_call_active(ad, call_id=new_call_id): 1476 tel_result_wrapper.result_value = CallResult( 1477 'CALL_STATE_NOT_ACTIVE_DURING_ESTABLISHMENT') 1478 else: 1479 ad.log.info( 1480 "callProperties = %s", 1481 ad.droid.telecomCallGetProperties(new_call_id)) 1482 1483 if not ad.droid.telecomCallGetAudioState(): 1484 ad.log.error("Audio is not in call state") 1485 tel_result_wrapper.result_value = CallResult( 1486 'AUDIO_STATE_NOT_INCALL_DURING_ESTABLISHMENT') 1487 1488 if call_func(log, ad): 1489 ad.log.info("Call is in %s state", call_func.__name__) 1490 else: 1491 ad.log.error("Call is not in %s state, voice in RAT %s", 1492 call_func.__name__, 1493 ad.droid.telephonyGetCurrentVoiceNetworkType()) 1494 tel_result_wrapper.result_value = CallResult( 1495 'CALL_DROP_OR_WRONG_STATE_DURING_ESTABLISHMENT') 1496 if not tel_result_wrapper: 1497 return tel_result_wrapper 1498 1499 if not wait_for_sending_sms( 1500 ad_tx, 1501 max_wait_time=MAX_WAIT_TIME_SMS_SENT_SUCCESS_IN_COLLISION): 1502 return False 1503 1504 tasks = [ 1505 (wait_for_matching_sms, 1506 (log, ad_rx, phonenumber_tx, text, 1507 MAX_WAIT_TIME_SMS_RECEIVE_IN_COLLISION, True)), 1508 (wait_for_call_end, 1509 (log, ad_caller, ad_callee, ad_hangup, verify_caller_func, 1510 verify_callee_func, call_begin_time, 5, tel_result_wrapper, 1511 WAIT_TIME_IN_CALL))] 1512 1513 results = run_multithread_func(log, tasks) 1514 1515 if not results[0]: 1516 ad_rx.log.error("No matching received SMS of length %s.", 1517 length) 1518 return False 1519 1520 tel_result_wrapper = results[1] 1521 1522 except Exception as e: 1523 log.error("Exception error %s", e) 1524 raise 1525 finally: 1526 ad_rx.messaging_droid.smsStopTrackingIncomingSmsMessage() 1527 1528 return tel_result_wrapper 1529 1530 1531def is_mms_match(event, phonenumber_tx, text): 1532 """Return True if 'text' equals to event['data']['Text'] 1533 and phone number match. 1534 1535 Args: 1536 event: Event object to verify. 1537 phonenumber_tx: phone number for sender. 1538 text: text string to verify. 1539 1540 Returns: 1541 Return True if 'text' equals to event['data']['Text'] 1542 and phone number match. 1543 """ 1544 #TODO: add mms matching after mms message parser is added in sl4a. b/34276948 1545 return True 1546 1547 1548def wait_for_matching_mms(log, 1549 ad_rx, 1550 phonenumber_tx, 1551 text, 1552 max_wait_time=MAX_WAIT_TIME_MMS_RECEIVE): 1553 """Wait for matching incoming SMS. 1554 1555 Args: 1556 log: Log object. 1557 ad_rx: Receiver's Android Device Object 1558 phonenumber_tx: Sender's phone number. 1559 text: SMS content string. 1560 allow_multi_part_long_sms: is long SMS allowed to be received as 1561 multiple short SMS. This is optional, default value is True. 1562 1563 Returns: 1564 True if matching incoming SMS is received. 1565 """ 1566 try: 1567 #TODO: add mms matching after mms message parser is added in sl4a. b/34276948 1568 ad_rx.messaging_ed.wait_for_event(EventMmsDownloaded, is_mms_match, 1569 max_wait_time, phonenumber_tx, text) 1570 ad_rx.log.info("Got event %s", EventMmsDownloaded) 1571 return True 1572 except Empty: 1573 ad_rx.log.warning("No matched MMS downloaded event.") 1574 return False 1575 1576 1577def mms_send_receive_verify(log, 1578 ad_tx, 1579 ad_rx, 1580 array_message, 1581 max_wait_time=MAX_WAIT_TIME_MMS_RECEIVE, 1582 expected_result=True, 1583 slot_id_rx=None): 1584 """Send MMS, receive MMS, and verify content and sender's number. 1585 1586 Send (several) MMS from droid_tx to droid_rx. 1587 Verify MMS is sent, delivered and received. 1588 Verify received content and sender's number are correct. 1589 1590 Args: 1591 log: Log object. 1592 ad_tx: Sender's Android Device Object 1593 ad_rx: Receiver's Android Device Object 1594 array_message: the array of message to send/receive 1595 """ 1596 subid_tx = get_outgoing_message_sub_id(ad_tx) 1597 if slot_id_rx is None: 1598 subid_rx = get_incoming_message_sub_id(ad_rx) 1599 else: 1600 subid_rx = get_subid_from_slot_index(log, ad_rx, slot_id_rx) 1601 1602 result = mms_send_receive_verify_for_subscription( 1603 log, ad_tx, ad_rx, subid_tx, subid_rx, array_message, max_wait_time) 1604 if result != expected_result: 1605 log_messaging_screen_shot(ad_tx, test_name="mms_tx") 1606 log_messaging_screen_shot(ad_rx, test_name="mms_rx") 1607 return result == expected_result 1608 1609 1610def sms_mms_send_logcat_check(ad, type, begin_time): 1611 type = type.upper() 1612 log_results = ad.search_logcat( 1613 "%s Message sent successfully" % type, begin_time=begin_time) 1614 if log_results: 1615 ad.log.info("Found %s sent successful log message: %s", type, 1616 log_results[-1]["log_message"]) 1617 return True 1618 else: 1619 log_results = ad.search_logcat( 1620 "ProcessSentMessageAction: Done sending %s message" % type, 1621 begin_time=begin_time) 1622 if log_results: 1623 for log_result in log_results: 1624 if "status is SUCCEEDED" in log_result["log_message"]: 1625 ad.log.info( 1626 "Found BugleDataModel %s send succeed log message: %s", 1627 type, log_result["log_message"]) 1628 return True 1629 return False 1630 1631 1632def sms_mms_receive_logcat_check(ad, type, begin_time): 1633 type = type.upper() 1634 smshandle_logs = ad.search_logcat( 1635 "InboundSmsHandler: No broadcast sent on processing EVENT_BROADCAST_SMS", 1636 begin_time=begin_time) 1637 if smshandle_logs: 1638 ad.log.warning("Found %s", smshandle_logs[-1]["log_message"]) 1639 log_results = ad.search_logcat( 1640 "New %s Received" % type, begin_time=begin_time) or \ 1641 ad.search_logcat("New %s Downloaded" % type, begin_time=begin_time) 1642 if log_results: 1643 ad.log.info("Found SL4A %s received log message: %s", type, 1644 log_results[-1]["log_message"]) 1645 return True 1646 else: 1647 log_results = ad.search_logcat( 1648 "Received %s message" % type, begin_time=begin_time) 1649 if log_results: 1650 ad.log.info("Found %s received log message: %s", type, 1651 log_results[-1]["log_message"]) 1652 log_results = ad.search_logcat( 1653 "ProcessDownloadedMmsAction", begin_time=begin_time) 1654 for log_result in log_results: 1655 ad.log.info("Found %s", log_result["log_message"]) 1656 if "status is SUCCEEDED" in log_result["log_message"]: 1657 ad.log.info("Download succeed with ProcessDownloadedMmsAction") 1658 return True 1659 return False 1660 1661 1662#TODO: add mms matching after mms message parser is added in sl4a. b/34276948 1663def mms_send_receive_verify_for_subscription( 1664 log, 1665 ad_tx, 1666 ad_rx, 1667 subid_tx, 1668 subid_rx, 1669 array_payload, 1670 max_wait_time=MAX_WAIT_TIME_MMS_RECEIVE): 1671 """Send MMS, receive MMS, and verify content and sender's number. 1672 1673 Send (several) MMS from droid_tx to droid_rx. 1674 Verify MMS is sent, delivered and received. 1675 Verify received content and sender's number are correct. 1676 1677 Args: 1678 log: Log object. 1679 ad_tx: Sender's Android Device Object.. 1680 ad_rx: Receiver's Android Device Object. 1681 subid_tx: Sender's subscription ID to be used for SMS 1682 subid_rx: Receiver's subscription ID to be used for SMS 1683 array_message: the array of message to send/receive 1684 """ 1685 1686 phonenumber_tx = ad_tx.telephony['subscription'][subid_tx]['phone_num'] 1687 phonenumber_rx = ad_rx.telephony['subscription'][subid_rx]['phone_num'] 1688 toggle_enforce = False 1689 1690 for ad in (ad_tx, ad_rx): 1691 if "Permissive" not in ad.adb.shell("su root getenforce"): 1692 ad.adb.shell("su root setenforce 0") 1693 toggle_enforce = True 1694 if not getattr(ad, "messaging_droid", None): 1695 ad.messaging_droid, ad.messaging_ed = ad.get_droid() 1696 ad.messaging_ed.start() 1697 else: 1698 try: 1699 if not ad.messaging_droid.is_live: 1700 ad.messaging_droid, ad.messaging_ed = ad.get_droid() 1701 ad.messaging_ed.start() 1702 else: 1703 ad.messaging_ed.clear_all_events() 1704 ad.messaging_droid.logI( 1705 "Start mms_send_receive_verify_for_subscription test") 1706 except Exception: 1707 ad.log.info("Create new sl4a session for messaging") 1708 ad.messaging_droid, ad.messaging_ed = ad.get_droid() 1709 ad.messaging_ed.start() 1710 1711 for subject, message, filename in array_payload: 1712 ad_tx.messaging_ed.clear_events(EventMmsSentSuccess) 1713 ad_tx.messaging_ed.clear_events(EventMmsSentFailure) 1714 ad_rx.messaging_ed.clear_events(EventMmsDownloaded) 1715 ad_rx.messaging_droid.smsStartTrackingIncomingMmsMessage() 1716 ad_tx.log.info( 1717 "Sending MMS from %s to %s, subject: %s, message: %s, file: %s.", 1718 phonenumber_tx, phonenumber_rx, subject, message, filename) 1719 try: 1720 ad_tx.messaging_droid.smsSendMultimediaMessage( 1721 phonenumber_rx, subject, message, phonenumber_tx, filename) 1722 try: 1723 events = ad_tx.messaging_ed.pop_events( 1724 "(%s|%s)" % (EventMmsSentSuccess, 1725 EventMmsSentFailure), max_wait_time) 1726 for event in events: 1727 ad_tx.log.info("Got event %s", event["name"]) 1728 if event["name"] == EventMmsSentFailure: 1729 if event.get("data") and event["data"].get("Reason"): 1730 ad_tx.log.error("%s with reason: %s", 1731 event["name"], 1732 event["data"]["Reason"]) 1733 return False 1734 elif event["name"] == EventMmsSentSuccess: 1735 break 1736 except Empty: 1737 ad_tx.log.warning("No %s or %s event.", EventMmsSentSuccess, 1738 EventMmsSentFailure) 1739 return False 1740 1741 if not wait_for_matching_mms(log, ad_rx, phonenumber_tx, 1742 message, max_wait_time): 1743 return False 1744 except Exception as e: 1745 log.error("Exception error %s", e) 1746 raise 1747 finally: 1748 ad_rx.messaging_droid.smsStopTrackingIncomingMmsMessage() 1749 for ad in (ad_tx, ad_rx): 1750 if toggle_enforce: 1751 ad.send_keycode("BACK") 1752 ad.adb.shell("su root setenforce 1") 1753 return True 1754 1755 1756def mms_receive_verify_after_call_hangup( 1757 log, ad_tx, ad_rx, array_message, 1758 max_wait_time=MAX_WAIT_TIME_MMS_RECEIVE): 1759 """Verify the suspanded MMS during call will send out after call release. 1760 1761 Hangup call from droid_tx to droid_rx. 1762 Verify MMS is sent, delivered and received. 1763 Verify received content and sender's number are correct. 1764 1765 Args: 1766 log: Log object. 1767 ad_tx: Sender's Android Device Object 1768 ad_rx: Receiver's Android Device Object 1769 array_message: the array of message to send/receive 1770 """ 1771 return mms_receive_verify_after_call_hangup_for_subscription( 1772 log, ad_tx, ad_rx, get_outgoing_message_sub_id(ad_tx), 1773 get_incoming_message_sub_id(ad_rx), array_message, max_wait_time) 1774 1775 1776#TODO: add mms matching after mms message parser is added in sl4a. b/34276948 1777def mms_receive_verify_after_call_hangup_for_subscription( 1778 log, 1779 ad_tx, 1780 ad_rx, 1781 subid_tx, 1782 subid_rx, 1783 array_payload, 1784 max_wait_time=MAX_WAIT_TIME_MMS_RECEIVE): 1785 """Verify the suspanded MMS during call will send out after call release. 1786 1787 Hangup call from droid_tx to droid_rx. 1788 Verify MMS is sent, delivered and received. 1789 Verify received content and sender's number are correct. 1790 1791 Args: 1792 log: Log object. 1793 ad_tx: Sender's Android Device Object.. 1794 ad_rx: Receiver's Android Device Object. 1795 subid_tx: Sender's subscription ID to be used for SMS 1796 subid_rx: Receiver's subscription ID to be used for SMS 1797 array_message: the array of message to send/receive 1798 """ 1799 1800 phonenumber_tx = ad_tx.telephony['subscription'][subid_tx]['phone_num'] 1801 phonenumber_rx = ad_rx.telephony['subscription'][subid_rx]['phone_num'] 1802 for ad in (ad_tx, ad_rx): 1803 if not getattr(ad, "messaging_droid", None): 1804 ad.messaging_droid, ad.messaging_ed = ad.get_droid() 1805 ad.messaging_ed.start() 1806 for subject, message, filename in array_payload: 1807 ad_rx.log.info( 1808 "Waiting MMS from %s to %s, subject: %s, message: %s, file: %s.", 1809 phonenumber_tx, phonenumber_rx, subject, message, filename) 1810 ad_rx.messaging_droid.smsStartTrackingIncomingMmsMessage() 1811 time.sleep(5) 1812 try: 1813 hangup_call(log, ad_tx) 1814 hangup_call(log, ad_rx) 1815 try: 1816 ad_tx.messaging_ed.pop_event(EventMmsSentSuccess, 1817 max_wait_time) 1818 ad_tx.log.info("Got event %s", EventMmsSentSuccess) 1819 except Empty: 1820 log.warning("No sent_success event.") 1821 if not wait_for_matching_mms(log, ad_rx, phonenumber_tx, message): 1822 return False 1823 finally: 1824 ad_rx.messaging_droid.smsStopTrackingIncomingMmsMessage() 1825 return True 1826 1827 1828def log_messaging_screen_shot(ad, test_name=""): 1829 ad.ensure_screen_on() 1830 ad.send_keycode("HOME") 1831 ad.adb.shell("am start -n com.google.android.apps.messaging/.ui." 1832 "ConversationListActivity") 1833 time.sleep(3) 1834 ad.screenshot(test_name) 1835 ad.adb.shell("am start -n com.google.android.apps.messaging/com.google." 1836 "android.apps.messaging.ui.conversation." 1837 "LaunchConversationShimActivity -e conversation_id 1") 1838 time.sleep(3) 1839 ad.screenshot(test_name) 1840 ad.send_keycode("HOME")