tree 3f2aac64ae9ed994c1f4a9006d3ea7a23aa63d81
parent 6c29a6fb047c2426201e7bc855afd9ba6526607a
author Riddle Hsu <riddlehsu@google.com> 1696438444 +0000
committer Riddle Hsu <riddlehsu@google.com> 1696492695 +0000

Run normal finish for entering standalone recents activity

After adding the behavior to finish recents transition when recents
activity is launched on top of home, the case of launching home
again no longer finishes from shell:merge -> recents:onTasksAppeared
-> shell:finish.

The behavior will be like a regular launch, so just make home invisible
after recents activity is launched. And when launching home again,
it will be a new regular task-open transition which is handled by
DefaultTransitionHandler.

Bug: 302703228
Bug: 294029838
Test: WindowInsetsBehaviorTests
Change-Id: I3cf5772fcc72d95426365fd474ed35891c6d0d86
