1 /* 2 * Copyright 2016 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.bluetooth.map; 18 19 import static org.mockito.Mockito.*; 20 21 import android.app.Activity; 22 import android.content.ContentProviderClient; 23 import android.content.ContentValues; 24 import android.content.Context; 25 import android.content.Intent; 26 import android.database.Cursor; 27 import android.database.MatrixCursor; 28 import android.database.sqlite.SQLiteException; 29 import android.net.Uri; 30 import android.os.Handler; 31 import android.os.Looper; 32 import android.os.RemoteException; 33 import android.os.UserManager; 34 import android.provider.ContactsContract; 35 import android.provider.Telephony; 36 import android.provider.Telephony.Mms; 37 import android.provider.Telephony.Sms; 38 import android.telephony.TelephonyManager; 39 import android.test.mock.MockContentProvider; 40 import android.test.mock.MockContentResolver; 41 42 import androidx.test.filters.MediumTest; 43 import androidx.test.runner.AndroidJUnit4; 44 45 import com.android.bluetooth.BluetoothMethodProxy; 46 import com.android.bluetooth.SignedLongLong; 47 import com.android.bluetooth.map.BluetoothMapUtils.TYPE; 48 import com.android.bluetooth.mapapi.BluetoothMapContract; 49 import com.android.bluetooth.mapapi.BluetoothMapContract.MessageColumns; 50 import com.android.obex.ResponseCodes; 51 52 import com.google.android.mms.pdu.PduHeaders; 53 54 import org.junit.After; 55 import org.junit.Assert; 56 import org.junit.Assume; 57 import org.junit.Before; 58 import org.junit.Test; 59 import org.junit.runner.RunWith; 60 import org.mockito.Mock; 61 import org.mockito.Mockito; 62 import org.mockito.MockitoAnnotations; 63 import org.mockito.Spy; 64 65 import java.io.IOException; 66 import java.text.SimpleDateFormat; 67 import java.util.Calendar; 68 import java.util.HashMap; 69 import java.util.HashSet; 70 import java.util.Map; 71 import java.util.concurrent.TimeUnit; 72 73 @MediumTest 74 @RunWith(AndroidJUnit4.class) 75 public class BluetoothMapContentObserverTest { 76 static final String TEST_NUMBER_ONE = "5551212"; 77 static final String TEST_NUMBER_TWO = "5551234"; 78 static final int TEST_ID = 1; 79 static final long TEST_HANDLE_ONE = 1; 80 static final long TEST_HANDLE_TWO = 2; 81 static final String TEST_URI_STR = "http://www.google.com"; 82 static final int TEST_STATUS_VALUE = 1; 83 static final int TEST_THREAD_ID = 1; 84 static final long TEST_OLD_THREAD_ID = 2; 85 static final int TEST_PLACEHOLDER_INT = 1; 86 static final String TEST_ADDRESS = "test_address"; 87 static final long TEST_DELETE_FOLDER_ID = BluetoothMapContract.FOLDER_ID_DELETED; 88 static final long TEST_INBOX_FOLDER_ID = BluetoothMapContract.FOLDER_ID_INBOX; 89 static final long TEST_SENT_FOLDER_ID = BluetoothMapContract.FOLDER_ID_SENT; 90 static final long TEST_DRAFT_FOLDER_ID = BluetoothMapContract.FOLDER_ID_DRAFT; 91 static final long TEST_OLD_FOLDER_ID = 6; 92 static final int TEST_READ_FLAG_ONE = 1; 93 static final int TEST_READ_FLAG_ZERO = 0; 94 static final long TEST_DATE_MS = Calendar.getInstance().getTimeInMillis(); 95 static final long TEST_DATE_SEC = TimeUnit.MILLISECONDS.toSeconds(TEST_DATE_MS); 96 static final String TEST_SUBJECT = "subject"; 97 static final int TEST_MMS_MTYPE = 1; 98 static final int TEST_MMS_TYPE_ALL = Telephony.BaseMmsColumns.MESSAGE_BOX_ALL; 99 static final int TEST_MMS_TYPE_INBOX = Telephony.BaseMmsColumns.MESSAGE_BOX_INBOX; 100 static final int TEST_SMS_TYPE_ALL = Telephony.TextBasedSmsColumns.MESSAGE_TYPE_ALL; 101 static final int TEST_SMS_TYPE_INBOX = Telephony.BaseMmsColumns.MESSAGE_BOX_INBOX; 102 static final Uri TEST_URI = Mms.CONTENT_URI; 103 static final String TEST_AUTHORITY = "test_authority"; 104 105 static final long TEST_CONVO_ID = 1; 106 static final String TEST_NAME = "col_name"; 107 static final String TEST_DISPLAY_NAME = "col_nickname"; 108 static final String TEST_BT_UID = "1111"; 109 static final int TEST_CHAT_STATE = 1; 110 static final int TEST_CHAT_STATE_DIFFERENT = 2; 111 static final String TEST_UCI = "col_uci"; 112 static final String TEST_UCI_DIFFERENT = "col_uci_different"; 113 static final long TEST_LAST_ACTIVITY = 1; 114 static final int TEST_PRESENCE_STATE = 1; 115 static final int TEST_PRESENCE_STATE_DIFFERENT = 2; 116 static final String TEST_STATUS_TEXT = "col_status_text"; 117 static final String TEST_STATUS_TEXT_DIFFERENT = "col_status_text_different"; 118 static final int TEST_PRIORITY = 1; 119 static final int TEST_LAST_ONLINE = 1; 120 121 @Mock 122 private BluetoothMnsObexClient mClient; 123 @Mock 124 private BluetoothMapMasInstance mInstance; 125 @Mock 126 private TelephonyManager mTelephonyManager; 127 @Mock 128 private UserManager mUserService; 129 @Mock 130 private Context mContext; 131 @Mock 132 private ContentProviderClient mProviderClient; 133 @Mock 134 private BluetoothMapAccountItem mItem; 135 @Mock 136 private Intent mIntent; 137 @Spy 138 private BluetoothMethodProxy mMapMethodProxy = BluetoothMethodProxy.getInstance(); 139 140 private ExceptionTestProvider mProvider; 141 private MockContentResolver mMockContentResolver; 142 private BluetoothMapContentObserver mObserver; 143 private BluetoothMapFolderElement mFolders; 144 private BluetoothMapFolderElement mCurrentFolder; 145 146 static class ExceptionTestProvider extends MockContentProvider { 147 HashSet<String> mContents = new HashSet<String>(); 148 ExceptionTestProvider(Context context)149 public ExceptionTestProvider(Context context) { 150 super(context); 151 } 152 153 @Override query(Uri uri, String[] b, String s, String[] c, String d)154 public Cursor query(Uri uri, String[] b, String s, String[] c, String d) { 155 // Throw exception for SMS queries for easy initialization 156 if (Sms.CONTENT_URI.equals(uri)) throw new SQLiteException(); 157 158 // Return a cursor otherwise for Thread IDs 159 Cursor cursor = Mockito.mock(Cursor.class); 160 when(cursor.moveToFirst()).thenReturn(true); 161 when(cursor.getLong(anyInt())).thenReturn(0L); 162 return cursor; 163 } 164 165 @Override insert(Uri uri, ContentValues values)166 public Uri insert(Uri uri, ContentValues values) { 167 // Store addresses for later verification 168 Object address = values.get(Mms.Addr.ADDRESS); 169 if (address != null) mContents.add((String) address); 170 return Uri.withAppendedPath(Mms.Outbox.CONTENT_URI, "0"); 171 } 172 } 173 174 @Before setUp()175 public void setUp() throws Exception { 176 MockitoAnnotations.initMocks(this); 177 BluetoothMethodProxy.setInstanceForTesting(mMapMethodProxy); 178 if (Looper.myLooper() == null) { 179 Looper.prepare(); 180 } 181 mMockContentResolver = new MockContentResolver(); 182 mProvider = new ExceptionTestProvider(mContext); 183 mMockContentResolver.addProvider("sms", mProvider); 184 mFolders = new BluetoothMapFolderElement("placeholder", null); 185 mCurrentFolder = new BluetoothMapFolderElement("current", null); 186 187 // Functions that get called when BluetoothMapContentObserver is created 188 when(mUserService.isUserUnlocked()).thenReturn(true); 189 when(mContext.getContentResolver()).thenReturn(mMockContentResolver); 190 when(mContext.getSystemService(Context.TELEPHONY_SERVICE)).thenReturn(mTelephonyManager); 191 when(mContext.getSystemServiceName(TelephonyManager.class)) 192 .thenReturn(Context.TELEPHONY_SERVICE); 193 when(mContext.getSystemService(Context.USER_SERVICE)).thenReturn(mUserService); 194 when(mContext.getSystemServiceName(UserManager.class)).thenReturn(Context.USER_SERVICE); 195 when(mInstance.getMasId()).thenReturn(TEST_ID); 196 197 mObserver = new BluetoothMapContentObserver(mContext, mClient, mInstance, null, true); 198 mObserver.mProviderClient = mProviderClient; 199 mObserver.mAccount = mItem; 200 when(mItem.getType()).thenReturn(TYPE.IM); 201 } 202 203 @After tearDown()204 public void tearDown() throws Exception { 205 BluetoothMethodProxy.setInstanceForTesting(null); 206 } 207 208 @Test testPushGroupMMS()209 public void testPushGroupMMS() { 210 if (Looper.myLooper() == null) { 211 Looper.prepare(); 212 } 213 mMockContentResolver.addProvider("mms", mProvider); 214 mMockContentResolver.addProvider("mms-sms", mProvider); 215 216 BluetoothMapbMessageMime message = new BluetoothMapbMessageMime(); 217 message.setType(BluetoothMapUtils.TYPE.MMS); 218 message.setFolder("telecom/msg/outbox"); 219 message.addSender("Zero", "0"); 220 message.addRecipient("One", new String[]{TEST_NUMBER_ONE}, null); 221 message.addRecipient("Two", new String[]{TEST_NUMBER_TWO}, null); 222 BluetoothMapbMessageMime.MimePart body = message.addMimePart(); 223 try { 224 body.mContentType = "text/plain"; 225 body.mData = "HelloWorld".getBytes("utf-8"); 226 } catch (Exception e) { 227 Assert.fail("Failed to setup test message"); 228 } 229 230 BluetoothMapAppParams appParams = new BluetoothMapAppParams(); 231 BluetoothMapFolderElement folderElement = new BluetoothMapFolderElement("outbox", null); 232 233 try { 234 // The constructor of BluetoothMapContentObserver calls initMsgList 235 BluetoothMapContentObserver observer = 236 new BluetoothMapContentObserver(mContext, null, mInstance, null, true); 237 observer.pushMessage(message, folderElement, appParams, null); 238 } catch (RemoteException e) { 239 Assert.fail("Failed to created BluetoothMapContentObserver object"); 240 } catch (SQLiteException e) { 241 Assert.fail("Threw SQLiteException instead of Assert.failing cleanly"); 242 } catch (IOException e) { 243 Assert.fail("Threw IOException"); 244 } catch (NullPointerException e) { 245 //expected that the test case will end in a NPE as part of the sendMultimediaMessage 246 //pendingSendIntent 247 } 248 249 // Validate that 3 addresses were inserted into the database with 2 being the recipients 250 Assert.assertEquals(3, mProvider.mContents.size()); 251 Assert.assertTrue(mProvider.mContents.contains(TEST_NUMBER_ONE)); 252 Assert.assertTrue(mProvider.mContents.contains(TEST_NUMBER_TWO)); 253 } 254 255 @Test testSendEvent_withZeroEventFilter()256 public void testSendEvent_withZeroEventFilter() { 257 when(mClient.isConnected()).thenReturn(true); 258 mObserver.setNotificationFilter(0); 259 260 String eventType = BluetoothMapContentObserver.EVENT_TYPE_NEW; 261 BluetoothMapContentObserver.Event event = mObserver.new Event(eventType, TEST_HANDLE_ONE, 262 null, null); 263 mObserver.sendEvent(event); 264 verify(mClient, never()).sendEvent(any(), anyInt()); 265 266 event.eventType = BluetoothMapContentObserver.EVENT_TYPE_DELETE; 267 mObserver.sendEvent(event); 268 verify(mClient, never()).sendEvent(any(), anyInt()); 269 270 event.eventType = BluetoothMapContentObserver.EVENT_TYPE_REMOVED; 271 mObserver.sendEvent(event); 272 verify(mClient, never()).sendEvent(any(), anyInt()); 273 274 event.eventType = BluetoothMapContentObserver.EVENT_TYPE_SHIFT; 275 mObserver.sendEvent(event); 276 verify(mClient, never()).sendEvent(any(), anyInt()); 277 278 event.eventType = BluetoothMapContentObserver.EVENT_TYPE_DELEVERY_SUCCESS; 279 mObserver.sendEvent(event); 280 verify(mClient, never()).sendEvent(any(), anyInt()); 281 282 event.eventType = BluetoothMapContentObserver.EVENT_TYPE_SENDING_SUCCESS; 283 mObserver.sendEvent(event); 284 verify(mClient, never()).sendEvent(any(), anyInt()); 285 286 event.eventType = BluetoothMapContentObserver.EVENT_TYPE_SENDING_FAILURE; 287 mObserver.sendEvent(event); 288 verify(mClient, never()).sendEvent(any(), anyInt()); 289 290 event.eventType = BluetoothMapContentObserver.EVENT_TYPE_READ_STATUS; 291 mObserver.sendEvent(event); 292 verify(mClient, never()).sendEvent(any(), anyInt()); 293 294 event.eventType = BluetoothMapContentObserver.EVENT_TYPE_CONVERSATION; 295 mObserver.sendEvent(event); 296 verify(mClient, never()).sendEvent(any(), anyInt()); 297 298 event.eventType = BluetoothMapContentObserver.EVENT_TYPE_PRESENCE; 299 mObserver.sendEvent(event); 300 verify(mClient, never()).sendEvent(any(), anyInt()); 301 302 event.eventType = BluetoothMapContentObserver.EVENT_TYPE_CHAT_STATE; 303 mObserver.sendEvent(event); 304 verify(mClient, never()).sendEvent(any(), anyInt()); 305 } 306 307 @Test testEvent_withNonZeroEventFilter()308 public void testEvent_withNonZeroEventFilter() throws Exception { 309 when(mClient.isConnected()).thenReturn(true); 310 311 String eventType = BluetoothMapContentObserver.EVENT_TYPE_NEW; 312 BluetoothMapContentObserver.Event event = mObserver.new Event(eventType, TEST_HANDLE_ONE, 313 null, null); 314 315 mObserver.sendEvent(event); 316 317 verify(mClient).sendEvent(event.encode(), TEST_ID); 318 } 319 320 @Test testSetContactList()321 public void testSetContactList() { 322 Map<String, BluetoothMapConvoContactElement> map = Map.of(); 323 324 mObserver.setContactList(map, true); 325 326 Assert.assertEquals(mObserver.getContactList(), map); 327 } 328 329 @Test testSetMsgListSms()330 public void testSetMsgListSms() { 331 Map<Long, BluetoothMapContentObserver.Msg> map = Map.of(); 332 333 mObserver.setMsgListSms(map, true); 334 335 Assert.assertEquals(mObserver.getMsgListSms(), map); 336 } 337 338 @Test testSetMsgListMsg()339 public void testSetMsgListMsg() { 340 Map<Long, BluetoothMapContentObserver.Msg> map = Map.of(); 341 342 mObserver.setMsgListMsg(map, true); 343 344 Assert.assertEquals(mObserver.getMsgListMsg(), map); 345 } 346 347 @Test testSetMsgListMms()348 public void testSetMsgListMms() { 349 Map<Long, BluetoothMapContentObserver.Msg> map = Map.of(); 350 351 mObserver.setMsgListMms(map, true); 352 353 Assert.assertEquals(mObserver.getMsgListMms(), map); 354 } 355 356 @Test testSetNotificationRegistration_withNullHandler()357 public void testSetNotificationRegistration_withNullHandler() throws Exception { 358 when(mClient.getMessageHandler()).thenReturn(null); 359 360 Assert.assertEquals( 361 mObserver.setNotificationRegistration(BluetoothMapAppParams.NOTIFICATION_STATUS_NO), 362 ResponseCodes.OBEX_HTTP_UNAVAILABLE); 363 } 364 365 @Test testSetNotificationRegistration_withInvalidMnsRecord()366 public void testSetNotificationRegistration_withInvalidMnsRecord() throws Exception { 367 if (Looper.myLooper() == null) { 368 Looper.prepare(); 369 } 370 Handler handler = new Handler(); 371 when(mClient.getMessageHandler()).thenReturn(handler); 372 when(mClient.isValidMnsRecord()).thenReturn(false); 373 374 Assert.assertEquals( 375 mObserver.setNotificationRegistration(BluetoothMapAppParams.NOTIFICATION_STATUS_NO), 376 ResponseCodes.OBEX_HTTP_OK); 377 } 378 379 @Test testSetNotificationRegistration_withValidMnsRecord()380 public void testSetNotificationRegistration_withValidMnsRecord() throws Exception { 381 if (Looper.myLooper() == null) { 382 Looper.prepare(); 383 } 384 Handler handler = new Handler(); 385 when(mClient.getMessageHandler()).thenReturn(handler); 386 when(mClient.isValidMnsRecord()).thenReturn(true); 387 388 Assert.assertEquals( 389 mObserver.setNotificationRegistration(BluetoothMapAppParams.NOTIFICATION_STATUS_NO), 390 ResponseCodes.OBEX_HTTP_OK); 391 } 392 393 @Test testSetMessageStatusRead_withTypeSmsGsm()394 public void testSetMessageStatusRead_withTypeSmsGsm() throws Exception { 395 TYPE type = TYPE.SMS_GSM; 396 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 397 BluetoothMapContentObserver.Msg msg = createSimpleMsg(); 398 map.put(TEST_HANDLE_ONE, msg); 399 mObserver.setMsgListSms(map, true); 400 doReturn(TEST_PLACEHOLDER_INT).when(mMapMethodProxy).contentResolverUpdate(any(), any(), 401 any(), any(), any()); 402 403 Assert.assertTrue(mObserver.setMessageStatusRead(TEST_HANDLE_ONE, type, TEST_URI_STR, 404 TEST_STATUS_VALUE)); 405 406 Assert.assertEquals(msg.flagRead, TEST_STATUS_VALUE); 407 } 408 409 @Test testSetMessageStatusRead_withTypeMms()410 public void testSetMessageStatusRead_withTypeMms() throws Exception { 411 TYPE type = TYPE.MMS; 412 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 413 BluetoothMapContentObserver.Msg msg = createSimpleMsg(); 414 map.put(TEST_HANDLE_ONE, msg); 415 mObserver.setMsgListMms(map, true); 416 doReturn(TEST_PLACEHOLDER_INT).when(mMapMethodProxy).contentResolverUpdate(any(), any(), 417 any(), any(), any()); 418 419 Assert.assertTrue(mObserver.setMessageStatusRead(TEST_HANDLE_ONE, type, TEST_URI_STR, 420 TEST_STATUS_VALUE)); 421 422 Assert.assertEquals(msg.flagRead, TEST_STATUS_VALUE); 423 } 424 425 @Test testSetMessageStatusRead_withTypeEmail()426 public void testSetMessageStatusRead_withTypeEmail() throws Exception { 427 TYPE type = TYPE.EMAIL; 428 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 429 BluetoothMapContentObserver.Msg msg = createSimpleMsg(); 430 map.put(TEST_HANDLE_ONE, msg); 431 mObserver.setMsgListMsg(map, true); 432 mObserver.mProviderClient = mProviderClient; 433 when(mProviderClient.update(any(), any(), any(), any())).thenReturn(TEST_PLACEHOLDER_INT); 434 435 Assert.assertTrue(mObserver.setMessageStatusRead(TEST_HANDLE_ONE, type, TEST_URI_STR, 436 TEST_STATUS_VALUE)); 437 438 Assert.assertEquals(msg.flagRead, TEST_STATUS_VALUE); 439 } 440 441 @Test testDeleteMessageMms_withNonDeletedThreadId()442 public void testDeleteMessageMms_withNonDeletedThreadId() { 443 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 444 BluetoothMapContentObserver.Msg msg = createMsgWithTypeAndThreadId(Mms.MESSAGE_BOX_ALL, 445 TEST_THREAD_ID); 446 map.put(TEST_HANDLE_ONE, msg); 447 mObserver.setMsgListMms(map, true); 448 Assert.assertEquals(msg.threadId, TEST_THREAD_ID); 449 450 MatrixCursor cursor = new MatrixCursor(new String[] {Mms.THREAD_ID}); 451 cursor.addRow(new Object[] {TEST_THREAD_ID}); 452 doReturn(cursor).when(mMapMethodProxy).contentResolverQuery(any(), any(), any(), any(), 453 any(), any()); 454 doReturn(TEST_PLACEHOLDER_INT).when(mMapMethodProxy).contentResolverUpdate(any(), any(), 455 any(), any(), any()); 456 457 Assert.assertTrue(mObserver.deleteMessageMms(TEST_HANDLE_ONE)); 458 459 Assert.assertEquals(msg.threadId, BluetoothMapContentObserver.DELETED_THREAD_ID); 460 } 461 462 @Test testDeleteMessageMms_withDeletedThreadId()463 public void testDeleteMessageMms_withDeletedThreadId() { 464 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 465 BluetoothMapContentObserver.Msg msg = createMsgWithTypeAndThreadId(Mms.MESSAGE_BOX_ALL, 466 TEST_THREAD_ID); 467 map.put(TEST_HANDLE_ONE, msg); 468 mObserver.setMsgListMms(map, true); 469 Assert.assertNotNull(mObserver.getMsgListMms().get(TEST_HANDLE_ONE)); 470 471 MatrixCursor cursor = new MatrixCursor(new String[] {Mms.THREAD_ID}); 472 cursor.addRow(new Object[] {BluetoothMapContentObserver.DELETED_THREAD_ID}); 473 doReturn(cursor).when(mMapMethodProxy).contentResolverQuery(any(), any(), any(), any(), 474 any(), any()); 475 doReturn(TEST_PLACEHOLDER_INT).when(mMapMethodProxy).contentResolverDelete(any(), any(), 476 any(), any()); 477 478 Assert.assertTrue(mObserver.deleteMessageMms(TEST_HANDLE_ONE)); 479 480 Assert.assertNull(mObserver.getMsgListMms().get(TEST_HANDLE_ONE)); 481 } 482 483 @Test testDeleteMessageSms_withNonDeletedThreadId()484 public void testDeleteMessageSms_withNonDeletedThreadId() { 485 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 486 BluetoothMapContentObserver.Msg msg = createMsgWithTypeAndThreadId(Sms.MESSAGE_TYPE_ALL, 487 TEST_THREAD_ID); 488 map.put(TEST_HANDLE_ONE, msg); 489 mObserver.setMsgListSms(map, true); 490 Assert.assertEquals(msg.threadId, TEST_THREAD_ID); 491 492 MatrixCursor cursor = new MatrixCursor(new String[] {Mms.THREAD_ID}); 493 cursor.addRow(new Object[] {TEST_THREAD_ID}); 494 doReturn(cursor).when(mMapMethodProxy).contentResolverQuery(any(), any(), any(), any(), 495 any(), any()); 496 doReturn(TEST_PLACEHOLDER_INT).when(mMapMethodProxy).contentResolverUpdate(any(), any(), 497 any(), any(), any()); 498 499 Assert.assertTrue(mObserver.deleteMessageSms(TEST_HANDLE_ONE)); 500 501 Assert.assertEquals(msg.threadId, BluetoothMapContentObserver.DELETED_THREAD_ID); 502 } 503 504 @Test testDeleteMessageSms_withDeletedThreadId()505 public void testDeleteMessageSms_withDeletedThreadId() { 506 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 507 BluetoothMapContentObserver.Msg msg = createMsgWithTypeAndThreadId(Sms.MESSAGE_TYPE_ALL, 508 TEST_THREAD_ID); 509 map.put(TEST_HANDLE_ONE, msg); 510 mObserver.setMsgListSms(map, true); 511 Assert.assertNotNull(mObserver.getMsgListSms().get(TEST_HANDLE_ONE)); 512 513 MatrixCursor cursor = new MatrixCursor(new String[] {Mms.THREAD_ID}); 514 cursor.addRow(new Object[] {BluetoothMapContentObserver.DELETED_THREAD_ID}); 515 doReturn(cursor).when(mMapMethodProxy).contentResolverQuery(any(), any(), any(), any(), 516 any(), any()); 517 doReturn(TEST_PLACEHOLDER_INT).when(mMapMethodProxy).contentResolverDelete(any(), any(), 518 any(), any()); 519 520 Assert.assertTrue(mObserver.deleteMessageSms(TEST_HANDLE_ONE)); 521 522 Assert.assertNull(mObserver.getMsgListSms().get(TEST_HANDLE_ONE)); 523 } 524 525 @Test testUnDeleteMessageMms_withDeletedThreadId_andMessageBoxInbox()526 public void testUnDeleteMessageMms_withDeletedThreadId_andMessageBoxInbox() { 527 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 528 BluetoothMapContentObserver.Msg msg = createMsgWithTypeAndThreadId(Mms.MESSAGE_BOX_ALL, 529 TEST_THREAD_ID); 530 map.put(TEST_HANDLE_ONE, msg); 531 mObserver.setMsgListMms(map, true); 532 Assert.assertEquals(msg.threadId, TEST_THREAD_ID); 533 Assert.assertEquals(msg.type, Mms.MESSAGE_BOX_ALL); 534 535 MatrixCursor cursor = new MatrixCursor( 536 new String[] {Mms.THREAD_ID, Mms._ID, Mms.MESSAGE_BOX, Mms.Addr.ADDRESS}); 537 cursor.addRow(new Object[] {BluetoothMapContentObserver.DELETED_THREAD_ID, 1L, 538 Mms.MESSAGE_BOX_INBOX, TEST_ADDRESS}); 539 doReturn(cursor).when(mMapMethodProxy).contentResolverQuery(any(), any(), any(), any(), 540 any(), any()); 541 doReturn(TEST_PLACEHOLDER_INT).when(mMapMethodProxy).contentResolverUpdate(any(), any(), 542 any(), any(), any()); 543 doReturn(TEST_OLD_THREAD_ID).when(mMapMethodProxy).telephonyGetOrCreateThreadId(any(), 544 any()); 545 546 Assert.assertTrue(mObserver.unDeleteMessageMms(TEST_HANDLE_ONE)); 547 548 Assert.assertEquals(msg.threadId, TEST_OLD_THREAD_ID); 549 Assert.assertEquals(msg.type, Mms.MESSAGE_BOX_INBOX); 550 } 551 552 @Test testUnDeleteMessageMms_withDeletedThreadId_andMessageBoxSent()553 public void testUnDeleteMessageMms_withDeletedThreadId_andMessageBoxSent() { 554 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 555 BluetoothMapContentObserver.Msg msg = createMsgWithTypeAndThreadId(Mms.MESSAGE_BOX_ALL, 556 TEST_THREAD_ID); 557 map.put(TEST_HANDLE_ONE, msg); 558 mObserver.setMsgListMms(map, true); 559 Assert.assertEquals(msg.threadId, TEST_THREAD_ID); 560 Assert.assertEquals(msg.type, Mms.MESSAGE_BOX_ALL); 561 562 MatrixCursor cursor = new MatrixCursor( 563 new String[] {Mms.THREAD_ID, Mms._ID, Mms.MESSAGE_BOX, Mms.Addr.ADDRESS}); 564 cursor.addRow(new Object[] {BluetoothMapContentObserver.DELETED_THREAD_ID, 1L, 565 Mms.MESSAGE_BOX_SENT, TEST_ADDRESS}); 566 doReturn(cursor).when(mMapMethodProxy).contentResolverQuery(any(), any(), any(), any(), 567 any(), any()); 568 doReturn(TEST_PLACEHOLDER_INT).when(mMapMethodProxy).contentResolverUpdate(any(), any(), 569 any(), any(), any()); 570 doReturn(TEST_OLD_THREAD_ID).when(mMapMethodProxy).telephonyGetOrCreateThreadId(any(), 571 any()); 572 573 Assert.assertTrue(mObserver.unDeleteMessageMms(TEST_HANDLE_ONE)); 574 575 Assert.assertEquals(msg.threadId, TEST_OLD_THREAD_ID); 576 Assert.assertEquals(msg.type, Mms.MESSAGE_BOX_INBOX); 577 } 578 579 @Test testUnDeleteMessageMms_withoutDeletedThreadId()580 public void testUnDeleteMessageMms_withoutDeletedThreadId() { 581 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 582 BluetoothMapContentObserver.Msg msg = createMsgWithTypeAndThreadId(Mms.MESSAGE_BOX_ALL, 583 TEST_THREAD_ID); 584 map.put(TEST_HANDLE_ONE, msg); 585 mObserver.setMsgListMms(map, true); 586 Assert.assertEquals(msg.threadId, TEST_THREAD_ID); 587 Assert.assertEquals(msg.type, Mms.MESSAGE_BOX_ALL); 588 589 MatrixCursor cursor = new MatrixCursor( 590 new String[] {Mms.THREAD_ID, Mms._ID, Mms.MESSAGE_BOX, Mms.Addr.ADDRESS,}); 591 cursor.addRow(new Object[] {TEST_THREAD_ID, 1L, Mms.MESSAGE_BOX_SENT, TEST_ADDRESS}); 592 doReturn(cursor).when(mMapMethodProxy).contentResolverQuery(any(), any(), any(), any(), 593 any(), any()); 594 doReturn(TEST_OLD_THREAD_ID).when(mMapMethodProxy).telephonyGetOrCreateThreadId(any(), 595 any()); 596 597 Assert.assertTrue(mObserver.unDeleteMessageMms(TEST_HANDLE_ONE)); 598 599 // Nothing changes when thread id is not BluetoothMapContentObserver.DELETED_THREAD_ID 600 Assert.assertEquals(msg.threadId, TEST_THREAD_ID); 601 Assert.assertEquals(msg.type, Sms.MESSAGE_TYPE_ALL); 602 } 603 604 @Test testUnDeleteMessageSms_withDeletedThreadId()605 public void testUnDeleteMessageSms_withDeletedThreadId() { 606 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 607 BluetoothMapContentObserver.Msg msg = createMsgWithTypeAndThreadId(Sms.MESSAGE_TYPE_ALL, 608 TEST_THREAD_ID); 609 map.put(TEST_HANDLE_ONE, msg); 610 mObserver.setMsgListSms(map, true); 611 Assert.assertEquals(msg.threadId, TEST_THREAD_ID); 612 Assert.assertEquals(msg.type, Sms.MESSAGE_TYPE_ALL); 613 614 MatrixCursor cursor = new MatrixCursor( 615 new String[] {Sms.THREAD_ID, Sms.ADDRESS}); 616 cursor.addRow(new Object[] {BluetoothMapContentObserver.DELETED_THREAD_ID, TEST_ADDRESS}); 617 doReturn(cursor).when(mMapMethodProxy).contentResolverQuery(any(), any(), any(), any(), 618 any(), any()); 619 doReturn(TEST_PLACEHOLDER_INT).when(mMapMethodProxy).contentResolverUpdate(any(), any(), 620 any(), any(), any()); 621 doReturn(TEST_OLD_THREAD_ID).when(mMapMethodProxy).telephonyGetOrCreateThreadId(any(), 622 any()); 623 624 Assert.assertTrue(mObserver.unDeleteMessageSms(TEST_HANDLE_ONE)); 625 626 Assert.assertEquals(msg.threadId, TEST_OLD_THREAD_ID); 627 Assert.assertEquals(msg.type, Sms.MESSAGE_TYPE_INBOX); 628 } 629 630 @Test testUnDeleteMessageSms_withoutDeletedThreadId()631 public void testUnDeleteMessageSms_withoutDeletedThreadId() { 632 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 633 BluetoothMapContentObserver.Msg msg = createMsgWithTypeAndThreadId(Sms.MESSAGE_TYPE_ALL, 634 TEST_THREAD_ID); 635 map.put(TEST_HANDLE_ONE, msg); 636 mObserver.setMsgListSms(map, true); 637 Assert.assertEquals(msg.threadId, TEST_THREAD_ID); 638 Assert.assertEquals(msg.type, Sms.MESSAGE_TYPE_ALL); 639 640 MatrixCursor cursor = new MatrixCursor( 641 new String[] {Sms.THREAD_ID, Sms.ADDRESS}); 642 cursor.addRow(new Object[] {TEST_THREAD_ID, TEST_ADDRESS}); 643 doReturn(cursor).when(mMapMethodProxy).contentResolverQuery(any(), any(), any(), any(), 644 any(), any()); 645 doReturn(TEST_OLD_THREAD_ID).when(mMapMethodProxy).telephonyGetOrCreateThreadId(any(), 646 any()); 647 648 Assert.assertTrue(mObserver.unDeleteMessageSms(TEST_HANDLE_ONE)); 649 650 // Nothing changes when thread id is not BluetoothMapContentObserver.DELETED_THREAD_ID 651 Assert.assertEquals(msg.threadId, TEST_THREAD_ID); 652 Assert.assertEquals(msg.type, Sms.MESSAGE_TYPE_ALL); 653 } 654 655 @Test testPushMsgInfo()656 public void testPushMsgInfo() { 657 long id = 1; 658 int transparent = 1; 659 int retry = 1; 660 String phone = "test_phone"; 661 Uri uri = mock(Uri.class); 662 663 BluetoothMapContentObserver.PushMsgInfo msgInfo = 664 new BluetoothMapContentObserver.PushMsgInfo(id, transparent, retry, phone, uri); 665 666 Assert.assertEquals(msgInfo.id, id); 667 Assert.assertEquals(msgInfo.transparent, transparent); 668 Assert.assertEquals(msgInfo.retry, retry); 669 Assert.assertEquals(msgInfo.phone, phone); 670 Assert.assertEquals(msgInfo.uri, uri); 671 } 672 673 @Test setEmailMessageStatusDelete_withStatusValueYes()674 public void setEmailMessageStatusDelete_withStatusValueYes() { 675 setFolderStructureWithTelecomAndMsg(mFolders, BluetoothMapContract.FOLDER_NAME_DELETED, 676 TEST_DELETE_FOLDER_ID); 677 mObserver.setFolderStructure(mFolders); 678 679 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 680 BluetoothMapContentObserver.Msg msg = createSimpleMsg(); 681 map.put(TEST_HANDLE_ONE, msg); 682 mObserver.setMsgListMsg(map, true); 683 doReturn(TEST_PLACEHOLDER_INT).when(mMapMethodProxy).contentResolverUpdate(any(), any(), 684 any(), any(), any()); 685 686 Assert.assertTrue(mObserver.setEmailMessageStatusDelete(mCurrentFolder, TEST_URI_STR, 687 TEST_HANDLE_ONE, BluetoothMapAppParams.STATUS_VALUE_YES)); 688 Assert.assertEquals(msg.folderId, TEST_DELETE_FOLDER_ID); 689 } 690 691 @Test setEmailMessageStatusDelete_withStatusValueYes_andUpdateCountZero()692 public void setEmailMessageStatusDelete_withStatusValueYes_andUpdateCountZero() { 693 setFolderStructureWithTelecomAndMsg(mFolders, BluetoothMapContract.FOLDER_NAME_DELETED, 694 TEST_DELETE_FOLDER_ID); 695 mObserver.setFolderStructure(mFolders); 696 697 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 698 BluetoothMapContentObserver.Msg msg = createSimpleMsg(); 699 map.put(TEST_HANDLE_ONE, msg); 700 mObserver.setMsgListMsg(map, true); 701 doReturn(0).when(mMapMethodProxy).contentResolverUpdate(any(), any(), 702 any(), any(), any()); 703 704 Assert.assertFalse(mObserver.setEmailMessageStatusDelete(mCurrentFolder, TEST_URI_STR, 705 TEST_HANDLE_ONE, BluetoothMapAppParams.STATUS_VALUE_YES)); 706 } 707 708 @Test setEmailMessageStatusDelete_withStatusValueNo()709 public void setEmailMessageStatusDelete_withStatusValueNo() { 710 setFolderStructureWithTelecomAndMsg(mCurrentFolder, BluetoothMapContract.FOLDER_NAME_INBOX, 711 TEST_INBOX_FOLDER_ID); 712 setFolderStructureWithTelecomAndMsg(mFolders, BluetoothMapContract.FOLDER_NAME_DELETED, 713 TEST_DELETE_FOLDER_ID); 714 mObserver.setFolderStructure(mFolders); 715 716 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 717 BluetoothMapContentObserver.Msg msg = createSimpleMsg(); 718 msg.oldFolderId = TEST_OLD_FOLDER_ID; 719 msg.folderId = TEST_DELETE_FOLDER_ID; 720 map.put(TEST_HANDLE_ONE, msg); 721 mObserver.setMsgListMsg(map, true); 722 doReturn(TEST_PLACEHOLDER_INT).when(mMapMethodProxy).contentResolverUpdate(any(), any(), 723 any(), any(), any()); 724 725 Assert.assertTrue(mObserver.setEmailMessageStatusDelete(mCurrentFolder, TEST_URI_STR, 726 TEST_HANDLE_ONE, BluetoothMapAppParams.STATUS_VALUE_NO)); 727 Assert.assertEquals(msg.folderId, TEST_INBOX_FOLDER_ID); 728 } 729 730 @Test setEmailMessageStatusDelete_withStatusValueNo_andOldFolderIdMinusOne()731 public void setEmailMessageStatusDelete_withStatusValueNo_andOldFolderIdMinusOne() { 732 int oldFolderId = -1; 733 setFolderStructureWithTelecomAndMsg(mCurrentFolder, BluetoothMapContract.FOLDER_NAME_INBOX, 734 TEST_INBOX_FOLDER_ID); 735 setFolderStructureWithTelecomAndMsg(mFolders, BluetoothMapContract.FOLDER_NAME_DELETED, 736 TEST_DELETE_FOLDER_ID); 737 mObserver.setFolderStructure(mFolders); 738 739 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 740 BluetoothMapContentObserver.Msg msg = createSimpleMsg(); 741 msg.oldFolderId = oldFolderId; 742 msg.folderId = TEST_DELETE_FOLDER_ID; 743 map.put(TEST_HANDLE_ONE, msg); 744 mObserver.setMsgListMsg(map, true); 745 doReturn(TEST_PLACEHOLDER_INT).when(mMapMethodProxy).contentResolverUpdate(any(), any(), 746 any(), any(), any()); 747 748 Assert.assertTrue(mObserver.setEmailMessageStatusDelete(mCurrentFolder, TEST_URI_STR, 749 TEST_HANDLE_ONE, BluetoothMapAppParams.STATUS_VALUE_NO)); 750 Assert.assertEquals(msg.folderId, TEST_INBOX_FOLDER_ID); 751 } 752 753 @Test setEmailMessageStatusDelete_withStatusValueNo_andInboxFolderNull()754 public void setEmailMessageStatusDelete_withStatusValueNo_andInboxFolderNull() { 755 // This sets mCurrentFolder to have a sent folder, but not an inbox folder 756 setFolderStructureWithTelecomAndMsg(mCurrentFolder, BluetoothMapContract.FOLDER_NAME_SENT, 757 BluetoothMapContract.FOLDER_ID_SENT); 758 setFolderStructureWithTelecomAndMsg(mFolders, BluetoothMapContract.FOLDER_NAME_DELETED, 759 TEST_DELETE_FOLDER_ID); 760 mObserver.setFolderStructure(mFolders); 761 762 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 763 BluetoothMapContentObserver.Msg msg = createSimpleMsg(); 764 msg.oldFolderId = TEST_OLD_FOLDER_ID; 765 msg.folderId = TEST_DELETE_FOLDER_ID; 766 map.put(TEST_HANDLE_ONE, msg); 767 mObserver.setMsgListMsg(map, true); 768 doReturn(TEST_PLACEHOLDER_INT).when(mMapMethodProxy).contentResolverUpdate(any(), any(), 769 any(), any(), any()); 770 771 Assert.assertTrue(mObserver.setEmailMessageStatusDelete(mCurrentFolder, TEST_URI_STR, 772 TEST_HANDLE_ONE, BluetoothMapAppParams.STATUS_VALUE_NO)); 773 Assert.assertEquals(msg.folderId, TEST_OLD_FOLDER_ID); 774 } 775 776 @Test setMessageStatusDeleted_withTypeEmail()777 public void setMessageStatusDeleted_withTypeEmail() { 778 setFolderStructureWithTelecomAndMsg(mFolders, BluetoothMapContract.FOLDER_NAME_DELETED, 779 TEST_DELETE_FOLDER_ID); 780 mObserver.setFolderStructure(mFolders); 781 782 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 783 BluetoothMapContentObserver.Msg msg = createSimpleMsg(); 784 map.put(TEST_HANDLE_ONE, msg); 785 mObserver.setMsgListMsg(map, true); 786 doReturn(TEST_PLACEHOLDER_INT).when(mMapMethodProxy).contentResolverUpdate(any(), any(), 787 any(), any(), any()); 788 789 Assert.assertTrue(mObserver.setMessageStatusDeleted(TEST_HANDLE_ONE, TYPE.EMAIL, 790 mCurrentFolder, TEST_URI_STR, BluetoothMapAppParams.STATUS_VALUE_YES)); 791 } 792 793 @Test setMessageStatusDeleted_withTypeIm()794 public void setMessageStatusDeleted_withTypeIm() { 795 Assert.assertFalse(mObserver.setMessageStatusDeleted(TEST_HANDLE_ONE, TYPE.IM, 796 mCurrentFolder, TEST_URI_STR, BluetoothMapAppParams.STATUS_VALUE_YES)); 797 } 798 799 @Test setMessageStatusDeleted_withTypeGsmOrMms_andStatusValueNo()800 public void setMessageStatusDeleted_withTypeGsmOrMms_andStatusValueNo() { 801 doReturn(null).when(mMapMethodProxy).contentResolverQuery(any(), any(), any(), any(), 802 any(), any()); 803 doReturn(TEST_OLD_THREAD_ID).when(mMapMethodProxy).telephonyGetOrCreateThreadId(any(), 804 any()); 805 806 // setMessageStatusDeleted with type Gsm or Mms calls either deleteMessage() or 807 // unDeleteMessage(), which returns false when no cursor is set with BluetoothMethodProxy. 808 Assert.assertFalse(mObserver.setMessageStatusDeleted(TEST_HANDLE_ONE, TYPE.MMS, 809 mCurrentFolder, TEST_URI_STR, BluetoothMapAppParams.STATUS_VALUE_NO)); 810 Assert.assertFalse(mObserver.setMessageStatusDeleted(TEST_HANDLE_ONE, TYPE.SMS_GSM, 811 mCurrentFolder, TEST_URI_STR, BluetoothMapAppParams.STATUS_VALUE_NO)); 812 } 813 814 @Test setMessageStatusDeleted_withTypeGsmOrMms_andStatusValueYes()815 public void setMessageStatusDeleted_withTypeGsmOrMms_andStatusValueYes() { 816 doReturn(null).when(mMapMethodProxy).contentResolverQuery(any(), any(), any(), any(), 817 any(), any()); 818 doReturn(TEST_PLACEHOLDER_INT).when(mMapMethodProxy).contentResolverUpdate(any(), any(), 819 any(), any(), any()); 820 821 // setMessageStatusDeleted with type Gsm or Mms calls either deleteMessage() or 822 // unDeleteMessage(), which returns false when no cursor is set with BluetoothMethodProxy. 823 Assert.assertFalse(mObserver.setMessageStatusDeleted(TEST_HANDLE_ONE, TYPE.MMS, 824 mCurrentFolder, TEST_URI_STR, BluetoothMapAppParams.STATUS_VALUE_YES)); 825 Assert.assertFalse(mObserver.setMessageStatusDeleted(TEST_HANDLE_ONE, TYPE.SMS_GSM, 826 mCurrentFolder, TEST_URI_STR, BluetoothMapAppParams.STATUS_VALUE_YES)); 827 } 828 829 @Test initMsgList_withMsgSms()830 public void initMsgList_withMsgSms() throws Exception { 831 MatrixCursor cursor = new MatrixCursor(new String[] {Sms._ID, Sms.TYPE, Sms.THREAD_ID, 832 Sms.READ}); 833 cursor.addRow(new Object[] {(long) TEST_ID, TEST_SMS_TYPE_ALL, TEST_THREAD_ID, 834 TEST_READ_FLAG_ONE}); 835 doReturn(cursor).when(mMapMethodProxy).contentResolverQuery(any(), any(), 836 eq(BluetoothMapContentObserver.SMS_PROJECTION_SHORT), any(), any(), any()); 837 cursor.moveToFirst(); 838 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 839 mObserver.setMsgListMsg(map, true); 840 841 mObserver.initMsgList(); 842 843 BluetoothMapContentObserver.Msg msg = mObserver.getMsgListSms().get((long) TEST_ID); 844 Assert.assertEquals(msg.id, TEST_ID); 845 Assert.assertEquals(msg.type, TEST_SMS_TYPE_ALL); 846 Assert.assertEquals(msg.threadId, TEST_THREAD_ID); 847 Assert.assertEquals(msg.flagRead, TEST_READ_FLAG_ONE); 848 } 849 850 @Test initMsgList_withMsgMms()851 public void initMsgList_withMsgMms() throws Exception { 852 MatrixCursor cursor = new MatrixCursor(new String[] {Mms._ID, Mms.MESSAGE_BOX, 853 Mms.THREAD_ID, Mms.READ}); 854 cursor.addRow(new Object[] {(long) TEST_ID, TEST_MMS_TYPE_ALL, TEST_THREAD_ID, 855 TEST_READ_FLAG_ZERO}); 856 doReturn(null).when(mMapMethodProxy).contentResolverQuery(any(), any(), 857 eq(BluetoothMapContentObserver.SMS_PROJECTION_SHORT), any(), any(), any()); 858 doReturn(cursor).when(mMapMethodProxy).contentResolverQuery(any(), any(), 859 eq(BluetoothMapContentObserver.MMS_PROJECTION_SHORT), any(), any(), any()); 860 cursor.moveToFirst(); 861 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 862 mObserver.setMsgListMsg(map, true); 863 864 mObserver.initMsgList(); 865 866 BluetoothMapContentObserver.Msg msg = mObserver.getMsgListMms().get((long) TEST_ID); 867 Assert.assertEquals(msg.id, TEST_ID); 868 Assert.assertEquals(msg.type, TEST_MMS_TYPE_ALL); 869 Assert.assertEquals(msg.threadId, TEST_THREAD_ID); 870 Assert.assertEquals(msg.flagRead, TEST_READ_FLAG_ZERO); 871 } 872 873 @Test initMsgList_withMsg()874 public void initMsgList_withMsg() throws Exception { 875 MatrixCursor cursor = new MatrixCursor(new String[] {MessageColumns._ID, 876 MessageColumns.FOLDER_ID, MessageColumns.FLAG_READ}); 877 cursor.addRow(new Object[] {(long) TEST_ID, TEST_INBOX_FOLDER_ID, TEST_READ_FLAG_ONE}); 878 doReturn(null).when(mMapMethodProxy).contentResolverQuery(any(), any(), 879 eq(BluetoothMapContentObserver.SMS_PROJECTION_SHORT), any(), any(), any()); 880 doReturn(null).when(mMapMethodProxy).contentResolverQuery(any(), any(), 881 eq(BluetoothMapContentObserver.MMS_PROJECTION_SHORT), any(), any(), any()); 882 when(mProviderClient.query(any(), any(), any(), any(), any())).thenReturn(cursor); 883 cursor.moveToFirst(); 884 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 885 mObserver.setMsgListMsg(map, true); 886 887 mObserver.initMsgList(); 888 889 BluetoothMapContentObserver.Msg msg = mObserver.getMsgListMsg().get((long) TEST_ID); 890 Assert.assertEquals(msg.id, TEST_ID); 891 Assert.assertEquals(msg.folderId, TEST_INBOX_FOLDER_ID); 892 Assert.assertEquals(msg.flagRead, TEST_READ_FLAG_ONE); 893 } 894 895 @Test initContactsList()896 public void initContactsList() throws Exception { 897 MatrixCursor cursor = new MatrixCursor( 898 new String[] {BluetoothMapContract.ConvoContactColumns.CONVO_ID, 899 BluetoothMapContract.ConvoContactColumns.NAME, 900 BluetoothMapContract.ConvoContactColumns.NICKNAME, 901 BluetoothMapContract.ConvoContactColumns.X_BT_UID, 902 BluetoothMapContract.ConvoContactColumns.CHAT_STATE, 903 BluetoothMapContract.ConvoContactColumns.UCI, 904 BluetoothMapContract.ConvoContactColumns.LAST_ACTIVE, 905 BluetoothMapContract.ConvoContactColumns.PRESENCE_STATE, 906 BluetoothMapContract.ConvoContactColumns.STATUS_TEXT, 907 BluetoothMapContract.ConvoContactColumns.PRIORITY, 908 BluetoothMapContract.ConvoContactColumns.LAST_ONLINE}); 909 cursor.addRow(new Object[] {TEST_CONVO_ID, TEST_NAME, TEST_DISPLAY_NAME, TEST_BT_UID, 910 TEST_CHAT_STATE, TEST_UCI, TEST_LAST_ACTIVITY, TEST_PRESENCE_STATE, 911 TEST_STATUS_TEXT, TEST_PRIORITY, TEST_LAST_ONLINE}); 912 doReturn(cursor).when(mMapMethodProxy).contentResolverQuery(any(), any(), any(), any(), 913 any(), any()); 914 915 mObserver.mContactUri = mock(Uri.class); 916 when(mProviderClient.query(any(), any(), any(), any(), any())).thenReturn(cursor); 917 918 Map<String, BluetoothMapConvoContactElement> map = new HashMap<>(); 919 mObserver.setContactList(map, true); 920 mObserver.initContactsList(); 921 BluetoothMapConvoContactElement contactElement = mObserver.getContactList().get(TEST_UCI); 922 923 final SimpleDateFormat format = new SimpleDateFormat("yyyyMMdd'T'HHmmss"); 924 Assert.assertEquals(contactElement.getContactId(), TEST_UCI); 925 Assert.assertEquals(contactElement.getName(), TEST_NAME); 926 Assert.assertEquals(contactElement.getDisplayName(), TEST_DISPLAY_NAME); 927 Assert.assertEquals(contactElement.getBtUid(), TEST_BT_UID); 928 Assert.assertEquals(contactElement.getChatState(), TEST_CHAT_STATE); 929 Assert.assertEquals(contactElement.getPresenceStatus(), TEST_STATUS_TEXT); 930 Assert.assertEquals(contactElement.getPresenceAvailability(), TEST_PRESENCE_STATE); 931 Assert.assertEquals(contactElement.getLastActivityString(), format.format( 932 TEST_LAST_ACTIVITY)); 933 Assert.assertEquals(contactElement.getPriority(), TEST_PRIORITY); 934 } 935 936 @Test handleMsgListChangesMsg_withNonExistingMessage_andVersion11()937 public void handleMsgListChangesMsg_withNonExistingMessage_andVersion11() throws Exception { 938 MatrixCursor cursor = new MatrixCursor(new String[] { 939 BluetoothMapContract.MessageColumns._ID, 940 BluetoothMapContract.MessageColumns.FOLDER_ID, 941 BluetoothMapContract.MessageColumns.FLAG_READ, 942 BluetoothMapContract.MessageColumns.DATE, 943 BluetoothMapContract.MessageColumns.SUBJECT, 944 BluetoothMapContract.MessageColumns.FROM_LIST, 945 BluetoothMapContract.MessageColumns.FLAG_HIGH_PRIORITY}); 946 cursor.addRow(new Object[] {TEST_HANDLE_ONE, TEST_INBOX_FOLDER_ID, TEST_READ_FLAG_ONE, 947 TEST_DATE_MS, TEST_SUBJECT, TEST_ADDRESS, 1}); 948 when(mProviderClient.query(any(), any(), any(), any(), any())).thenReturn(cursor); 949 950 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 951 // Giving a different handle for msg below and cursor above makes handleMsgListChangesMsg() 952 // function for a non-existing message 953 BluetoothMapContentObserver.Msg msg = new BluetoothMapContentObserver.Msg(TEST_HANDLE_TWO, 954 TEST_INBOX_FOLDER_ID, TEST_READ_FLAG_ONE); 955 msg.localInitiatedSend = true; 956 msg.transparent = true; 957 map.put(TEST_HANDLE_TWO, msg); 958 mObserver.setMsgListMsg(map, true); 959 mObserver.mMapEventReportVersion = BluetoothMapUtils.MAP_EVENT_REPORT_V11; 960 mFolders.setFolderId(TEST_INBOX_FOLDER_ID); 961 mObserver.setFolderStructure(mFolders); 962 963 mObserver.handleMsgListChangesMsg(TEST_URI); 964 965 Assert.assertEquals(mObserver.getMsgListMsg().get(TEST_HANDLE_ONE).id, TEST_HANDLE_ONE); 966 Assert.assertEquals(mObserver.getMsgListMsg().get(TEST_HANDLE_ONE).type, 967 TEST_INBOX_FOLDER_ID); 968 Assert.assertEquals(mObserver.getMsgListMsg().get(TEST_HANDLE_ONE).flagRead, 969 TEST_READ_FLAG_ONE); 970 } 971 972 @Test handleMsgListChangesMsg_withNonExistingMessage_andVersion12()973 public void handleMsgListChangesMsg_withNonExistingMessage_andVersion12() throws Exception { 974 MatrixCursor cursor = new MatrixCursor(new String[] { 975 BluetoothMapContract.MessageColumns._ID, 976 BluetoothMapContract.MessageColumns.FOLDER_ID, 977 BluetoothMapContract.MessageColumns.FLAG_READ, 978 BluetoothMapContract.MessageColumns.DATE, 979 BluetoothMapContract.MessageColumns.SUBJECT, 980 BluetoothMapContract.MessageColumns.FROM_LIST, 981 BluetoothMapContract.MessageColumns.FLAG_HIGH_PRIORITY, 982 BluetoothMapContract.MessageColumns.THREAD_ID, 983 BluetoothMapContract.MessageColumns.THREAD_NAME}); 984 cursor.addRow(new Object[] {TEST_HANDLE_ONE, TEST_INBOX_FOLDER_ID, TEST_READ_FLAG_ONE, 985 TEST_DATE_MS, TEST_SUBJECT, TEST_ADDRESS, 1, 1, "threadName"}); 986 when(mProviderClient.query(any(), any(), any(), any(), any())).thenReturn(cursor); 987 988 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 989 // Giving a different handle for msg below and cursor above makes handleMsgListChangesMsg() 990 // function for a non-existing message 991 BluetoothMapContentObserver.Msg msg = new BluetoothMapContentObserver.Msg(TEST_HANDLE_TWO, 992 TEST_INBOX_FOLDER_ID, TEST_READ_FLAG_ONE); 993 msg.localInitiatedSend = false; 994 msg.transparent = false; 995 map.put(TEST_HANDLE_TWO, msg); 996 mObserver.setMsgListMsg(map, true); 997 mObserver.mMapEventReportVersion = BluetoothMapUtils.MAP_EVENT_REPORT_V12; 998 999 mObserver.handleMsgListChangesMsg(TEST_URI); 1000 1001 Assert.assertEquals(mObserver.getMsgListMsg().get(TEST_HANDLE_ONE).id, TEST_HANDLE_ONE); 1002 Assert.assertEquals(mObserver.getMsgListMsg().get(TEST_HANDLE_ONE).type, 1003 TEST_INBOX_FOLDER_ID); 1004 Assert.assertEquals(mObserver.getMsgListMsg().get(TEST_HANDLE_ONE).flagRead, 1005 TEST_READ_FLAG_ONE); 1006 } 1007 1008 @Test handleMsgListChangesMsg_withNonExistingMessage_andVersion10()1009 public void handleMsgListChangesMsg_withNonExistingMessage_andVersion10() throws Exception { 1010 MatrixCursor cursor = new MatrixCursor(new String[] { 1011 BluetoothMapContract.MessageColumns._ID, 1012 BluetoothMapContract.MessageColumns.FOLDER_ID, 1013 BluetoothMapContract.MessageColumns.FLAG_READ}); 1014 cursor.addRow(new Object[] {TEST_HANDLE_ONE, TEST_INBOX_FOLDER_ID, TEST_READ_FLAG_ONE}); 1015 when(mProviderClient.query(any(), any(), any(), any(), any())).thenReturn(cursor); 1016 1017 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 1018 // Giving a different handle for msg below and cursor above makes handleMsgListChangesMsg() 1019 // function for a non-existing message 1020 BluetoothMapContentObserver.Msg msg = new BluetoothMapContentObserver.Msg(TEST_HANDLE_TWO, 1021 TEST_INBOX_FOLDER_ID, TEST_READ_FLAG_ONE); 1022 msg.localInitiatedSend = false; 1023 msg.transparent = false; 1024 map.put(TEST_HANDLE_TWO, msg); 1025 mObserver.setMsgListMsg(map, true); 1026 mObserver.mMapEventReportVersion = BluetoothMapUtils.MAP_EVENT_REPORT_V10; 1027 mFolders.setFolderId(TEST_HANDLE_TWO); 1028 mObserver.setFolderStructure(mFolders); 1029 1030 mObserver.handleMsgListChangesMsg(TEST_URI); 1031 1032 Assert.assertEquals(mObserver.getMsgListMsg().get(TEST_HANDLE_ONE).id, TEST_HANDLE_ONE); 1033 Assert.assertEquals(mObserver.getMsgListMsg().get(TEST_HANDLE_ONE).type, 1034 TEST_INBOX_FOLDER_ID); 1035 Assert.assertEquals(mObserver.getMsgListMsg().get(TEST_HANDLE_ONE).flagRead, 1036 TEST_READ_FLAG_ONE); 1037 } 1038 1039 @Test handleMsgListChangesMsg_withExistingMessage_andNonNullDeletedFolder()1040 public void handleMsgListChangesMsg_withExistingMessage_andNonNullDeletedFolder() 1041 throws Exception { 1042 MatrixCursor cursor = new MatrixCursor(new String[] { 1043 BluetoothMapContract.MessageColumns._ID, 1044 BluetoothMapContract.MessageColumns.FOLDER_ID, 1045 BluetoothMapContract.MessageColumns.FLAG_READ,}); 1046 cursor.addRow(new Object[] {TEST_HANDLE_ONE, TEST_DELETE_FOLDER_ID, TEST_READ_FLAG_ONE}); 1047 when(mProviderClient.query(any(), any(), any(), any(), any())).thenReturn(cursor); 1048 1049 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 1050 // Giving the same handle for msg below and cursor above makes handleMsgListChangesMsg() 1051 // function for an existing message 1052 BluetoothMapContentObserver.Msg msg = new BluetoothMapContentObserver.Msg(TEST_HANDLE_ONE, 1053 TEST_INBOX_FOLDER_ID, TEST_READ_FLAG_ZERO); 1054 map.put(TEST_HANDLE_ONE, msg); 1055 mObserver.setMsgListMsg(map, true); 1056 mObserver.mMapEventReportVersion = BluetoothMapUtils.MAP_EVENT_REPORT_V11; 1057 setFolderStructureWithTelecomAndMsg(mFolders, BluetoothMapContract.FOLDER_NAME_DELETED, 1058 TEST_DELETE_FOLDER_ID); 1059 mObserver.setFolderStructure(mFolders); 1060 1061 mObserver.handleMsgListChangesMsg(TEST_URI); 1062 1063 Assert.assertEquals(mObserver.getMsgListMsg().get(TEST_HANDLE_ONE).id, TEST_HANDLE_ONE); 1064 Assert.assertEquals(mObserver.getMsgListMsg().get(TEST_HANDLE_ONE).folderId, 1065 TEST_DELETE_FOLDER_ID); 1066 Assert.assertEquals(mObserver.getMsgListMsg().get(TEST_HANDLE_ONE).flagRead, 1067 TEST_READ_FLAG_ONE); 1068 } 1069 1070 @Test handleMsgListChangesMsg_withExistingMessage_andNonNullSentFolder()1071 public void handleMsgListChangesMsg_withExistingMessage_andNonNullSentFolder() 1072 throws Exception { 1073 MatrixCursor cursor = new MatrixCursor(new String[] { 1074 BluetoothMapContract.MessageColumns._ID, 1075 BluetoothMapContract.MessageColumns.FOLDER_ID, 1076 BluetoothMapContract.MessageColumns.FLAG_READ,}); 1077 cursor.addRow(new Object[] {TEST_HANDLE_ONE, TEST_SENT_FOLDER_ID, TEST_READ_FLAG_ONE}); 1078 when(mProviderClient.query(any(), any(), any(), any(), any())).thenReturn(cursor); 1079 1080 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 1081 // Giving the same handle for msg below and cursor above makes handleMsgListChangesMsg() 1082 // function for an existing message 1083 BluetoothMapContentObserver.Msg msg = new BluetoothMapContentObserver.Msg(TEST_HANDLE_ONE, 1084 TEST_INBOX_FOLDER_ID, TEST_READ_FLAG_ZERO); 1085 msg.localInitiatedSend = true; 1086 msg.transparent = false; 1087 map.put(TEST_HANDLE_ONE, msg); 1088 mObserver.setMsgListMsg(map, true); 1089 mObserver.mMapEventReportVersion = BluetoothMapUtils.MAP_EVENT_REPORT_V11; 1090 setFolderStructureWithTelecomAndMsg(mFolders, BluetoothMapContract.FOLDER_NAME_SENT, 1091 TEST_SENT_FOLDER_ID); 1092 mObserver.setFolderStructure(mFolders); 1093 1094 mObserver.handleMsgListChangesMsg(TEST_URI); 1095 1096 Assert.assertEquals(mObserver.getMsgListMsg().get(TEST_HANDLE_ONE).id, TEST_HANDLE_ONE); 1097 Assert.assertEquals(mObserver.getMsgListMsg().get(TEST_HANDLE_ONE).folderId, 1098 TEST_SENT_FOLDER_ID); 1099 Assert.assertEquals(mObserver.getMsgListMsg().get(TEST_HANDLE_ONE).flagRead, 1100 TEST_READ_FLAG_ONE); 1101 } 1102 1103 @Test handleMsgListChangesMsg_withExistingMessage_andNonNullTransparentSentFolder()1104 public void handleMsgListChangesMsg_withExistingMessage_andNonNullTransparentSentFolder() 1105 throws Exception { 1106 MatrixCursor cursor = new MatrixCursor(new String[] { 1107 BluetoothMapContract.MessageColumns._ID, 1108 BluetoothMapContract.MessageColumns.FOLDER_ID, 1109 BluetoothMapContract.MessageColumns.FLAG_READ,}); 1110 cursor.addRow(new Object[] {TEST_HANDLE_ONE, TEST_SENT_FOLDER_ID, TEST_READ_FLAG_ONE}); 1111 when(mProviderClient.query(any(), any(), any(), any(), any())).thenReturn(cursor); 1112 1113 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 1114 // Giving the same handle for msg below and cursor above makes handleMsgListChangesMsg() 1115 // function for an existing message 1116 BluetoothMapContentObserver.Msg msg = new BluetoothMapContentObserver.Msg(TEST_HANDLE_ONE, 1117 TEST_INBOX_FOLDER_ID, TEST_READ_FLAG_ZERO); 1118 msg.localInitiatedSend = true; 1119 msg.transparent = true; 1120 map.put(TEST_HANDLE_ONE, msg); 1121 mObserver.setMsgListMsg(map, true); 1122 mObserver.mMapEventReportVersion = BluetoothMapUtils.MAP_EVENT_REPORT_V11; 1123 doReturn(TEST_PLACEHOLDER_INT).when(mMapMethodProxy).contentResolverDelete(any(), any(), 1124 any(), any()); 1125 setFolderStructureWithTelecomAndMsg(mFolders, BluetoothMapContract.FOLDER_NAME_SENT, 1126 TEST_SENT_FOLDER_ID); 1127 mObserver.setFolderStructure(mFolders); 1128 mObserver.mMessageUri = Mms.CONTENT_URI; 1129 1130 mObserver.handleMsgListChangesMsg(TEST_URI); 1131 1132 Assert.assertEquals(mObserver.getMsgListMsg().get(TEST_HANDLE_ONE).id, TEST_HANDLE_ONE); 1133 Assert.assertEquals(mObserver.getMsgListMsg().get(TEST_HANDLE_ONE).folderId, 1134 TEST_SENT_FOLDER_ID); 1135 Assert.assertEquals(mObserver.getMsgListMsg().get(TEST_HANDLE_ONE).flagRead, 1136 TEST_READ_FLAG_ONE); 1137 } 1138 1139 @Test handleMsgListChangesMsg_withExistingMessage_andUnknownOldFolder()1140 public void handleMsgListChangesMsg_withExistingMessage_andUnknownOldFolder() 1141 throws Exception { 1142 MatrixCursor cursor = new MatrixCursor(new String[] { 1143 BluetoothMapContract.MessageColumns._ID, 1144 BluetoothMapContract.MessageColumns.FOLDER_ID, 1145 BluetoothMapContract.MessageColumns.FLAG_READ,}); 1146 cursor.addRow(new Object[] {TEST_HANDLE_ONE, TEST_INBOX_FOLDER_ID, TEST_READ_FLAG_ONE}); 1147 when(mProviderClient.query(any(), any(), any(), any(), any())).thenReturn(cursor); 1148 1149 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 1150 // Giving the same handle for msg below and cursor above makes handleMsgListChangesMsg() 1151 // function for an existing message 1152 BluetoothMapContentObserver.Msg msg = new BluetoothMapContentObserver.Msg(TEST_HANDLE_ONE, 1153 TEST_SENT_FOLDER_ID, TEST_READ_FLAG_ZERO); 1154 msg.localInitiatedSend = true; 1155 msg.transparent = false; 1156 map.put(TEST_HANDLE_ONE, msg); 1157 mObserver.setMsgListMsg(map, true); 1158 mObserver.mMapEventReportVersion = BluetoothMapUtils.MAP_EVENT_REPORT_V11; 1159 setFolderStructureWithTelecomAndMsg(mFolders, BluetoothMapContract.FOLDER_NAME_DRAFT, 1160 TEST_DRAFT_FOLDER_ID); 1161 mObserver.setFolderStructure(mFolders); 1162 1163 mObserver.handleMsgListChangesMsg(TEST_URI); 1164 1165 Assert.assertEquals(mObserver.getMsgListMsg().get(TEST_HANDLE_ONE).id, TEST_HANDLE_ONE); 1166 Assert.assertEquals(mObserver.getMsgListMsg().get(TEST_HANDLE_ONE).folderId, 1167 TEST_INBOX_FOLDER_ID); 1168 Assert.assertEquals(mObserver.getMsgListMsg().get(TEST_HANDLE_ONE).flagRead, 1169 TEST_READ_FLAG_ONE); 1170 } 1171 1172 @Test handleMsgListChangesMms_withNonExistingMessage_andVersion11()1173 public void handleMsgListChangesMms_withNonExistingMessage_andVersion11() { 1174 MatrixCursor cursor = new MatrixCursor(new String[] {Mms._ID, Mms.MESSAGE_BOX, 1175 Mms.MESSAGE_TYPE, Mms.THREAD_ID, Mms.READ, Mms.DATE, Mms.SUBJECT, 1176 Mms.PRIORITY, Mms.Addr.ADDRESS}); 1177 cursor.addRow(new Object[] {TEST_HANDLE_ONE, TEST_MMS_TYPE_ALL, TEST_MMS_MTYPE, 1178 TEST_THREAD_ID, TEST_READ_FLAG_ONE, TEST_DATE_SEC, TEST_SUBJECT, 1179 PduHeaders.PRIORITY_HIGH, null}); 1180 doReturn(cursor).when(mMapMethodProxy).contentResolverQuery(any(), any(), any(), any(), 1181 any(), any()); 1182 1183 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 1184 // Giving a different handle for msg below and cursor above makes handleMsgListChangesMms() 1185 // function for a non-existing message 1186 BluetoothMapContentObserver.Msg msg = new BluetoothMapContentObserver.Msg(TEST_HANDLE_TWO, 1187 TEST_INBOX_FOLDER_ID, TEST_READ_FLAG_ONE); 1188 map.put(TEST_HANDLE_TWO, msg); 1189 mObserver.setMsgListMms(map, true); 1190 mObserver.mMapEventReportVersion = BluetoothMapUtils.MAP_EVENT_REPORT_V11; 1191 1192 mObserver.handleMsgListChangesMms(); 1193 1194 Assert.assertEquals(mObserver.getMsgListMms().get(TEST_HANDLE_ONE).id, TEST_HANDLE_ONE); 1195 Assert.assertEquals(mObserver.getMsgListMms().get(TEST_HANDLE_ONE).type, TEST_MMS_TYPE_ALL); 1196 Assert.assertEquals(mObserver.getMsgListMms().get(TEST_HANDLE_ONE).threadId, 1197 TEST_THREAD_ID); 1198 Assert.assertEquals(mObserver.getMsgListMms().get(TEST_HANDLE_ONE).flagRead, 1199 TEST_READ_FLAG_ONE); 1200 } 1201 1202 @Test handleMsgListChangesMms_withNonExistingMessage_andVersion12()1203 public void handleMsgListChangesMms_withNonExistingMessage_andVersion12() { 1204 MatrixCursor cursor = new MatrixCursor(new String[] {Mms._ID, Mms.MESSAGE_BOX, 1205 Mms.MESSAGE_TYPE, Mms.THREAD_ID, Mms.READ, Mms.DATE, Mms.SUBJECT, 1206 Mms.PRIORITY, Mms.Addr.ADDRESS}); 1207 cursor.addRow(new Object[] {TEST_HANDLE_ONE, TEST_MMS_TYPE_ALL, TEST_MMS_MTYPE, 1208 TEST_THREAD_ID, TEST_READ_FLAG_ONE, TEST_DATE_SEC, TEST_SUBJECT, 1209 PduHeaders.PRIORITY_HIGH, null}); 1210 doReturn(cursor).when(mMapMethodProxy).contentResolverQuery(any(), any(), any(), any(), 1211 any(), any()); 1212 1213 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 1214 // Giving a different handle for msg below and cursor above makes handleMsgListChangesMms() 1215 // function for a non-existing message 1216 BluetoothMapContentObserver.Msg msg = new BluetoothMapContentObserver.Msg(TEST_HANDLE_TWO, 1217 TEST_INBOX_FOLDER_ID, TEST_READ_FLAG_ONE); 1218 map.put(TEST_HANDLE_TWO, msg); 1219 mObserver.setMsgListMms(map, true); 1220 mObserver.mMapEventReportVersion = BluetoothMapUtils.MAP_EVENT_REPORT_V12; 1221 1222 mObserver.handleMsgListChangesMms(); 1223 1224 Assert.assertEquals(mObserver.getMsgListMms().get(TEST_HANDLE_ONE).id, TEST_HANDLE_ONE); 1225 Assert.assertEquals(mObserver.getMsgListMms().get(TEST_HANDLE_ONE).type, TEST_MMS_TYPE_ALL); 1226 Assert.assertEquals(mObserver.getMsgListMms().get(TEST_HANDLE_ONE).threadId, 1227 TEST_THREAD_ID); 1228 Assert.assertEquals(mObserver.getMsgListMms().get(TEST_HANDLE_ONE).flagRead, 1229 TEST_READ_FLAG_ONE); 1230 } 1231 1232 @Test handleMsgListChangesMms_withNonExistingOldMessage_andVersion12()1233 public void handleMsgListChangesMms_withNonExistingOldMessage_andVersion12() { 1234 Calendar cal = Calendar.getInstance(); 1235 cal.add(Calendar.YEAR, -1); 1236 cal.add(Calendar.DATE, -1); 1237 long timestampSec = TimeUnit.MILLISECONDS.toSeconds(cal.getTimeInMillis()); 1238 1239 MatrixCursor cursor = new MatrixCursor(new String[] {Mms._ID, Mms.MESSAGE_BOX, 1240 Mms.MESSAGE_TYPE, Mms.THREAD_ID, Mms.READ, Mms.DATE, Mms.SUBJECT, 1241 Mms.PRIORITY, Mms.Addr.ADDRESS}); 1242 cursor.addRow(new Object[] {TEST_HANDLE_ONE, TEST_MMS_TYPE_ALL, TEST_MMS_MTYPE, 1243 TEST_THREAD_ID, TEST_READ_FLAG_ONE, timestampSec, TEST_SUBJECT, 1244 PduHeaders.PRIORITY_HIGH, null}); 1245 doReturn(cursor).when(mMapMethodProxy).contentResolverQuery(any(), any(), any(), any(), 1246 any(), any()); 1247 1248 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 1249 // Giving a different handle for msg below and cursor above makes handleMsgListChangesMms() 1250 // function for a non-existing message 1251 BluetoothMapContentObserver.Msg msg = new BluetoothMapContentObserver.Msg(TEST_HANDLE_TWO, 1252 TEST_INBOX_FOLDER_ID, TEST_READ_FLAG_ONE); 1253 map.put(TEST_HANDLE_TWO, msg); 1254 mObserver.setMsgListMms(map, true); 1255 mObserver.mMapEventReportVersion = BluetoothMapUtils.MAP_EVENT_REPORT_V12; 1256 1257 mObserver.handleMsgListChangesMms(); 1258 1259 Assert.assertEquals(mObserver.getMsgListMms().get(TEST_HANDLE_ONE), null); 1260 } 1261 1262 @Test handleMsgListChangesMms_withNonExistingMessage_andVersion10()1263 public void handleMsgListChangesMms_withNonExistingMessage_andVersion10() { 1264 MatrixCursor cursor = new MatrixCursor(new String[] {Mms._ID, Mms.MESSAGE_BOX, 1265 Mms.MESSAGE_TYPE, Mms.THREAD_ID, Mms.READ}); 1266 cursor.addRow(new Object[] {TEST_HANDLE_ONE, TEST_MMS_TYPE_ALL, TEST_MMS_MTYPE, 1267 TEST_THREAD_ID, TEST_READ_FLAG_ONE}); 1268 doReturn(cursor).when(mMapMethodProxy).contentResolverQuery(any(), any(), any(), any(), 1269 any(), any()); 1270 1271 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 1272 // Giving a different handle for msg below and cursor above makes handleMsgListChangesMms() 1273 // function for a non-existing message 1274 BluetoothMapContentObserver.Msg msg = new BluetoothMapContentObserver.Msg(TEST_HANDLE_TWO, 1275 TEST_INBOX_FOLDER_ID, TEST_READ_FLAG_ONE); 1276 map.put(TEST_HANDLE_TWO, msg); 1277 mObserver.setMsgListMms(map, true); 1278 mObserver.mMapEventReportVersion = BluetoothMapUtils.MAP_EVENT_REPORT_V10; 1279 1280 mObserver.handleMsgListChangesMms(); 1281 1282 Assert.assertEquals(mObserver.getMsgListMms().get(TEST_HANDLE_ONE).id, TEST_HANDLE_ONE); 1283 Assert.assertEquals(mObserver.getMsgListMms().get(TEST_HANDLE_ONE).type, TEST_MMS_TYPE_ALL); 1284 Assert.assertEquals(mObserver.getMsgListMms().get(TEST_HANDLE_ONE).threadId, 1285 TEST_THREAD_ID); 1286 Assert.assertEquals(mObserver.getMsgListMms().get(TEST_HANDLE_ONE).flagRead, 1287 TEST_READ_FLAG_ONE); 1288 } 1289 1290 @Test handleMsgListChangesMms_withExistingMessage_withNonEqualType_andLocalSendFalse()1291 public void handleMsgListChangesMms_withExistingMessage_withNonEqualType_andLocalSendFalse() { 1292 MatrixCursor cursor = new MatrixCursor(new String[] {Mms._ID, Mms.MESSAGE_BOX, 1293 Mms.MESSAGE_TYPE, Mms.THREAD_ID, Mms.READ}); 1294 cursor.addRow(new Object[] {TEST_HANDLE_ONE, TEST_MMS_TYPE_ALL, TEST_MMS_MTYPE, 1295 TEST_THREAD_ID, TEST_READ_FLAG_ONE}); 1296 doReturn(cursor).when(mMapMethodProxy).contentResolverQuery(any(), any(), any(), any(), 1297 any(), any()); 1298 1299 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 1300 // Giving the same handle for msg below and cursor above makes handleMsgListChangesMms() 1301 // function for an existing message 1302 BluetoothMapContentObserver.Msg msg = new BluetoothMapContentObserver.Msg(TEST_HANDLE_ONE, 1303 TEST_MMS_TYPE_INBOX, TEST_THREAD_ID, TEST_READ_FLAG_ZERO); 1304 map.put(TEST_HANDLE_ONE, msg); 1305 msg.localInitiatedSend = false; 1306 mObserver.setMsgListMms(map, true); 1307 mObserver.mMapEventReportVersion = BluetoothMapUtils.MAP_EVENT_REPORT_V12; 1308 1309 mObserver.handleMsgListChangesMms(); 1310 1311 Assert.assertEquals(mObserver.getMsgListMms().get(TEST_HANDLE_ONE).id, TEST_HANDLE_ONE); 1312 Assert.assertEquals(mObserver.getMsgListMms().get(TEST_HANDLE_ONE).type, TEST_MMS_TYPE_ALL); 1313 Assert.assertEquals(mObserver.getMsgListMms().get(TEST_HANDLE_ONE).threadId, 1314 TEST_THREAD_ID); 1315 Assert.assertEquals(mObserver.getMsgListMms().get(TEST_HANDLE_ONE).flagRead, 1316 TEST_READ_FLAG_ONE); 1317 } 1318 1319 @Test handleMsgListChangesMms_withExistingMessage_withNonEqualType_andLocalSendTrue()1320 public void handleMsgListChangesMms_withExistingMessage_withNonEqualType_andLocalSendTrue() { 1321 MatrixCursor cursor = new MatrixCursor(new String[] {Mms._ID, Mms.MESSAGE_BOX, 1322 Mms.MESSAGE_TYPE, Mms.THREAD_ID, Mms.READ}); 1323 cursor.addRow(new Object[] {TEST_HANDLE_ONE, TEST_MMS_TYPE_ALL, TEST_MMS_MTYPE, 1324 TEST_THREAD_ID, TEST_READ_FLAG_ONE}); 1325 doReturn(cursor).when(mMapMethodProxy).contentResolverQuery(any(), any(), any(), any(), 1326 any(), any()); 1327 1328 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 1329 // Giving the same handle for msg below and cursor above makes handleMsgListChangesMms() 1330 // function for an existing message 1331 BluetoothMapContentObserver.Msg msg = new BluetoothMapContentObserver.Msg(TEST_HANDLE_ONE, 1332 TEST_MMS_TYPE_INBOX, TEST_THREAD_ID, TEST_READ_FLAG_ZERO); 1333 map.put(TEST_HANDLE_ONE, msg); 1334 msg.localInitiatedSend = true; 1335 mObserver.setMsgListMms(map, true); 1336 mObserver.mMapEventReportVersion = BluetoothMapUtils.MAP_EVENT_REPORT_V12; 1337 1338 mObserver.handleMsgListChangesMms(); 1339 1340 Assert.assertEquals(mObserver.getMsgListMms().get(TEST_HANDLE_ONE).id, TEST_HANDLE_ONE); 1341 Assert.assertEquals(mObserver.getMsgListMms().get(TEST_HANDLE_ONE).type, TEST_MMS_TYPE_ALL); 1342 Assert.assertEquals(mObserver.getMsgListMms().get(TEST_HANDLE_ONE).threadId, 1343 TEST_THREAD_ID); 1344 Assert.assertEquals(mObserver.getMsgListMms().get(TEST_HANDLE_ONE).flagRead, 1345 TEST_READ_FLAG_ONE); 1346 } 1347 1348 @Test handleMsgListChangesMms_withExistingMessage_withDeletedThreadId()1349 public void handleMsgListChangesMms_withExistingMessage_withDeletedThreadId() { 1350 MatrixCursor cursor = new MatrixCursor(new String[] {Mms._ID, Mms.MESSAGE_BOX, 1351 Mms.MESSAGE_TYPE, Mms.THREAD_ID, Mms.READ}); 1352 cursor.addRow(new Object[] {TEST_HANDLE_ONE, TEST_MMS_TYPE_ALL, TEST_MMS_MTYPE, 1353 BluetoothMapContentObserver.DELETED_THREAD_ID, TEST_READ_FLAG_ONE}); 1354 doReturn(cursor).when(mMapMethodProxy).contentResolverQuery(any(), any(), any(), any(), 1355 any(), any()); 1356 1357 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 1358 // Giving the same handle for msg below and cursor above makes handleMsgListChangesMms() 1359 // function for an existing message 1360 BluetoothMapContentObserver.Msg msg = new BluetoothMapContentObserver.Msg(TEST_HANDLE_ONE, 1361 TEST_MMS_TYPE_ALL, TEST_THREAD_ID, TEST_READ_FLAG_ZERO); 1362 map.put(TEST_HANDLE_ONE, msg); 1363 msg.localInitiatedSend = true; 1364 mObserver.setMsgListMms(map, true); 1365 mObserver.mMapEventReportVersion = BluetoothMapUtils.MAP_EVENT_REPORT_V12; 1366 1367 mObserver.handleMsgListChangesMms(); 1368 1369 Assert.assertEquals(mObserver.getMsgListMms().get(TEST_HANDLE_ONE).id, TEST_HANDLE_ONE); 1370 Assert.assertEquals(mObserver.getMsgListMms().get(TEST_HANDLE_ONE).type, TEST_MMS_TYPE_ALL); 1371 Assert.assertEquals(mObserver.getMsgListMms().get(TEST_HANDLE_ONE).threadId, 1372 BluetoothMapContentObserver.DELETED_THREAD_ID); 1373 Assert.assertEquals(mObserver.getMsgListMms().get(TEST_HANDLE_ONE).flagRead, 1374 TEST_READ_FLAG_ONE); 1375 } 1376 1377 @Test handleMsgListChangesMms_withExistingMessage_withUndeletedThreadId()1378 public void handleMsgListChangesMms_withExistingMessage_withUndeletedThreadId() { 1379 int undeletedThreadId = 0; 1380 MatrixCursor cursor = new MatrixCursor(new String[] {Mms._ID, Mms.MESSAGE_BOX, 1381 Mms.MESSAGE_TYPE, Mms.THREAD_ID, Mms.READ}); 1382 cursor.addRow(new Object[] {TEST_HANDLE_ONE, TEST_MMS_TYPE_ALL, TEST_MMS_MTYPE, 1383 undeletedThreadId, TEST_READ_FLAG_ONE}); 1384 doReturn(cursor).when(mMapMethodProxy).contentResolverQuery(any(), any(), any(), any(), 1385 any(), any()); 1386 1387 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 1388 // Giving the same handle for msg below and cursor above makes handleMsgListChangesMms() 1389 // function for an existing message 1390 BluetoothMapContentObserver.Msg msg = new BluetoothMapContentObserver.Msg(TEST_HANDLE_ONE, 1391 TEST_MMS_TYPE_ALL, TEST_THREAD_ID, TEST_READ_FLAG_ZERO); 1392 map.put(TEST_HANDLE_ONE, msg); 1393 msg.localInitiatedSend = true; 1394 mObserver.setMsgListMms(map, true); 1395 mObserver.mMapEventReportVersion = BluetoothMapUtils.MAP_EVENT_REPORT_V12; 1396 1397 mObserver.handleMsgListChangesMms(); 1398 1399 Assert.assertEquals(mObserver.getMsgListMms().get(TEST_HANDLE_ONE).id, TEST_HANDLE_ONE); 1400 Assert.assertEquals(mObserver.getMsgListMms().get(TEST_HANDLE_ONE).type, TEST_MMS_TYPE_ALL); 1401 Assert.assertEquals(mObserver.getMsgListMms().get(TEST_HANDLE_ONE).threadId, 1402 undeletedThreadId); 1403 Assert.assertEquals(mObserver.getMsgListMms().get(TEST_HANDLE_ONE).flagRead, 1404 TEST_READ_FLAG_ONE); 1405 } 1406 1407 @Test handleMsgListChangesSms_withNonExistingMessage_andVersion11()1408 public void handleMsgListChangesSms_withNonExistingMessage_andVersion11() { 1409 MatrixCursor cursor = new MatrixCursor(new String[] {Sms._ID, Sms.TYPE, Sms.THREAD_ID, 1410 Sms.READ, Sms.DATE, Sms.BODY, Sms.ADDRESS, ContactsContract.Contacts.DISPLAY_NAME}); 1411 cursor.addRow(new Object[] {TEST_HANDLE_ONE, TEST_SMS_TYPE_INBOX, TEST_THREAD_ID, 1412 TEST_READ_FLAG_ONE, TEST_DATE_MS, TEST_SUBJECT, TEST_ADDRESS, null}); 1413 doReturn(cursor).when(mMapMethodProxy).contentResolverQuery(any(), any(), any(), any(), 1414 any(), any()); 1415 1416 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 1417 // Giving a different handle for msg below and cursor above makes handleMsgListChangesSms() 1418 // function for a non-existing message 1419 BluetoothMapContentObserver.Msg msg = new BluetoothMapContentObserver.Msg(TEST_HANDLE_TWO, 1420 TEST_SMS_TYPE_ALL, TEST_READ_FLAG_ONE); 1421 map.put(TEST_HANDLE_TWO, msg); 1422 mObserver.setMsgListSms(map, true); 1423 mObserver.mMapEventReportVersion = BluetoothMapUtils.MAP_EVENT_REPORT_V11; 1424 1425 mObserver.handleMsgListChangesSms(); 1426 1427 Assert.assertEquals(mObserver.getMsgListSms().get(TEST_HANDLE_ONE).id, TEST_HANDLE_ONE); 1428 Assert.assertEquals(mObserver.getMsgListSms().get(TEST_HANDLE_ONE).type, 1429 TEST_SMS_TYPE_INBOX); 1430 Assert.assertEquals(mObserver.getMsgListSms().get(TEST_HANDLE_ONE).threadId, 1431 TEST_THREAD_ID); 1432 Assert.assertEquals(mObserver.getMsgListSms().get(TEST_HANDLE_ONE).flagRead, 1433 TEST_READ_FLAG_ONE); 1434 } 1435 1436 @Test handleMsgListChangesSms_withNonExistingMessage_andVersion12()1437 public void handleMsgListChangesSms_withNonExistingMessage_andVersion12() { 1438 MatrixCursor cursor = new MatrixCursor(new String[] {Sms._ID, Sms.TYPE, Sms.THREAD_ID, 1439 Sms.READ, Sms.DATE, Sms.BODY, Sms.ADDRESS}); 1440 cursor.addRow(new Object[] {TEST_HANDLE_ONE, TEST_SMS_TYPE_ALL, TEST_THREAD_ID, 1441 TEST_READ_FLAG_ONE, TEST_DATE_MS, "", null}); 1442 doReturn(cursor).when(mMapMethodProxy).contentResolverQuery(any(), any(), any(), any(), 1443 any(), any()); 1444 1445 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 1446 // Giving a different handle for msg below and cursor above makes handleMsgListChangesSms() 1447 // function for a non-existing message 1448 BluetoothMapContentObserver.Msg msg = new BluetoothMapContentObserver.Msg(TEST_HANDLE_TWO, 1449 TEST_SMS_TYPE_INBOX, TEST_READ_FLAG_ONE); 1450 map.put(TEST_HANDLE_TWO, msg); 1451 mObserver.setMsgListSms(map, true); 1452 mObserver.mMapEventReportVersion = BluetoothMapUtils.MAP_EVENT_REPORT_V12; 1453 1454 mObserver.handleMsgListChangesSms(); 1455 1456 Assert.assertEquals(mObserver.getMsgListSms().get(TEST_HANDLE_ONE).id, TEST_HANDLE_ONE); 1457 Assert.assertEquals(mObserver.getMsgListSms().get(TEST_HANDLE_ONE).type, 1458 TEST_SMS_TYPE_ALL); 1459 Assert.assertEquals(mObserver.getMsgListSms().get(TEST_HANDLE_ONE).threadId, 1460 TEST_THREAD_ID); 1461 Assert.assertEquals(mObserver.getMsgListSms().get(TEST_HANDLE_ONE).flagRead, 1462 TEST_READ_FLAG_ONE); 1463 } 1464 1465 @Test handleMsgListChangesSms_withNonExistingOldMessage_andVersion12()1466 public void handleMsgListChangesSms_withNonExistingOldMessage_andVersion12() { 1467 Calendar cal = Calendar.getInstance(); 1468 cal.add(Calendar.YEAR, -1); 1469 cal.add(Calendar.DATE, -1); 1470 1471 MatrixCursor cursor = new MatrixCursor(new String[] {Sms._ID, Sms.TYPE, Sms.THREAD_ID, 1472 Sms.READ, Sms.DATE, Sms.BODY, Sms.ADDRESS}); 1473 cursor.addRow(new Object[] {TEST_HANDLE_ONE, TEST_SMS_TYPE_ALL, TEST_THREAD_ID, 1474 TEST_READ_FLAG_ONE, cal.getTimeInMillis(), "", null}); 1475 doReturn(cursor).when(mMapMethodProxy).contentResolverQuery(any(), any(), any(), any(), 1476 any(), any()); 1477 1478 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 1479 // Giving a different handle for msg below and cursor above makes handleMsgListChangesMms() 1480 // function for a non-existing message 1481 BluetoothMapContentObserver.Msg msg = new BluetoothMapContentObserver.Msg(TEST_HANDLE_TWO, 1482 TEST_SMS_TYPE_INBOX, TEST_READ_FLAG_ONE); 1483 map.put(TEST_HANDLE_TWO, msg); 1484 mObserver.setMsgListSms(map, true); 1485 mObserver.mMapEventReportVersion = BluetoothMapUtils.MAP_EVENT_REPORT_V12; 1486 1487 mObserver.handleMsgListChangesSms(); 1488 1489 Assert.assertEquals(mObserver.getMsgListSms().get(TEST_HANDLE_ONE), null); 1490 } 1491 1492 @Test handleMsgListChangesSms_withNonExistingMessage_andVersion10()1493 public void handleMsgListChangesSms_withNonExistingMessage_andVersion10() { 1494 MatrixCursor cursor = new MatrixCursor(new String[] {Sms._ID, Sms.TYPE, Sms.THREAD_ID, 1495 Sms.READ}); 1496 cursor.addRow(new Object[] {TEST_HANDLE_ONE, TEST_SMS_TYPE_ALL, TEST_THREAD_ID, 1497 TEST_READ_FLAG_ONE}); 1498 doReturn(cursor).when(mMapMethodProxy).contentResolverQuery(any(), any(), any(), any(), 1499 any(), any()); 1500 1501 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 1502 // Giving a different handle for msg below and cursor above makes handleMsgListChangesSms() 1503 // function for a non-existing message 1504 BluetoothMapContentObserver.Msg msg = new BluetoothMapContentObserver.Msg(TEST_HANDLE_TWO, 1505 TEST_SMS_TYPE_INBOX, TEST_READ_FLAG_ONE); 1506 map.put(TEST_HANDLE_TWO, msg); 1507 mObserver.setMsgListSms(map, true); 1508 mObserver.mMapEventReportVersion = BluetoothMapUtils.MAP_EVENT_REPORT_V10; 1509 1510 mObserver.handleMsgListChangesSms(); 1511 1512 Assert.assertEquals(mObserver.getMsgListSms().get(TEST_HANDLE_ONE).id, TEST_HANDLE_ONE); 1513 Assert.assertEquals(mObserver.getMsgListSms().get(TEST_HANDLE_ONE).type, 1514 TEST_SMS_TYPE_ALL); 1515 Assert.assertEquals(mObserver.getMsgListSms().get(TEST_HANDLE_ONE).threadId, 1516 TEST_THREAD_ID); 1517 Assert.assertEquals(mObserver.getMsgListSms().get(TEST_HANDLE_ONE).flagRead, 1518 TEST_READ_FLAG_ONE); 1519 } 1520 1521 @Test handleMsgListChangesSms_withExistingMessage_withNonEqualType()1522 public void handleMsgListChangesSms_withExistingMessage_withNonEqualType() { 1523 MatrixCursor cursor = new MatrixCursor(new String[] {Sms._ID, Sms.TYPE, Sms.THREAD_ID, 1524 Sms.READ}); 1525 cursor.addRow(new Object[] {TEST_HANDLE_ONE, TEST_SMS_TYPE_ALL, TEST_THREAD_ID, 1526 TEST_READ_FLAG_ONE}); 1527 doReturn(cursor).when(mMapMethodProxy).contentResolverQuery(any(), any(), any(), any(), 1528 any(), any()); 1529 1530 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 1531 // Giving the same handle for msg below and cursor above makes handleMsgListChangesSms() 1532 // function for an existing message 1533 BluetoothMapContentObserver.Msg msg = new BluetoothMapContentObserver.Msg(TEST_HANDLE_ONE, 1534 TEST_SMS_TYPE_INBOX, TEST_THREAD_ID, TEST_READ_FLAG_ZERO); 1535 map.put(TEST_HANDLE_ONE, msg); 1536 mObserver.setMsgListSms(map, true); 1537 mObserver.mMapEventReportVersion = BluetoothMapUtils.MAP_EVENT_REPORT_V12; 1538 1539 mObserver.handleMsgListChangesSms(); 1540 1541 Assert.assertEquals(mObserver.getMsgListSms().get(TEST_HANDLE_ONE).id, TEST_HANDLE_ONE); 1542 Assert.assertEquals(mObserver.getMsgListSms().get(TEST_HANDLE_ONE).type, 1543 TEST_SMS_TYPE_ALL); 1544 Assert.assertEquals(mObserver.getMsgListSms().get(TEST_HANDLE_ONE).threadId, 1545 TEST_THREAD_ID); 1546 Assert.assertEquals(mObserver.getMsgListSms().get(TEST_HANDLE_ONE).flagRead, 1547 TEST_READ_FLAG_ONE); 1548 } 1549 1550 @Test handleMsgListChangesSms_withExistingMessage_withDeletedThreadId()1551 public void handleMsgListChangesSms_withExistingMessage_withDeletedThreadId() { 1552 MatrixCursor cursor = new MatrixCursor(new String[] {Sms._ID, Sms.TYPE, Sms.THREAD_ID, 1553 Sms.READ}); 1554 cursor.addRow(new Object[] {TEST_HANDLE_ONE, TEST_SMS_TYPE_ALL, 1555 BluetoothMapContentObserver.DELETED_THREAD_ID, TEST_READ_FLAG_ONE}); 1556 doReturn(cursor).when(mMapMethodProxy).contentResolverQuery(any(), any(), any(), any(), 1557 any(), any()); 1558 1559 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 1560 // Giving the same handle for msg below and cursor above makes handleMsgListChangesSms() 1561 // function for an existing message 1562 BluetoothMapContentObserver.Msg msg = new BluetoothMapContentObserver.Msg(TEST_HANDLE_ONE, 1563 TEST_SMS_TYPE_ALL, TEST_THREAD_ID, TEST_READ_FLAG_ZERO); 1564 map.put(TEST_HANDLE_ONE, msg); 1565 mObserver.setMsgListSms(map, true); 1566 mObserver.mMapEventReportVersion = BluetoothMapUtils.MAP_EVENT_REPORT_V12; 1567 1568 mObserver.handleMsgListChangesSms(); 1569 1570 Assert.assertEquals(mObserver.getMsgListSms().get(TEST_HANDLE_ONE).id, TEST_HANDLE_ONE); 1571 Assert.assertEquals(mObserver.getMsgListSms().get(TEST_HANDLE_ONE).type, TEST_SMS_TYPE_ALL); 1572 Assert.assertEquals(mObserver.getMsgListSms().get(TEST_HANDLE_ONE).threadId, 1573 BluetoothMapContentObserver.DELETED_THREAD_ID); 1574 Assert.assertEquals(mObserver.getMsgListSms().get(TEST_HANDLE_ONE).flagRead, 1575 TEST_READ_FLAG_ONE); 1576 } 1577 1578 @Test handleMsgListChangesSms_withExistingMessage_withUndeletedThreadId()1579 public void handleMsgListChangesSms_withExistingMessage_withUndeletedThreadId() { 1580 int undeletedThreadId = 0; 1581 MatrixCursor cursor = new MatrixCursor(new String[] {Sms._ID, Sms.TYPE, Sms.THREAD_ID, 1582 Sms.READ}); 1583 cursor.addRow(new Object[] {TEST_HANDLE_ONE, TEST_SMS_TYPE_ALL, undeletedThreadId, 1584 TEST_READ_FLAG_ONE}); 1585 doReturn(cursor).when(mMapMethodProxy).contentResolverQuery(any(), any(), any(), any(), 1586 any(), any()); 1587 1588 Map<Long, BluetoothMapContentObserver.Msg> map = new HashMap<>(); 1589 // Giving the same handle for msg below and cursor above makes handleMsgListChangesSms() 1590 // function for an existing message 1591 BluetoothMapContentObserver.Msg msg = new BluetoothMapContentObserver.Msg(TEST_HANDLE_ONE, 1592 TEST_SMS_TYPE_ALL, TEST_THREAD_ID, TEST_READ_FLAG_ZERO); 1593 map.put(TEST_HANDLE_ONE, msg); 1594 mObserver.setMsgListSms(map, true); 1595 mObserver.mMapEventReportVersion = BluetoothMapUtils.MAP_EVENT_REPORT_V12; 1596 1597 mObserver.handleMsgListChangesSms(); 1598 1599 Assert.assertEquals(mObserver.getMsgListSms().get(TEST_HANDLE_ONE).id, TEST_HANDLE_ONE); 1600 Assert.assertEquals(mObserver.getMsgListSms().get(TEST_HANDLE_ONE).type, TEST_SMS_TYPE_ALL); 1601 Assert.assertEquals(mObserver.getMsgListSms().get(TEST_HANDLE_ONE).threadId, 1602 undeletedThreadId); 1603 Assert.assertEquals(mObserver.getMsgListSms().get(TEST_HANDLE_ONE).flagRead, 1604 TEST_READ_FLAG_ONE); 1605 } 1606 1607 @Test handleMmsSendIntent_withMnsClientNotConnected()1608 public void handleMmsSendIntent_withMnsClientNotConnected() { 1609 when(mClient.isConnected()).thenReturn(false); 1610 1611 Assert.assertFalse(mObserver.handleMmsSendIntent(mContext, mIntent)); 1612 } 1613 1614 @Test handleMmsSendIntent_withInvalidHandle()1615 public void handleMmsSendIntent_withInvalidHandle() { 1616 when(mClient.isConnected()).thenReturn(true); 1617 doReturn((long) -1).when(mIntent).getLongExtra( 1618 BluetoothMapContentObserver.EXTRA_MESSAGE_SENT_HANDLE, -1); 1619 1620 Assert.assertTrue(mObserver.handleMmsSendIntent(mContext, mIntent)); 1621 } 1622 1623 @Test handleMmsSendIntent_withActivityResultOk()1624 public void handleMmsSendIntent_withActivityResultOk() { 1625 when(mClient.isConnected()).thenReturn(true); 1626 doReturn(TEST_HANDLE_ONE).when(mIntent).getLongExtra( 1627 BluetoothMapContentObserver.EXTRA_MESSAGE_SENT_HANDLE, -1); 1628 doReturn(Activity.RESULT_OK).when(mIntent).getIntExtra( 1629 BluetoothMapContentObserver.EXTRA_MESSAGE_SENT_RESULT, Activity.RESULT_CANCELED); 1630 doReturn(0).when(mIntent).getIntExtra( 1631 BluetoothMapContentObserver.EXTRA_MESSAGE_SENT_TRANSPARENT, 0); 1632 mObserver.mObserverRegistered = true; 1633 1634 Assert.assertTrue(mObserver.handleMmsSendIntent(mContext, mIntent)); 1635 } 1636 1637 @Test handleMmsSendIntent_withActivityResultFirstUser()1638 public void handleMmsSendIntent_withActivityResultFirstUser() { 1639 when(mClient.isConnected()).thenReturn(true); 1640 doReturn(TEST_HANDLE_ONE).when(mIntent).getLongExtra( 1641 BluetoothMapContentObserver.EXTRA_MESSAGE_SENT_HANDLE, -1); 1642 doReturn(Activity.RESULT_FIRST_USER).when(mIntent).getIntExtra( 1643 BluetoothMapContentObserver.EXTRA_MESSAGE_SENT_RESULT, Activity.RESULT_CANCELED); 1644 mObserver.mObserverRegistered = true; 1645 doReturn(TEST_PLACEHOLDER_INT).when(mMapMethodProxy).contentResolverDelete(any(), any(), 1646 any(), any()); 1647 1648 Assert.assertTrue(mObserver.handleMmsSendIntent(mContext, mIntent)); 1649 } 1650 1651 @Test actionMessageSentDisconnected_withTypeMms()1652 public void actionMessageSentDisconnected_withTypeMms() { 1653 Map<Long, BluetoothMapContentObserver.Msg> mmsMsgList = new HashMap<>(); 1654 BluetoothMapContentObserver.Msg msg = createSimpleMsg(); 1655 mmsMsgList.put(TEST_HANDLE_ONE, msg); 1656 doReturn(1).when(mIntent).getIntExtra( 1657 BluetoothMapContentObserver.EXTRA_MESSAGE_SENT_TRANSPARENT, 0); 1658 doReturn((long) -1).when(mIntent).getLongExtra( 1659 BluetoothMapContentObserver.EXTRA_MESSAGE_SENT_HANDLE, -1); 1660 // This mock sets type to MMS 1661 doReturn(4).when(mIntent).getIntExtra( 1662 BluetoothMapContentObserver.EXTRA_MESSAGE_SENT_MSG_TYPE, TYPE.NONE.ordinal()); 1663 1664 mObserver.actionMessageSentDisconnected(mContext, mIntent, 1); 1665 1666 Assert.assertTrue(mmsMsgList.containsKey(TEST_HANDLE_ONE)); 1667 } 1668 1669 @Test actionMessageSentDisconnected_withTypeEmail()1670 public void actionMessageSentDisconnected_withTypeEmail() { 1671 // This sets to null uriString 1672 doReturn(null).when(mIntent).getStringExtra( 1673 BluetoothMapContentObserver.EXTRA_MESSAGE_SENT_URI); 1674 doReturn(1).when(mIntent).getIntExtra( 1675 BluetoothMapContentObserver.EXTRA_MESSAGE_SENT_TRANSPARENT, 0); 1676 // This mock sets type to Email 1677 doReturn(1).when(mIntent).getIntExtra( 1678 BluetoothMapContentObserver.EXTRA_MESSAGE_SENT_MSG_TYPE, TYPE.NONE.ordinal()); 1679 clearInvocations(mContext); 1680 1681 mObserver.actionMessageSentDisconnected(mContext, mIntent, Activity.RESULT_FIRST_USER); 1682 1683 verify(mContext, never()).getContentResolver(); 1684 } 1685 1686 @Test actionMmsSent_withInvalidHandle()1687 public void actionMmsSent_withInvalidHandle() { 1688 Map<Long, BluetoothMapContentObserver.Msg> mmsMsgList = new HashMap<>(); 1689 BluetoothMapContentObserver.Msg msg = createSimpleMsg(); 1690 mmsMsgList.put(TEST_HANDLE_ONE, msg); 1691 doReturn(1).when(mIntent).getIntExtra( 1692 BluetoothMapContentObserver.EXTRA_MESSAGE_SENT_TRANSPARENT, 0); 1693 doReturn((long) -1).when(mIntent).getLongExtra( 1694 BluetoothMapContentObserver.EXTRA_MESSAGE_SENT_HANDLE, -1); 1695 1696 mObserver.actionMmsSent(mContext, mIntent, 1, mmsMsgList); 1697 1698 Assert.assertTrue(mmsMsgList.containsKey(TEST_HANDLE_ONE)); 1699 } 1700 1701 @Test actionMmsSent_withTransparency()1702 public void actionMmsSent_withTransparency() { 1703 Map<Long, BluetoothMapContentObserver.Msg> mmsMsgList = new HashMap<>(); 1704 BluetoothMapContentObserver.Msg msg = createSimpleMsg(); 1705 mmsMsgList.put(TEST_HANDLE_ONE, msg); 1706 // This mock turns on the transparent flag 1707 doReturn(1).when(mIntent).getIntExtra( 1708 BluetoothMapContentObserver.EXTRA_MESSAGE_SENT_TRANSPARENT, 0); 1709 doReturn(TEST_HANDLE_ONE).when(mIntent).getLongExtra( 1710 BluetoothMapContentObserver.EXTRA_MESSAGE_SENT_HANDLE, -1); 1711 doReturn(TEST_PLACEHOLDER_INT).when(mMapMethodProxy).contentResolverDelete(any(), any(), 1712 any(), any()); 1713 1714 mObserver.actionMmsSent(mContext, mIntent, 1, mmsMsgList); 1715 1716 Assert.assertFalse(mmsMsgList.containsKey(TEST_HANDLE_ONE)); 1717 } 1718 1719 @Test actionMmsSent_withActivityResultOk()1720 public void actionMmsSent_withActivityResultOk() { 1721 Map<Long, BluetoothMapContentObserver.Msg> mmsMsgList = new HashMap<>(); 1722 BluetoothMapContentObserver.Msg msg = createSimpleMsg(); 1723 mmsMsgList.put(TEST_HANDLE_ONE, msg); 1724 // This mock turns off the transparent flag 1725 doReturn(0).when(mIntent).getIntExtra( 1726 BluetoothMapContentObserver.EXTRA_MESSAGE_SENT_TRANSPARENT, 0); 1727 doReturn(TEST_HANDLE_ONE).when(mIntent).getLongExtra( 1728 BluetoothMapContentObserver.EXTRA_MESSAGE_SENT_HANDLE, -1); 1729 1730 MatrixCursor cursor = new MatrixCursor(new String[] {}); 1731 doReturn(cursor).when(mMapMethodProxy).contentResolverQuery(any(), any(), any(), any(), 1732 any(), any()); 1733 doReturn(TEST_PLACEHOLDER_INT).when(mMapMethodProxy).contentResolverUpdate(any(), any(), 1734 any(), any(), any()); 1735 1736 mObserver.actionMmsSent(mContext, mIntent, Activity.RESULT_OK, mmsMsgList); 1737 1738 Assert.assertTrue(mmsMsgList.containsKey(TEST_HANDLE_ONE)); 1739 } 1740 1741 @Test actionMmsSent_withActivityResultFirstUser()1742 public void actionMmsSent_withActivityResultFirstUser() { 1743 Map<Long, BluetoothMapContentObserver.Msg> mmsMsgList = new HashMap<>(); 1744 BluetoothMapContentObserver.Msg msg = createSimpleMsg(); 1745 mmsMsgList.put(TEST_HANDLE_ONE, msg); 1746 // This mock turns off the transparent flag 1747 doReturn(0).when(mIntent).getIntExtra( 1748 BluetoothMapContentObserver.EXTRA_MESSAGE_SENT_TRANSPARENT, 0); 1749 doReturn(TEST_HANDLE_ONE).when(mIntent).getLongExtra( 1750 BluetoothMapContentObserver.EXTRA_MESSAGE_SENT_HANDLE, -1); 1751 1752 mObserver.actionMmsSent(mContext, mIntent, Activity.RESULT_FIRST_USER, mmsMsgList); 1753 1754 Assert.assertEquals(msg.type, Mms.MESSAGE_BOX_OUTBOX); 1755 } 1756 1757 @Test actionSmsSentDisconnected_withNullUriString()1758 public void actionSmsSentDisconnected_withNullUriString() { 1759 // This sets to null uriString 1760 doReturn(null).when(mIntent).getStringExtra( 1761 BluetoothMapContentObserver.EXTRA_MESSAGE_SENT_URI); 1762 doReturn(1).when(mIntent).getIntExtra( 1763 BluetoothMapContentObserver.EXTRA_MESSAGE_SENT_TRANSPARENT, 0); 1764 1765 clearInvocations(mContext); 1766 mObserver.actionSmsSentDisconnected(mContext, mIntent, Activity.RESULT_FIRST_USER); 1767 1768 verify(mContext, never()).getContentResolver(); 1769 } 1770 1771 @Test actionSmsSentDisconnected_withActivityResultOk_andTransparentOff()1772 public void actionSmsSentDisconnected_withActivityResultOk_andTransparentOff() { 1773 doReturn(TEST_URI_STR).when(mIntent).getStringExtra( 1774 BluetoothMapContentObserver.EXTRA_MESSAGE_SENT_URI); 1775 // This mock turns off the transparent flag 1776 doReturn(0).when(mIntent).getIntExtra( 1777 BluetoothMapContentObserver.EXTRA_MESSAGE_SENT_TRANSPARENT, 0); 1778 doReturn(TEST_PLACEHOLDER_INT).when(mMapMethodProxy).contentResolverUpdate(any(), any(), 1779 any(), any(), any()); 1780 1781 clearInvocations(mContext); 1782 mObserver.actionSmsSentDisconnected(mContext, mIntent, Activity.RESULT_OK); 1783 1784 verify(mContext).getContentResolver(); 1785 } 1786 1787 @Test actionSmsSentDisconnected_withActivityResultOk_andTransparentOn()1788 public void actionSmsSentDisconnected_withActivityResultOk_andTransparentOn() { 1789 doReturn(TEST_URI_STR).when(mIntent).getStringExtra( 1790 BluetoothMapContentObserver.EXTRA_MESSAGE_SENT_URI); 1791 // This mock turns on the transparent flag 1792 doReturn(1).when(mIntent).getIntExtra( 1793 BluetoothMapContentObserver.EXTRA_MESSAGE_SENT_TRANSPARENT, 0); 1794 doReturn(TEST_PLACEHOLDER_INT).when(mMapMethodProxy).contentResolverDelete(any(), any(), 1795 any(), any()); 1796 1797 clearInvocations(mContext); 1798 mObserver.actionSmsSentDisconnected(mContext, mIntent, Activity.RESULT_OK); 1799 1800 verify(mContext).getContentResolver(); 1801 } 1802 1803 @Test actionSmsSentDisconnected_withActivityResultFirstUser_andTransparentOff()1804 public void actionSmsSentDisconnected_withActivityResultFirstUser_andTransparentOff() { 1805 doReturn(TEST_URI_STR).when(mIntent).getStringExtra( 1806 BluetoothMapContentObserver.EXTRA_MESSAGE_SENT_URI); 1807 // This mock turns off the transparent flag 1808 doReturn(0).when(mIntent).getIntExtra( 1809 BluetoothMapContentObserver.EXTRA_MESSAGE_SENT_TRANSPARENT, 0); 1810 doReturn(TEST_PLACEHOLDER_INT).when(mMapMethodProxy).contentResolverUpdate(any(), any(), 1811 any(), any(), any()); 1812 1813 clearInvocations(mContext); 1814 mObserver.actionSmsSentDisconnected(mContext, mIntent, Activity.RESULT_OK); 1815 1816 verify(mContext).getContentResolver(); 1817 } 1818 1819 @Test actionSmsSentDisconnected_withActivityResultFirstUser_andTransparentOn()1820 public void actionSmsSentDisconnected_withActivityResultFirstUser_andTransparentOn() { 1821 doReturn(TEST_URI_STR).when(mIntent).getStringExtra( 1822 BluetoothMapContentObserver.EXTRA_MESSAGE_SENT_URI); 1823 // This mock turns on the transparent flag 1824 doReturn(1).when(mIntent).getIntExtra( 1825 BluetoothMapContentObserver.EXTRA_MESSAGE_SENT_TRANSPARENT, 0); 1826 doReturn(null).when(mContext).getContentResolver(); 1827 1828 clearInvocations(mContext); 1829 mObserver.actionSmsSentDisconnected(mContext, mIntent, Activity.RESULT_OK); 1830 1831 verify(mContext).getContentResolver(); 1832 } 1833 1834 @Test handleContactListChanges_withNullContactForUci()1835 public void handleContactListChanges_withNullContactForUci() throws Exception { 1836 Uri uri = mock(Uri.class); 1837 mObserver.mAuthority = TEST_AUTHORITY; 1838 when(uri.getAuthority()).thenReturn(TEST_AUTHORITY); 1839 1840 MatrixCursor cursor = new MatrixCursor( 1841 new String[]{BluetoothMapContract.ConvoContactColumns.CONVO_ID, 1842 BluetoothMapContract.ConvoContactColumns.NAME, 1843 BluetoothMapContract.ConvoContactColumns.NICKNAME, 1844 BluetoothMapContract.ConvoContactColumns.X_BT_UID, 1845 BluetoothMapContract.ConvoContactColumns.CHAT_STATE, 1846 BluetoothMapContract.ConvoContactColumns.UCI, 1847 BluetoothMapContract.ConvoContactColumns.LAST_ACTIVE, 1848 BluetoothMapContract.ConvoContactColumns.PRESENCE_STATE, 1849 BluetoothMapContract.ConvoContactColumns.STATUS_TEXT, 1850 BluetoothMapContract.ConvoContactColumns.PRIORITY, 1851 BluetoothMapContract.ConvoContactColumns.LAST_ONLINE}); 1852 cursor.addRow(new Object[] {TEST_CONVO_ID, TEST_NAME, TEST_DISPLAY_NAME, TEST_BT_UID, 1853 TEST_CHAT_STATE, TEST_UCI, TEST_LAST_ACTIVITY, TEST_PRESENCE_STATE, 1854 TEST_STATUS_TEXT, TEST_PRIORITY, TEST_LAST_ONLINE}); 1855 doReturn(cursor).when(mProviderClient).query(any(), any(), any(), any(), any()); 1856 1857 Map<String, BluetoothMapConvoContactElement> map = new HashMap<>(); 1858 map.put(TEST_UCI_DIFFERENT, null); 1859 mObserver.setContactList(map, true); 1860 mObserver.mMapEventReportVersion = BluetoothMapUtils.MAP_EVENT_REPORT_V12; 1861 1862 mObserver.handleContactListChanges(uri); 1863 1864 BluetoothMapConvoContactElement contactElement = mObserver.getContactList().get(TEST_UCI); 1865 final SimpleDateFormat format = new SimpleDateFormat("yyyyMMdd'T'HHmmss"); 1866 Assert.assertEquals(contactElement.getContactId(), TEST_UCI); 1867 Assert.assertEquals(contactElement.getName(), TEST_NAME); 1868 Assert.assertEquals(contactElement.getDisplayName(), TEST_DISPLAY_NAME); 1869 Assert.assertEquals(contactElement.getBtUid(), TEST_BT_UID); 1870 Assert.assertEquals(contactElement.getChatState(), TEST_CHAT_STATE); 1871 Assert.assertEquals(contactElement.getPresenceStatus(), TEST_STATUS_TEXT); 1872 Assert.assertEquals(contactElement.getPresenceAvailability(), TEST_PRESENCE_STATE); 1873 Assert.assertEquals(contactElement.getLastActivityString(), format.format( 1874 TEST_LAST_ACTIVITY)); 1875 Assert.assertEquals(contactElement.getPriority(), TEST_PRIORITY); 1876 } 1877 1878 @Test handleContactListChanges_withNonNullContactForUci()1879 public void handleContactListChanges_withNonNullContactForUci() throws Exception { 1880 Uri uri = mock(Uri.class); 1881 mObserver.mAuthority = TEST_AUTHORITY; 1882 when(uri.getAuthority()).thenReturn(TEST_AUTHORITY); 1883 1884 MatrixCursor cursor = new MatrixCursor( 1885 new String[]{BluetoothMapContract.ConvoContactColumns.CONVO_ID, 1886 BluetoothMapContract.ConvoContactColumns.NAME, 1887 BluetoothMapContract.ConvoContactColumns.NICKNAME, 1888 BluetoothMapContract.ConvoContactColumns.X_BT_UID, 1889 BluetoothMapContract.ConvoContactColumns.CHAT_STATE, 1890 BluetoothMapContract.ConvoContactColumns.UCI, 1891 BluetoothMapContract.ConvoContactColumns.LAST_ACTIVE, 1892 BluetoothMapContract.ConvoContactColumns.PRESENCE_STATE, 1893 BluetoothMapContract.ConvoContactColumns.STATUS_TEXT, 1894 BluetoothMapContract.ConvoContactColumns.PRIORITY, 1895 BluetoothMapContract.ConvoContactColumns.LAST_ONLINE}); 1896 cursor.addRow(new Object[] {TEST_CONVO_ID, TEST_NAME, TEST_DISPLAY_NAME, TEST_BT_UID, 1897 TEST_CHAT_STATE, TEST_UCI, TEST_LAST_ACTIVITY, TEST_PRESENCE_STATE, 1898 TEST_STATUS_TEXT, TEST_PRIORITY, TEST_LAST_ONLINE}); 1899 doReturn(cursor).when(mProviderClient).query(any(), any(), any(), any(), any()); 1900 1901 Map<String, BluetoothMapConvoContactElement> map = new HashMap<>(); 1902 map.put(TEST_UCI_DIFFERENT, null); 1903 BluetoothMapConvoContactElement contact = new BluetoothMapConvoContactElement(TEST_UCI, 1904 TEST_NAME, TEST_DISPLAY_NAME, TEST_STATUS_TEXT_DIFFERENT, 1905 TEST_PRESENCE_STATE_DIFFERENT, TEST_LAST_ACTIVITY, TEST_CHAT_STATE_DIFFERENT, 1906 TEST_PRIORITY, TEST_BT_UID); 1907 map.put(TEST_UCI, contact); 1908 mObserver.setContactList(map, true); 1909 mObserver.mMapEventReportVersion = BluetoothMapUtils.MAP_EVENT_REPORT_V12; 1910 when(mTelephonyManager.getLine1Number()).thenReturn(""); 1911 1912 mObserver.handleContactListChanges(uri); 1913 1914 BluetoothMapConvoContactElement contactElement = mObserver.getContactList().get(TEST_UCI); 1915 final SimpleDateFormat format = new SimpleDateFormat("yyyyMMdd'T'HHmmss"); 1916 Assert.assertEquals(contactElement.getContactId(), TEST_UCI); 1917 Assert.assertEquals(contactElement.getName(), TEST_NAME); 1918 Assert.assertEquals(contactElement.getDisplayName(), TEST_DISPLAY_NAME); 1919 Assert.assertEquals(contactElement.getBtUid(), TEST_BT_UID); 1920 Assert.assertEquals(contactElement.getChatState(), TEST_CHAT_STATE); 1921 Assert.assertEquals(contactElement.getPresenceStatus(), TEST_STATUS_TEXT); 1922 Assert.assertEquals(contactElement.getPresenceAvailability(), TEST_PRESENCE_STATE); 1923 Assert.assertEquals(contactElement.getLastActivityString(), format.format( 1924 TEST_LAST_ACTIVITY)); 1925 Assert.assertEquals(contactElement.getPriority(), TEST_PRIORITY); 1926 } 1927 1928 @Test handleContactListChanges_withMapEventReportVersion11()1929 public void handleContactListChanges_withMapEventReportVersion11() throws Exception { 1930 Uri uri = mock(Uri.class); 1931 mObserver.mAuthority = TEST_AUTHORITY; 1932 when(uri.getAuthority()).thenReturn(TEST_AUTHORITY); 1933 mObserver.mMapEventReportVersion = BluetoothMapUtils.MAP_EVENT_REPORT_V11; 1934 1935 mObserver.handleContactListChanges(uri); 1936 1937 verify(mProviderClient, never()).query(any(), any(), any(), any(), any(), any()); 1938 } 1939 createSimpleMsg()1940 private BluetoothMapContentObserver.Msg createSimpleMsg() { 1941 return new BluetoothMapContentObserver.Msg(1, 1L, 1); 1942 } 1943 createMsgWithTypeAndThreadId(int type, int threadId)1944 private BluetoothMapContentObserver.Msg createMsgWithTypeAndThreadId(int type, int threadId) { 1945 return new BluetoothMapContentObserver.Msg(1, type, threadId, 1); 1946 } 1947 setFolderStructureWithTelecomAndMsg(BluetoothMapFolderElement folderElement, String folderName, long folderId)1948 private void setFolderStructureWithTelecomAndMsg(BluetoothMapFolderElement folderElement, 1949 String folderName, long folderId) { 1950 folderElement.addFolder("telecom"); 1951 folderElement.getSubFolder("telecom").addFolder("msg"); 1952 BluetoothMapFolderElement subFolder = folderElement.getSubFolder("telecom").getSubFolder( 1953 "msg").addFolder(folderName); 1954 subFolder.setFolderId(folderId); 1955 } 1956 } 1957