1 /* 2 * Copyright (C) 2021 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.server.accessibility; 18 19 import static android.accessibilityservice.MagnificationConfig.MAGNIFICATION_MODE_FULLSCREEN; 20 import static android.accessibilityservice.MagnificationConfig.MAGNIFICATION_MODE_WINDOW; 21 import static android.provider.Settings.Secure.ACCESSIBILITY_MAGNIFICATION_MODE_FULLSCREEN; 22 import static android.provider.Settings.Secure.ACCESSIBILITY_MAGNIFICATION_MODE_WINDOW; 23 24 import static org.junit.Assert.assertEquals; 25 import static org.junit.Assert.assertFalse; 26 import static org.junit.Assert.assertTrue; 27 import static org.junit.Assert.fail; 28 import static org.mockito.ArgumentMatchers.any; 29 import static org.mockito.ArgumentMatchers.anyBoolean; 30 import static org.mockito.ArgumentMatchers.anyFloat; 31 import static org.mockito.ArgumentMatchers.anyInt; 32 import static org.mockito.ArgumentMatchers.eq; 33 import static org.mockito.Mockito.doAnswer; 34 import static org.mockito.Mockito.never; 35 import static org.mockito.Mockito.verify; 36 import static org.mockito.Mockito.when; 37 38 import android.accessibilityservice.MagnificationConfig; 39 import android.graphics.Region; 40 41 import com.android.server.accessibility.magnification.FullScreenMagnificationController; 42 import com.android.server.accessibility.magnification.MagnificationController; 43 import com.android.server.accessibility.magnification.MagnificationProcessor; 44 import com.android.server.accessibility.magnification.WindowMagnificationManager; 45 46 import org.junit.Before; 47 import org.junit.Test; 48 import org.mockito.Mock; 49 import org.mockito.Mockito; 50 import org.mockito.MockitoAnnotations; 51 import org.mockito.stubbing.Answer; 52 53 /** 54 * Tests for the {@link MagnificationProcessor} 55 */ 56 public class MagnificationProcessorTest { 57 58 private static final int TEST_DISPLAY = 0; 59 private static final int SERVICE_ID = 42; 60 private static final float TEST_SCALE = 1.8f; 61 private static final float TEST_CENTER_X = 50.5f; 62 private static final float TEST_CENTER_Y = 100.5f; 63 private MagnificationProcessor mMagnificationProcessor; 64 @Mock 65 private MagnificationController mMockMagnificationController; 66 @Mock 67 private FullScreenMagnificationController mMockFullScreenMagnificationController; 68 @Mock 69 private WindowMagnificationManager mMockWindowMagnificationManager; 70 FullScreenMagnificationControllerStub mFullScreenMagnificationControllerStub; 71 WindowMagnificationManagerStub mWindowMagnificationManagerStub; 72 73 @Before setup()74 public void setup() { 75 MockitoAnnotations.initMocks(this); 76 mFullScreenMagnificationControllerStub = new FullScreenMagnificationControllerStub( 77 mMockFullScreenMagnificationController); 78 mWindowMagnificationManagerStub = new WindowMagnificationManagerStub( 79 mMockWindowMagnificationManager); 80 when(mMockMagnificationController.getFullScreenMagnificationController()).thenReturn( 81 mMockFullScreenMagnificationController); 82 when(mMockMagnificationController.getWindowMagnificationMgr()).thenReturn( 83 mMockWindowMagnificationManager); 84 mMagnificationProcessor = new MagnificationProcessor(mMockMagnificationController); 85 } 86 87 @Test getScale_fullscreenMode_expectedValue()88 public void getScale_fullscreenMode_expectedValue() { 89 final MagnificationConfig config = new MagnificationConfig.Builder() 90 .setMode(MAGNIFICATION_MODE_FULLSCREEN) 91 .setScale(TEST_SCALE).build(); 92 setMagnificationActivated(TEST_DISPLAY, config); 93 94 float scale = mMagnificationProcessor.getScale(TEST_DISPLAY); 95 96 assertEquals(scale, TEST_SCALE, 0); 97 } 98 99 @Test getScale_windowMode_expectedValue()100 public void getScale_windowMode_expectedValue() { 101 final MagnificationConfig config = new MagnificationConfig.Builder() 102 .setMode(MAGNIFICATION_MODE_WINDOW) 103 .setScale(TEST_SCALE).build(); 104 setMagnificationActivated(TEST_DISPLAY, config); 105 106 float scale = mMagnificationProcessor.getMagnificationConfig(TEST_DISPLAY).getScale(); 107 108 assertEquals(scale, TEST_SCALE, 0); 109 } 110 111 @Test getCenterX_canControlFullscreenMagnification_returnCenterX()112 public void getCenterX_canControlFullscreenMagnification_returnCenterX() { 113 final MagnificationConfig config = new MagnificationConfig.Builder() 114 .setMode(MAGNIFICATION_MODE_FULLSCREEN) 115 .setCenterX(TEST_CENTER_X).build(); 116 setMagnificationActivated(TEST_DISPLAY, config); 117 118 float centerX = mMagnificationProcessor.getCenterX( 119 TEST_DISPLAY, /* canControlMagnification= */true); 120 121 assertEquals(centerX, TEST_CENTER_X, 0); 122 } 123 124 @Test getCenterX_controlWindowMagnification_returnCenterX()125 public void getCenterX_controlWindowMagnification_returnCenterX() { 126 final MagnificationConfig config = new MagnificationConfig.Builder() 127 .setMode(MAGNIFICATION_MODE_WINDOW) 128 .setCenterX(TEST_CENTER_X).build(); 129 setMagnificationActivated(TEST_DISPLAY, config); 130 131 float centerX = mMagnificationProcessor.getMagnificationConfig(TEST_DISPLAY).getCenterX(); 132 133 assertEquals(centerX, TEST_CENTER_X, 0); 134 } 135 136 @Test getCenterY_canControlFullscreenMagnification_returnCenterY()137 public void getCenterY_canControlFullscreenMagnification_returnCenterY() { 138 final MagnificationConfig config = new MagnificationConfig.Builder() 139 .setMode(MAGNIFICATION_MODE_FULLSCREEN) 140 .setCenterY(TEST_CENTER_Y).build(); 141 setMagnificationActivated(TEST_DISPLAY, config); 142 143 float centerY = mMagnificationProcessor.getCenterY( 144 TEST_DISPLAY, /* canControlMagnification= */false); 145 146 assertEquals(centerY, TEST_CENTER_Y, 0); 147 } 148 149 @Test getCenterY_controlWindowMagnification_returnCenterY()150 public void getCenterY_controlWindowMagnification_returnCenterY() { 151 final MagnificationConfig config = new MagnificationConfig.Builder() 152 .setMode(MAGNIFICATION_MODE_WINDOW) 153 .setCenterY(TEST_CENTER_Y).build(); 154 setMagnificationActivated(TEST_DISPLAY, config); 155 156 float centerY = mMagnificationProcessor.getMagnificationConfig(TEST_DISPLAY).getCenterY(); 157 158 assertEquals(centerY, TEST_CENTER_Y, 0); 159 } 160 161 @Test getMagnificationRegion_canControlFullscreenMagnification_returnRegion()162 public void getMagnificationRegion_canControlFullscreenMagnification_returnRegion() { 163 final Region region = new Region(10, 20, 100, 200); 164 setMagnificationActivated(TEST_DISPLAY, MAGNIFICATION_MODE_FULLSCREEN); 165 mMagnificationProcessor.getFullscreenMagnificationRegion(TEST_DISPLAY, 166 region, /* canControlMagnification= */true); 167 168 verify(mMockFullScreenMagnificationController).getMagnificationRegion(eq(TEST_DISPLAY), 169 eq(region)); 170 } 171 172 @Test getMagnificationRegion_fullscreenModeNotRegistered_shouldRegisterThenUnregister()173 public void getMagnificationRegion_fullscreenModeNotRegistered_shouldRegisterThenUnregister() { 174 final Region region = new Region(10, 20, 100, 200); 175 setMagnificationActivated(TEST_DISPLAY, MAGNIFICATION_MODE_FULLSCREEN); 176 doAnswer((invocation) -> { 177 ((Region) invocation.getArguments()[1]).set(region); 178 return null; 179 }).when(mMockFullScreenMagnificationController).getMagnificationRegion(eq(TEST_DISPLAY), 180 any()); 181 182 final Region result = new Region(); 183 mMagnificationProcessor.getFullscreenMagnificationRegion(TEST_DISPLAY, 184 result, /* canControlMagnification= */true); 185 assertEquals(region, result); 186 verify(mMockFullScreenMagnificationController).register(TEST_DISPLAY); 187 verify(mMockFullScreenMagnificationController).unregister(TEST_DISPLAY); 188 } 189 190 @Test getCurrentMagnificationRegion_windowModeActivated_returnRegion()191 public void getCurrentMagnificationRegion_windowModeActivated_returnRegion() { 192 final Region region = new Region(10, 20, 100, 200); 193 setMagnificationActivated(TEST_DISPLAY, MAGNIFICATION_MODE_WINDOW); 194 doAnswer((invocation) -> { 195 ((Region) invocation.getArguments()[1]).set(region); 196 return null; 197 }).when(mMockWindowMagnificationManager).getMagnificationSourceBounds(eq(TEST_DISPLAY), 198 any()); 199 200 final Region result = new Region(); 201 mMagnificationProcessor.getCurrentMagnificationRegion(TEST_DISPLAY, 202 result, /* canControlMagnification= */true); 203 assertEquals(region, result); 204 } 205 206 @Test getCurrentMagnificationRegion_fullscreenModeActivated_returnRegion()207 public void getCurrentMagnificationRegion_fullscreenModeActivated_returnRegion() { 208 final Region region = new Region(10, 20, 100, 200); 209 setMagnificationActivated(TEST_DISPLAY, MAGNIFICATION_MODE_FULLSCREEN); 210 doAnswer((invocation) -> { 211 ((Region) invocation.getArguments()[1]).set(region); 212 return null; 213 }).when(mMockFullScreenMagnificationController).getMagnificationRegion(eq(TEST_DISPLAY), 214 any()); 215 216 final Region result = new Region(); 217 mMagnificationProcessor.getCurrentMagnificationRegion(TEST_DISPLAY, 218 result, /* canControlMagnification= */true); 219 assertEquals(region, result); 220 } 221 222 @Test getMagnificationCenterX_fullscreenModeNotRegistered_shouldRegisterThenUnregister()223 public void getMagnificationCenterX_fullscreenModeNotRegistered_shouldRegisterThenUnregister() { 224 final MagnificationConfig config = new MagnificationConfig.Builder() 225 .setMode(MAGNIFICATION_MODE_FULLSCREEN) 226 .setCenterX(TEST_CENTER_X).build(); 227 setMagnificationActivated(TEST_DISPLAY, config); 228 229 final float result = mMagnificationProcessor.getCenterX( 230 TEST_DISPLAY, /* canControlMagnification= */ true); 231 assertEquals(TEST_CENTER_X, result, 0); 232 verify(mMockFullScreenMagnificationController).register(TEST_DISPLAY); 233 verify(mMockFullScreenMagnificationController).unregister(TEST_DISPLAY); 234 } 235 236 @Test getMagnificationCenterY_fullscreenModeNotRegistered_shouldRegisterThenUnregister()237 public void getMagnificationCenterY_fullscreenModeNotRegistered_shouldRegisterThenUnregister() { 238 final MagnificationConfig config = new MagnificationConfig.Builder() 239 .setMode(MAGNIFICATION_MODE_FULLSCREEN) 240 .setCenterY(TEST_CENTER_Y).build(); 241 setMagnificationActivated(TEST_DISPLAY, config); 242 243 final float result = mMagnificationProcessor.getCenterY( 244 TEST_DISPLAY, /* canControlMagnification= */ true); 245 assertEquals(TEST_CENTER_Y, result, 0); 246 verify(mMockFullScreenMagnificationController).register(TEST_DISPLAY); 247 verify(mMockFullScreenMagnificationController).unregister(TEST_DISPLAY); 248 } 249 250 @Test getCurrentMode_configDefaultMode_returnActivatedMode()251 public void getCurrentMode_configDefaultMode_returnActivatedMode() { 252 final int targetMode = MAGNIFICATION_MODE_WINDOW; 253 setMagnificationActivated(TEST_DISPLAY, targetMode); 254 255 int currentMode = mMagnificationProcessor.getControllingMode(TEST_DISPLAY); 256 257 assertEquals(MAGNIFICATION_MODE_WINDOW, currentMode); 258 } 259 260 @Test getCurrentMode_changeOtherDisplayMode_returnDefaultModeOnDefaultDisplay()261 public void getCurrentMode_changeOtherDisplayMode_returnDefaultModeOnDefaultDisplay() { 262 final int otherDisplayId = TEST_DISPLAY + 1; 263 setMagnificationActivated(otherDisplayId, MAGNIFICATION_MODE_WINDOW); 264 265 int currentMode = mMagnificationProcessor.getControllingMode(TEST_DISPLAY); 266 267 assertFalse(mMockMagnificationController.isActivated(TEST_DISPLAY, 268 ACCESSIBILITY_MAGNIFICATION_MODE_FULLSCREEN)); 269 assertFalse(mMockMagnificationController.isActivated(TEST_DISPLAY, 270 ACCESSIBILITY_MAGNIFICATION_MODE_WINDOW)); 271 assertEquals(MAGNIFICATION_MODE_FULLSCREEN, currentMode); 272 } 273 274 @Test resetFullscreenMagnification_fullscreenMagnificationActivated()275 public void resetFullscreenMagnification_fullscreenMagnificationActivated() { 276 setMagnificationActivated(TEST_DISPLAY, MAGNIFICATION_MODE_FULLSCREEN); 277 278 mMagnificationProcessor.resetFullscreenMagnification(TEST_DISPLAY, /* animate= */false); 279 280 verify(mMockFullScreenMagnificationController).reset(TEST_DISPLAY, false); 281 } 282 283 @Test resetCurrentMagnification_windowMagnificationActivated()284 public void resetCurrentMagnification_windowMagnificationActivated() { 285 setMagnificationActivated(TEST_DISPLAY, MAGNIFICATION_MODE_WINDOW); 286 287 mMagnificationProcessor.resetCurrentMagnification(TEST_DISPLAY, /* animate= */false); 288 289 verify(mMockWindowMagnificationManager).disableWindowMagnification(TEST_DISPLAY, false, 290 null); 291 } 292 293 @Test resetAllIfNeeded_resetFullscreenAndWindowMagnificationByConnectionId()294 public void resetAllIfNeeded_resetFullscreenAndWindowMagnificationByConnectionId() { 295 final int connectionId = 1; 296 mMagnificationProcessor.resetAllIfNeeded(connectionId); 297 298 verify(mMockFullScreenMagnificationController).resetAllIfNeeded(eq(connectionId)); 299 verify(mMockWindowMagnificationManager).resetAllIfNeeded(eq(connectionId)); 300 } 301 302 @Test setMagnificationConfig_fullscreenModeNotRegistered_shouldRegister()303 public void setMagnificationConfig_fullscreenModeNotRegistered_shouldRegister() { 304 final MagnificationConfig config = new MagnificationConfig.Builder() 305 .setMode(MAGNIFICATION_MODE_FULLSCREEN) 306 .setScale(TEST_SCALE) 307 .setCenterX(TEST_CENTER_X) 308 .setCenterY(TEST_CENTER_Y).build(); 309 setMagnificationActivated(TEST_DISPLAY, config); 310 311 final boolean result = mMagnificationProcessor.setMagnificationConfig( 312 TEST_DISPLAY, config, true, SERVICE_ID); 313 assertTrue(result); 314 verify(mMockFullScreenMagnificationController).register(TEST_DISPLAY); 315 } 316 317 @Test setMagnificationConfig_windowMode_enableMagnification()318 public void setMagnificationConfig_windowMode_enableMagnification() { 319 final MagnificationConfig config = new MagnificationConfig.Builder() 320 .setMode(MAGNIFICATION_MODE_WINDOW) 321 .setScale(TEST_SCALE) 322 .setCenterX(TEST_CENTER_X) 323 .setCenterY(TEST_CENTER_Y).build(); 324 setMagnificationActivated(TEST_DISPLAY, config); 325 326 final boolean result = mMagnificationProcessor.setMagnificationConfig( 327 TEST_DISPLAY, config, true, SERVICE_ID); 328 329 assertTrue(result); 330 } 331 332 @Test getMagnificationConfig_fullscreenEnabled_expectedConfigValues()333 public void getMagnificationConfig_fullscreenEnabled_expectedConfigValues() { 334 final MagnificationConfig config = new MagnificationConfig.Builder() 335 .setMode(MAGNIFICATION_MODE_FULLSCREEN) 336 .setScale(TEST_SCALE) 337 .setCenterX(TEST_CENTER_X) 338 .setCenterY(TEST_CENTER_Y).build(); 339 setMagnificationActivated(TEST_DISPLAY, config); 340 341 final MagnificationConfig result = mMagnificationProcessor.getMagnificationConfig( 342 TEST_DISPLAY); 343 344 assertConfigEquals(config, result); 345 } 346 347 @Test getMagnificationConfig_windowEnabled_expectedConfigValues()348 public void getMagnificationConfig_windowEnabled_expectedConfigValues() { 349 final MagnificationConfig config = new MagnificationConfig.Builder() 350 .setMode(MAGNIFICATION_MODE_WINDOW) 351 .setScale(TEST_SCALE) 352 .setCenterX(TEST_CENTER_X) 353 .setCenterY(TEST_CENTER_Y).build(); 354 setMagnificationActivated(TEST_DISPLAY, config); 355 356 final MagnificationConfig result = mMagnificationProcessor.getMagnificationConfig( 357 TEST_DISPLAY); 358 359 assertConfigEquals(config, result); 360 } 361 362 @Test setWindowModeConfig_fullScreenMode_transitionConfigMode()363 public void setWindowModeConfig_fullScreenMode_transitionConfigMode() { 364 final int currentActivatedMode = MAGNIFICATION_MODE_FULLSCREEN; 365 final MagnificationConfig oldConfig = new MagnificationConfig.Builder() 366 .setMode(currentActivatedMode) 367 .setScale(TEST_SCALE) 368 .setCenterX(TEST_CENTER_X) 369 .setCenterY(TEST_CENTER_Y).build(); 370 setMagnificationActivated(TEST_DISPLAY, oldConfig); 371 final MagnificationConfig targetConfig = new MagnificationConfig.Builder() 372 .setMode(MAGNIFICATION_MODE_WINDOW) 373 .setScale(TEST_SCALE) 374 .setCenterX(TEST_CENTER_X + 10) 375 .setCenterY(TEST_CENTER_Y + 10).build(); 376 377 mMagnificationProcessor.setMagnificationConfig(TEST_DISPLAY, targetConfig, false, 378 SERVICE_ID); 379 380 verify(mMockMagnificationController).transitionMagnificationConfigMode(eq(TEST_DISPLAY), 381 eq(targetConfig), eq(false), eq(SERVICE_ID)); 382 } 383 384 @Test setConfigWithDefaultMode_fullScreenMode_expectedConfig()385 public void setConfigWithDefaultMode_fullScreenMode_expectedConfig() { 386 final MagnificationConfig oldConfig = new MagnificationConfig.Builder() 387 .setMode(MAGNIFICATION_MODE_FULLSCREEN) 388 .setScale(TEST_SCALE) 389 .setCenterX(TEST_CENTER_X) 390 .setCenterY(TEST_CENTER_Y).build(); 391 setMagnificationActivated(TEST_DISPLAY, oldConfig); 392 final MagnificationConfig targetConfig = new MagnificationConfig.Builder() 393 .setScale(TEST_SCALE + 1) 394 .setCenterX(TEST_CENTER_X + 10) 395 .setCenterY(TEST_CENTER_Y + 10).build(); 396 397 mMagnificationProcessor.setMagnificationConfig(TEST_DISPLAY, targetConfig, false, 398 SERVICE_ID); 399 400 verify(mMockMagnificationController, never()).transitionMagnificationConfigMode( 401 eq(TEST_DISPLAY), any(MagnificationConfig.class), eq(false), eq(SERVICE_ID)); 402 final MagnificationConfig expectedConfig = new MagnificationConfig.Builder() 403 .setMode(MAGNIFICATION_MODE_FULLSCREEN) 404 .setScale(TEST_SCALE + 1) 405 .setCenterX(TEST_CENTER_X + 10) 406 .setCenterY(TEST_CENTER_Y + 10).build(); 407 assertConfigEquals(expectedConfig, 408 mMagnificationProcessor.getMagnificationConfig(TEST_DISPLAY)); 409 } 410 411 @Test setWindowModeConfig_transitionToFullScreenModeWithAnimation_transitionConfigMode()412 public void setWindowModeConfig_transitionToFullScreenModeWithAnimation_transitionConfigMode() { 413 final int currentActivatedMode = MAGNIFICATION_MODE_WINDOW; 414 final int targetMode = MAGNIFICATION_MODE_WINDOW; 415 final MagnificationConfig oldConfig = new MagnificationConfig.Builder() 416 .setMode(currentActivatedMode) 417 .setScale(TEST_SCALE) 418 .setCenterX(TEST_CENTER_X) 419 .setCenterY(TEST_CENTER_Y).build(); 420 setMagnificationActivated(TEST_DISPLAY, oldConfig); 421 final MagnificationConfig newConfig = new MagnificationConfig.Builder() 422 .setMode(targetMode) 423 .setScale(TEST_SCALE) 424 .setCenterX(TEST_CENTER_X + 10) 425 .setCenterY(TEST_CENTER_Y + 10).build(); 426 // Has magnification animation running 427 when(mMockMagnificationController.hasDisableMagnificationCallback(TEST_DISPLAY)).thenReturn( 428 true); 429 430 mMagnificationProcessor.setMagnificationConfig(TEST_DISPLAY, newConfig, false, SERVICE_ID); 431 432 verify(mMockMagnificationController).transitionMagnificationConfigMode(eq(TEST_DISPLAY), 433 eq(newConfig), anyBoolean(), anyInt()); 434 } 435 436 @Test setMagnificationConfigWithActivatedFalse_fullScreenEnabled_resetMagnification()437 public void setMagnificationConfigWithActivatedFalse_fullScreenEnabled_resetMagnification() { 438 setMagnificationActivated(TEST_DISPLAY, MAGNIFICATION_MODE_FULLSCREEN); 439 final MagnificationConfig config = new MagnificationConfig.Builder() 440 .setActivated(false).build(); 441 mMagnificationProcessor.setMagnificationConfig(TEST_DISPLAY, config, false, SERVICE_ID); 442 443 verify(mMockFullScreenMagnificationController).reset(eq(TEST_DISPLAY), anyBoolean()); 444 } 445 446 @Test setMagnificationConfigWithActivatedFalse_windowEnabled_disableMagnification()447 public void setMagnificationConfigWithActivatedFalse_windowEnabled_disableMagnification() { 448 setMagnificationActivated(TEST_DISPLAY, MAGNIFICATION_MODE_WINDOW); 449 final MagnificationConfig config = new MagnificationConfig.Builder() 450 .setActivated(false).build(); 451 mMagnificationProcessor.setMagnificationConfig(TEST_DISPLAY, config, false, SERVICE_ID); 452 453 verify(mMockWindowMagnificationManager) 454 .disableWindowMagnification(eq(TEST_DISPLAY), anyBoolean()); 455 } 456 457 @Test setMagnificationConfigWithActivatedFalse_expectedReturnedValue()458 public void setMagnificationConfigWithActivatedFalse_expectedReturnedValue() { 459 final MagnificationConfig config = new MagnificationConfig.Builder() 460 .setActivated(false).build(); 461 assertFalse(mMagnificationProcessor.setMagnificationConfig( 462 TEST_DISPLAY, config, false, SERVICE_ID)); 463 } 464 setMagnificationActivated(int displayId, int configMode)465 private void setMagnificationActivated(int displayId, int configMode) { 466 setMagnificationActivated(displayId, 467 new MagnificationConfig.Builder() 468 .setMode(configMode) 469 .setScale(TEST_SCALE).build()); 470 } 471 setMagnificationActivated(int displayId, MagnificationConfig config)472 private void setMagnificationActivated(int displayId, MagnificationConfig config) { 473 if (!config.isActivated()) { 474 fail("setMagnificationActivated method should be called with config activated true"); 475 } 476 477 when(mMockMagnificationController.isActivated(displayId, config.getMode())).thenReturn( 478 true); 479 mMagnificationProcessor.setMagnificationConfig(displayId, config, false, SERVICE_ID); 480 if (config.getMode() == MAGNIFICATION_MODE_FULLSCREEN) { 481 mFullScreenMagnificationControllerStub.resetAndStubMethods(); 482 mMockFullScreenMagnificationController.setScaleAndCenter(displayId, config.getScale(), 483 config.getCenterX(), config.getCenterY(), false, SERVICE_ID); 484 mWindowMagnificationManagerStub.deactivateIfNeed(); 485 } else if (config.getMode() == MAGNIFICATION_MODE_WINDOW) { 486 mWindowMagnificationManagerStub.resetAndStubMethods(); 487 mMockWindowMagnificationManager.enableWindowMagnification(displayId, config.getScale(), 488 config.getCenterX(), config.getCenterY()); 489 mFullScreenMagnificationControllerStub.deactivateIfNeed(); 490 } 491 } 492 assertConfigEquals(MagnificationConfig expected, MagnificationConfig actual)493 private void assertConfigEquals(MagnificationConfig expected, MagnificationConfig actual) { 494 assertEquals(expected.getMode(), actual.getMode()); 495 assertEquals(expected.getScale(), actual.getScale(), 0); 496 assertEquals(expected.getCenterX(), actual.getCenterX(), 0); 497 assertEquals(expected.getCenterY(), actual.getCenterY(), 0); 498 } 499 500 private static class FullScreenMagnificationControllerStub { 501 private final FullScreenMagnificationController mScreenMagnificationController; 502 private float mScale = 1.0f; 503 private float mCenterX = 0; 504 private float mCenterY = 0; 505 private boolean mIsActivated = false; 506 private boolean mIsRegistered = false; 507 FullScreenMagnificationControllerStub( FullScreenMagnificationController screenMagnificationController)508 FullScreenMagnificationControllerStub( 509 FullScreenMagnificationController screenMagnificationController) { 510 mScreenMagnificationController = screenMagnificationController; 511 } 512 stubMethods()513 private void stubMethods() { 514 doAnswer(invocation -> mScale).when(mScreenMagnificationController).getScale( 515 TEST_DISPLAY); 516 doAnswer(invocation -> mCenterX).when(mScreenMagnificationController).getCenterX( 517 TEST_DISPLAY); 518 doAnswer(invocation -> mCenterY).when(mScreenMagnificationController).getCenterY( 519 TEST_DISPLAY); 520 doAnswer(invocation -> mIsRegistered).when(mScreenMagnificationController).isRegistered( 521 TEST_DISPLAY); 522 doAnswer(invocation -> mIsActivated).when(mScreenMagnificationController).isActivated( 523 TEST_DISPLAY); 524 525 Answer enableMagnificationStubAnswer = invocation -> { 526 mIsActivated = true; 527 mScale = invocation.getArgument(1); 528 mCenterX = invocation.getArgument(2); 529 mCenterY = invocation.getArgument(3); 530 return true; 531 }; 532 doAnswer(enableMagnificationStubAnswer).when( 533 mScreenMagnificationController).setScaleAndCenter(eq(TEST_DISPLAY), anyFloat(), 534 anyFloat(), anyFloat(), anyBoolean(), eq(SERVICE_ID)); 535 536 Answer disableMagnificationStubAnswer = invocation -> { 537 deactivateIfNeed(); 538 return true; 539 }; 540 doAnswer(disableMagnificationStubAnswer).when( 541 mScreenMagnificationController).reset(eq(TEST_DISPLAY), anyBoolean()); 542 543 Answer registerStubAnswer = invocation -> { 544 mIsRegistered = true; 545 return true; 546 }; 547 doAnswer(registerStubAnswer).when( 548 mScreenMagnificationController).register(eq(TEST_DISPLAY)); 549 550 Answer unregisterStubAnswer = invocation -> { 551 mIsRegistered = false; 552 return true; 553 }; 554 doAnswer(unregisterStubAnswer).when( 555 mScreenMagnificationController).unregister(eq(TEST_DISPLAY)); 556 } 557 resetAndStubMethods()558 public void resetAndStubMethods() { 559 Mockito.reset(mScreenMagnificationController); 560 stubMethods(); 561 } 562 deactivateIfNeed()563 public void deactivateIfNeed() { 564 mScale = 1.0f; 565 mCenterX = 0; 566 mCenterY = 0; 567 mIsActivated = false; 568 } 569 } 570 571 private static class WindowMagnificationManagerStub { 572 private final WindowMagnificationManager mWindowMagnificationManager; 573 private float mScale = 1.0f; 574 private float mCenterX = 0; 575 private float mCenterY = 0; 576 private boolean mIsEnabled = false; 577 WindowMagnificationManagerStub( WindowMagnificationManager windowMagnificationManager)578 WindowMagnificationManagerStub( 579 WindowMagnificationManager windowMagnificationManager) { 580 mWindowMagnificationManager = windowMagnificationManager; 581 } 582 stubMethods()583 private void stubMethods() { 584 doAnswer(invocation -> mScale).when(mWindowMagnificationManager).getScale( 585 TEST_DISPLAY); 586 doAnswer(invocation -> mCenterX).when(mWindowMagnificationManager).getCenterX( 587 TEST_DISPLAY); 588 doAnswer(invocation -> mCenterY).when(mWindowMagnificationManager).getCenterY( 589 TEST_DISPLAY); 590 doAnswer(invocation -> mIsEnabled).when(mWindowMagnificationManager) 591 .isWindowMagnifierEnabled(TEST_DISPLAY); 592 593 Answer enableWindowMagnificationStubAnswer = invocation -> { 594 mIsEnabled = true; 595 mScale = invocation.getArgument(1); 596 mCenterX = invocation.getArgument(2); 597 mCenterY = invocation.getArgument(3); 598 return true; 599 }; 600 doAnswer(enableWindowMagnificationStubAnswer).when( 601 mWindowMagnificationManager).enableWindowMagnification(eq(TEST_DISPLAY), 602 anyFloat(), anyFloat(), anyFloat()); 603 doAnswer(enableWindowMagnificationStubAnswer).when( 604 mWindowMagnificationManager).enableWindowMagnification(eq(TEST_DISPLAY), 605 anyFloat(), anyFloat(), anyFloat(), any(), anyInt()); 606 607 Answer disableWindowMagnificationStubAnswer = invocation -> { 608 deactivateIfNeed(); 609 return true; 610 }; 611 doAnswer(disableWindowMagnificationStubAnswer).when( 612 mWindowMagnificationManager).disableWindowMagnification(eq(TEST_DISPLAY), 613 anyBoolean()); 614 doAnswer(disableWindowMagnificationStubAnswer).when( 615 mWindowMagnificationManager).disableWindowMagnification(eq(TEST_DISPLAY), 616 anyBoolean(), any()); 617 } 618 resetAndStubMethods()619 public void resetAndStubMethods() { 620 Mockito.reset(mWindowMagnificationManager); 621 stubMethods(); 622 } 623 deactivateIfNeed()624 public void deactivateIfNeed() { 625 mScale = 1.0f; 626 mCenterX = Float.NaN; 627 mCenterY = Float.NaN; 628 mIsEnabled = false; 629 } 630 } 631 } 632