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