diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000..927c5a8 --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,70 @@ +name: ci + +on: + push: + branches: + - work/3.0.0 + - 'release/**' + - main + pull_request: + branches: + - work/3.0.0 + - 'release/**' + - main + +permissions: + contents: read + +concurrency: + group: ci-${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +jobs: + build-test-lint: + name: Build, test, and lint + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Set up JDK 17 + uses: actions/setup-java@v4 + with: + distribution: temurin + java-version: '17' + cache: gradle + + - name: Grant execute permission for gradlew + run: chmod +x gradlew + + - name: Assemble debug builds + run: ./gradlew :core:assembleDebug :sample:assembleDebug + + - name: Assemble and publish release artifact + run: ./gradlew :core:assembleRelease :core:publishToMavenLocal + + - name: Run unit tests + run: ./gradlew :core:testDebugUnitTest :lint:test :sample:testDebugUnitTest + + - name: Run Android lint + run: ./gradlew :core:lintDebug :sample:lintDebug + + - name: Upload test reports + if: failure() + uses: actions/upload-artifact@v4 + with: + name: test-reports + path: | + **/build/reports/tests/ + **/build/test-results/ + retention-days: 7 + + - name: Upload lint reports + if: failure() + uses: actions/upload-artifact@v4 + with: + name: lint-reports + path: | + **/build/reports/lint-results*.html + **/build/reports/lint-results*.xml + retention-days: 7 diff --git a/.serena/.gitignore b/.serena/.gitignore new file mode 100644 index 0000000..2e510af --- /dev/null +++ b/.serena/.gitignore @@ -0,0 +1,2 @@ +/cache +/project.local.yml diff --git a/.serena/project.yml b/.serena/project.yml new file mode 100644 index 0000000..a4e72e8 --- /dev/null +++ b/.serena/project.yml @@ -0,0 +1,169 @@ +# the name by which the project can be referenced within Serena/when chatting with the LLM. +project_name: "Android-OverlayViewManager" + +# list of language servers to start when using the LSP backend; choose from: +# ada al angular ansible bash +# bsl clojure cpp cpp_ccls crystal +# csharp csharp_omnisharp cue dart deno +# elixir elm erlang fortran fsharp +# gdscript gleam go groovy haskell +# haxe hlsl html java json +# julia kotlin latex lean4 lua +# luau markdown matlab msl nextflow +# nix ocaml pascal perl php +# php_phpactor php_phpantom powershell python python_basedpyright +# python_jedi python_pyrefly python_ty qml r +# rego ruby ruby_solargraph rust scala +# scss solidity svelte swift systemverilog +# terraform toml typescript typescript_vts vue +# wolfram yaml zig +# (This list may be outdated; generated with scripts/print_language_list.py; +# For the current list, see values of the LanguageServerId enum here: +# https://github.com/oraios/serena/blob/main/src/solidlsp/ls_config.py) +# For some languages, there are several alternative language servers, e.g. csharp_omnisharp, ruby_solargraph.) +# Note: +# - For C, use cpp +# - For JavaScript, use typescript +# - For Angular projects, use angular (subsumes typescript+html; requires `npm install` in the project root) +# - For Svelte projects, use svelte (subsumes typescript/javascript for .svelte projects; requires npm) +# - For Deno projects, use deno (serves the same .ts/.js files as typescript; requires the deno CLI on PATH) +# - For SCSS / Sass / plain CSS, use scss (some-sass-language-server handles all three) +# - For Free Pascal/Lazarus, use pascal +# Special requirements: +# Some language servers require additional setup/installations. +# See here for details: https://oraios.github.io/serena/01-about/020_programming-languages.html#language-servers +# When using multiple language servers, the first language server that supports a given file will be used for that file. +# The first language server is the default language and the respective language server will be used as a fallback. +# Note that when using the JetBrains backend, language servers are not used and this list is correspondingly ignored. +language_servers: +- java + +# the encoding used by text files in the project +# For a list of possible encodings, see https://docs.python.org/3.11/library/codecs.html#standard-encodings +encoding: "utf-8" + +# optional shell command to run before the language backend (LSP or JetBrains) is initialised. +# the command runs in the project root directory and is only executed if the project is trusted +# (see trusted_project_path_patterns in the global configuration). +# serena waits for the command to exit: a non-zero exit code is logged as an error but does not +# abort activation. a per-project timeout (activation_command_timeout, default 180s) is the safety +# backstop for non-terminating commands; on expiry the process is killed and activation continues. +# example: activation_command: "npx nx run-many -t build" +activation_command: + +# maximum time in seconds to wait for activation_command to complete before killing it (default 180s). +# must be a positive number. +activation_command_timeout: 180.0 + +# line ending convention to use when writing source files. +# Possible values: unset (use global setting), "lf", "crlf", or "native" (platform default) +# This does not affect Serena's own files (e.g. memories and configuration files), which always use native line endings. +line_ending: + +# The language backend to use for this project. +# If not set, the global setting from serena_config.yml is used. +# Valid values: LSP, JetBrains +# Note: the backend is fixed at startup. If a project with a different backend +# is activated post-init, an error will be returned. +language_backend: + +# whether to use project's .gitignore files to ignore files +ignore_all_files_in_gitignore: true + +# advanced configuration option allowing to configure language server-specific options. +# Maps the language key to the options. +# The settings are considered only if the project is trusted (see global configuration to define trusted projects). +# See https://oraios.github.io/serena/02-usage/050_configuration.html#language-server-specific-settings +ls_specific_settings: {} + +# list of workspace folder paths (LSP backend only). +# These folders will be used to build up Serena's symbol index. +# Paths must be within the project root and should thus be relative to the project root. +# Furthermore, the paths should not be filtered by ignore settings. +# Default setting: The entire project root folder (".") is considered. +# In (large) monorepos, this can be used to index only subfolders of the project root, e.g. +# ls_workspace_folders: +# - "./subproject1" +# - "./subproject2" +ls_workspace_folders: +- "." + +# list of additional workspace folder paths for cross-package reference support. +# Paths can be absolute or relative to the project root. +# Each folder is registered as an LSP workspace folder, enabling language servers to discover +# symbols and references across package boundaries, but these folders are not indexed by Serena, +# i.e. the respective symbols will not be found using Serena's symbol search tools. +# Example: +# additional_workspace_folders: +# - ../sibling-package +# - ../shared-lib +ls_additional_workspace_folders: [] + +# list of additional paths to ignore in this project. +# Same syntax as gitignore, so you can use * and **. +# Important: quote patterns that start with `*`, otherwise YAML treats them as aliases. +# Example: +# ignored_paths: +# - "examples/**" +# - ".worktrees/**" +# - "**/bin/**" +# - "**/obj/**" +# Note: global ignored_paths from serena_config.yml are also applied additively. +ignored_paths: [] + +# whether the project is in read-only mode +# If set to true, all editing tools will be disabled and attempts to use them will result in an error +# Added on 2025-04-18 +read_only: false + +# list of tool names to exclude. +# This extends the existing exclusions (e.g. from the global configuration) +# Find the list of tools here: https://oraios.github.io/serena/01-about/035_tools.html +excluded_tools: [] + +# list of tools to include that would otherwise be disabled (particularly optional tools that are disabled by default). +# This extends the existing inclusions (e.g. from the global configuration). +# Find the list of tools here: https://oraios.github.io/serena/01-about/035_tools.html +included_optional_tools: [] + +# fixed set of tools to use as the base tool set (if non-empty), replacing Serena's default set of tools. +# This cannot be combined with non-empty excluded_tools or included_optional_tools. +# Find the list of tools here: https://oraios.github.io/serena/01-about/035_tools.html +fixed_tools: [] + +# list of mode names that are to be activated by default, overriding the setting in the global configuration. +# The full set of modes to be activated is base_modes (from global config) + default_modes + added_modes. +# If the setting is undefined/empty, the default_modes from the global configuration (serena_config.yml) apply. +# Otherwise, this overrides the setting from the global configuration (serena_config.yml). +# Therefore, you can set this to [] if you do not want the default modes defined in the global config to apply +# for this project. +# This setting can, in turn, be overridden by CLI parameters (--mode). +# See https://oraios.github.io/serena/02-usage/050_configuration.html#modes +default_modes: + +# list of mode names to be activated additionally for this project, e.g. ["query-projects"] +# The full set of modes to be activated is base_modes (from global config) + default_modes + added_modes. +# See https://oraios.github.io/serena/02-usage/050_configuration.html#modes +added_modes: + +# initial prompt for the project. It will always be given to the LLM upon activating the project +# (contrary to the memories, which are loaded on demand). +initial_prompt: "" + +# time budget (seconds) per tool call for the retrieval of additional symbol information +# such as docstrings or parameter information. +# This overrides the corresponding setting in the global configuration; see the documentation there. +# If null or missing, use the setting from the global configuration. +symbol_info_budget: + +# list of regex patterns which, when matched, mark a memory entry as read‑only. +# Extends the list from the global configuration, merging the two lists. +read_only_memory_patterns: [] + +# list of regex patterns for memories to completely ignore. +# Matching memories will not appear in list_memories or activate_project output +# and cannot be accessed via read_memory or write_memory. +# To access ignored memory files, use the read_file tool on the raw file path. +# Extends the list from the global configuration, merging the two lists. +# Example: ["_archive/.*", "_episodes/.*"] +ignored_memory_patterns: [] diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 0000000..26866f7 --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,72 @@ +# Repository Guidelines + +## Astra Workflow (2026-09-13) + +Based on the [official GPT-6 Astra guide](https://developers.openai.com/api/docs/guides/latest-model?model=gpt-6-astra), with delegation adapted to the user's explicit preference. These instructions govern agent behavior; they do not change model or API configuration. + +- Carry authorized work through implementation, proportionate validation, and a concrete result. Resolve routine choices from context, preserve prior approvals, and avoid repeated permission requests. When clarification is necessary, complete independent work first and identify the remaining decision precisely. +- Apply mid-task corrections to the ongoing objective and preserve completed work. Answer side questions and continue unless the user explicitly stops or replaces the task. +- Follow explicit user instructions over skill guidelines within system and developer constraints. If an instruction file causes a pause, permission request, or incomplete work, link the exact file, quote the relevant instruction, and distinguish its requirement from your interpretation. +- Default to direct work by the parent agent, including investigation, implementation, validation, and review. Start subagents only when the user explicitly requests them for the task; do not routinely ask whether to delegate. Independent read-only tool calls may still run in parallel. +- This delegation policy supersedes the earlier mandatory subagent workflow in `V3_0_0_PLAN.md` and older coordination records. For coordinated 3.0.0 work, the existing Codex and Claude coordinators perform their owned work and reciprocal reviews directly. Preserve ownership, isolated worktrees, task branches, current-head approval, and CI gates. +- Report outcomes in concise Japanese prose, using lists or tables when they clarify steps or comparisons. State changes, validation evidence, and unresolved issues without repetitive summaries or unnecessary formatting. + +## 3.0.0 Preparation and Coordination + +- Read `V3_0_0_PLAN.md` before working on 3.0.0. The user explicitly started coordinated work on 2026-09-12 JST; follow its ownership, review, and validation gates. +- Preparation commit `1646b3b` is shared on `work/3.0.0`. Subsequent changes must use task branches and reciprocal reviewed PRs; the final scope ends at the release PR to main. +- Coordinators: Codex uses Astra (`gpt-6-astra`) / medium; Claude uses Fable 5.1 / high. Verify actual launcher identifiers before starting agents. +- Only when the user explicitly requests subagents, choose their model and effort from Luna (`gpt-5.6-luna`), Terra (`gpt-5.6-terra`), or Sonnet 5, subject to the resource allocation policy below. Do not silently substitute another model when an allowed model is unavailable. Record model, effort, scope, and role in the task record. +- Each coordinator directly performs investigation, implementation, and validation within the agreed ownership. The opposite coordinator performs the required reciprocal review; no additional review subagent is required by default. +- Coordinate ownership through Orca orchestration and use isolated worktrees. Codex-side PRs require Claude coordinator approval; Claude-side PRs require Codex coordinator approval. Merge only after explicit approval for the current head SHA and successful required checks. Follow the plan for evidence and GitHub account constraints. +- Update `V3_0_0_PLAN.md` at scope, ownership, dependency, review, validation, and integration checkpoints. +- Keep coordinator exchanges and decisions in Git-managed Markdown under `docs/coordination/3.0.0/`. Record proposals, responses, disagreements, rationale, outcomes, and references; do not rely on ephemeral terminal messages alone. Distinguish pending proposals from bilateral agreement. Codex serializes shared plan/log integration to avoid concurrent edits. +- Use `rtk` as the prefix for shell commands (`rtk proxy` for commands without a wrapper). + +## Language and Kotlin Migration + +- Communicate with the user in Japanese. Write PR titles and bodies in English, including release PRs. +- Write source comments, JavaDoc, and KDoc in English. Keep new or changed comments in build scripts and configuration files in English as well. +- Planning and coordination logs may use Japanese for later review by the user. +- Replace Java with Kotlin where it improves maintainability as part of the planned work. Coordinators agree on migration boundaries and record the rationale; do not mechanically convert the entire repository. +- Separate mechanical conversion from behavior changes where practical. Preserve or explicitly document Java-callable API changes, nullability, JVM signatures, and 2.x migration requirements. Validate both Java and Kotlin consumers for converted public APIs. + +## Project Structure & Module Organization + +- `core/`: overlay APIs, permission handling, and internal window/lifecycle management. +- `lint/`: Java library containing custom Android lint detectors and their tests. +- `sample/`: Android demo app; layouts are in `src/main/res/`, and displayed code examples are in `src/main/assets/`. + +Java and Kotlin sources live under each module's `src/main/java/` or `src/main/kotlin/`. Local tests use `src/test/java/` or `src/test/kotlin/`; device tests use `src/androidTest/java/` in `core` and `sample`. Documentation animations are in `images/anime/`. + +## Build, Test, and Development Commands + +Use JDK 17, Android SDK 36 (Build Tools 36.0.0), and the checked-in Gradle wrapper (Gradle 9.4.1). The Android modules use AGP 9.2.1 with built-in Kotlin 2.2.10 and support API 23 or later. Configure your SDK through `ANDROID_HOME` or an untracked `local.properties`. + +- `./gradlew :core:assembleDebug :sample:assembleDebug`: build the library and the demo APK. +- `./gradlew :core:testDebugUnitTest :lint:test :sample:testDebugUnitTest`: run local tests. +- `./gradlew :core:lintDebug :sample:lintDebug`: run Android lint checks. +- `./gradlew :core:connectedDebugAndroidTest :sample:connectedDebugAndroidTest`: run instrumentation tests on a connected device or emulator. +- `./gradlew :sample:installDebug`: install the demo; launch it from the device and grant overlay permission when prompted. + +## Coding Style & Naming Conventions + +Match existing Java style: four-space indentation, same-line opening braces, `UpperCamelCase` classes, `lowerCamelCase` methods and fields, and `UPPER_SNAKE_CASE` constants. Keep packages under `com.nagopy.android.overlayviewmanager`. Use `snake_case` resource names and the `overlayviewmanager_` prefix for core resources. Preserve public API JavaDocs and nullability annotations. No dedicated formatter is configured; keep formatting consistent with surrounding code. + +## Testing Guidelines + +Local tests use JUnit 4, Mockito, and Robolectric; lint tests use Android lint's testing infrastructure. Device tests use AndroidX Test, Espresso, and UI Automator. Name classes `*Test` and use descriptive methods such as `show_isVisibleFalse_isDraggableFalse`. Add regression tests for behavior changes, especially permission, lifecycle, and overlay interactions. Core debug coverage is enabled, but no minimum percentage is configured. + +Choose validation for the affected behavior and modules, and complete all mandatory task and release checks. For documentation-only edits, check content, references, and diffs; do not run Gradle unless a required gate calls for it. Avoid tests that only repeat the implementation. Once checks pass, repeat or broaden them only for new changes, failures, or unresolved concerns. Report unexecuted checks as unverified; these limits do not waive release-blocking device validation in `V3_0_0_PLAN.md`. + +## Commit & Pull Request Guidelines + +Recent commits use short imperative subjects, such as `Update JavaDocs` and `Remove redundant timber dependency in tests`. Follow that style and keep commits focused. In pull requests, describe the problem, affected modules, and validation performed; link relevant issues. Include screenshots or recordings for visible sample or overlay changes. Update usage documentation when public APIs change. + +## 3.0.0 Resource Allocation (updated 2026-09-13) + +Preserve the agreed larger Claude Code share because Codex usage is constrained. Under the user's 2026-09-13 instruction, both coordinators work directly without starting subagents by default. If the user explicitly requests delegated work, prefer Claude Code / Sonnet 5 within the agreed ownership. Codex coordinates ownership, performs focused approval synthesis, and serializes integration. If Claude cannot run a required local check, Codex may execute the supplied minimal commands directly. Approval by the opposite coordinator for the current head SHA and successful CI remain required before merging. Record handoffs and decisions in V3_0_0_PLAN.md and docs/coordination/3.0.0/. + +## Claude permission prompts + +The user explicitly authorizes the Codex coordinator to inspect Claude permission prompts and approve appropriate in-scope actions on the user's behalf. Inspect the complete command, target, and effects before approving. This supersedes the earlier convention of always waiting for the user; it does not authorize unrelated or destructive actions or bypass reciprocal PR approval. Record delegated approvals in the coordination log. diff --git a/CHANGELOG.md b/CHANGELOG.md index a0583a0..fa344df 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,17 @@ # Change Log +## 3.0.0 (Unreleased) + +- Introduce immutable `OverlaySpec` configuration, Java builders and Kotlin copy-based updates, and synchronous `OverlayResult` outcomes with classified failures. +- Define Activity/application ownership and explicit transactional disposal. Activity destruction releases owned references; application owners retain failed-disposal handles for retry. +- Replace overlay fluent configuration, visibility getters and library-owned permission dialogs with the new state/spec API and host-owned permission flow. See the [2.x migration guide](docs/migration/2.x-to-3.0.md). +- Remove the 2.x methods outright instead of deprecating them: the `OverlayView` setters, the `OverlayViewManager` permission and display-size helpers, `PermissionRequestDialogFragment` with its strings, and the public `DraggableOnTouchListener`. `core` no longer depends on AndroidX Fragment, and `OverlayView` handles can be created only through `OverlayViewManager`. +- Rework window geometry, drag handling and managed pass-through opacity admission. A drag normalizes the spec to top-left offsets without margins; with `allowOutsideBounds` it keeps the gravity and margins. `START` and `END` now resolve correctly on the first show in an RTL configuration. +- Remove the optional Timber integration: the `overlayviewmanager-opt-timber` artifact and `DebugOverlayTree` have no replacement. With one published artifact, the JitPack dependency becomes `com.github.75py:Android-OverlayViewManager`. +- Raise minimum Android support to API 23 and modernize the build to JDK 17, SDK 36, Gradle 9.4.1 and AGP 9.2.1 with built-in Kotlin. +- Retarget the bundled lint check to `OverlaySpec.Builder.setAllowOutsideBounds` and rename its issue id from `ALLOW_VIEW_TO_EXTEND_OUTSIDE_SCREEN` to `ALLOW_OUTSIDE_BOUNDS`. +- Update CI and Java/Kotlin regression coverage, add device tests for drag geometry, cross-UID pass-through and permission flows, and add `jitpack.yml` for JDK 17 builds. + ## [1.1.0](https://github.com/75py/Android-OverlayViewManager/tree/1.1.0) (2018-01-10) [Full Changelog](https://github.com/75py/Android-OverlayViewManager/compare/1.0.0...1.1.0) diff --git a/README.md b/README.md index 117e1a2..922d59b 100644 --- a/README.md +++ b/README.md @@ -1,175 +1,159 @@ -# OverlayViewManager [![](https://jitpack.io/v/75py/Android-OverlayViewManager.svg)](https://jitpack.io/#75py/Android-OverlayViewManager) [![codebeat badge](https://codebeat.co/badges/41006b87-ccb5-4eba-bfc5-57b35cf8335f)](https://codebeat.co/projects/github-com-75py-android-overlayviewmanager-master) +# OverlayViewManager -OverlayViewManager is a lightweight Android library that allows you to overlay views on top of other apps, providing a simple interface to manage and customize these overlays. This library is particularly useful for creating floating widgets or overlays that need to be displayed across the entire system, regardless of the activity or app in the foreground. +OverlayViewManager manages Android overlay views with explicit configuration, synchronous operation results, and Activity or application ownership. Java and Kotlin callers use the same API. -Try out [the sample application on Google Play](https://play.google.com/store/apps/details?id=com.nagopy.android.overlayviewmanager.sample). +This branch documents **3.0.0 (unreleased)**. For an existing 2.x application, start with the [migration guide](docs/migration/2.x-to-3.0.md). It has not been published yet, so do not assume a 3.0.0 artifact is available. -## Features +## Requirements and installation -- **Easy to Use**: Simple API to create and manage overlay views. -- **Customizable**: Supports various customization options like touchable, draggable, and view positioning. -- **Lifecycle Management**: Manages the overlay view lifecycle based on activity or application context. -- **Permission Handling**: Provides methods to check and request overlay permissions. +The library supports Android API 23 and later. This repository builds with JDK 17, Gradle 9.4.1, AGP 9.2.1, and Android SDK 36. Its Android modules use AGP's built-in Kotlin support. -## Installation +Add JitPack to your dependency repositories, then use an available release or commit version: - -Latest version: [![](https://jitpack.io/v/75py/Android-OverlayViewManager.svg)](https://jitpack.io/#75py/Android-OverlayViewManager) - -Step 1. Add the JitPack repository to your build file ```groovy - dependencyResolutionManagement { - repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS) - repositories { - mavenCentral() - maven { url 'https://jitpack.io' } - } - } +dependencyResolutionManagement { + repositories { + google() + mavenCentral() + maven { url 'https://jitpack.io' } + } +} ``` -Step 2. Add the dependency ```groovy dependencies { - implementation 'com.github.75py.Android-OverlayViewManager:overlayviewmanager:{version}' + implementation 'com.github.75py:Android-OverlayViewManager:' } ``` -## Usage +The JitPack build of this coordinate can only be checked once a 3.0.0 tag exists. See the [sample project](sample/) for source dependencies during development. -### Initialization +## Initialize once per process -Initialize the `OverlayViewManager` in your `Application` class: +Call `OverlayViewManager.init()` from your manifest-registered `Application.onCreate()` on the main thread. Repeating it with the same Application is harmless; using a different Application in the same process throws. ```java -public class MyApplication extends Application { - @Override - public void onCreate() { +public final class MyApplication extends android.app.Application { + @Override public void onCreate() { super.onCreate(); OverlayViewManager.init(this); } } ``` -### Creating an Overlay View +## Choose an owner -To create an overlay view, use the `OverlayViewManager` to get an instance of `OverlayView`: +| Scope | Factory | Lifetime and permission | +| --- | --- | --- | +| Activity | `newOverlayView(view, activity, spec)` | Attached to the Activity window; no draw-over-other-apps permission. Explicitly dispose when finished. Activity destruction is a cleanup safety net. | +| Application | `newOverlayView(view, spec)` | Can appear above other apps while permitted. Keep a process- or service-owned handle and dispose it explicitly. The library does not start a service or keep the process alive. | -```java -OverlayViewManager overlayViewManager = OverlayViewManager.getInstance(); -TextView overlayTextView = new TextView(this); -overlayTextView.setText("Hello, World!"); +Create each managed View without an existing parent. For an application overlay, use an application/service context rather than retaining an Activity through its View. -OverlayView overlayView = overlayViewManager.newOverlayView(overlayTextView); -``` +## Activity overlay in Kotlin -### Displaying the Overlay View +In an Activity, keep the handle as a field. `OverlaySpec` is immutable; use Kotlin defaults and `copy()` for updates. -To display the overlay view, call the `show` method: +```kotlin +private var overlay: OverlayView? = null -```java -overlayView.show(); -``` +private fun showMessage() { + val handle = overlay ?: OverlayViewManager.getInstance().newOverlayView( + TextView(this).apply { text = "Drag me" }, + this, + OverlaySpec(touchMode = OverlayTouchMode.DRAGGABLE, x = 24, y = 48), + ).also { overlay = it } + handle.view.setOnClickListener { + Toast.makeText(this, "Overlay clicked", Toast.LENGTH_SHORT).show() + } + report(handle.show()) +} -### Hiding the Overlay View +private fun moveMessage() { + val handle = overlay ?: return + report(handle.update(handle.spec.copy(x = 80, y = 120))) +} -To hide the overlay view, call the `hide` method: +private fun closeMessage() { + val handle = overlay ?: return + val result = handle.dispose() + report(result) + if (result.isSuccess) overlay = null +} -```java -overlayView.hide(); +private fun report(result: OverlayResult) { + if (!result.isSuccess) Log.w("Overlay", "Operation failed: ${result.failure}", result.cause) +} + +override fun onDestroy() { + closeMessage() + super.onDestroy() +} ``` - +These members belong to an Activity; imports are Android `TextView`, `Toast`, `Log` and the library types. A failed explicit disposal retains the handle for a retry while the owner is alive. When an Activity is destroyed, the library makes one final removal attempt and releases its Activity-owned references even if removal fails. This safety net is different from retryable explicit disposal. -### Customizing the Overlay View +## Java configuration and results -You can customize various properties of the overlay view, such as its position, size, and touch behavior: +Java callers use `OverlaySpec.Builder` and `toBuilder()`. In the owner of an existing handle: ```java -overlayView - .setWidth(ViewGroup.LayoutParams.WRAP_CONTENT) - .setHeight(ViewGroup.LayoutParams.WRAP_CONTENT) - .setTouchable(true) - .setDraggable(true) - .setGravity(Gravity.TOP | Gravity.START) - .setX(100) - .setY(100) - .setAlpha(0.8f); +OverlaySpec next = overlay.getSpec().toBuilder() + .setTouchMode(OverlayTouchMode.INTERACTIVE) + .setAlpha(0.8f) + .setX(80) + .setY(120) + .build(); +OverlayResult result = overlay.update(next); +if (!result.isSuccess()) { + Log.w("Overlay", "Update failed: " + result.getFailure(), result.getCause()); +} ``` - +`show()`, `update(spec)`, `hide()` and `dispose()` return `OverlayResult`; they no longer form a fluent chain. Inspect `isSuccess`, `failure`, `state` and `changed`. `ATTACHED` reports the handle's attachment state, not a guarantee that Android or another window is letting the user see it. Invalid arguments and off-main-thread use are programming errors and can still throw. - +`hide()` allows later reuse. Successful `dispose()` releases the View; do not read `view` or call `show()` afterward. Keep the sole application-overlay handle when disposal fails, so a host action can retry. See the [application ownership example](docs/migration/2.x-to-3.0.md#application-overlay-and-permission-return). - +## Permission belongs to the host -### Handling Permissions +Application overlays require the manifest declaration: -To check if the app has overlay permissions, use the `canDrawOverlays` method: - -```java -if (!overlayViewManager.canDrawOverlays()) { - // Request permission - overlayViewManager.requestOverlayPermission(); -} +```xml + ``` -To show a permission request dialog: +Use `OverlayPermission.isGranted(context)` before a user-requested show. Launch `settingsIntent(context)` through the host's Activity Result launcher, then query `isGranted` again on return; the result code alone is not permission evidence. Remember whether the user requested a show, consume that request once, and never reopen Settings or retry automatically on denial. The library does not launch permission UI. The [migration guide](docs/migration/2.x-to-3.0.md#application-overlay-and-permission-return) shows the full flow. -```java -overlayViewManager.showPermissionRequestDialog(getSupportFragmentManager(), R.string.app_name); -``` +A grant can be revoked after the check. Always inspect the subsequent operation result. Activity overlays do not need this permission flow. -## Example +## Touch, positioning, and brightness -Here is a complete example of how to use the `OverlayViewManager`: +- `PASS_THROUGH` does not receive touches; `INTERACTIVE` receives View interactions; `DRAGGABLE` adds library drag handling. Install click listeners on the managed View. +- `CrossUidPassThrough.SAME_UID_ONLY` is the default. Opt into `WHEN_SYSTEM_ALLOWS` only when passing touches to another app is required. Android's opacity and window policies can reject this with `PASS_THROUGH_OPACITY_EXCEEDED` or `PASS_THROUGH_UNSUPPORTED`; the library cannot guarantee another app receives the touch. `SAME_UID_ONLY` does not isolate touches by UID; Android decides. For a pass-through application overlay above the maximum obscuring opacity (0.8 by default), the outcome depends on whether the build includes the window manager's opacity clamp. A build with the clamp lowers the overlay to that value and passes the touch through, and a build without it keeps the overlay opaque and blocks the touch. For example, the API 36 emulator image has the clamp, while the API 31 emulator images, including the initial Android 12 release, do not. Overlapping overlays can exceed the combined limit either way. +- Geometry uses the owning window's bounds and insets. Obtain slider limits from the host window, with a compatible fallback on older supported APIs. `allowOutsideBounds` relaxes normal bounds handling; it does not guarantee placement over system bars or other restricted areas. A drag normalizes `spec` to top-left offsets without margins; with `allowOutsideBounds` it keeps the gravity and margins and only changes `x` and `y`. +- `screenBrightness` is an optional Activity-scope setting. Supplying it to an application overlay is an argument error. -```java -public class MainActivity extends AppCompatActivity { - - @Override - protected void onCreate(Bundle savedInstanceState) { - super.onCreate(savedInstanceState); - - // Initialize OverlayViewManager - OverlayViewManager.init(getApplication()); - - // Create a new overlay view - TextView overlayTextView = new TextView(this); - overlayTextView.setText("Hello, Overlay!"); - - OverlayView overlayView = OverlayViewManager.getInstance().newOverlayView(overlayTextView); - - // Set properties - overlayView - .setWidth(ViewGroup.LayoutParams.WRAP_CONTENT) - .setHeight(ViewGroup.LayoutParams.WRAP_CONTENT) - .setTouchable(true) - .setDraggable(true) - .setGravity(Gravity.TOP | Gravity.START) - .setX(100) - .setY(100) - .setAlpha(0.8f); - - // Show the overlay view - overlayView.show(); - } -} -``` +Factories, operations, and `view`/`spec` access belong on the main thread. Only `state` and `lastFailure` are thread-safe handle reads. `OverlayPermission` is immutable and thread-safe. -## License +## Development and limits -``` -Copyright 2017 75py +See [the 3.0.0 migration guide](docs/migration/2.x-to-3.0.md) and these sample sources: -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at +- [Kotlin Activity overlay](sample/src/main/kotlin/com/nagopy/android/overlayviewmanager/sample/Sample1Activity.kt). +- [Java permission recheck](sample/src/main/java/com/nagopy/android/overlayviewmanager/sample/SampleStartActivity.java), without automatic showing on return. +- [Java application overlay owner](sample/src/main/java/com/nagopy/android/overlayviewmanager/sample/Sample2OverlayController.java) and [Service/retry UI](sample/src/main/java/com/nagopy/android/overlayviewmanager/sample/Sample2Activity.java). +- [Java spec updates and host-window bounds](sample/src/main/java/com/nagopy/android/overlayviewmanager/sample/SampleAllOptionsActivity.java). - http://www.apache.org/licenses/LICENSE-2.0 + The library does not provide background execution, a foreground service, notifications, or automatic permission recovery. The host owns those responsibilities for long-running application overlays. OS and device window policies still apply. -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. -``` +Device tests ran on emulators at API 23, 26, 31, 35 and 36. Results and the exact builds are recorded in [V3_0_0_PLAN.md](V3_0_0_PLAN.md). + +Known limits: + +- With `allowOutsideBounds`, fill gravity changes the window's size during a drag instead of moving it. +- A layout direction declared in XML cannot be read before the first measure. If it differs from the configuration, an overlay using `START` or `END` can appear on the estimated side until its first layout. +- The bundled lint check inspects `OverlaySpec.Builder.setAllowOutsideBounds` only, not Kotlin constructor or `copy` arguments. + +## License + +Copyright 2017 75py. Licensed under the [Apache License, Version 2.0](LICENSE). diff --git a/V3_0_0_PLAN.md b/V3_0_0_PLAN.md new file mode 100644 index 0000000..2ef95dc --- /dev/null +++ b/V3_0_0_PLAN.md @@ -0,0 +1,647 @@ +# OverlayViewManager 3.0.0 作業計画・エージェント指示 + +作成日: 2026-09-11 + +## 現在の状態と今回の作業範囲 + +- 2026-11-01最新依頼: C1〜C4のユーザー判断を確定。C1はdata class維持・デフォルト付き末尾追加・Kotlin constructor/copyとJava Builderのソース互換維持・中間ライブラリのconstructor/copyのminor間バイナリ互換非保証、JavaはBuilder。C2はRestrictTo/internalパッケージ慣習の現状維持、C3は3.0導入せず3.1着手前へ、C4は記録類をmainに維持。CodexがKDoc/文書/検証/統合、Claudeが対向レビューを担当。基点c1eafebの修正済みコアでAPI23/26は各26件、API35は31件のsample connected試験が成功（各failure/error/skip0、専用AVD、物理実機未検証）。指定Gradle全タスクと161 unit testsも成功。製品/テスト変更なし。最終headの対向承認・CI・統合SHAはPR66コメントで追跡する。詳細は[ユーザー決定と追加検証](docs/coordination/3.0.0/2026-11-01-review-fixes.md#c1c4のユーザー決定と追加端末検証)。 + +- 2026-11-01追加依頼: PR66レビューの削除中再入・drag alpha・A1〜A5・BはPR70/71で修正・検証し、相互承認とCI成功後に `4b9b2a7` へ統合済み。161 unit tests、API36 sample31件、build/lint/publish/consumer成功。coreと設計書をClaude、CI・移行文書・計画/ログ・検証/統合をCodexが所有する。この時点のC1〜C4推奨案は、上記の後続ユーザー決定で確定した。全PRのbaseはrelease/3.0.0。最新の経過は[レビュー対応記録](docs/coordination/3.0.0/2026-11-01-review-fixes.md)。 + +- Timber削除統合時点の状態: **2026-11-01 JST: [PR68](https://github.com/75py/Android-OverlayViewManager/pull/68)（Timber連携の削除）を対向承認・CI成功後に `8794018` へ統合済み**。`work/3.0.0` も同SHAへfast-forwardして同期した。文書追記後を含む最新のrelease head、CI、SHA付き対向確認は [PR66](https://github.com/75py/Android-OverlayViewManager/pull/66) で追跡する。Timber削除時点の候補は134 unit tests（core 118、lint 12、sample 4）、配布はcoreのみ。Debug/Release、lint、core単体のJava/Kotlin/R8 consumerが成功し、sample全31件をAPI36で再検証した。API23/26/35は2026-10-31の検証結果を維持し、今回は再実行していない。JitPackサービス上の確認はタグ後。mainマージ・タグ・正式配布は未実施で今回の範囲外。詳細は[Timber削除の記録](docs/coordination/3.0.0/2026-11-01-remove-timber.md)。 +- 2026-10-31時点の状態: main向けリリースPR作成まで完了。PR65の修正とPR63の最終検証記録を対向承認・CI成功後に統合し、`395f2ff10109068451611a7f3573eb75b2fa923c` から `release/3.0.0` を作成、[Release 3.0.0 PR #66](https://github.com/75py/Android-OverlayViewManager/pull/66) をmain向けに作成した。必須API23/26/35/36、183 unit tests、Debug/Release、lint、独立Java/Kotlin/R8 consumer成功。追加API31のfreeform2件はhost入力非表示による未検証として記録。mainマージ・タグ・正式配布は未実施で今回の範囲外。詳細は[最終検証記録](docs/coordination/3.0.0/2026-10-31-release-validation.md)。 +- 作業・統合ブランチ: `work/3.0.0`。 +- 分岐元: ローカル `main` の `c71f7fb950ee2a4ce6cba00be82d1b6e02226789`。作成時のローカル `origin/main` も同一。2026-09-12 JSTのfetchでもorigin/mainは同一。 +- 準備文書・共有設定を1646b3bへコミット済み。ユーザーの開始指示を受け、同コミットをorigin/work/3.0.0へ初回pushした。以降の変更は個別PRと相互承認を経由する。 +- **開始指示受領済み**: 「あなたはcodex側の司令塔として、claudeと一緒に作業を開始してください」。準備中の停止条件を解除し、本書の分担合意・相互承認・検証条件に従って進める。 +- `release/3.0.0` は最終統合・検証後の `395f2ff` から作成済み。main向けPRは #66。以後の変更はrelease向けタスクPRと対向承認を経由する。 +- `AGENTS.md`、この計画書、`docs/coordination/3.0.0/` の記録、共有用 `.serena/project.yml` と `.serena/.gitignore` をGit管理する。Serenaのcacheとproject.local.ymlはコミットしない。 + +停止時点の履歴: [2026-09-13-pause.md](docs/coordination/3.0.0/2026-09-13-pause.md)。現在の再開・担当判断: [2026-09-13-coordinator-resume.md](docs/coordination/3.0.0/2026-09-13-coordinator-resume.md)。 + +## 目的・到達点 + +ライブラリを3.0.0として大幅に更新し、表示の信頼性、Android互換性、公開API、テスト、配布と利用ドキュメントを整える。破壊的変更は3.0.0として許容するが、必要性・移行方法を記録する。 + +最終到達点は、検証済みの `release/3.0.0` を作成し、`main` をbaseにしたリリースPRを作成すること。mainへの最終マージ、タグ作成、配布先への公開はこの計画の完了条件に含めない。 + +## 司令塔・サブエージェントの作業規約 + +### 固定する司令塔 + +| 司令塔 | モデル | effort | 責務 | +| --- | --- | --- | --- | +| Codex | Astra (`gpt-6-astra`) | medium | Claudeとの設計・分担合意、担当範囲の直接作業・検証、成果物統合、Claude側PRのレビューと承認 | +| Claude | Fable 5.1 | high | Codexとの設計・分担合意、担当範囲の直接作業・検証、成果物統合、Codex側PRのレビューと承認 | + +- 開始時に実際のモデル・effortを確認する。Claudeの正確なCLIモデル識別子は利用環境で確認し、推測で指定しない。指定モデルが利用できなければ、その問題を報告し、無断で代替モデルに変更しない。 +- 2026-09-13更新のリポジトリAGENTS.mdに従い、既存の両司令塔が担当範囲の調査・実装・検証と対向レビューを直接行う。従来の必須サブエージェント規約と過去ログの起動案は既定の手順として使用しない。ユーザーが対象作業で明示要求した場合だけ委譲する。 +- サブエージェントのモデル・effortは各司令塔がタスクに応じて判断し、**Luna (`gpt-5.6-luna`)、Terra (`gpt-5.6-terra`)、Sonnet 5**から選ぶ。以前のサブエージェント選択方針よりこの指定を優先する。GPT-5.5やHaikuは原則使用しない。許可されたモデルが使えない場合も無断で別モデルに置き換えない。Sonnet 5のCLI識別子も起動時に確認する。 +- 両側ともモデル・effort・役割・選択理由をタスク記録へ残す。司令塔のモデル指定とサブエージェントのモデル指定を混同しない。 +- サブエージェントの成果報告だけで自動承認しない。相手の司令塔が指摘・検証根拠を確認し、承認判断を行う。 +- この指示書とユーザーの最新指示を両司令塔・担当サブエージェントに渡す。作業途中のユーザーによる変更指示も共有する。 + +### 連絡・作業場所・競合防止 + +- Orcaの `orca-cli` / `orchestration` スキルを開始時に読み、実環境のガイドに従って調整する。司令塔同士の相談・質問・合意・担当と完了状態をOrca orchestrationへ記録し、**やり取りと判断結果を `docs/coordination/3.0.0/` のMarkdownにも残してGit管理する**。記録方法とテンプレートは同ディレクトリのREADMEを参照する。 +- Run、Task、Dispatch、端末、子worktreeは実行時の実在するIDのみ記録する。 +- 各編集担当は独立したOrca worktree・ブランチを使い、同じcheckoutを複数エージェントで編集しない。 +- 各タスクの開始前に、目的、対象ファイル、編集禁止範囲、依存タスク、受け入れ条件、担当とレビュー担当を双方で合意する。 +- 同じファイル、公開API、ビルド設定、バージョン定義、計画書の同時変更は避ける。重なる場合は所有者を一人にし、依存タスクとして順序を付ける。 +- Gradle・SDK・エミュレータなど共有資源を変更する作業は調整する。特に依存更新と他担当の基準検証を同時に行わない。 +- 担当変更・API変更・新たな不具合・検証失敗・競合を検知したら、影響する作業を止め、両司令塔で範囲と次の手順を決める。無関係な独立作業は継続できる。 +- 計画書と統合ブランチの更新・マージ操作はCodex司令塔が直列化する。技術判断と最終的な担当配分は両司令塔の合意を必要とする。 +- 連絡や完了確認が途絶えても、同じ編集タスクを重複起動しない。実行状態を確認し、Orcaの復旧手順に従う。 + +### 言語・計画更新・判断記録 + +- ユーザーとのやりとりは日本語。PRタイトル・本文は個別PRとリリースPRを含め英語。ソースコードのコメント、JavaDoc、KDocも英語にする。 +- 計画と判断ログは振り返り用に日本語で記録してよい。議論の双方の発言要旨・異論・判断根拠・結論を残し、単なる完了一覧にしない。 +- タスク着手・担当変更・設計変更・レビュー・検証・統合の節目で、この計画書の台帳と関連ログを更新する。詳細ログを参照しつつ、台帳を現在の状態へ保つ。 +- ログには時刻・発言者・Task ID・Orcaメッセージ参照・PR/head SHAを実在する範囲で記録する。未相談・未回答・未承認を合意済みと書かない。 +- 合意後は依存する作業への引き渡し前に記録を作る。ログ・計画の更新も関連PRまたは文書PRでGitへ保存し、実装開始後は相互承認規約を適用する。 + +### PRと相互承認 + +1. 担当サブエージェントが自己レビューと変更に見合うコンパイル・テストを行い、担当司令塔へ報告する。 +2. 担当側がタスクブランチから `work/3.0.0` へのPRを作成する。本文にタスクID、変更理由、破壊的変更、検証結果、未解決事項を記載する。 +3. **Codex側のPRはClaude司令塔が、Claude側のPRはCodex司令塔がレビューする。** 相手側の独立サブエージェントによるレビューを使い、相手司令塔が結論を出す。 +4. 指摘は実装担当へ戻す。修正後は対象箇所・影響範囲を再確認する。 +5. **相手司令塔の明示的なAPPROVE、必要チェック成功、未解決の必須指摘なし**を満たしたPRだけマージする。自分側のレビュー、沈黙、タイムアウトを相手の承認とみなさない。 +6. 承認はPR番号とhead commit SHAへ紐付ける。承認後にコード変更、競合解消、rebase等でheadが変われば、相手が差分を再確認して承認を更新する。 +7. マージ直前にhead SHA、base、チェック、承認を再確認する。相手の変更を無断で上書きせず、競合解消結果もレビュー対象とする。 +8. マージ後は関連タスクの状態と統合SHAを記録し、後続ブランチへ取り込む。新しい変更・失敗・懸念がなければ同じ検証を無目的に繰り返さない。 + +GitHubのレビュー権限・認証アカウントは開始時に確認する。同一GitHubアカウントでPR作者のself-approvalができない場合も、相手の承認を偽装しない。相手司令塔が実行者・PR番号・head SHA・根拠を記した明示的なAPPROVEコメントを残し、エージェント間承認の証跡とする。GitHubのrequired reviewを満たせない場合、そのコメントで保護ルールを迂回せず、必要な権限・レビュアーの問題として報告する。 + +## ブランチ運用 + +```text +main + └─ work/3.0.0 # 今回作成した統合先 + ├─ codex/3.0.0/ # 個別PR → work/3.0.0 + ├─ claude/3.0.0/ # 個別PR → work/3.0.0 + └─ release/3.0.0 # 統合完了後に分岐 → mainへのPR +``` + +- 個別タスクは合意済みの最新 `work/3.0.0` から分岐する。独立していない変更だけ明示的な依存ブランチを使う。 +- 統合先へ実装を直接pushせず、変更は個別PRと相互承認を経由する。 +- 開始時のブランチ初回pushには、ユーザー許可済みの準備用文書・共有設定コミットを含めてよい。今回の準備ではpushせず、実装変更を混ぜない。 +- release分岐後の修正は `fix/3.0.0/` 等から `release/3.0.0` へのPRで行い、同じ承認規約を適用する。`work/3.0.0` への反映要否も記録する。 +- タスクID、担当、状態、PR、承認SHAを以下の台帳へ記録する。初期担当は提案であり、開始前に両司令塔が確定する。 + +## 前回レビューの基準値 + +2026-09-11、変更前の `c71f7fb` をJDK 17、Gradle 8.9、Android SDK 34で検証。 + +| 検証 | 結果 | +| --- | --- | +| core / opt-timber / sample Debugビルド | 成功 | +| ローカルテスト | 89件成功（core 69、opt-timber 15、lint 4、sample 1） | +| core lint | エラー0、警告9 | +| sample lint | エラー2、警告124 | +| 実機・エミュレータ試験 | 未実施 | + +sampleのエラーは `SampleAllOptionsActivity` と `SampleOverrideScreenBrightnessActivity` のData Binding内部向け `OnProgressChanged` 利用による `RestrictedApi`。 + +表示状態、並行処理、Androidのタッチ制限などの所見はコード・仕様による確認であり、全てが端末で再現済みではない。Activity保持のリーク懸念は未確定。修正タスクでは再現・根拠を確認してから変更する。 + +## 作業リスト・依存関係 + +状態は `未着手 → 合意済み → 作業中 → 相互レビュー中 → 統合済み` とする。検証不能・判断待ちは理由と担当を記録し、完了扱いにしない。 + +| ID | 作業 | 担当（未合意は案） | 依存 | 状態 | +| --- | --- | --- | --- | --- | +| T00 | 司令塔起動・作業体制と担当の合意 | 両司令塔 | 開始指示 | 統合済み（PR #21、追記あり） | +| T01 | 3.0 API・互換性・ライフサイクル設計 | Codex主担当、Claude協議 | T00 | 統合済み | +| T02 | CI導入・既存lintエラー解消 | Claude | T00 | 統合済み | +| T03 | ビルド・依存・SDKの更新 | Codex（Claudeから残修正を移管） | T01, T02 | 統合済み | +| T04 | 表示状態とスレッド処理の修正（T04a〜cの集約行） | Codex | T01, T03 | 統合済み（T04a〜c） | +| T04a | 不変設定・結果・状態型の追加 | Codex | T01, T03 | 統合済み（補足PR36も統合） | +| T04b | 同期表示状態機械の段階移行 | Codex | T04a | 統合済み（PR40、3e960b8） | +| T04c | 一時互換APIの最終除去 | Claude実装・Codex対向承認（実際はDevin実装・Claudeレビュー） | T07, T10 | 統合済み: PR61 2c256a8（Devin再実装、旧Claude worktreeの7d5af7b/WIPは不採用）、JVM可視性の追補PR62 208588f。両PRともCI成功。PR62はCodex承認なし・ユーザー許可でマージ | +| T05 | 監視・座標・権限境界の見直し | Claude（T05aテスト修正のみCodexが直接実施） | T04b | 実装統合済み。必須matrixの権限・実座標検証成功、追加修正PR65を497a5e2へ統合済み | +| T06 | タッチ透過・ドラッグの互換性改善 | Claude | T05b実装統合 | 実装統合済み。別UIDはPR64で検証/統合、最終drag/freeformはAPI35/36成功。PR65を497a5e2へ統合済み | +| T07 | Timber連携の安全性改善 | Claude | T01 | 段階1〜3統合済み（PR37）。寿命L1〜L7はPR54 head `c13acee`、40 tests成功・lintエラー0/警告2・3 module build成功。最終相互承認・CI成功後6c9e2aaへ統合済み。2026-11-01: ユーザー判断でTimber連携自体を削除（PR68、`8794018` へ統合済み） | +| T08 | 初期化・Activity寿命・リソース解放 | Claude | T05, T06実装統合 | 統合済み（PR51 d6ccdf2、111 tests成功） | +| T09 | カスタムlintの修正・配布 | Claude | T03, T06 | 統合済み（T09a PR42 65c7e95、stage 2はPR61 2c256a8）。Kotlinの`OverlaySpec(allowOutsideBounds = true)`/`copy`は未検出で、移行ガイドに既知の制限として記載 | +| T10 | sample・README・3.0移行ガイド | Claude: sample / Codex: docs、相互レビュー | T07寿命統合、T08、T09 stage 1 | 完了: PR57 c298798 / PR56 9708061へ統合。現SHA対向承認・CI成功、API36端末3件・HTML表示・リンク確認済み | +| T11 | 3.0.0バージョン・成果物の整備 | Claude実装、Codex最終検証 | T10, T04c | 完了: 3.0.0/id10、AAR/POM/sources/consumer rules/lint.jar、独立Java/Kotlin/R8 consumer成功。JitPackサービス上のビルドはユーザー判断に従いタグ作成後。2026-11-01: 配布をcoreのみとし、導入座標を `com.github.75py:Android-OverlayViewManager` へ変更、core単体consumer成功（PR68、`8794018` へ統合済み） | +| T12 | 統合検証・端末試験・最終相互レビュー | 両司令塔 | T11 | 完了: PR65/63の対向承認・CI成功を確認し395f2ffへ統合。183 unit tests、必須端末matrix成功。追加API31 freeform2件は前提不成立の未検証（詳細記録参照）。2026-11-01: Timber削除後の候補で134 unit tests、API36 sample全31件成功。API23/26/35は10/31の結果を維持（PR68、`8794018` へ統合済み） | +| T13 | release/3.0.0作成・mainへのPR | Codex、Claude確認 | T12 | 完了: 395f2ffからrelease/3.0.0を作成しmain向けPR66を作成。mainマージ・タグ・配布は未実施・対象外 | + +T02とT01、T04とT07などは編集範囲が独立する場合に並列実行する。T03中のビルド検証や、T04〜T06・T08の同一coreファイル変更は直列化する。大きいタスクはファイル所有範囲が明確な小PRへ分割してよい。 + +### T00: 起動・合意 + +- [x] 両司令塔のモデル・effort、Orca連絡経路、GitHub権限とレビュー証跡の方式を確認する。 +- [x] main/originの状態と準備用計画書を確認し、`work/3.0.0` を共有する。 +- [x] 各司令塔が担当サブエージェントを起動する。Task/Dispatch、worktree、ブランチ、モデル・effortを記録する。 +- [x] 各タスクの担当・レビュー担当・ファイル所有者・受け入れ条件を確定する。 + +受け入れ条件: 両司令塔の合意が記録され、担当が重複せず、相手が実際にレビュー可能。 + +### T01: 3.0の設計 + +以下のチェックは設計判断と移行範囲の合意を示す。各機能の実装完了はT04以降で管理する。 + +- [x] Activity内表示と他アプリ上の表示の責務・権限・公開APIを区別する。 +- [x] 公開APIのスレッド契約、表示要求と実際のattachment、失敗通知、再試行、hide/disposeの意味を決める。 +- [x] initの複数回呼び出し、Activity破棄・再生成、呼び出し側の所有・終了責任を決める。 +- [x] minSdk、compileSdk/targetSdk、JDK/Gradle/AGP、検証OS、Java/Kotlin利用互換性を合意する。バージョンは開始時の公式情報で確認する。 +- [x] 保守性改善に合わせて適宜JavaをKotlinへ置き換える。両司令塔が対象・理由・所有者を合意し、各関連タスクに移行範囲を追記する。全面的な機械変換やCompose対応は自動的にスコープへ入れない。 +- [x] Kotlin変換と動作変更は可能な範囲でPRまたはコミットを分ける。Java呼び出し互換性、nullability、JVMシグネチャ、公開APIと移行ガイドへの影響を検証する。 +- [x] 破壊的変更と2.xからの移行方針を記録する。 + +受け入れ条件: API・寿命・スレッド・対応環境の判断が文書化され、双方が合意している。 + +### T02 / T03: CIとビルド基盤 + +- [x] Debugビルド、全ローカルテスト、core/sample lintをCI化する。 +- [x] sampleのRestrictedApiエラー2件を解消する。全体抑制やbaseline追加だけで隠さない。 +- [x] 警告を実害・互換性・文書等に分類し、残すものは理由を記録する。 +- [x] AGP 3.2.1の旧buildscript宣言と8.5.1のplugins宣言の二重管理を解消する。 +- [x] 合意したバージョンへ関連依存を段階更新する。Kotlin移行に必要な設定・依存を維持・整備し、不要なktx、legacy依存、Jetifierの要否を確認する。 +- [x] Manifestの古いpackage指定・overrideLibrary等、Gradle非推奨設定、wrapperの整合性・checksumを見直す。 + +受け入れ条件: 合意したツールチェーンでCI成功。残存警告に説明があり、クリーンな環境で再現できる。 + +### T04: 表示状態・スレッド + +- [x] addView失敗後にisVisibleがtrueになる問題を再現して修正する。 +- [x] workerのshowがキュー待ち中にmainのhideが先行する問題を再現して修正する。 +- [x] WindowManager操作と状態遷移を一体で直列化し、可変LayoutParamsの共有も契約に合わせて扱う。 +- [x] add/update/removeの失敗通知、失敗後の再試行、連続show/hide/updateを確認する。 + +受け入れ条件: 権限未許可→許可→再表示、無効token、キュー順序、重複操作の回帰テストが通り、実表示と状態が矛盾しない。 + +### T05 / T06: 監視・座標・操作 + +- [x] `setDraggable(true).show(); setDraggable(false); hide();` の監視解除漏れを修正する。 +- [x] Activity内ドラッグがシステムオーバーレイ権限に依存しないようにする。 +- [x] ScreenMonitorの追加ウィンドウ方式を再評価し、対象ウィンドウのInsets・座標とWindowMetrics等を使う方針を検討する。 +- [x] Android 12以降の非タッチウィンドウ・不透明度・複数重なりへの対応を行う。alphaを一律0.8にするだけで完了としない。 +- [x] DOWN/MOVE/UP/CANCEL、クリックとドラッグの区別、タッチ消費、multitouch、画面外配置を確認する。 +- [x] 回転、RTL、ステータス/ナビゲーションバー、edge-to-edge、マルチウィンドウで座標を確認する。 + +受け入れ条件: 権限なしのActivity内ドラッグ、監視終了、別UIDアプリへのタッチ透過を確認でき、対応範囲・制限が明文化されている。 + +### T07: Timber + +2026-11-01: ユーザー判断でTimber連携自体をリリース前に削除する（PR68）。以下は削除前の作業記録として残す。 + +- [x] ログバッファ変更とTextView更新を安全に直列化する。 +- [x] `maxLines` の0・負数・縮小時の仕様を定め、境界テストを追加する。 +- [x] 高頻度ログによるUI負荷、複数行ログ、Activity登録と表示・終了を確認する。 +- [x] Timberの対応バージョンと公開依存関係を確認する。 + +受け入れ条件: 背景・同時ログでUIスレッド違反やコレクション競合がなく、保持量・更新負荷が制御される。 + +### T08: 寿命と解放 + +- [x] WeakHashMapの値からActivityが間接保持される懸念を、参照経路・画面再生成・必要に応じヒープで確認する。 +- [x] Activity終了時のwindow、cache、listenerの解放を設計に合わせて実装する。 +- [x] 再initで既存の監視windowが残らないことを確認する。 +- [x] アプリ外表示のContextと明示的な終了処理を検証する。 + +受け入れ条件: 破棄済みActivityや終了済みwindowの不要な保持がなく、再初期化と終了が定義通り。未再現の懸念を修正済みと報告しない。 + +### T09: lint + +- [x] `lintPublish`でAARへlint.jarを同梱する。 +- [x] IssueRegistryのAPI互換性・vendor等の宣言を現行lintへ合わせる。 +- [x] Detectorで宣言クラス・引数数・定数値を確認し、同名の他APIで誤警告・例外を出さない。 +- [x] Java/Kotlin、quick fix、実際のjarロード、別consumerでの検出を検証する。 +- [x] 3.0で変更する公開APIに検査内容を合わせる。 + +受け入れ条件: 生成AARを取り込む別アプリで必要な警告が出て、無関係なコードには反応しない。 + +### T10: 利用例・文書 + +- [x] READMEにActivity内表示とアプリ外表示の動く例を分けて載せる。 +- [x] 権限設定からの復帰・再確認、表示参照の保持・終了、スレッド契約を説明する。 +- [x] sampleのHTML表示コードと実装を同期する。可能なら実装から生成し、package-private APIの案内を除く。 +- [x] 対応OSと制限、長時間表示とアプリ側のサービス責任、現在のAndroid制限を公式仕様で確認して説明する。 +- [x] CHANGELOGと2.x→3.0移行ガイドを作る。破壊的変更・置換例を網羅する。 +- [x] 見た目や操作の変更はスクリーンショット・動画をPRへ添える。 + +受け入れ条件: 公開APIだけで例がコンパイル・動作し、初回未許可と終了まで説明されている。 + +### T11: バージョン・配布 + +- [x] `version.properties`を3.0.0へ更新する。変更前の値は2.0.0 / id=9、現在は3.0.0 / id=10。sample用versionCodeの増分と既存公開履歴の整合を確認する。 +- [x] core / opt-timberの成果物バージョン、artifactId、POM、公開APIに現れる依存のapi/implementationを確認する。 +- [x] Release AAR、sources、consumer rules、lint.jar、ライセンスを確認する。 +- [x] 新しいconsumerからRelease成果物を取り込み、依存解決・R8有効ビルド・利用例を確認する。 +- [x] JitPack等の配布手順・必要なJDK設定・導入座標を確認する。ここでは正式公開しない。 +- [x] 2026-11-01: Timber削除後のcoreのみの配布を確認する。AAR/POM/sources/consumer rules/lint.jar、core単体のJava/Kotlin/R8 consumer成功。導入座標は公式の全モジュール形式 `com.github.75py:Android-OverlayViewManager:` へ変更。 +- [ ] タグ作成後、JitPackサービス上のビルドと導入座標の解決を確認する。ユーザー判断後に実施。 + +受け入れ条件: 3.0.0の成果物が一貫し、別consumerから利用でき、配布手順が再現可能。 + +### T12 / T13: 統合とリリース候補 + +- [x] 実装タスクのPR・相手承認・統合SHA・検証根拠を照合する（PR61/62は記録済みユーザー指示による例外を明記）。最終記録PR63もa47d95cへのClaude承認・CI成功後に統合済み。 +- [x] 計画書と司令塔間ログをGit管理し、分担・異論・判断・承認の経緯を記録する。最終台帳はPR63でレビュー/統合済み。 +- [x] Debug/Releaseビルド、全ローカルテスト、lint、consumer試験を最終製品候補で実行する（以後test/doc変更のみ、詳細SHAは最終検証記録）。 +- [x] 合意したAPI23/26/35/36の端末で、権限拒否/許可、実表示、再表示、別UID透過、ドラッグ、画面再生成を確認する。SDK対象外と追加API31のfreeform未検証は最終記録で区別する。 +- [x] 現AGENTS.mdに従い両司令塔が直接、公開API・移行・配布・状態遷移を相互確認する（追加subagentなし）。 +- [x] 合意した統合SHA `395f2ff` から `release/3.0.0` を作成してpushする。 +- [x] `release/3.0.0` → `main` のPR #66を作成する。版、変更要約、移行方法、検証結果、既知の制限、関連PRを記載し、Claude司令塔へ最終確認を依頼済み。 +- [ ] ユーザーへreleaseブランチ、main向けPR URL、実施済み検証、残課題、利用したエージェント構成を報告する。 +- [x] 2026-11-01: Timber削除後の候補で全ローカルテスト134件、lint、Debug/Release、core単体consumer、API36 sample全31件を確認する。API23/26/35は10/31の結果を維持する。 +- [x] 2026-11-01: PR68の現head対向承認・CI成功後に `8794018` へ統合し、統合SHAをPR66コメントへ記録、work/3.0.0を同SHAへfast-forwardしてpushした。merge操作はCodex。 +- 文書追記後を含むPR66の現headごとのCIと対向確認は、同PRのchecksとSHA付き確認コメントで追跡する。 + +受け入れ条件: 検証済みリリース候補のmain向けPRが存在する。未解決の不具合・未実施試験・承認状態を隠さない。 + +## 実行時の記録テンプレート + +各タスクについて以下を追記する。計画書の更新担当へ報告し、複数担当が同時にこのファイルを編集しない。 + +```text +Task ID: +状態: +担当司令塔 / 相手レビュー司令塔: +実装・検証・レビュー担当（モデル / effort）: +Orca Run / Task / Dispatch / worktree: +編集対象・禁止範囲: +依存タスク・合意記録: +ブランチ / base SHA: +PR URL / head SHA: +検証コマンド・結果・証跡: +相手のAPPROVE（URL・対象SHA）: +統合SHA: +未解決事項・次の担当: +``` + +## 開始後の最初の指示 + +ユーザーから開始指示を受けた司令塔は、この文書とユーザーの最新指示を読み、T00から始める。相手の司令塔と担当・API設計の進め方を合意してから、それぞれのサブエージェントに限定したタスクを渡す。相手からの承認前に個別PRをマージしない。 + +## 2026-09-12: T00実行記録 + +- 開始ログ: [T00開始・分担協議](docs/coordination/3.0.0/2026-09-12-t00-start.md)。 +- Orca Run: `run_18f7185e91aa`。 +- Codex: 既存端末でAstra / mediumを確認。 +- Claude: 既存端末でFable 5.1 / highを確認。Task `task_7ce398407cc5` / Dispatch `ctx_1916f5521532` の開始を確認。 +- CLI内のモデル識別子: `claude-fable-5-1`、`claude-sonnet-5`。子の実利用は起動結果で別途確認する。 +- 認証: GitHub `75py`、ADMIN。統合ブランチはprotected=false。同一アカウントの場合は相手司令塔自身のSHA付きAPPROVEコメントを用いる。 +- 記録用ブランチ: `codex/3.0.0/t00-coordination`。統合先と別worktreeで文書を編集する。 +- 提案中: T01の設計文書はCodex、T02のCI/sample既存lintはClaude。実装着手は双方の所有範囲合意後。 +- 未解決: ClaudeがCLI実行不能を最終報告。worker_done送信も不能なため当該試行をabandonし既存端末を保持。ユーザーによる実行環境の復旧後、同一Taskを新Dispatchで再開する。双方の分担合意、各側の子起動、相互レビューは未実施。 + +### 00:32 JST以降の再開 + +- ユーザーがClaude復旧済みと再開を指示。ClaudeからOrca経由で復旧・分担提案を受信（msg_ce45742087c4）、Codexが同意（msg_0ffb232045e4）。 +- T01とT02の所有範囲合意により最初の並列作業を開始。T00のレビュー通信/GitHub側確認は継続する。 +- T01: Terra / high（launch.effective確認）、Task task_5c129e6aca40 / Dispatch ctx_f585ff543e5e。隔離worktree codex-3.0.0-t01-design。編集対象docs/design/3.0.0-api.mdのみ。実装・Gradle実行はなし。 +- T02: Claude所有の.github/workflows、sampleの既存RestrictedApi修正のみ。ビルド設定・core・opt-timber・lint・version.propertiesの編集禁止。Gradle共有資源はT02側で使用。 +- PR #21: 開始記録の文書PR。復旧・合意・子起動記録を追記し、最新headでClaudeの承認を受ける。 + +### 第1波の台帳（2026-09-12 00:49 JST） + +- T00: PR [#21](https://github.com/75py/Android-OverlayViewManager/pull/21)、head cdcd6003559db84aa64b7434bb72a3a5db658b5c、Claude承認 [5636971646](https://github.com/75py/Android-OverlayViewManager/pull/21#issuecomment-5636971646)、統合SHA d67f2e7212fe6b4757b316afae15e384056cfee6。文書差分検査成功、必須CIなし。 +- Claudeはユーザーによる復旧後、独立司令塔Run run_3ae778449744を作成。Codex Run run_18f7185e91aaとの対等な相互連絡へ移行。旧T00試行を再Dispatchしない。 +- T02: Sonnet 5 / high（Claudeからlaunch.effective報告）、Task task_336fecdad101 / Dispatch ctx_bebb1ab66ddc。worktree claude-3.0.0-t02-ci-lint、base 1646b3b。CIとsampleの指定2 Activity・関連layout/assetsのみ。Codex側の独立レビュー待ち、実装中で未承認。 +- T01: 初稿ebccbc8をCodexが確認し、仕様矛盾をTerra highへ差し戻し。後続Task task_5eec657e9b5e / Dispatch ctx_68f179dceb5c、head b374eeeca3403de0c080faecf96b1dec232063c0、[PR #22](https://github.com/75py/Android-OverlayViewManager/pull/22)。文書差分検査成功、Gradle未実行。Claude側レビュー依頼済み、API決定は未承認。子端末はworker_done後に解放済み、worktreeと成果は保持。 +- 詳細: [第1波の判断ログ](docs/coordination/3.0.0/2026-09-12-wave1.md)。 + +- 00:52 JST: T01主要方針は双方合意（msg_aa4d17bac5ae、msg_14ab33b282fa）。cause nullable、有効spec/部分更新、focus/移行例の修正をTerra high（task_a00e41713481 / ctx_422c19486993）が実施中。最新head承認はまだない。 + +## 中断・再開入口（2026-09-12） + +ユーザー: 「そろそろ寝ようと思うので、キリのいいところで中断して」。以降は保存・状態確認のみ。T03以降は未着手。 + +1. 本書と [中断ログ](docs/coordination/3.0.0/2026-09-12-pause.md) を読む。文書更新はcodex/3.0.0/coordination-wave1に保存し、未承認のため統合しない。 +2. ユーザー再開後、両司令塔のOrca Run/端末を再確認。T02既存Dispatchを重複起動せず、許可待ちの解消を確認する。 +3. PR22最新headのClaude側増分レビューを実施。旧head b374eeeにはREQUEST CHANGESがあり、最新headの承認はない。 +4. T02は未コミットのsample変更を既存worktreeに保持。CI未完成、ビルド/テスト/lint未検証、push/PRなし。検証環境復旧後に担当が完成させる。 +5. 文書PRの相互レビュー後に計画・ログを統合。T01/T02が統合されるまでT03へ進まない。 + +- 中断確定: PR22最新head a1fcfeb11fe61391e3372b9184c30e9568ac73a8をpush/clean確認。設計子はOrca完了通知失敗後に最終応答で終了したためworker-stopで端末を停止。T01再レビューとT02許可待ちは未完了のまま保持。 + +## 13:17 JST: 再開 + +- ユーザーが「再開してください」と指示。Codexのmsg_3c935a7e5029、Claudeのmsg_ea9f31f2fa95で再開連絡を確認。 +- PR22 a1fcfebに未反映の既知指摘をCodexが確認。Luna/high（launch.effective確認）のtask_0939bd1375f5 / ctx_8da0aa6c1a15が限定修正。spec getter main-thread、明示的spec/Java overload、NOT_ATTACHED診断、移行表の不足を対象とする。新設計は導入しない。 +- T02は同一ctx_bebb1ab66ddcのBash許可待ちが続き、進行中扱いだが実行は停止中。ユーザー側操作が必要。重複Dispatch・許可代答はしない。 +- ClaudeはFable5.1/highで復帰。PR23の記録確認は継続、最新再開追記後のSHAを承認対象にする。 + +## 13:25 JST: 段階移行の合意 + +- T04依存にT03を追加。T04aはcoreの新しいspec/result/state/failure型とJava/Kotlin consumerコンパイル試験のみ、既存OverlayView/OverlayViewManagerへ触れない。 +- T04b以降で状態機械・寿命・ドラッグを段階移行。旧API除去はT07/T10のconsumer更新と同期し、最終版に互換shimを残さず各途中PRはビルド可能に保つ。 +- T07はT01承認後にJavaのスレッド/maxLines修正を先行可能。新core API依存のdisposeはT04/T08後へ分ける。GradleはT02と直列化する。 +- 合意元: Codex msg_e9a0f7964a8b、Claude msg_81f062bf63c9、Codex msg_d08b59b6b18d、Claude msg_ca3fc083ed95。 +- PR23 head64f959fへの[Claude承認](https://github.com/75py/Android-OverlayViewManager/pull/23#issuecomment-5643424389)を確認し、506f996474423482b33d14eb80dcaaa278633fa4へ統合。 + +## 13:35 JST: T01統合・T02検証移管 + +- T01: Luna/high修正head6a2ce743e724358a1da7548c8cc07a5abf49cf0aへの[Claude承認](https://github.com/75py/Android-OverlayViewManager/pull/22#issuecomment-5643464042)を確認。PR22統合SHA=c8c2660df3a44b14831ab307b0ee4f0b135c0561。文書差分検査成功。Lunaのworker_doneは実受信してsettlement/release済み。 +- T02: ユーザーが許可応答し作業再開した後、Claude側JDK読み取り・SSH制約でローカル検証とpushが失敗。ブランチclaude/3.0.0/t02-ci-lintのbf3e42bb48a60d87d5cd838263f4cdad408639cb（12706b6 CI＋bf3e42b sample修正）をCodexが通常権限経路でpush。 +- T02独立レビュー・検証: Terra/high、task_2be9b58c2828 / ctx_382b023d4c6e、別worktree codex-3.0.0-t02-review、bf3e42b固定。Gradle共有資源はこの担当へ移管。結果待ち、承認は未実施。 +- Claudeが同SHAのdraft PR/remote CIを作成担当。コード変更時は再検証範囲を調整する。 + +### T02独立検証（2026-09-12 13:42 JST） + +- Terra/high（task_2be9b58c2828 / ctx_382b023d4c6e）がbf3e42bb48a60d87d5cd838263f4cdad408639cbを検証。必須ビルド・89テスト・core/sample lint成功（エラー0、警告9/124）。168タスクを再実行し、生成Data Bindingコードもレビューした。 +- CIの明示的read権限と既存HTMLのonDestroy順序差を改善提案。Codex司令塔は現在の振る舞いの回帰とは判定せず、限定修正をClaude側へ依頼（msg_aab84c40f1c7）。PR・GitHub Actionsの結果を待ち、承認は最新headへ別途行う。 +- ローカルGradle資源を解放。検証担当は最終回答まで完了したがworker_doneがruntime不達で届かず、transcript確認後に当該端末のみworker-stop。成果とworktreeは保持。 + +### T02統合とT03引渡し（2026-09-12 13:54 JST） + +- PR24最新head8510b6e0c8cfd855cc6fcbbe3f3de6e14b47d4edはCodexが限定差分を再確認し、GitHub Actions run34673893306成功後にAPPROVE。統合SHA9192f8360b79ad71d2b37fc3b886d5e5d91c467c。PR25はClaude承認済みhead2b0182fをf69e7bf21f6d27e35d913ef7c6eb856d67700e7fへ統合。 +- 残存警告の対応先を双方で合意（msg_611bc9df8fa2 / msg_b0528f5bf522）。SDK/依存はT03、core accessibilityはT06、VisibleForTestsはT04、sample固有はT10。詳細分類はPR24本文。 +- msg_5dc7170819a3でClaudeへT03開始を引渡し。Sonnet5/high、統合SHAから独立worktree、公式情報で版を確定、必要ならCodexが検証担当。T07のJava先行段階はソースのみ並行可、dispose統合はT04/T08後、GradleはT03優先。 +- 詳細: docs/coordination/3.0.0/2026-09-12-wave2.md。 + +- 13:58 JST実起動（msg_add30b0b0135）: T03 task_ddc6ad210b34 / ctx_2f7b18d0b503、T07段階1 task_3bee9d099ded / ctx_5816cf1fe027。双方Sonnet5/highをlaunch.effectiveで確認。T07はJavaのバッファ・main描画・maxLinesのみ、dispose/lifecycleは未実施。 + +### T07段階1統合とT03復旧（2026-09-12 14:19 JST） + +- T07 PR27: head27d4f8205b9ff07cfb47388c04173ab55f2c49f2をTerra/high（task_e055de0f3863 / ctx_d7cc040001a3）が独立レビュー。24テスト成功（15既存+9新規）、opt-timber lintエラー0・既存依存警告3。CI run34674836991成功とCodex承認後、5eca72527047b9f16ed931570635e3836f3f60efへ統合。 +- T07全体は未完了。次段階でthresholdのスレッド間可視性をvolatile/lockにより修正する（msg_2e4494b74956提案 / msg_4492b071b8f0同意）。Kotlin化はT03後、dispose/lifecycle統合はT04/T08後。今回の承認を全スレッド安全性・寿命管理の完成とは扱わない。 +- T03 ctx_2f7b18d0b503は調査後にworker_doneなしでターン終了。Codexがrendered screenで確認しmsg_b7c41f28cf73で通知、Claudeがmsg_8c33cf721900で事実を確認して所有側で復旧すると回答。編集成果はまだない。重複起動しない。 +- 最新詳細: docs/coordination/3.0.0/2026-09-12-wave3.md。 + +- T03再試行（msg_b8baecba66f8）: task_ddc6ad210b34 / ctx_d9dde85f3055、term_d69f62a2-5043-41ba-8710-54fec875164e、同一worktree。旧試行をstop/release後にretry-ofで起動。Sonnet5/highは起動引数で指定、launch.effectiveは空で実効値確認待ち。旧調査を引き継ぐ方針に双方同意（msg_ad03ab603726 / msg_b9dc244277f7）。 + +- T07実装attemptはターン終了後stop/release（msg_c07bedb9cf18）。PR成果の統合済みとOrca成功通知未受理を区別。旧T03の完全なtranscript回収は停止後に失敗し、確認済み事項の要旨のみを再担当へ引き継いだ。 + +### T04の段階と最終互換API除去（14:32 JST双方合意） + +- T04a: T03統合後に新しいimmutable spec/result/enumを追加。既存OverlayView/Managerは変更しない。 +- T04b: 状態機械とmain-thread同期処理を導入。段階の受け入れ合格でT05/T06/T08を順に進められるが、一時互換APIを残す間はT04全体を完了としない。 +- T04c: T07/T10のconsumer移行PR後、Codexがcore一時互換APIを除去する独立PRを担当。最終公開APIとJava/Kotlin利用を検証し、Claudeが承認する。 +- T10の依存はT04全体ではなくT04bまでとし、T04cとの循環を避ける。T11はT10とT04cの双方完了が必要。 +- 提案msg_58204d3d71a0（14:29:50 JST）、Claude同意msg_31c3ba95b7b4（14:32:18 JST）。API設計自体の変更はない。 + +T03はClaude報告でAGP9.2.1・Gradle9.4.1/JDK17・compile/target36/minSdk23の3コミットまで進行、依存更新中。ここではビルド検証済み・採用確定とは扱わず、候補SHAと公式根拠・検証を次に確認する。 + +### T03構成判断と基準検証（14:50 JST） + +- AGP9の組み込みKotlinと新DSLを採用し、無効化フラグ・明示的kotlin.android適用を除去する方針に双方合意（msg_f61c1953e946 / msg_1a1846f89349）。新DSLへの設定移行をT03内で完了する。 +- Terra/high task_5fa509223d3f / ctx_d750aaf55990が86eb4f8を実検証。Gradle9.4.1の設定フェーズでlint/build.gradleのProject直下sourceCompatibilityが未知プロパティとなり停止。ビルド・テスト・lintは未実行。wrapper bootstrap/checksumは成功、選定した直接依存の公式POMは実在を確認した。 +- CodexはこれをP1の候補ビルド阻害として修正必須と判断。初期の「coreにKotlin pluginがない可能性」という仮説は実コード確認で訂正（既に適用済み）。JVM target不整合はこの時点で再現されておらず、修正版でJava/Kotlin17の実コンパイルを確認する。 +- Claude報告msg_0efbd3db7da6: 新DSL移行c914d43782ef284bc4739c277166f9425eaf1e0e完成、lint DSL修正中。AGP9.2.1 POM上のKotlin2.2.10・lint32.2.1を確認。担当自己申告はclaude-sonnet-5/high（手動起動のlaunch.effectiveは空のまま）。 +- PR28は承認・CI成功後に1af6dfb6b23202eca18a3e4f42f8a084061440acへ統合。非ブロッキング指摘のT04a/b台帳行を本更新で追加。 +- 詳細: docs/coordination/3.0.0/2026-09-12-toolchain.md。 + +- T03修正版24fc1f2faacedf088eb7dbefd6d2bf961562af6bをpushし、Terra/high task_74810ea07694 / ctx_d88e20a3160aで再検証開始（msg_be74df233e72 / msg_15ff4dbb7933）。組み込みKotlinのjvmTargetがcompileOptionsを継承する公式既定を採用し、一時Java/Kotlinコードで実証する。前回未実行だった全チェックをこのSHAで行う。 + +- 24fc1f2のCI run34676815383とTerra再検証はsample/build.gradle36の旧proguard-android.txtで設定失敗（msg_30d961482558）。core/Timberは個別構成でJava/Kotlin双方向コンパイル・class major61を実証。全98テストとlintは未実行のまま。次の設定修正後に必須全チェックを再実行する（msg_4c4ceee43442 / msg_8e7f857cf73f / msg_5b1b01e48d25）。 + +### T03残修正の担当移管（2026-09-12 15:29 JST） + +- 7a05b90のProGuard修正をCI・Terra/highで検証。core/Timberビルド、Timber24件・lint4件は成功。sampleのR.id switchで46件のコンパイルエラー、残るcore/sampleテストとAndroid lintは未完了。 +- 事前の条件付き合意に該当し、Claudeから最終SHA・未解決事項・PR本文を引き継いだ（msg_36833232803e）。旧担当のworker_done/releaseと編集終了を確認（msg_f0d13fbdf431）してから、Codex Terra/high task_219a9b571780 / ctx_f6d6f9259023を新checkoutに起動。Gradleと編集を専有する。 +- R.id分岐の最小互換修正をT10からT03へ前倒し。広いKotlin移行はT10のまま。既存コミットを保持し、新T03 PRをClaudeが独立レビュー、SHA固定APPROVE後にCodexが統合。PR29は新PRへの参照付きでClaudeがcloseする。 +- PR30文書は19c4252674e448cf46bcfdd092cbea4268c48d96へ統合。詳細と根拠はdocs/coordination/3.0.0/2026-09-12-toolchain.md参照。 + +### T03候補の検証完了（2026-09-12 15:43 JST） + +- PR31 head24e93fd78b1e89c4d8d7c737f16b4d1bf2a69546。sampleのID分岐を互換化し、Robolectric fixtureをAPI23へ移行。許可・拒否の両ケースを検証。本番coreの権限動作は未変更。 +- 全ビルド・テスト・lint成功後、テストのみの追補をcore70件で確認。総数99件（70/24/4/1）、failure/error/skip 0。core/sample lint error0、warning12/61。sample androidTest APKビルド成功、端末実行は未実施。最終headのCI run34678799436成功。 +- 独立レビューと最終SHA APPROVEはClaude待ち。相手端末の受信確認コマンドが許可待ちで停止していることを確認。未承認のため未マージ、T04a以降は未着手。AGENTS.mdのSDK/Gradle記載更新はT03統合後に行う。 +- 残存警告の対応案・受信処理の手戻り・担当終了の証拠はtoolchainログに保存。後続作業へ進む前に相手のレビュー/承認を確認する。 + +### T03統合とT04a開始（2026-09-12 16:10 JST） + +- PR31はClaude/Sonnet5 highの独立レビューと24e93fdへのAPPROVE（comment5644370904）、CI run34678799436成功後、00b45cb9fbc78d4911e164fc8c5109b936eafc16へ統合。PR32文書は先に7be795cへ統合済み。 +- T04a: Terra/high task_6ca5c3ca3e03 / ctx_31dbaecdd7b2、codex-3.0.0-t04a-models、base00b45cb。新Kotlin spec/result/enumとJava/Kotlin利用テストのみ。既存表示処理は未変更、Gradleはこの担当が専有。 +- AGENTS.mdのJDK17/SDK36/Gradle9.4.1/AGP9.2.1と組み込みKotlinの記載を実構成へ更新。成果物のstdlib依存とPOMはT11/T12で実測する。既存Kotlin相互コンパイル証拠と、最終公開成果物の検証を混同しない。 +- T04bの読取調査を完了。新結果APIをT04cへ遅らせる子の案は依存循環のため不採用。最小consumer修正を含む分担をClaudeへ相談中。詳細: docs/coordination/3.0.0/2026-09-12-api-implementation.md。 + +### T04a・T07段階2統合とT04b開始（2026-09-12 17:03 JST） + +- T04a PR33: head3224165、Claudeの独立レビューとAPPROVE（5644524714）、CI34680272503成功後、復旧対応Codex端末が997a958へ統合。Java異常系・既定値・Builder snapshot補足と不要なconstructor overload削減は小さな別PRで対応する。 +- T07 PR34: headf86c40fec07845a91dead130cee175407a7a84f9。Terra/high独立レビューtask_0f937a90d7eb / ctx_e954a5fd2d52でblockingなし、25 tests成功、lintエラー0。CI34681799560成功、Codex承認5644608014後、d2a1dd6dd78fc1dd30ae0caa7f185cb6b30cb66aへ統合。テストの同期自体にhappens-beforeがあるため、volatile削除を検出するテストとは扱わない。 +- T04b: Terra/high（launch.effective確認）task_8dae019402ea / ctx_026ea69247c9、codex-3.0.0-t04b-state、base d2a1dd6。core manager/view/adapterのKotlin同期状態処理、新結果API・4 factoryを導入する。旧setter/noarg updateはeffective specと分離した一時橋渡しのみとしT04cで除去する。 +- 段階移行案はClaudeがmsg_bf7ddf364470で合意。Sample2Activityのshow代入分割だけT04bに含め、sample全体はT10、同一Application init契約はT04b、Activity寿命はT08、opacity budgetはT06とする。 +- msg_44fa28c940e9でClaudeへT07 Kotlin段階を引き渡し。opt-timberとcoreの編集を分離し、GradleはClaudeに先行枠、T04bは編集後に検証枠を問い合わせる。詳細: docs/coordination/3.0.0/2026-09-12-api-implementation.md。 + +### 補足検証とKotlin移行のレビュー（2026-09-12 17:25 JST） + +- T04a補足PR36 head2d2dc4b: 不要constructor overload削減、Java正常/異常値とsnapshot検証。初回テストの正常サイズ誤認を親が差し戻し、Luna/high修正後83 core testsとjavap確認成功。Claudeの独立レビュー待ち。 +- T04b候補4a24cd2は未承認。親が破棄後のbackend参照・古いdetachListener保持等を6点差し戻し、同じTerra/high担当が修正中。 +- T04bに補助monitor request/cancel除去と最小drag座標橋渡しを含めることにClaudeが同意（msg_16212d73b4f5）。T05は完全bounds/insetsとmonitor撤去、T06は完全drag処理とopacity admission。橋渡しの限界と検証を明示する。 +- T07 Kotlin候補a95f227をpushし、Terra/high task_18c7821b0712 / ctx_c704670bf482で独立レビュー・Gradle検証中。テスト用メンバのpublic化は公開APIの審査対象であり、未承認。 +- PR35はClaude承認・CI成功後に復旧端末が9691d35へ統合。次ログに実施者、検証未完了の差戻し、通信制限から同じ担当を復帰させた経緯を保存する。 + +### T04a補足の統合とTimber Kotlin候補の差戻し（17:31 JST） + +- PR36: Claude承認5644737864、CI34683075403成功後、41d74aaへ統合。設定型のJava補足を完了。 +- PR37 a95f227: 25 tests/lint/sample build成功、ただし旧内部可変メンバがpublic JVM APIへ拡大するため承認せず差戻し（5644737303）。private化とtest側アクセス適応、KDoc訂正をClaudeが担当する。 +- T04b: terminal diagnostic補足b316ff8のみでは親の6点指摘が未完了。同じ担当へ修正を再提示しGradle専有を許可。検証・独立レビューはまだ完了していない。 + +### T04b検証不足の補足と端末環境の準備（2026-09-12 17:55 JST） + +- T04b fbfd42eの実XMLは51 tests。誤報46を訂正し、旧tests対応表で不足を確認。drag listener再生成とdispose後setter再保持を追加差戻しし、同じTerra/high task_6a0a8696194e / ctx_3cedaff14c1aが実gesture・API23/26・permission/type検証も補う。 +- T07はprivate化とtest適応を継続。Kotlin view propertyと、core main/init契約に合うfixtureを両側で揃え、組み合わせたunit testsで確認する。必要なopt-timber testImplementation Robolectric4.16追加のみを許可した。 +- API23/26/35画像を追加し、23/26/35/36の専用AVD作成に成功。起動・device testsは未実行でT12は未完了。詳細: docs/coordination/3.0.0/2026-09-12-device-preparation.md。 + +### 2026-09-12 18:05 JST checkpoint + +- T04b候補2ea8c02: core 59 testsと3 module assemble成功。Timberは既知fixtureで25件失敗、統合は保留。 +- 両司令塔がproduction reset APIを追加しない方針に合意。Terra/high継続担当が既存test hookを除去し、Claude側はtest-only reflectionでfixtureを適応する。 +- 次の受け入れ条件: 修正候補の独立レビュー、core/Timberの組み合わせ検証、CI成功、相手司令塔の候補SHA承認。 + +### 2026-09-12 18:18 JST checkpoint + +- PR39統合: 3f7ceb5。T04b候補20ae42aは63 core tests・3 module assemble成功、PR40 draftでClaude独立レビュー中。 +- PR37はc0d27e1の3件のtest reflection失敗を9eb38b7で修正。独立Terra/highが候補単体・T04b組み合わせを検証中、承認・統合は未実施。 +- T05a/T05b分割をClaudeへ提案中。core同一ファイルの編集はPR40受け入れ後に直列化する。 + +### T04c / T06 follow-ups from PR40 + +- [x] constructorのJava公開可視性を最終API監査で閉じる（RestrictToだけをaccess controlと扱わない）。PR62でprivate constructorと`@JvmSynthetic`の内部factoryに変更し、reflectionテストで保護。 +- [x] 暫定public DraggableOnTouchListener/custom listener setterをT06/T04cで除去・内部化する。PR61でsetter除去・`internal class`化。 +- [ ] DISPOSED show/updateのdiagnostic保持KDocを補足し、合意済みnullability方針を適用する。 + +### 2026-09-12 18:32 JST: 利用制限に伴う分担変更 + +ユーザーの最新指示により、以後の実装・検証・独立レビューはClaude Code / Sonnet 5を優先する。Codex子の新規起動は既定で行わず、Codex司令塔は調整・焦点を絞った承認・統合を担当する。独立レビュアーを実装担当と分離し、対向司令塔のSHA固定承認とCI成功の条件を維持する。Claudeが必要なローカル検証を実行できない場合だけ、Codex司令塔が指定コマンドを直接実行する。 + +- T05aのCodex途中成果を安全な区切りでClaudeへ移管し、以後T05b/T06/T08/T07寿命/T10/T11の実装・検証をClaudeが担当する。 +- T09 stage 1（registry/vendor/lintPublish/現detector堅牢化）はClaude先行着手を合意。最終APIへの合わせ込みはT06/T04c後。 +- T04c最終API整理もClaude Code担当を優先し、Codexが対向承認・統合する。 +- 専用API23/26/35/36 AVDの起動確認はLuna/mediumが完了して解放済み。アプリの端末テストは未実行。 + +### 2026-09-12 19:25 JST: 集約検証・PR作成とT05aテスト修正 + +- T09a PR42 head5e9c142c17c2a0baf28e91891c2ce205d3dc18cd: lint9 tests、core lintエラー0/警告14、release AAR内lint.jarを確認。CI34688032126成功。 +- T05a PR43は初期65d35f4でテストコンパイル失敗。ユーザーの明示依頼によりCodex司令塔が型引数誤用と不要importだけを修正し4a92b95d9ab24582bc34dacfaadea6cd196ae8d7をpush。core65/Timber25 tests成功、core lintエラー0/警告13、指定3 assemble成功。 +- 更新SHAのCI34688283404はSUCCESS。独立レビュー根拠・対向司令塔承認を確認するまでdraft維持。製品コードとテストassertionは修正していない。 +- このside conversationではサブエージェントを起動・操作していない。実行結果とレビュー依頼をClaudeへ通知済み。詳細はdocs/coordination/3.0.0/2026-09-12-batched-validation.md。 + +### T09a / T05a SHA固定承認の確認（2026-09-12） + +- PR43 head `4a92b95d9ab24582bc34dacfaadea6cd196ae8d7`: [CI34688283404](https://github.com/75py/Android-OverlayViewManager/actions/runs/34688283404) SUCCESS（19:24:49 JST）。[Claude承認5645326671](https://github.com/75py/Android-OverlayViewManager/pull/43#issuecomment-5645326671)と[Codex承認5645345329](https://github.com/75py/Android-OverlayViewManager/pull/43#issuecomment-5645345329)が同じ完全SHAを明記。 +- PR42 head `5e9c142c17c2a0baf28e91891c2ce205d3dc18cd`: [CI34688032126](https://github.com/75py/Android-OverlayViewManager/actions/runs/34688032126) SUCCESS（19:20:59 JST）。[Claude承認5645326598](https://github.com/75py/Android-OverlayViewManager/pull/42#issuecomment-5645326598)と[Codex承認5645344873](https://github.com/75py/Android-OverlayViewManager/pull/42#issuecomment-5645344873)が同じ完全SHAを明記。headは変更していない。 +- Claude msg_ead5f3f29cc2の独立Sonnet 5/highレビュー報告を確認。実装担当とは別のレビューでblockingなし。T05aのテストだけの修正差分はClaude司令塔が確認済み。自己承認で相手の承認を代用していない。 +- [ ] T05b/T04c: showの権限確認をhelperへ集約し、grant→revoke→失敗のshow/update検証とupdate事前権限確認の設計判断を補う。 +- [ ] T09 stage 2: vendor値の厳密assertion、getApiの同一定数比較の見直し、Kotlin宣言のOverlayView fixtureを補う。 +- 両実装PRはdraft・未マージ。統合時にはhead・CI・相手承認と保護ルールを再確認する。今回の文書更新はPR41を基点とする別ブランチcodex/3.0.0/validation-batch-logに分離し、PR41のheadは変更しない。 + +### T09a / T05a統合結果（2026-09-12 19:36 JST） + +文書PR44を先に作成後、両実装PRをreadyへ変更し、base work/3.0.0・完全head・CI SUCCESS・相互承認・MERGEABLE/CLEANを再確認。--match-head-commit付きの通常mergeでPR42を65c7e956d18bbd4bb72ffa073bf6fe73f02f98c7（19:35:52 JST）、PR43を40c45dcee6916cd1991ccc3db73a34a0eeafb9ac（19:36:18 JST）へ統合した。保護ルール迂回なし。main/releaseへのマージ・公開なし。先の未統合記載は各checkpoint時点の履歴。T05b・T09 stage 2と文書PR44のClaudeレビューは未完了。 + +### 2026-09-12 20:37 JST: 司令塔復旧・T05b開始 + +- PR41/44を対向承認・CI確認後に統合。work/3.0.0は53c2c2a。 +- Claude司令塔を新端末term_370f23caへ再接続し、Fable5.1/highを確認。Codex rootは変更なし。 +- T05bはClaudeのSonnet5/high担当がt05b-geometryで実装中。原点変換とpermission revoke回帰が対象。候補・検証・承認は未完了。 +- T10→T04cの順序を維持。新しいCodex子を起動せず、必要時のローカル検証は司令塔が直接実行する。 +- 詳細: docs/coordination/3.0.0/2026-09-12-coordinator-recovery.md。 + +### 2026-09-12 21:03 JST: 利用料上限前の中断 + +- ユーザーの明示指示で両司令塔・子担当の新規作業を停止。PR45はab2e9e9へ統合済み。 +- T05b初回候補8ec06ceはcore build成功、76 unit tests中3失敗、lint最終結果未完了。実装PRは未作成・未承認。 +- Claude修正ラウンドtask_41130117f375 / ctx_b9e23e8e0859へ現在地点の保存・中断を依頼。成果は再開後に確認する。独立レビューは中断され未完了。 +- API30+ cross-checkの代替案msg_c04af62e6d73は未合意。端末検証へ繰り延べる案とscope別fallbackの妥当性を再開時に協議し、T05を完了扱いしない。 +- 再開順: Claude担当の保存済みSHA/差分を確認 → 3テスト修正と座標モデル合意 → 独立レビューと必要なGradle再検証 → 実装PR・現SHA対向承認・CI → 通常merge。T06以降にはまだ着手しない。 +- 記録: docs/coordination/3.0.0/2026-09-12-t05b-validation.md。中断ログはcoordination-wave12に保存し、この中断中にレビュー依頼・統合を進めない。 + +### 2026-09-12 21:31 JST: 再開 + +- ユーザーの再開指示で既存Claude担当を復帰。中断中に新しい検証・PR・承認は行っていない。 +- T05bは3テスト修正と独立レビューを再開。Codexは指定Gradle検証と対向承認・統合を担当する。 +- T12に繰り延べるT05端末検証はreleaseを妨げる未完了項目として維持する。両scope、非ゼロ原点、RTL、edge-to-edge、allowOutsideBoundsの各条件で、ACTION_DOWN時に飛ばず、実際のscreen上の移動量がgestureに一致することを確認する。同じ原点減算式の再assertionだけでは受け入れない。 +- 失敗時の修正方式をActivity限定fallbackへ先に固定せず、実際の結果で協議する。T05完了とはまだ扱わない。 + +### 2026-09-12 21:38 JST: T05b再検証成功 + +- draft PR46 head867d85c: core75 tests全成功、lintエラー0/警告13、core assemble成功。独立レビュー・最終SHA承認・CIは未完了。 +- T05端末検証はrelease-blockingとしてT12へ持ち越す合意を維持。未完了事項と初回失敗は検証ログに保存した。 + +### 2026-09-12 22:06 JST: T05b統合・T06開始 + +- PR46 head e246370を相互承認・最終CI成功後にbeafd014へ統合。PR47の計画・ログも統合済み。T05端末検証はT12のrelease-blocking項目として未完了。 +- Claude Sonnet5/highがt06-touch-opacity、task_5bd2567d9bc3でT06を開始。実装・独立レビューをClaude中心としCodexは集約検証と対向承認・統合を担当。 +- ユーザーの指示で、Claudeの許可待ちはCodexが内容を確認し妥当なら代理許可できる運用へ変更。詳細はAGENTS.mdとdocs/coordination/3.0.0/2026-09-12-t06-start.md。 + +### 2026-09-12 22:44 JST: T06初回検証 + +- 候補3fcdb36はcore build成功、101 tests中11件のgestureテスト失敗。opacity17件は成功。元のClaude担当へfixture/dispatch assertionの見直しを依頼し、製品動作と後続assertionの検証を維持する。 +- T06のpush・PR・承認は保留。T05bまでの統合状態は変更しない。 + +### 2026-09-12 22:58 JST: T06修正版の再検証 + +- 候補1f25a82は101 tests中2件のクリック検証が失敗。初回のdispatch判定に関する失敗は解消したが、fixture寸法・座標・attachmentを元担当が調査する。期待値を維持し、成功確認までPR作成は保留。 + +### 2026-09-12 23:05 JST: T06検証成功・T08範囲合意 + +- 候補eb8e9f1のgesture限定試験とcore全101 tests成功。lintエラー0/警告13、core assemble成功。レビュー用ブランチへpushしdraft PRへ進む。CI・最終SHA承認は未完了。 +- T08はF1〜F6を明示合意。Activity破棄時の1回のremove、失敗分類維持、参照・cache・listenerの決定的解放検証が対象。実装はT06統合後。詳細と議論は2026-09-12-t06-start.md。 + +### 2026-09-12 23:14 JST: T06統合・T08開始 + +- PR49をb105885、文書PR50をcd41b81へ、個別の相互承認・CI成功確認後に通常merge。 +- T08はSonnet5/high、task_572d2116f4c5 / ctx_70332de7736c、t08-lifecycleで実装開始。候補・検証・承認は未完了。詳細はdocs/coordination/3.0.0/2026-09-12-t08-lifecycle.md。 + +### 2026-09-12 23:36 JST: T08検証成功 + +- PR51 head59ef303: core111 tests全成功、lintエラー0/警告13、assemble成功。独立レビュー・CI34699740974・最終承認は未完了。 +- T07寿命L1〜L7は明示合意済みでT08統合後に開始。削除失敗の結果を返しretry可能な状態を保ち、成功時だけ参照・callback・bufferを解放する。 + +### 2026-09-12 23:47 JST: T08統合・T07寿命管理へ + +- PR52文書をbe1843c、PR51 T08をd6ccdf2へ、現SHA承認とCI成功後に通常merge。 +- T07寿命L1〜L7を最新基点で開始依頼済み。T04cのJVM API監査とT12端末検証は未完了。代理許可2件とレビュー表現訂正もログに記録した。 + +### 2026-09-13 02:30 JST: T07寿命管理の再開 + +- ユーザーの再開指示を受け、Orca runtimeを復旧して既存のTask `task_2db547061e3f`／Dispatch `ctx_72258eaf9359`／Terminal `term_b4d72bee-a9a2-447b-99b6-b125837cf663`／worktree `t07-lifecycle` を再確認した。新規worker・worktree・Dispatchは作成していない。 +- 再開送信 `requestId 72e6aca0-8864-4248-8902-32209a1fa595` は `input_accepted` と `turn_started` を確認し、協調メッセージ `msg_3336a2f54803` はDispatch宛てにdurable enqueueされた。active worktreeコメントも再開状態へ更新した。 +- 再開時点で作業ツリーは `DebugOverlayTree.kt` の未コミット変更（+192/-37）のみ（`.claude/`はユーザー所有として触れない）。担当はセッション制限前の差分・3件の未解決指摘・回帰テストから継続する。候補SHA、PR、検証、独立レビュー、相手のexact-head承認、CI、統合は未完了であり、完了扱いしない。 + +### 2026-09-13 02:49 JST: T07再開のauthority blocker + +- 再開後、担当はWIP `4c080f8` → `8aa29f5` → `6e243c3` と進み、世代別render回帰テスト、初期化の同期、dispose入口のmain-thread検査を含む変更を保存した。最終worktreeは `codex/t07-lifecycle` の `6e243c3`、tracked差分なし、`.claude/`のみ未追跡でユーザー所有のため触れていない。 +- 古い停止操作により、既存Dispatch `ctx_72258eaf9359` は capability revoked 後に `stop_unknown` を経て `abandoned/failed`（completed `2026-09-13 02:49:24 JST`相当）となった。Orcaのworker authorityは再開中に失われ、terminal `term_b4d72bee-a9a2-447b-99b6-b125837cf663` は外部管理のまま `live`。停止・終了は確認できない。 +- Orca recovery規約により、live terminalを残したまま同じT07のreplacement worker／retryを起動しない。T07はWIPを保持したblocked状態とし、端末停止または新しい担当への安全なauthority移管が確認できるまで、検証・PR・レビュー・統合を行わない。 + + +### 2026-09-13 Claude coordinator effort update + +ユーザーの最新指示により、以後のClaude司令塔はFable 5.1 / mediumとする。旧high指定より優先する。復旧端末term_66423650-ee22-4e09-a6ba-65ed19561512で表示と引継ぎturn_startedを確認済み。 + + +### 2026-09-13チェックポイント: 来週まで中断（後続指示で解除） + +ユーザーの2026-09-13中断指示により両司令塔の作業を停止。T04cはClaude所有worktreeのローカル93b0423121419c758032d79c51b537a10b96e898（clean、core unit108件成功）まで保存済み。未push・未PR、manager側削除とJVM可視性整理は未完了。再開時は同worktreeから続ける。詳細は2026-09-13-coordinator-resume.md末尾。専用emulator5580は停止済み。 + +### 2026-09-14 02:30 JST: T04c再開調整 + +ユーザーの今回の明示指示により前回の中断を解除。既存T04c実装93b0423とwave19記録4463893はcleanで保存されている。Claude側も同時再開しているため実装を重複起動せず、Codexは既存調整worktreeで計画・記録と対向レビューを担当する。詳細と未確認事項は[再開記録](docs/coordination/3.0.0/2026-09-14-t04c-resume.md)参照。 + +### 2026-09-14 02:54 JST: 設定確認待ちのチェックポイント + +記録PR59を213a7d0へ対向承認・CI成功後に統合。T04c commit2は7d5af7b、core105 tests成功。Claudeの実effort highと前回指定mediumが不一致で、Orca設定入力は同ID再確認でもoperation_unknown。既存Claudeターンを中断し、commit3途中の7ファイルWIPをそのまま保存した。最新WIPは未コンパイル。ユーザーによる既存端末のmedium設定確認後、同じ所有者が継続する。詳細は2026-09-14-t04c-resume.md末尾。 + +### 2026-09-15 02:30 JST: T04c再開確認 + +ユーザー指示で再開。共有213a7d0、記録PR60、Claude所有7d5af7bと7ファイルWIPを確認・保持した。既存Claudeも同時再開中のため重複実装せず、Orcaで所有権と実effort high/指定mediumの整合を確認中。現在WIPは未コンパイル、前回105 tests成功とは区別する。詳細は[今回の再開記録](docs/coordination/3.0.0/2026-09-15-t04c-resume.md)。 + +02:37 JST: 実effort不一致に加え、Orca注意喚起入力が同ID再確認でoperation_unknownとなった。Claude画面はInterruptedで待機、途中成果は保持。medium設定と端末入力状態の確認が必要なblockerとして記録し、重複入力・実装・統合は行わない。 + +### 2026-10-18 JST: PR61・PR62・PR60の統合 + +ユーザーの「どこまで終わったか」の確認を受け、Claude司令塔（Opus 5.5）が状態を調査。2026-09-20にユーザー依頼のDevinがPR61でT04c/T09 stage 2/T11/T12を実装していた。ユーザーはPR61の採用・レビュー・マージを指示。Claudeが全差分をレビューし、承認コメントを付けた。PR61はユーザー許可で2c256a8へ統合。レビュー指摘のうちJVM可視性と文書をPR62で修正し、CI成功後、ユーザーのコマンドで208588fへ統合。PR60はおすすめどおり記録として9776926へ統合。サンドボックス制約によりGradle・端末試験はローカルで再現していない。詳細は[統合記録](docs/coordination/3.0.0/2026-10-18-pr61-integration.md)。 + +### 2026-10-25 JST: PR64のAPI31/36再検証（T12全体の完了とは区別） + +Codexレビュー後、Settingsが非システムoverlayを隠すため、以前のSettingsに対する成功結果を別UID透過の証拠から除外した。Claudeがtest APK内の別UID受信Activityへ変更。候補 `c9d8334f358a72217419947ddc3bc2bb57c61e9a` をCodexがAPI31初期r02・更新r03・API36で実行し、各3/3成功（skipなし）。API31はalpha1.0で遮断、API36は約0.8へ補正して到達する。詳細・所有権合意・再現情報は[PR64再検証記録](docs/coordination/3.0.0/2026-10-25-pr64-device-validation.md)。 + +PR64は最終文書と記録の対向確認・現headの承認/CI確認を経て統合する。今回mergeは未実行。PR63の「端末確認済み／次はT13」は旧Settings結果に基づくため、統合時に本checkpointと整合する。API23/26/35を含むT12の他のrelease-blocking項目は今回未検証で、T12全体やT13着手条件を充足したとは扱わない。JitPack継続のユーザー判断は維持する。 + +### 2026-10-31 JST: 最終検証とリリースPR作成の再開 + +ユーザーは両司令塔の連携でmain向けPR作成まで進め、通常判断は双方で相談し確認を減らすよう指示した。ClaudeはPR63/plan/logをCodexへ移管し、CodexがGradle/SDK/端末・成果物検証と統合を直列化する。ClaudeはPR64と不足する座標等の端末テスト、公開API・配布・利用文書の最終レビューを担当する。新規サブエージェントは起動しない。最終SHAの相互承認とCI条件は維持する。詳細は[最終検証記録](docs/coordination/3.0.0/2026-10-31-release-validation.md)。 + +### 2026-10-31: 最終検証完了・統合待ち + +T04〜T11の詳細チェックを既存PRと今回の最終検証証拠へ照合した。必須端末matrixとconsumerが成功。PR65/63の現head承認とCIの確認後にreleaseへ進む。追加API31のfreeform2件は未検証のまま明記し、必須API35/36で同条件の成功を確認済み。詳細な不具合発見・差戻し・設計判断・SHA・件数は[最終検証記録](docs/coordination/3.0.0/2026-10-31-release-validation.md)。 + +PR65はhead `ca3f7e0809a966e842d19ba7ea7d102a8ef48b86`、[Codex対向承認](https://github.com/75py/Android-OverlayViewManager/pull/65#issuecomment-6542296295)、[CI成功](https://github.com/75py/Android-OverlayViewManager/actions/runs/41193177729)を確認し、19:35:55 JSTに `497a5e2a6348ffbadd9455813d9bcf388012ebcc` へ通常merge。mainへのmergeは行っていない。最終台帳PR63の現head承認/CI/統合後にreleaseを作成する。 + +### 2026-10-31: T13のリリースPR作成完了 + +PR63 head `a47d95cb64f75fc87aa98c158b0bfc92af6b531a` の[Claude承認](https://github.com/75py/Android-OverlayViewManager/pull/63#issuecomment-6542332736)と[CI成功](https://github.com/75py/Android-OverlayViewManager/actions/runs/41193528060)を確認し、19:41:14 JSTに `395f2ff10109068451611a7f3573eb75b2fa923c` へ通常merge。承認済みheadと同一treeであることを確認し、同SHAからrelease/3.0.0を作成/push、[main向けPR66](https://github.com/75py/Android-OverlayViewManager/pull/66)を作成した。最後の計画・ログ更新はrelease向け文書PRで相互確認し、承認済みreleaseへのfast-forwardでwork/3.0.0にも同期する。製品コードを追加変更しない。 + +### 2026-11-01: Timber連携の削除（Codex対向レビュー待ち） + +ユーザーの判断を受け、前項の「製品コードを追加変更しない」を更新し、公開前に `opt-timber` を削除する変更を[PR68](https://github.com/75py/Android-OverlayViewManager/pull/68)としてrelease/3.0.0向けに提案した。Codexが差分レビューと検証を完了した。134 unit tests、API36 sample全31件、core単体consumerが成功し、API23/26/35は10/31の結果を維持する。導入座標は `com.github.75py:Android-OverlayViewManager` へ変更し、JitPackサービス上の確認はタグ後とする。mergeするとPR66のheadが変わるため、PR66の承認とCIは取り直しになる。PR68の現head承認・CI・統合は待ち。詳細は[Timber削除の記録](docs/coordination/3.0.0/2026-11-01-remove-timber.md)。 + +### 2026-11-01: Timber削除の統合完了 + +PR68 head `d773e7e83890aeaa4eae9e95750c4fe2b8c02391` の[Codex承認](https://github.com/75py/Android-OverlayViewManager/pull/68#issuecomment-6555266404)と[CI成功](https://github.com/75py/Android-OverlayViewManager/actions/runs/41286948503)、base `release/3.0.0`、同一head、CLEANを確認し、通常mergeで `8794018bcc6d67d338982bfaeaddef78db821540` へ統合した。承認headと統合SHAのtree差分なし。`work/3.0.0` も同SHAへfast-forward/push済み。[PR66の統合記録](https://github.com/75py/Android-OverlayViewManager/pull/66#issuecomment-6555284723)と本文を更新した。 + +本追記は計画・連携記録だけで、製品・テスト・ビルド設定に変更はない。最新release headのCIとClaude確認はPR66のchecksとSHA付きコメントを参照する。mainへのmerge、タグ、正式配布は引き続き対象外。 + + +### 2026-11-01: リリース前レビュー指摘の修正完了 + +PR70（CI公開タスク・移行文書・未参照画像）を `87c753d`、PR71（再入・drag alpha・host listener・破棄理由・小修正）を `4b9b2a7` へ、それぞれ現SHAの対向承認とCI成功後に通常merge。旧実装での再現失敗から修正後161 unit tests/skip0、API36 sample31/31、Debug/Release・lintエラー0・publish・独立Java/Kotlin/R8 consumer成功まで確認した。物理実機・API23/26/31/35は今回再実行していない。公開APIシグネチャとenum、README未公開表記、CHANGELOG日付は不変。C1〜C4は未実装の推奨案として[レビュー対応記録](docs/coordination/3.0.0/2026-11-01-review-fixes.md)に保存した。最終文書headの対向確認・CIはPR66を参照。mainマージ・タグ・正式公開は引き続き対象外。 + + +## 3.1着手前のタスク: API互換チェックの導入（C3） + +ユーザー決定により3.0.0には導入しない。3.0.0タグ作成後、そのタグをAPI baselineとして3.1の開発着手前に以下を完了する。タグ作成自体は今回の作業範囲外。 + +- [ ] binary-compatibility-validatorとKotlin Gradle plugin組み込みのABI validationを比較し、採用案と理由を記録する。 +- [ ] 両候補についてAGP 9のbuilt-in Kotlinと組み合わせた設定・実行可否を検証する。Kotlin二重適用を避け、利用可能なバージョン・制約を明記する。 +- [ ] 3.0.0タグからbaselineを生成し、CIで意図しない公開API差分を検出するチェックを導入する。 +- [ ] C1の互換性方針に沿う意図的なconstructor/copy差分のレビュー・baseline更新手順を決め、Java Builder/Kotlin consumer検証を併用する。 + +担当は3.1着手前に確定する。今回の変更は計画追加のみで、プラグイン・ビルド設定・API baselineは追加しない。 + + +### 2026-11-01: C1〜C4の決定反映と追加端末検証 + +ユーザー決定によりC1はdata class維持の互換性方針をKDoc/移行ガイドに明記、C2/C4は現状維持、C3は上記3.1着手前タスクへ追加した。C2のLIBRARY_GROUP方針と、現実装にあるLIBRARY/TESTS等のscopeを区別して記録し、注釈は変更していない。Codexが直接実装・検証、Claudeが対向レビュー。公開APIシグネチャ・enum・README未公開表記・CHANGELOG日付は不変。 + +API23は26/26（220.09秒）、API26は26/26（202.95秒）、API35は31/31（244.88秒）、すべてfailure/error/skip0。時間はGradle実行の実測値。API23/26のSDK条件対象外5件は成功やskipに加算しない。API35はfreeform2件を含む。指定Gradle全タスク、161 unit tests、lintエラー0、Release公開タスク成功。AVD設定は復元し専用AVDを終了済み。最終PRと統合SHA/CIの証跡は[PR66](https://github.com/75py/Android-OverlayViewManager/pull/66)の最新コメントを参照する。詳細と再現条件は[レビュー対応記録](docs/coordination/3.0.0/2026-11-01-review-fixes.md#c1c4のユーザー決定と追加端末検証)。 diff --git a/build.gradle b/build.gradle index 1edf68b..332688d 100644 --- a/build.gradle +++ b/build.gradle @@ -14,19 +14,9 @@ * limitations under the License. */ -buildscript { - repositories { - google() - } - dependencies { - classpath 'com.android.tools.build:gradle:3.2.1' - } -} - plugins { - id 'com.android.application' version '8.5.1' apply false - id 'com.android.library' version '8.5.1' apply false - id 'org.jetbrains.kotlin.android' version '1.9.20' apply false + id 'com.android.application' version '9.2.1' apply false + id 'com.android.library' version '9.2.1' apply false } task clean(type: Delete) { diff --git a/core/build.gradle b/core/build.gradle index 0db1169..5cfec74 100644 --- a/core/build.gradle +++ b/core/build.gradle @@ -16,30 +16,30 @@ plugins { id 'com.android.library' - id 'org.jetbrains.kotlin.android' id 'maven-publish' } android { - namespace 'com.nagopy.android.overlayviewmanager' - compileSdk 34 + namespace = 'com.nagopy.android.overlayviewmanager' + compileSdk = 36 defaultConfig { - minSdkVersion 21 - targetSdkVersion 34 - versionCode publish_version_code - versionName publish_version_name + minSdk = 23 + targetSdk = 36 + versionCode = publish_version_code + versionName = publish_version_name - testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner" + testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner" consumerProguardFiles 'proguard-rules.pro' resourcePrefix 'overlayviewmanager_' } buildTypes { debug { - testCoverageEnabled true + enableUnitTestCoverage = true + enableAndroidTestCoverage = true } release { - minifyEnabled false + minifyEnabled = false } } testOptions { @@ -47,8 +47,8 @@ android { unitTests.includeAndroidResources = true } compileOptions { - sourceCompatibility JavaVersion.VERSION_17 - targetCompatibility JavaVersion.VERSION_17 + sourceCompatibility = JavaVersion.VERSION_17 + targetCompatibility = JavaVersion.VERSION_17 } buildFeatures { buildConfig = true @@ -62,18 +62,19 @@ android { } dependencies { - implementation 'androidx.annotation:annotation:1.8.0' - implementation 'androidx.fragment:fragment-ktx:1.8.1' + implementation 'androidx.annotation:annotation:1.10.0' + // lintChecks runs the checks while developing core; lintPublish bundles lint.jar into the AAR. lintChecks project(':lint') + lintPublish project(':lint') testImplementation 'junit:junit:4.13.2' - testImplementation "org.mockito:mockito-core:5.12.0" - testImplementation "org.robolectric:robolectric:4.13" + testImplementation "org.mockito:mockito-core:5.23.0" + testImplementation "org.robolectric:robolectric:4.16" - androidTestImplementation 'androidx.test.uiautomator:uiautomator:2.3.0' - androidTestImplementation 'androidx.test:runner:1.6.1' - androidTestImplementation 'androidx.test.espresso:espresso-core:3.6.1' + androidTestImplementation 'androidx.test.uiautomator:uiautomator:2.4.0' + androidTestImplementation 'androidx.test:runner:1.7.0' + androidTestImplementation 'androidx.test.espresso:espresso-core:3.7.0' } publishing { diff --git a/core/proguard-rules.pro b/core/proguard-rules.pro index 07977e4..e69de29 100644 --- a/core/proguard-rules.pro +++ b/core/proguard-rules.pro @@ -1 +0,0 @@ -# Proguard for OverlayService diff --git a/core/src/androidTest/AndroidManifest.xml b/core/src/androidTest/AndroidManifest.xml index 61342a7..adbe645 100644 --- a/core/src/androidTest/AndroidManifest.xml +++ b/core/src/androidTest/AndroidManifest.xml @@ -14,7 +14,5 @@ ~ limitations under the License. --> - - - + diff --git a/core/src/androidTest/java/com/nagopy/android/overlayviewmanager/OverlayViewManagerTest.java b/core/src/androidTest/java/com/nagopy/android/overlayviewmanager/OverlayViewManagerTest.java index bc171e4..cebd1e1 100644 --- a/core/src/androidTest/java/com/nagopy/android/overlayviewmanager/OverlayViewManagerTest.java +++ b/core/src/androidTest/java/com/nagopy/android/overlayviewmanager/OverlayViewManagerTest.java @@ -9,7 +9,6 @@ import androidx.test.InstrumentationRegistry; import androidx.test.filters.SdkSuppress; import androidx.test.runner.AndroidJUnit4; -import androidx.test.uiautomator.UiDevice; import android.util.Log; import org.junit.Before; @@ -20,9 +19,7 @@ import java.io.InputStreamReader; import java.util.concurrent.TimeoutException; -import static org.hamcrest.Matchers.is; import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertThat; import static org.junit.Assert.assertTrue; @SdkSuppress(minSdkVersion = Build.VERSION_CODES.JELLY_BEAN_MR2) @@ -31,7 +28,6 @@ public class OverlayViewManagerTest { OverlayViewManager overlayViewManager; - private UiDevice uiDevice; private Application application; private UiAutomation uiAutomation; @@ -39,10 +35,14 @@ public class OverlayViewManagerTest { public void setup() { Instrumentation instrumentation = InstrumentationRegistry.getInstrumentation(); application = (Application) instrumentation.getTargetContext().getApplicationContext(); - OverlayViewManager.init(application); - overlayViewManager = OverlayViewManager.getInstance(); + // init() and getInstance() are main-thread only; @Before runs on the instrumentation thread. + OverlayViewManager[] holder = new OverlayViewManager[1]; + instrumentation.runOnMainSync(() -> { + OverlayViewManager.init(application); + holder[0] = OverlayViewManager.getInstance(); + }); + overlayViewManager = holder[0]; - uiDevice = UiDevice.getInstance(instrumentation); uiAutomation = InstrumentationRegistry.getInstrumentation().getUiAutomation(); } @@ -51,7 +51,7 @@ public void setup() { // @SdkSuppress(minSdkVersion = Build.VERSION_CODES.M) @SdkSuppress(minSdkVersion = Build.VERSION_CODES.N) @Test - public void canDrawOverlays_granted() throws Exception { + public void overlayPermissionIsGranted_afterShellGrant() throws Exception { executeShellCommand( "pm grant " + application.getPackageName() @@ -59,38 +59,29 @@ public void canDrawOverlays_granted() throws Exception { + Manifest.permission.SYSTEM_ALERT_WINDOW , 5000); - assertTrue(overlayViewManager.canDrawOverlays()); + assertTrue(overlayViewManager.overlayPermission().isGranted(application)); } - // Cannot grant SYSTEM_ALERT_WINDOW permission by "pm grant pkg" command on Marshmallow. + // Cannot revoke SYSTEM_ALERT_WINDOW permission by "pm revoke pkg" command on Marshmallow. // So skip the test. // @SdkSuppress(minSdkVersion = Build.VERSION_CODES.M) @SdkSuppress(minSdkVersion = Build.VERSION_CODES.N) @Test - public void canDrawOverlays_denied() throws Exception { + public void overlayPermissionIsDenied_afterShellRevoke() throws Exception { executeShellCommand( "pm revoke " + application.getPackageName() + " " + Manifest.permission.SYSTEM_ALERT_WINDOW , 5000); - assertFalse(overlayViewManager.canDrawOverlays()); - } - - @SdkSuppress(maxSdkVersion = Build.VERSION_CODES.LOLLIPOP_MR1) - @Test - public void canDrawOverlays_API22() throws Exception { - assertTrue(overlayViewManager.canDrawOverlays()); - } - @Test - public void getDisplayWidth() throws Exception { - assertThat(overlayViewManager.getDisplayWidth(), is(uiDevice.getDisplayWidth())); + assertFalse(overlayViewManager.overlayPermission().isGranted(application)); } + @SdkSuppress(maxSdkVersion = Build.VERSION_CODES.LOLLIPOP_MR1) @Test - public void getDisplayHeight() throws Exception { - assertThat(overlayViewManager.getDisplayHeight(), is(uiDevice.getDisplayHeight())); + public void overlayPermissionIsGranted_API22() throws Exception { + assertTrue(overlayViewManager.overlayPermission().isGranted(application)); } private void executeShellCommand(String cmd, long timeoutInMillis) throws Exception { @@ -102,8 +93,8 @@ private void executeShellCommand(String cmd, long timeoutInMillis) throws Except new InputStreamReader(new ParcelFileDescriptor.AutoCloseInputStream(pfDescriptor))); String line; while ((line = reader.readLine()) != null) { - Log.i("canDrawOverlays_API23_deny", line); - if (endTimeInMillis > System.currentTimeMillis()) { + Log.i("OverlayViewManagerTest", line); + if (endTimeInMillis > 0 && System.currentTimeMillis() > endTimeInMillis) { throw new TimeoutException(); } } @@ -114,4 +105,4 @@ private void executeShellCommand(String cmd, long timeoutInMillis) throws Except } } -} \ No newline at end of file +} diff --git a/core/src/main/AndroidManifest.xml b/core/src/main/AndroidManifest.xml index 9434378..8d323b3 100644 --- a/core/src/main/AndroidManifest.xml +++ b/core/src/main/AndroidManifest.xml @@ -14,11 +14,7 @@ ~ limitations under the License. --> - + - - diff --git a/core/src/main/java/com/nagopy/android/overlayviewmanager/DraggableOnTouchListener.java b/core/src/main/java/com/nagopy/android/overlayviewmanager/DraggableOnTouchListener.java deleted file mode 100644 index db874c1..0000000 --- a/core/src/main/java/com/nagopy/android/overlayviewmanager/DraggableOnTouchListener.java +++ /dev/null @@ -1,130 +0,0 @@ -/* - * Copyright 2017 75py - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.nagopy.android.overlayviewmanager; - -import android.annotation.SuppressLint; -import androidx.annotation.VisibleForTesting; -import android.view.Gravity; -import android.view.MotionEvent; -import android.view.View; - -import com.nagopy.android.overlayviewmanager.internal.Logger; -import com.nagopy.android.overlayviewmanager.internal.ScreenMonitor; - -public class DraggableOnTouchListener implements View.OnTouchListener { - - OverlayView overlayView; - ScreenMonitor screenMonitor; - float backupAlpha; - private float mLastTouchX; - private float mLastTouchY; - private float mPosX; - private float mPosY; - - public DraggableOnTouchListener(OverlayView overlayView) { - this.overlayView = overlayView; - this.screenMonitor = ScreenMonitor.getInstance(); - backupAlpha = overlayView.params.alpha; - } - - @SuppressLint("ClickableViewAccessibility") - @Override - public boolean onTouch(View view, MotionEvent ev) { - final int action = ev.getActionMasked(); - - switch (action) { - case MotionEvent.ACTION_DOWN: - Logger.d("ACTION_DOWN"); - onTouchDown(ev); - break; - - case MotionEvent.ACTION_MOVE: - Logger.d("ACTION_MOVE"); - onTouchMove(ev); - break; - - case MotionEvent.ACTION_UP: - Logger.d("ACTION_UP"); - overlayView.setAlpha(backupAlpha).update(); - break; - - case MotionEvent.ACTION_CANCEL: - Logger.d("ACTION_CANCEL"); - overlayView.setAlpha(backupAlpha).update(); - break; - } - - return false; - } - - @VisibleForTesting - void onTouchMove(MotionEvent ev) { - final float x = ev.getRawX(); - final float y = ev.getRawY(); - - // Calculate the distance moved - final float dx = x - mLastTouchX; - final float dy = y - mLastTouchY; - Logger.d("x:%f, y:%f, dx:%f, dy:%f", x, y, dx, dy); - - mPosX += dx; - mPosY += dy; - Logger.d("mPosX:%f, mPosY:%f", mPosX, mPosY); - - // Update layout position - overlayView - .setX((int) mPosX) - .setY((int) mPosY) - .update(); - - - // Remember this touch position for the next move event - mLastTouchX = x; - mLastTouchY = y; - } - - @VisibleForTesting - void onTouchDown(MotionEvent ev) { - final float x = ev.getRawX(); - final float y = ev.getRawY(); - - // Remember where we started (for dragging) - mLastTouchX = x; - mLastTouchY = y; - Logger.d("mLastTouchX:%f, mLastTouchY:%f", mLastTouchX, mLastTouchY); - - backupAlpha = overlayView.params.alpha; - overlayView.params.alpha *= 0.6; - - int statusBarHeight = screenMonitor.getStatusBarHeight(); - - // Disable verticalMargin/horizontalMargin and set current position to XY. - overlayView.params.verticalMargin = 0; - overlayView.params.horizontalMargin = 0; - int[] location = new int[2]; - overlayView.view.getLocationOnScreen(location); - overlayView.params.x = location[0]; - overlayView.params.y = location[1] - statusBarHeight; - overlayView.params.gravity = Gravity.TOP | Gravity.LEFT; - overlayView.update(); - - mPosX = location[0]; - mPosY = location[1] - statusBarHeight; - Logger.d("mPosX:%f, mPosY:%f", mPosX, mPosY); - } - -} diff --git a/core/src/main/java/com/nagopy/android/overlayviewmanager/OverlayView.java b/core/src/main/java/com/nagopy/android/overlayviewmanager/OverlayView.java deleted file mode 100644 index e5ceb6d..0000000 --- a/core/src/main/java/com/nagopy/android/overlayviewmanager/OverlayView.java +++ /dev/null @@ -1,465 +0,0 @@ -/* - * Copyright 2017 75py - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.nagopy.android.overlayviewmanager; - -import android.app.Activity; -import android.graphics.PixelFormat; -import android.os.Build; -import android.view.Gravity; -import android.view.View; -import android.view.ViewGroup; -import android.view.WindowManager; - -import com.nagopy.android.overlayviewmanager.internal.Logger; -import com.nagopy.android.overlayviewmanager.internal.OverlayWindowManager; -import com.nagopy.android.overlayviewmanager.internal.ScreenMonitor; - -import androidx.annotation.FloatRange; -import androidx.annotation.NonNull; -import androidx.annotation.Nullable; -import androidx.annotation.VisibleForTesting; -import androidx.core.view.GravityCompat; -import androidx.core.view.ViewCompat; - -import static android.view.ViewGroup.LayoutParams.WRAP_CONTENT; -import static android.view.WindowManager.LayoutParams.FLAG_LAYOUT_INSET_DECOR; -import static android.view.WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN; -import static android.view.WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS; -import static android.view.WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE; -import static android.view.WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE; -import static android.view.WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL; -import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION; -import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY; -import static android.view.WindowManager.LayoutParams.TYPE_SYSTEM_ALERT; -import static android.view.WindowManager.LayoutParams.TYPE_SYSTEM_ERROR; -import static android.view.WindowManager.LayoutParams.TYPE_SYSTEM_OVERLAY; - -/** - * The wrapper class of the view to overlay. - * This class allows a view to be displayed as an overlay on top of other content. - * - * @param The type of the view to be overlaid. - */ -public class OverlayView { - - @VisibleForTesting - T view; - @VisibleForTesting - WindowManager.LayoutParams params; - @VisibleForTesting - boolean isVisible; - - @VisibleForTesting - boolean isDraggable; - @VisibleForTesting - boolean isTouchable; - @VisibleForTesting - boolean allowViewToExtendOutsideScreen; - - @VisibleForTesting - int lastWindowType; - - @VisibleForTesting - OverlayWindowManager overlayWindowManager; - - @VisibleForTesting - ScreenMonitor screenMonitor; - - enum ViewScope {APPLICATION, ACTIVITY} - - @VisibleForTesting - ViewScope viewScope; - - /** - * Create a new instance with ViewScope set to APPLICATION. - * This is used when the overlay is to be displayed regardless of the activity lifecycle. - * - * @param view The view to overlay. - * @param The type of the view. - * @return A new instance of OverlayView. - */ - @NonNull - static OverlayView create(@NonNull T view) { - OverlayView overlayView = new OverlayView<>(view); - overlayView.viewScope = ViewScope.APPLICATION; - overlayView.overlayWindowManager = OverlayWindowManager.getApplicationInstance(); - return overlayView; - } - - /** - * Create a new instance with ViewScope set to ACTIVITY. - * This is used when the overlay should be managed within an activity's lifecycle. - * - * @param view The view to overlay. - * @param The type of the view. - * @param activity The parent activity. - * @return A new instance of OverlayView. - */ - @NonNull - static OverlayView create(@NonNull T view, Activity activity) { - OverlayView overlayView = new OverlayView<>(view); - overlayView.viewScope = ViewScope.ACTIVITY; - overlayView.overlayWindowManager = OverlayWindowManager.getActivityInstance(activity); - return overlayView; - } - - /** - * Private constructor. - * Use {@link OverlayView#create(View)} or {@link OverlayView#create(View, Activity)} to get an instance. - * - * @param view The view to overlay. - */ - private OverlayView(@NonNull T view) { - this.view = view; - params = new WindowManager.LayoutParams(); - params.format = PixelFormat.TRANSLUCENT; - setWidth(WRAP_CONTENT) - .setHeight(WRAP_CONTENT) - .setTouchable(false) - .setDraggable(false) - .allowViewToExtendOutsideScreen(false) - .setGravity(Gravity.TOP | Gravity.START); - isVisible = false; - screenMonitor = ScreenMonitor.getInstance(); - } - - /** - * Starts overlaying the view. - * If the view is already shown, this method does nothing. - * - * @return This object for method chaining. - */ - @NonNull - public synchronized OverlayView show() { - if (!isVisible()) { - updateParams(); - - overlayWindowManager.show(view, params); - isVisible = true; - lastWindowType = params.type; - - if (isDraggable) { - screenMonitor.request(this); - } - } - return this; - } - - /** - * Requests updating the window parameters. - * If the view is shown, it will call {@link WindowManager#updateViewLayout(View, ViewGroup.LayoutParams)}. - */ - public synchronized void update() { - if (isVisible()) { - updateParams(); - - if (lastWindowType == params.type) { - overlayWindowManager.update(view, params); - } else { - Logger.d("Window type is changed. %d => %d", lastWindowType, params.type); - overlayWindowManager.hide(view); - overlayWindowManager.show(view, params); - lastWindowType = params.type; - } - - if (isDraggable) { - screenMonitor.request(this); - } else { - screenMonitor.cancel(this); - } - } - } - - /** - * Stops overlaying the view. - * If the view is already hidden, this method does nothing. - */ - public synchronized void hide() { - if (isVisible()) { - overlayWindowManager.hide(view); - isVisible = false; - - if (isDraggable) { - screenMonitor.cancel(this); - } - } - } - - /** - * Returns the managed view. - * - * @return The overlaid view. - */ - @NonNull - public T getView() { - return view; - } - - /** - * Returns the visibility status of the view. - * - * @return true if the view is visible, false otherwise. - */ - public boolean isVisible() { - return isVisible; - } - - /** - * Registers a callback to click events. - * - * @param onClickListener The callback to be invoked on click events. - * @return This object for method chaining. - */ - @NonNull - public OverlayView setOnClickListener(@Nullable View.OnClickListener onClickListener) { - view.setOnClickListener(onClickListener); - return this; - } - - /** - * Enables or disables touch events for this view. - * - * @param touchable true to enable touch events, false to disable. - * @return This object for method chaining. - */ - @NonNull - public OverlayView setTouchable(boolean touchable) { - this.isTouchable = touchable; - return this; - } - - /** - * Allows or disallows the view to extend outside the screen. - * If true, the view can overlay on a navigation bar or a status bar. - * Note: Using this option may cause unexpected behavior. - * - * @param allowViewToExtendOutsideScreen true to allow extending, false otherwise. - * @return This object for method chaining. - */ - @NonNull - public OverlayView allowViewToExtendOutsideScreen(boolean allowViewToExtendOutsideScreen) { - this.allowViewToExtendOutsideScreen = allowViewToExtendOutsideScreen; - return this; - } - - /** - * Enables or disables moving the view by dragging. - * - * @param draggable true to enable dragging, false to disable. - * @return This object for method chaining. - */ - @NonNull - public OverlayView setDraggable(boolean draggable) { - return setDraggable(draggable, new DraggableOnTouchListener<>(this)); - } - - /** - * Enables or disables moving the view by dragging with a custom listener. - * - * @param draggable true to enable dragging, false to disable. - * @param listener The custom touch listener for handling drag events. - * @return This object for method chaining. - */ - @NonNull - public OverlayView setDraggable(boolean draggable, DraggableOnTouchListener listener) { - this.isDraggable = draggable; - if (draggable) { - view.setOnTouchListener(listener); - } else { - view.setOnTouchListener(null); - } - return this; - } - - /** - * Sets the width parameter of the view. - * - * @param width The width in pixels, or use {@link android.view.ViewGroup.LayoutParams#WRAP_CONTENT} - * or {@link android.view.ViewGroup.LayoutParams#MATCH_PARENT}. - * @return This object for method chaining. - */ - @NonNull - public OverlayView setWidth(int width) { - params.width = width; - return this; - } - - /** - * Sets the height parameter of the view. - * - * @param height The height in pixels, or use {@link android.view.ViewGroup.LayoutParams#WRAP_CONTENT} - * or {@link android.view.ViewGroup.LayoutParams#MATCH_PARENT}. - * @return This object for method chaining. - */ - @NonNull - public OverlayView setHeight(int height) { - params.height = height; - return this; - } - - /** - * Sets the placement of the window within the screen as per Gravity. - * - * @param gravity The gravity constants from {@link Gravity}. - * @return This object for method chaining. - * @see Gravity - * @see WindowManager.LayoutParams#gravity - */ - @NonNull - public OverlayView setGravity(int gravity) { - params.gravity = GravityCompat.getAbsoluteGravity(gravity, - ViewCompat.getLayoutDirection(view)); - return this; - } - - /** - * Sets the horizontal margin. - * - * @param margin The horizontal margin (0 to 1). - * @return This object for method chaining. - * @see WindowManager.LayoutParams#horizontalMargin - */ - @NonNull - public OverlayView setHorizontalMargin(@FloatRange(from = 0.0, to = 1.0) float margin) { - params.horizontalMargin = margin; - return this; - } - - /** - * Sets the vertical margin. - * - * @param margin The vertical margin (0 to 1). - * @return This object for method chaining. - * @see WindowManager.LayoutParams#verticalMargin - */ - @NonNull - public OverlayView setVerticalMargin(@FloatRange(from = 0.0, to = 1.0) float margin) { - params.verticalMargin = margin; - return this; - } - - /** - * Sets the opacity of the view. 0 means completely translucent. - * - * @param alpha The opacity value (0 to 1). - * @return This object for method chaining. - * @see WindowManager.LayoutParams#alpha - */ - @NonNull - public OverlayView setAlpha(@FloatRange(from = 0.0, to = 1.0) float alpha) { - params.alpha = alpha; - return this; - } - - /** - * Sets the X position of the view. - * - * @param x The X position in pixels. - * @return This object for method chaining. - * @see WindowManager.LayoutParams#x - */ - @NonNull - public OverlayView setX(int x) { - params.x = x; - return this; - } - - /** - * Gets the X position of the view. - * - * @return The X position in pixels. - * @see WindowManager.LayoutParams#x - */ - public int getX() { - return params.x; - } - - /** - * Sets the Y position of the view. - * - * @param y The Y position in pixels. - * @return This object for method chaining. - * @see WindowManager.LayoutParams#y - */ - @NonNull - public OverlayView setY(int y) { - params.y = y; - return this; - } - - /** - * Gets the Y position of the view. - * - * @return The Y position in pixels. - * @see WindowManager.LayoutParams#y - */ - public int getY() { - return params.y; - } - - /** - * Sets the brightness of the screen. - * - * @param screenBrightness The brightness value (0 to 1). - * @return This object for method chaining. - * @see WindowManager.LayoutParams#screenBrightness - */ - @NonNull - public OverlayView setScreenBrightness(float screenBrightness) { - params.screenBrightness = screenBrightness; - return this; - } - - @VisibleForTesting - void updateParams() { - params.type = TYPE_APPLICATION; - params.flags = FLAG_NOT_FOCUSABLE; - - if (allowViewToExtendOutsideScreen) { - params.flags |= FLAG_LAYOUT_NO_LIMITS; - params.flags |= FLAG_LAYOUT_INSET_DECOR; - params.flags |= FLAG_LAYOUT_IN_SCREEN; - } - - if (isTouchable || isDraggable) { - if (allowViewToExtendOutsideScreen && Build.VERSION.SDK_INT < Build.VERSION_CODES.O) { - // On the navigation - params.type = TYPE_SYSTEM_ERROR; - } else { - // Touchable, cannot overlay on the navigation - if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) { - params.type = TYPE_APPLICATION_OVERLAY; - } else { - params.type = TYPE_SYSTEM_ALERT; - } - } - } else { - params.flags |= FLAG_NOT_TOUCHABLE; - params.flags |= FLAG_NOT_TOUCH_MODAL; - if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) { - params.type = TYPE_APPLICATION_OVERLAY; - } else { - params.type = TYPE_SYSTEM_OVERLAY; - } - } - - if (viewScope == ViewScope.ACTIVITY) { - params.type = TYPE_APPLICATION; - } - } - -} diff --git a/core/src/main/java/com/nagopy/android/overlayviewmanager/OverlayViewManager.java b/core/src/main/java/com/nagopy/android/overlayviewmanager/OverlayViewManager.java deleted file mode 100644 index e48c22d..0000000 --- a/core/src/main/java/com/nagopy/android/overlayviewmanager/OverlayViewManager.java +++ /dev/null @@ -1,187 +0,0 @@ -/* - * Copyright 2017 75py - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.nagopy.android.overlayviewmanager; - -import android.annotation.TargetApi; -import android.app.Activity; -import android.app.Application; -import android.content.Context; -import android.content.Intent; -import android.net.Uri; -import android.os.Build; -import android.provider.Settings; - -import androidx.annotation.NonNull; -import androidx.annotation.StringRes; -import androidx.fragment.app.FragmentManager; - -import android.util.DisplayMetrics; -import android.view.View; -import android.view.WindowManager; - -import com.nagopy.android.overlayviewmanager.internal.Logger; -import com.nagopy.android.overlayviewmanager.internal.OverlayWindowManager; -import com.nagopy.android.overlayviewmanager.internal.ScreenMonitor; - -/** - * Overlay your views! - * This class manages the overlay views and their configurations. - */ -public final class OverlayViewManager { - - Context applicationContext; - WindowManager windowManager; - - static OverlayViewManager INSTANCE = new OverlayViewManager(); - - /** - * Initialize the OverlayViewManager. - * This method must be called before using any other methods of this class. - * - * @param application Your {@link Application} instance - */ - public static void init(Application application) { - INSTANCE.initialize(application); - } - - /** - * Return the singleton instance of {@link OverlayViewManager}. - * This instance is initialized through the {@link #init(Application)} method. - * - * @return the singleton instance of {@link OverlayViewManager} - * @throws IllegalStateException if the manager is not initialized - */ - public static OverlayViewManager getInstance() { - if (INSTANCE.applicationContext == null) { - throw new IllegalStateException("OverlayViewManager is not initialized. Please call initApplicationInstance(Application)."); - } - return INSTANCE; - } - - OverlayViewManager() { - } - - /** - * Initialize. Please call this method before {@link OverlayView} use. - * - * @param context {@link Context} - */ - void initialize(@NonNull Context context) { - applicationContext = context.getApplicationContext(); - windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE); - OverlayWindowManager.initApplicationInstance(windowManager); - ScreenMonitor.init(applicationContext); - } - - /** - * Checks if the application has permission to draw overlays on top of other apps. - *

- * This method is a wrapper for {@link Settings#canDrawOverlays(Context)}. - *

- * - * @return true if the application is allowed to display over other apps, false otherwise - */ - public boolean canDrawOverlays() { - //noinspection SimplifiableIfStatement - if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) { - return true; - } else { - return Settings.canDrawOverlays(applicationContext); - } - } - - /** - * Show permission request dialog. - * - * @param fragmentManager {@link FragmentManager} - * @param appNameId String resource id of application name - */ - @TargetApi(Build.VERSION_CODES.M) - public void showPermissionRequestDialog(@NonNull FragmentManager fragmentManager, @StringRes int appNameId) { - PermissionRequestDialogFragment dialog = PermissionRequestDialogFragment.newInstance(appNameId); - dialog.show(fragmentManager, "PermissionRequestDialogFragment"); - } - - /** - * Request overlay permission. Open the setting app. - */ - @TargetApi(Build.VERSION_CODES.M) - public void requestOverlayPermission() { - if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) { - if (!canDrawOverlays()) { - Intent intent = new Intent(Settings.ACTION_MANAGE_OVERLAY_PERMISSION, Uri.parse("package:" + applicationContext.getPackageName())); - intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP); - applicationContext.startActivity(intent); - } - } else { - Logger.d("API level %d is not required any user action.", Build.VERSION.SDK_INT); - } - } - - /** - * Get display width. - * - * @return Display width(px) - */ - public int getDisplayWidth() { - DisplayMetrics metrics = new DisplayMetrics(); - windowManager.getDefaultDisplay().getMetrics(metrics); - return metrics.widthPixels; - } - - /** - * Get display height. It includes the status bar and the navigation bar. - * - * @return Display height(px) - */ - public int getDisplayHeight() { - DisplayMetrics metrics = new DisplayMetrics(); - windowManager.getDefaultDisplay().getMetrics(metrics); - return metrics.heightPixels; - } - - /** - * Create a new OverlayView instance. ViewScope = ACTIVITY - * If you want to show your view in Activity's lifecycle, use #newOverlayView(View, Activity). - * Otherwise(If you want to show your view regardless of whether Activity is alive), use #newOverlayView(View). - *

- * If you use OverlayView from Activity only, you don't have to get "Draw over other apps" permission. - * - * @param view The view that you want to overlay - * @param View - * @param activity Parent activity - * @return A new instance of OverlayView - */ - @NonNull - public OverlayView newOverlayView(T view, Activity activity) { - return OverlayView.create(view, activity); - } - - /** - * Create a new OverlayView instance. ViewScope = APPLICATION - * If you want to show your view regardless of whether Activity is alive, use #newOverlayView(View). - * Otherwise(if you want to show your view in Activity's lifecycle), use #newOverlayView(View, Activity). - * - * @param view The view that you want to overlay - * @param View - * @return A new instance of OverlayView - */ - @NonNull - public OverlayView newOverlayView(T view) { - return OverlayView.create(view); - } -} diff --git a/core/src/main/java/com/nagopy/android/overlayviewmanager/PermissionRequestDialogFragment.java b/core/src/main/java/com/nagopy/android/overlayviewmanager/PermissionRequestDialogFragment.java deleted file mode 100644 index cc1ea86..0000000 --- a/core/src/main/java/com/nagopy/android/overlayviewmanager/PermissionRequestDialogFragment.java +++ /dev/null @@ -1,74 +0,0 @@ -/* - * Copyright 2017 75py - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.nagopy.android.overlayviewmanager; - - -import android.app.AlertDialog; -import android.app.Dialog; -import android.content.DialogInterface; -import android.os.Bundle; -import androidx.annotation.NonNull; -import androidx.annotation.StringRes; -import androidx.annotation.VisibleForTesting; -import androidx.fragment.app.DialogFragment; - -/** - * Permission request dialog. - */ -public class PermissionRequestDialogFragment extends DialogFragment { - - @VisibleForTesting - static final String KEY_APP_NAME_ID = "appNameId"; - - public PermissionRequestDialogFragment() { - super(); - } - - /** - * Create new instance of {@link PermissionRequestDialogFragment}. - * - * @param appNameId String resource id of application name - * @return instance - */ - public static PermissionRequestDialogFragment newInstance(@StringRes int appNameId) { - PermissionRequestDialogFragment dialog = new PermissionRequestDialogFragment(); - Bundle args = new Bundle(); - args.putInt(KEY_APP_NAME_ID, appNameId); - dialog.setArguments(args); - return dialog; - } - - @NonNull - @Override - public Dialog onCreateDialog(Bundle savedInstanceState) { - int appNameId = getArguments().getInt(KEY_APP_NAME_ID); - String appName = getString(appNameId); - String msg = getString( - R.string.overlayviewmanager_this_app_needs_permission - , appName); - return new AlertDialog.Builder(getActivity()) - .setTitle(appNameId) - .setMessage(msg) - .setPositiveButton(R.string.overlayviewmanager_grant_permission, new DialogInterface.OnClickListener() { - @Override - public void onClick(DialogInterface dialog, int which) { - OverlayViewManager.getInstance().requestOverlayPermission(); - } - }) - .create(); - } -} \ No newline at end of file diff --git a/core/src/main/java/com/nagopy/android/overlayviewmanager/internal/Logger.java b/core/src/main/java/com/nagopy/android/overlayviewmanager/internal/Logger.java index 3276b85..5ca89e0 100644 --- a/core/src/main/java/com/nagopy/android/overlayviewmanager/internal/Logger.java +++ b/core/src/main/java/com/nagopy/android/overlayviewmanager/internal/Logger.java @@ -21,12 +21,12 @@ import com.nagopy.android.overlayviewmanager.BuildConfig; -import static androidx.annotation.RestrictTo.Scope.LIBRARY; +import static androidx.annotation.RestrictTo.Scope.LIBRARY_GROUP; /** * Inner class for debug. */ -@RestrictTo(LIBRARY) +@RestrictTo(LIBRARY_GROUP) public class Logger { static final String TAG = "OverlayViewManager"; diff --git a/core/src/main/java/com/nagopy/android/overlayviewmanager/internal/OverlayWindowManager.java b/core/src/main/java/com/nagopy/android/overlayviewmanager/internal/OverlayWindowManager.java deleted file mode 100644 index 492a395..0000000 --- a/core/src/main/java/com/nagopy/android/overlayviewmanager/internal/OverlayWindowManager.java +++ /dev/null @@ -1,124 +0,0 @@ -/* - * Copyright 2017 75py - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.nagopy.android.overlayviewmanager.internal; - -import android.app.Activity; -import android.os.Handler; -import android.os.Looper; -import androidx.annotation.RestrictTo; -import androidx.annotation.VisibleForTesting; -import android.view.View; -import android.view.WindowManager; - -import java.util.WeakHashMap; - -import static androidx.annotation.RestrictTo.Scope.LIBRARY; -import static androidx.annotation.RestrictTo.Scope.TESTS; - -@RestrictTo(LIBRARY) -public class OverlayWindowManager { - - static OverlayWindowManager applicationInstance = new OverlayWindowManager(); - static Handler handler = new Handler(Looper.getMainLooper()); - static WeakHashMap activityInstances = new WeakHashMap<>(); - - public static OverlayWindowManager getApplicationInstance() { - return applicationInstance; - } - - @RestrictTo(TESTS) - public static void setApplicationInstance(OverlayWindowManager applicationInstance) { - OverlayWindowManager.applicationInstance = applicationInstance; - } - - public static void initApplicationInstance(WindowManager windowManager) { - applicationInstance.windowManager = windowManager; - } - - public static OverlayWindowManager getActivityInstance(Activity activity) { - OverlayWindowManager activityInstance = activityInstances.get(activity); - if (activityInstance == null) { - activityInstance = new OverlayWindowManager(); - activityInstance.windowManager = activity.getWindowManager(); - activityInstances.put(activity, activityInstance); - } - return activityInstance; - } - - @RestrictTo(TESTS) - public static void setActivityInstance(Activity activity, OverlayWindowManager activityInstance) { - activityInstances.put(activity, activityInstance); - } - - - WindowManager windowManager; - - OverlayWindowManager() { - } - - public void show(final View view, final WindowManager.LayoutParams params) { - runOnUiThread(new Runnable() { - @Override - public void run() { - try { - Logger.v("Call WindowManager#addView"); - windowManager.addView(view, params); - } catch (Exception e) { - Logger.v(e, "Fail: WindowManager#addView"); - } - } - }); - } - - public void update(final View view, final WindowManager.LayoutParams params) { - runOnUiThread(new Runnable() { - @Override - public void run() { - try { - Logger.v("Call WindowManager#updateViewLayout"); - windowManager.updateViewLayout(view, params); - } catch (Exception e) { - Logger.v(e, "Fail: WindowManager#removeView"); - } - } - }); - } - - public void hide(final View view) { - runOnUiThread(new Runnable() { - @Override - public void run() { - try { - Logger.v("Call WindowManager#removeView"); - windowManager.removeViewImmediate(view); - } catch (Exception e) { - Logger.v(e, "Fail: WindowManager#removeView"); - } - } - }); - } - - @VisibleForTesting - void runOnUiThread(Runnable action) { - Looper mainLooper = Looper.getMainLooper(); // Unit tests return null - if (mainLooper != null && !Thread.currentThread().equals(mainLooper.getThread())) { - handler.post(action); - } else { - action.run(); - } - } -} diff --git a/core/src/main/java/com/nagopy/android/overlayviewmanager/internal/ScreenMonitor.java b/core/src/main/java/com/nagopy/android/overlayviewmanager/internal/ScreenMonitor.java deleted file mode 100644 index 35637fb..0000000 --- a/core/src/main/java/com/nagopy/android/overlayviewmanager/internal/ScreenMonitor.java +++ /dev/null @@ -1,156 +0,0 @@ -/* - * Copyright 2017 75py - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.nagopy.android.overlayviewmanager.internal; - -import android.content.Context; -import android.graphics.PixelFormat; -import android.graphics.Rect; -import android.os.Build; -import androidx.annotation.RestrictTo; -import android.view.View; -import android.view.ViewTreeObserver; -import android.view.WindowManager; - -import com.nagopy.android.overlayviewmanager.OverlayView; - -import static androidx.annotation.RestrictTo.Scope.LIBRARY; -import static androidx.annotation.RestrictTo.Scope.TESTS; -import static android.view.ViewGroup.LayoutParams.MATCH_PARENT; -import static android.view.WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE; -import static android.view.WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE; -import static android.view.WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL; -import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY; -import static android.view.WindowManager.LayoutParams.TYPE_SYSTEM_OVERLAY; - -/** - * Inner class. Monitor the screen and calculate the height of the status bar. - */ -@RestrictTo(LIBRARY) -public class ScreenMonitor { - - ScreenMonitor() { - } - - static ScreenMonitor INSTANCE = new ScreenMonitor(); - - public static ScreenMonitor getInstance() { - return INSTANCE; - } - - @RestrictTo(TESTS) - public static void setInstance(ScreenMonitor screenMonitor) { - INSTANCE = screenMonitor; - } - - ScreenMonitorView monitorView; - WindowManager.LayoutParams params; - WeakReferenceCache> requestedViews; - OverlayWindowManager overlayWindowManager; - - public static void init(Context context) { - INSTANCE.initialize(context); - } - - void initialize(Context context) { - monitorView = new ScreenMonitorView(context); - params = new WindowManager.LayoutParams(); - params.width = 1; - params.height = MATCH_PARENT; - if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) { - params.type = TYPE_APPLICATION_OVERLAY; - } else { - params.type = TYPE_SYSTEM_OVERLAY; - } - params.flags = FLAG_NOT_TOUCHABLE; - params.flags |= FLAG_NOT_TOUCH_MODAL; - params.flags |= FLAG_NOT_FOCUSABLE; - params.format = PixelFormat.TRANSLUCENT; - requestedViews = new WeakReferenceCache<>(); - - overlayWindowManager = OverlayWindowManager.getApplicationInstance(); - } - - public synchronized void request(OverlayView overlayView) { - if (requestedViews.isEmpty()) { - // First request - Logger.d("Start monitoring"); - overlayWindowManager.show(monitorView, params); - } - requestedViews.add(overlayView); - } - - public synchronized void cancel(OverlayView overlayView) { - if (!requestedViews.isEmpty()) { - requestedViews.remove(overlayView); - if (requestedViews.isEmpty()) { - // Stop - Logger.d("Stop monitoring"); - overlayWindowManager.hide(monitorView); - } - } - } - - /** - * For unit test. If ScreenMonitorView is attached, it cannot find the overlay view by Espresso. - */ - @RestrictTo(TESTS) - public synchronized void cancelForce() { - overlayWindowManager.hide(monitorView); - } - - /** - * Get current height of the status bar. - * - * @return Height of the status bar - */ - public int getStatusBarHeight() { - return monitorView.statusBarHeight; - } - - static class ScreenMonitorView extends View implements ViewTreeObserver.OnGlobalLayoutListener { - - int statusBarHeight; - - public ScreenMonitorView(Context context) { - super(context); - statusBarHeight = 0; - } - - @Override - protected void onAttachedToWindow() { - super.onAttachedToWindow(); - getViewTreeObserver().addOnGlobalLayoutListener(this); - } - - @Override - protected void onDetachedFromWindow() { - super.onDetachedFromWindow(); - getViewTreeObserver().removeOnGlobalLayoutListener(this); - } - - @Override - public void onGlobalLayout() { - Rect outRect = new Rect(); - getWindowVisibleDisplayFrame(outRect); - - statusBarHeight = outRect.top; - Logger.d("Update statusBarHeight %d", statusBarHeight); - } - - } - -} diff --git a/core/src/main/java/com/nagopy/android/overlayviewmanager/internal/SimpleActivityLifecycleCallbacks.java b/core/src/main/java/com/nagopy/android/overlayviewmanager/internal/SimpleActivityLifecycleCallbacks.java index 319c11c..6abfe73 100644 --- a/core/src/main/java/com/nagopy/android/overlayviewmanager/internal/SimpleActivityLifecycleCallbacks.java +++ b/core/src/main/java/com/nagopy/android/overlayviewmanager/internal/SimpleActivityLifecycleCallbacks.java @@ -21,9 +21,9 @@ import android.os.Bundle; import androidx.annotation.RestrictTo; -import static androidx.annotation.RestrictTo.Scope.LIBRARY; +import static androidx.annotation.RestrictTo.Scope.LIBRARY_GROUP; -@RestrictTo(LIBRARY) +@RestrictTo(LIBRARY_GROUP) public abstract class SimpleActivityLifecycleCallbacks implements Application.ActivityLifecycleCallbacks { @Override diff --git a/core/src/main/java/com/nagopy/android/overlayviewmanager/internal/WeakReferenceCache.java b/core/src/main/java/com/nagopy/android/overlayviewmanager/internal/WeakReferenceCache.java deleted file mode 100644 index 36e303e..0000000 --- a/core/src/main/java/com/nagopy/android/overlayviewmanager/internal/WeakReferenceCache.java +++ /dev/null @@ -1,85 +0,0 @@ -/* - * Copyright 2017 75py - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.nagopy.android.overlayviewmanager.internal; - - -import androidx.annotation.RestrictTo; - -import java.lang.ref.WeakReference; -import java.util.ArrayList; -import java.util.Iterator; -import java.util.List; - -import static androidx.annotation.RestrictTo.Scope.LIBRARY; - -@RestrictTo(LIBRARY) -public class WeakReferenceCache { - - final List> cacheSet; - - public WeakReferenceCache() { - this.cacheSet = new ArrayList<>(); - } - - public synchronized void add(T obj) { - Iterator> iterator = cacheSet.iterator(); - while (iterator.hasNext()) { - T cachedObj = iterator.next().get(); - if (cachedObj == null) { - iterator.remove(); - } else if (cachedObj == obj) { - Logger.v("Already cached. %s", obj); - return; - } - } - cacheSet.add(new WeakReference<>(obj)); - } - - public synchronized void remove(T obj) { - Iterator> iterator = cacheSet.iterator(); - while (iterator.hasNext()) { - T cachedObj = iterator.next().get(); - if (cachedObj == null) { - iterator.remove(); - } else if (cachedObj == obj) { - iterator.remove(); - Logger.v("Removed. %s", obj); - return; - } - } - } - - public synchronized boolean isEmpty() { - Iterator> iterator = cacheSet.iterator(); - while (iterator.hasNext()) { - T cachedObj = iterator.next().get(); - if (cachedObj == null) { - iterator.remove(); - } - } - return cacheSet.isEmpty(); - } - - public synchronized boolean contains(T obj) { - for (WeakReference cache : cacheSet) { - if (cache.get() == obj) { - return true; - } - } - return false; - } -} diff --git a/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/CrossUidPassThrough.kt b/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/CrossUidPassThrough.kt new file mode 100644 index 0000000..f2fadf3 --- /dev/null +++ b/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/CrossUidPassThrough.kt @@ -0,0 +1,47 @@ +/* + * Copyright 2026 75py + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.nagopy.android.overlayviewmanager + +/** + * Controls whether the library checks an application [OverlayTouchMode.PASS_THROUGH] overlay + * against Android's cross-UID touch opacity limit before attaching it. + * + * Neither value isolates touches by UID; on Android 12 (API 31) and later the platform decides + * whether a touch reaches another application, based on the overlay's opacity against + * `InputManager.getMaximumObscuringOpacityForTouch()` (0.8 by default). When the alpha exceeds + * that maximum, the outcome depends on whether the build includes the window manager's opacity + * clamp, which the API level alone does not tell. A build with the clamp lowers the overlay to the + * maximum and lets the touch through; a build without it, such as the initial Android 12 release, + * keeps the overlay opaque and blocks the touch. Overlapping overlays of one application can exceed + * the combined limit and be blocked either way. + */ +public enum class CrossUidPassThrough { + /** + * The default. The library makes no cross-UID claim and runs no opacity check; whether another + * application receives the touch, and whether the overlay is dimmed, is up to the platform. + */ + SAME_UID_ONLY, + + /** + * Requests cross-UID pass-through. On API 31+ the library rejects a show or update whose + * combined library-managed opacity exceeds the maximum with + * [OverlayFailure.PASS_THROUGH_OPACITY_EXCEEDED], or with + * [OverlayFailure.PASS_THROUGH_UNSUPPORTED] when the maximum is unavailable. Delivery is still + * not guaranteed. + */ + WHEN_SYSTEM_ALLOWS, +} diff --git a/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/DraggableOnTouchListener.kt b/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/DraggableOnTouchListener.kt new file mode 100644 index 0000000..45912a7 --- /dev/null +++ b/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/DraggableOnTouchListener.kt @@ -0,0 +1,230 @@ +/* + * Copyright 2017 75py + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.nagopy.android.overlayviewmanager + +import android.annotation.SuppressLint +import android.view.Gravity +import android.view.MotionEvent +import android.view.View +import android.view.ViewConfiguration +import androidx.annotation.RestrictTo +import androidx.annotation.VisibleForTesting +import com.nagopy.android.overlayviewmanager.internal.Logger +import com.nagopy.android.overlayviewmanager.internal.OverlayGeometry +import com.nagopy.android.overlayviewmanager.internal.OverlayWindowFrame +import kotlin.math.abs + +/** + * Library-owned drag gesture for [OverlayTouchMode.DRAGGABLE]. It is not part of the 3.0 public + * API: Kotlin consumers cannot see this `internal` declaration, and no public member exposes it. + * + * `x`/`y` are converted from screen space into the target window's layout space using + * [OverlayGeometry] and [OverlayWindowFrame]. With `allowOutsideBounds` there is no usable frame, + * so the pointer's delta is added to the spec's offsets instead -- see [OverlayGeometry] for the + * coordinate model. A drag is not applied to the spec until + * [ViewConfiguration.getScaledTouchSlop] is exceeded. + * + * ## Consumption policy + * + * [onTouch] returns `true` for `ACTION_DOWN` only when the managed [View] is neither + * [View.isClickable] nor [View.isLongClickable]: there is no click to preserve, and consuming + * `DOWN` guarantees this listener keeps seeing every later event of the gesture regardless of + * what a parent would otherwise decide from an unconsumed `DOWN`. When the view is clickable or + * long-clickable, `DOWN` returns `false` so the view's own [View.onTouchEvent] tracks the press + * and can still perform an ordinary click. Once slop is exceeded, the gesture becomes a drag + * unconditionally: every later event of it is consumed, and [View.cancelLongPress] plus clearing + * [View.isPressed] cancel a pending click/long-press on a clickable view so `ACTION_UP` cannot + * fire one after a drag. + * + * ## Translucent feedback + * + * While a drag runs, [OverlayView] lowers the window's alpha. That is an appearance of the window, + * not configuration: `spec.alpha` keeps the caller's value, so a caller's update during the drag + * is never overwritten when the gesture ends. [OverlayView] also ends the feedback itself if the + * mode leaves [OverlayTouchMode.DRAGGABLE], since this listener is then removed before it can see + * the gesture's `ACTION_UP` or `ACTION_CANCEL`. + * + * ## Failure recovery + * + * The drag only advances its internal "last applied" position and raw touch reference after the + * corresponding [OverlayView.update] call actually succeeds. A rejected backend update therefore + * neither changes the effective spec (guaranteed by [OverlayView] itself) nor desyncs the + * listener: the next move recomputes the full accumulated delta since the last success against + * the same base position, so the drag continues from the effective spec's last applied position + * once updates start succeeding again, rather than jumping by whatever was attempted meanwhile. + * + * A second pointer touching down never changes which pointer drives the drag; if the active + * pointer itself lifts while others remain, tracking rebases onto a remaining pointer's current + * position instead of its stale prior position, so the overlay does not jump. + */ +@RestrictTo(RestrictTo.Scope.LIBRARY) +internal class DraggableOnTouchListener( + private val overlayView: OverlayView, +) : View.OnTouchListener { + + private var activePointerId = MotionEvent.INVALID_POINTER_ID + private var isDragging = false + private var dragApplied = false + private var consumesFromDown = false + private var downRawX = 0f + private var downRawY = 0f + private var lastRawX = 0f + private var lastRawY = 0f + private var posX = 0f + private var posY = 0f + + @SuppressLint("ClickableViewAccessibility") + override fun onTouch(view: View, ev: MotionEvent): Boolean = when (ev.actionMasked) { + MotionEvent.ACTION_DOWN -> { + Logger.d("ACTION_DOWN") + onActionDown(view, ev) + } + MotionEvent.ACTION_POINTER_DOWN -> consumed() + MotionEvent.ACTION_MOVE -> onActionMove(view, ev) + MotionEvent.ACTION_POINTER_UP -> { + onActionPointerUp(ev) + consumed() + } + MotionEvent.ACTION_UP -> { + Logger.d("ACTION_UP") + onActionEnd() + } + MotionEvent.ACTION_CANCEL -> { + Logger.d("ACTION_CANCEL") + onActionEnd() + } + else -> consumed() + } + + private fun consumed(): Boolean = consumesFromDown || isDragging + + private fun onActionDown(view: View, ev: MotionEvent): Boolean { + activePointerId = ev.getPointerId(0) + isDragging = false + dragApplied = false + downRawX = ev.rawX + downRawY = ev.rawY + lastRawX = downRawX + lastRawY = downRawY + + val spec = overlayView.spec + if (spec.allowOutsideBounds) { + posX = spec.x.toFloat() + posY = spec.y.toFloat() + } else { + // Convert the view's current screen location into the target window's layout space + // instead of assuming the display origin or a fixed status-bar inset. + val location = IntArray(2) + view.getLocationOnScreen(location) + val frame = OverlayWindowFrame.of(view) + posX = OverlayGeometry.screenToWindowX(location[0], frame.left).toFloat() + posY = OverlayGeometry.screenToWindowY(location[1], frame.top).toFloat() + } + + consumesFromDown = !view.isClickable && !view.isLongClickable + return consumesFromDown + } + + @VisibleForTesting + internal fun onActionMove(view: View, ev: MotionEvent): Boolean { + val pointerIndex = ev.findPointerIndex(activePointerId) + if (pointerIndex == -1) return consumed() + val (rawX, rawY) = rawCoordinates(ev, pointerIndex) + + if (!isDragging) { + val dx = rawX - downRawX + val dy = rawY - downRawY + val slop = ViewConfiguration.get(view.context).scaledTouchSlop + if (abs(dx) < slop && abs(dy) < slop) return consumesFromDown + isDragging = true + cancelPendingClick(view) + } + + // Only ever advance from the last successfully applied position: if the backend rejects + // this attempt, the next move recomputes the full delta since that last success instead + // of compounding an unapplied displacement. + val spec = overlayView.spec + val placement = if (dragApplied || spec.allowOutsideBounds) { + spec + } else { + spec.copy(gravity = Gravity.TOP or Gravity.LEFT, horizontalMargin = 0f, verticalMargin = 0f) + } + val gravity = OverlayGeometry.absoluteGravity(placement.gravity, view) + val candidateX = posX + OverlayGeometry.horizontalOffsetSign(gravity) * (rawX - lastRawX) + val candidateY = posY + OverlayGeometry.verticalOffsetSign(gravity) * (rawY - lastRawY) + val result = overlayView.updateDuringDrag( + placement.copy(x = candidateX.toInt(), y = candidateY.toInt()), + ) + if (result.isSuccess) { + posX = candidateX + posY = candidateY + lastRawX = rawX + lastRawY = rawY + dragApplied = true + } + return true + } + + private fun cancelPendingClick(view: View) { + view.cancelLongPress() + view.isPressed = false + } + + private fun onActionPointerUp(ev: MotionEvent) { + val liftedIndex = ev.actionIndex + if (ev.getPointerId(liftedIndex) != activePointerId) return + // The pointer driving the gesture just lifted while another remains: rebase onto that + // pointer's current position so the next move delta does not jump. + val newIndex = if (liftedIndex == 0) 1 else 0 + if (newIndex >= ev.pointerCount) { + activePointerId = MotionEvent.INVALID_POINTER_ID + return + } + activePointerId = ev.getPointerId(newIndex) + val (rawX, rawY) = rawCoordinates(ev, newIndex) + lastRawX = rawX + lastRawY = rawY + if (!isDragging) { + // The slop origin must also move to the new pointer, or a later stationary move from + // it would be measured against the old pointer's down point and spuriously exceed slop. + downRawX = rawX + downRawY = rawY + } + } + + private fun onActionEnd(): Boolean { + overlayView.endDragFeedback() + val result = consumed() + isDragging = false + dragApplied = false + activePointerId = MotionEvent.INVALID_POINTER_ID + consumesFromDown = false + return result + } + + /** + * The screen-space (raw) coordinates of [pointerIndex] within [ev]. [MotionEvent.getRawX] + * without an index argument only ever reports pointer index 0 (pre-API 29 has no indexed + * overload), so an arbitrary active pointer's raw position is derived from the constant + * view-to-screen offset that [MotionEvent.getRawX]/[MotionEvent.getX] expose for pointer 0. + */ + private fun rawCoordinates(ev: MotionEvent, pointerIndex: Int): Pair { + val offsetX = ev.rawX - ev.getX(0) + val offsetY = ev.rawY - ev.getY(0) + return (ev.getX(pointerIndex) + offsetX) to (ev.getY(pointerIndex) + offsetY) + } +} diff --git a/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/OverlayFailure.kt b/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/OverlayFailure.kt new file mode 100644 index 0000000..d40d7a7 --- /dev/null +++ b/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/OverlayFailure.kt @@ -0,0 +1,51 @@ +/* + * Copyright 2026 75py + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.nagopy.android.overlayviewmanager + +/** Classifies a failed overlay operation without requiring exception inspection. */ +public enum class OverlayFailure { + /** The overlay permission is missing, or the platform rejected the window with a security error. */ + PERMISSION_DENIED, + + /** [OverlayView.show] or [OverlayView.update] ran after the owning Activity's destruction disposed the handle. */ + ACTIVITY_DESTROYED, + + /** The platform rejected the window's token. */ + INVALID_WINDOW_TOKEN, + + /** + * The window manager rejected the operation for another reason. [OverlayView.show] and + * [OverlayView.update] also report this after an ordinary [OverlayView.dispose]. + */ + WINDOW_MANAGER_REJECTED, + + /** The managed View already has a parent, so it cannot be added to a window. */ + ALREADY_HAS_PARENT, + + /** + * The window was already gone. The handle reconciles, and the resulting state depends on the + * operation: [OverlayState.CONFIGURED] after [OverlayView.update] or [OverlayView.hide], and + * [OverlayState.DISPOSED] after [OverlayView.dispose]. + */ + NOT_ATTACHED, + + /** The combined opacity of the pass-through overlays would exceed the platform's maximum. */ + PASS_THROUGH_OPACITY_EXCEEDED, + + /** The platform's maximum obscuring opacity could not be read, so admission cannot be decided. */ + PASS_THROUGH_UNSUPPORTED, +} diff --git a/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/OverlayPermission.kt b/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/OverlayPermission.kt new file mode 100644 index 0000000..b81251e --- /dev/null +++ b/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/OverlayPermission.kt @@ -0,0 +1,43 @@ +/* + * Copyright 2026 75py + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.nagopy.android.overlayviewmanager + +import android.content.Context +import android.content.Intent +import android.net.Uri +import android.provider.Settings + +/** + * Immutable, thread-safe access to the "draw over other apps" permission. + * + * Every method takes the [Context] it needs and this class holds no state of its own, so an + * instance may be queried from any thread. The library's minSdk is API 23, so [isGranted] always + * delegates to [Settings.canDrawOverlays]; there is no lower-API branch. + */ +public class OverlayPermission { + /** Returns whether [context]'s package currently holds the overlay permission. */ + public fun isGranted(context: Context): Boolean = Settings.canDrawOverlays(context) + + /** + * Returns a new [Settings.ACTION_MANAGE_OVERLAY_PERMISSION] intent for [context]'s package. + * This does not start an activity and has no Fragment/Dialog dependency; the host launches it, + * for example through the Activity Result API, and rechecks [isGranted] on return. + */ + public fun settingsIntent(context: Context): Intent = Intent( + Settings.ACTION_MANAGE_OVERLAY_PERMISSION, + Uri.parse("package:${context.packageName}"), + ) +} diff --git a/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/OverlayResult.kt b/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/OverlayResult.kt new file mode 100644 index 0000000..b7752fd --- /dev/null +++ b/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/OverlayResult.kt @@ -0,0 +1,34 @@ +/* + * Copyright 2026 75py + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.nagopy.android.overlayviewmanager + +/** + * The outcome of one overlay operation. + * + * [cause] is diagnostic information for this result only. Callers should use [failure] to + * decide how to recover instead of relying on exception messages. + */ +public class OverlayResult( + public val state: OverlayState, + public val changed: Boolean, + public val failure: OverlayFailure?, + public val cause: Throwable?, +) { + /** Returns whether this operation has no classified failure. */ + public val isSuccess: Boolean + get() = failure == null +} diff --git a/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/OverlayScope.kt b/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/OverlayScope.kt new file mode 100644 index 0000000..71e3c83 --- /dev/null +++ b/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/OverlayScope.kt @@ -0,0 +1,23 @@ +/* + * Copyright 2026 75py + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.nagopy.android.overlayviewmanager + +/** Identifies whether an overlay belongs to an activity or the application. */ +public enum class OverlayScope { + ACTIVITY, + APPLICATION, +} diff --git a/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/OverlaySpec.kt b/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/OverlaySpec.kt new file mode 100644 index 0000000..4097b00 --- /dev/null +++ b/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/OverlaySpec.kt @@ -0,0 +1,199 @@ +/* + * Copyright 2026 75py + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.nagopy.android.overlayviewmanager + +import android.view.Gravity +import android.view.ViewGroup + +/** + * Immutable, value-based configuration for an overlay. + * + * Scope-specific rules are applied by the overlay factory. This value only validates its own + * dimensions and normalized numeric properties. + * + * This type remains a data class throughout 3.x. New properties will be appended at the end + * with default values to preserve source compatibility for Kotlin constructor/copy calls and + * Java [Builder] usage. Java callers must use [Builder], rather than the primary constructor + * or generated copy method. + * + * Across 3.x minor versions, binary compatibility of constructor/copy calls from already + * compiled intermediate libraries is not guaranteed. Recompile those libraries against the + * selected version when upgrading; default values do not preserve the old JVM signatures. + */ +public data class OverlaySpec constructor( + public val width: Int = ViewGroup.LayoutParams.WRAP_CONTENT, + public val height: Int = ViewGroup.LayoutParams.WRAP_CONTENT, + public val gravity: Int = Gravity.TOP or Gravity.START, + public val x: Int = 0, + public val y: Int = 0, + public val horizontalMargin: Float = 0f, + public val verticalMargin: Float = 0f, + public val alpha: Float = 1f, + public val touchMode: OverlayTouchMode = OverlayTouchMode.PASS_THROUGH, + public val crossUidPassThrough: CrossUidPassThrough = CrossUidPassThrough.SAME_UID_ONLY, + public val allowOutsideBounds: Boolean = false, + public val screenBrightness: Float? = null, +) { + init { + validate() + } + + /** Returns a Java-friendly mutable builder initialized from this value. */ + public fun toBuilder(): Builder = Builder(this) + + /** Java-friendly builder for [OverlaySpec]. */ + public class Builder { + private var width: Int = ViewGroup.LayoutParams.WRAP_CONTENT + private var height: Int = ViewGroup.LayoutParams.WRAP_CONTENT + private var gravity: Int = Gravity.TOP or Gravity.START + private var x: Int = 0 + private var y: Int = 0 + private var horizontalMargin: Float = 0f + private var verticalMargin: Float = 0f + private var alpha: Float = 1f + private var touchMode: OverlayTouchMode = OverlayTouchMode.PASS_THROUGH + private var crossUidPassThrough: CrossUidPassThrough = CrossUidPassThrough.SAME_UID_ONLY + private var allowOutsideBounds: Boolean = false + private var screenBrightness: Float? = null + + /** Creates a builder with the default configuration. */ + public constructor() + + /** Creates a builder initialized from [source]. */ + public constructor(source: OverlaySpec) { + width = source.width + height = source.height + gravity = source.gravity + x = source.x + y = source.y + horizontalMargin = source.horizontalMargin + verticalMargin = source.verticalMargin + alpha = source.alpha + touchMode = source.touchMode + crossUidPassThrough = source.crossUidPassThrough + allowOutsideBounds = source.allowOutsideBounds + screenBrightness = source.screenBrightness + } + + /** Sets the requested window width. */ + public fun setWidth(width: Int): Builder = apply { + validateDimension(width, "width") + this.width = width + } + + /** Sets the requested window height. */ + public fun setHeight(height: Int): Builder = apply { + validateDimension(height, "height") + this.height = height + } + + /** Sets the requested gravity. */ + public fun setGravity(gravity: Int): Builder = apply { + this.gravity = gravity + } + + /** Sets the horizontal offset. */ + public fun setX(x: Int): Builder = apply { + this.x = x + } + + /** Sets the vertical offset. */ + public fun setY(y: Int): Builder = apply { + this.y = y + } + + /** Sets the horizontal normalized margin. */ + public fun setHorizontalMargin(margin: Float): Builder = apply { + validateUnitInterval(margin, "horizontalMargin") + horizontalMargin = margin + } + + /** Sets the vertical normalized margin. */ + public fun setVerticalMargin(margin: Float): Builder = apply { + validateUnitInterval(margin, "verticalMargin") + verticalMargin = margin + } + + /** Sets the normalized overlay alpha. */ + public fun setAlpha(alpha: Float): Builder = apply { + validateUnitInterval(alpha, "alpha") + this.alpha = alpha + } + + /** Sets the overlay touch mode. */ + public fun setTouchMode(touchMode: OverlayTouchMode): Builder = apply { + this.touchMode = touchMode + } + + /** Sets the cross-UID pass-through policy. */ + public fun setCrossUidPassThrough(mode: CrossUidPassThrough): Builder = apply { + crossUidPassThrough = mode + } + + /** Sets whether normal layout bounds may be exceeded. */ + public fun setAllowOutsideBounds(allowOutsideBounds: Boolean): Builder = apply { + this.allowOutsideBounds = allowOutsideBounds + } + + /** Sets the optional normalized screen-brightness override. */ + public fun setScreenBrightness(brightness: Float?): Builder = apply { + brightness?.let { validateUnitInterval(it, "screenBrightness") } + screenBrightness = brightness + } + + /** Builds an immutable configuration after validating every stored property. */ + public fun build(): OverlaySpec = OverlaySpec( + width = width, + height = height, + gravity = gravity, + x = x, + y = y, + horizontalMargin = horizontalMargin, + verticalMargin = verticalMargin, + alpha = alpha, + touchMode = touchMode, + crossUidPassThrough = crossUidPassThrough, + allowOutsideBounds = allowOutsideBounds, + screenBrightness = screenBrightness, + ) + } + + private fun validate() { + validateDimension(width, "width") + validateDimension(height, "height") + validateUnitInterval(horizontalMargin, "horizontalMargin") + validateUnitInterval(verticalMargin, "verticalMargin") + validateUnitInterval(alpha, "alpha") + screenBrightness?.let { validateUnitInterval(it, "screenBrightness") } + } + + private companion object { + private fun validateDimension(value: Int, name: String) { + require( + value >= 0 || + value == ViewGroup.LayoutParams.MATCH_PARENT || + value == ViewGroup.LayoutParams.WRAP_CONTENT, + ) { "$name must be non-negative, MATCH_PARENT, or WRAP_CONTENT." } + } + + private fun validateUnitInterval(value: Float, name: String) { + require(!value.isNaN() && !value.isInfinite() && value in 0f..1f) { + "$name must be finite and in the range 0..1." + } + } + } +} diff --git a/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/OverlayState.kt b/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/OverlayState.kt new file mode 100644 index 0000000..2d4dee7 --- /dev/null +++ b/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/OverlayState.kt @@ -0,0 +1,24 @@ +/* + * Copyright 2026 75py + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.nagopy.android.overlayviewmanager + +/** The lifecycle state last established by an overlay operation. */ +public enum class OverlayState { + CONFIGURED, + ATTACHED, + DISPOSED, +} diff --git a/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/OverlayTouchMode.kt b/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/OverlayTouchMode.kt new file mode 100644 index 0000000..8050e2d --- /dev/null +++ b/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/OverlayTouchMode.kt @@ -0,0 +1,33 @@ +/* + * Copyright 2026 75py + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.nagopy.android.overlayviewmanager + +/** Defines whether an overlay passes through, receives, or handles drag touches. */ +public enum class OverlayTouchMode { + /** The window is not touchable. The library does not change the View's touch listener. */ + PASS_THROUGH, + + /** The View receives touches. The library does not change the View's touch listener. */ + INTERACTIVE, + + /** + * The library drags the window. It installs its own `View.OnTouchListener`, which replaces any + * listener the host had set, because a View holds only one. Leaving this mode or disposing the + * handle removes the listener without restoring the host's, so set it again if needed. + */ + DRAGGABLE, +} diff --git a/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/OverlayView.kt b/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/OverlayView.kt new file mode 100644 index 0000000..e454e59 --- /dev/null +++ b/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/OverlayView.kt @@ -0,0 +1,547 @@ +/* + * Copyright 2026 75py + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.nagopy.android.overlayviewmanager + +import android.os.Build +import android.os.Looper +import android.view.Gravity +import android.view.View +import android.view.WindowManager +import androidx.annotation.MainThread +import com.nagopy.android.overlayviewmanager.internal.Logger +import com.nagopy.android.overlayviewmanager.internal.MaximumObscuringOpacity +import com.nagopy.android.overlayviewmanager.internal.OverlayGeometry +import com.nagopy.android.overlayviewmanager.internal.OverlayWindowManager +import com.nagopy.android.overlayviewmanager.internal.PassThroughOpacityRegistry + +/** + * A synchronous, main-thread-owned overlay handle. + * + * Handles are created only by [OverlayViewManager]. The constructor is private rather than + * `internal` because Kotlin compiles an `internal` constructor to a public JVM constructor, which + * Java callers could invoke directly. + * + * The View's touch listener stays the host's unless the mode is [OverlayTouchMode.DRAGGABLE]. + * See that mode for what happens to a host listener. + */ +public class OverlayView private constructor( + view: T, + private val scope: OverlayScope, + backend: OverlayWindowManager, + initialSpec: OverlaySpec, + private val permission: OverlayPermission, + activityReleaseCallback: (() -> Unit)?, +) { + private var backend: OverlayWindowManager? = backend + private var ownedView: T? = view + private var detachListener: View.OnAttachStateChangeListener? = null + private var gravityCorrection: View.OnLayoutChangeListener? = null + private var appliedGravity: Int = Gravity.NO_GRAVITY + /** + * Invoked exactly once, from [release], to deregister this handle from the owning Activity's + * entry in `ActivityOverlayRegistry`. Cleared immediately after invocation so that the closure + * -- and whatever Activity it captured -- is not retained by a disposed handle. + */ + private var onActivityRelease: (() -> Unit)? = activityReleaseCallback + private var effectiveSpec: OverlaySpec = initialSpec + private var effectiveDragListener: DraggableOnTouchListener? = null + @Volatile private var currentState: OverlayState = OverlayState.CONFIGURED + @Volatile private var currentFailure: OverlayFailure? = null + private var libraryRemovalInProgress: Boolean = false + /** What [show] and [update] report once this handle is disposed. */ + private var disposedFailureKind: OverlayFailure = OverlayFailure.WINDOW_MANAGER_REJECTED + /** Whether a drag is showing its translucent feedback. It is never part of [effectiveSpec]. */ + private var dragFeedback: Boolean = false + /** + * Whether the window's last accepted layout carries the feedback. A failed restore leaves this + * `true` after [dragFeedback] became `false`, so the next [update] reapplies the layout. + */ + private var windowHasDragFeedback: Boolean = false + + init { + if (initialSpec.touchMode == OverlayTouchMode.DRAGGABLE) { + applyTouchListener(DraggableOnTouchListener(this)) + } + } + + /** The managed view. It cannot be read once this handle is disposed. */ + @get:MainThread + public val view: T + get() { + requireMainThread() + return ownedView ?: throw IllegalStateException("OverlayView is disposed.") + } + + /** The last state established by this handle. This value is safe to read from any thread. */ + public val state: OverlayState + get() = currentState + + /** The last classified failure. This value is safe to read from any thread. */ + public val lastFailure: OverlayFailure? + get() = currentFailure + + /** The immutable effective configuration, readable on the main thread even after disposal. */ + @get:MainThread + public val spec: OverlaySpec + get() { + requireMainThread() + return effectiveSpec + } + + /** Registers the view synchronously when it is not already attached. */ + @MainThread + public fun show(): OverlayResult { + requireMainThread() + when (currentState) { + OverlayState.DISPOSED -> return disposedFailure() + OverlayState.ATTACHED -> return success(changed = false) + OverlayState.CONFIGURED -> Unit + } + val candidate = effectiveSpec + val managedView = ownedView ?: return failure(OverlayFailure.WINDOW_MANAGER_REJECTED, null) + if (managedView.parent != null) return failure(OverlayFailure.ALREADY_HAS_PARENT, null) + if (scope == OverlayScope.APPLICATION && !permission.isGranted(managedView.context)) { + return failure(OverlayFailure.PERMISSION_DENIED, null) + } + admitPassThroughOpacity(candidate, managedView)?.let { return failure(it, null) } + val params = layoutParams(candidate) + try { + backendOrThrow().show(managedView, params) + } catch (exception: Exception) { + return failure(classify(exception), exception) + } + appliedGravity = params.gravity + updatePassThroughOpacityRegistration(candidate) + accept(candidate, nextDragListener(candidate)) + currentState = OverlayState.ATTACHED + installDetachListener(managedView) + installGravityCorrection(managedView) + return success(changed = true) + } + + /** + * Applies [spec] synchronously or replaces pending configuration before first show. + * + * Unlike [show], this performs no application-scope permission preflight -- neither does + * [hide] or [dispose]. Only the initial [show] checks [OverlayPermission.isGranted]. If the + * overlay permission is revoked while [ATTACHED][OverlayState.ATTACHED], the platform reports + * that on the next window operation: the backend throws [SecurityException], which is + * classified [OverlayFailure.PERMISSION_DENIED] like any other backend rejection, while the + * current [state] and the last effective [spec] are preserved unchanged. This mirrors how + * every other platform rejection here is a later observation rather than a proactive check, + * and avoids a redundant permission query on every mutation of an already-attached window. + */ + @MainThread + public fun update(spec: OverlaySpec): OverlayResult { + requireMainThread() + requireApplicationBrightnessIsAbsent(spec) + if (currentState == OverlayState.DISPOSED) return disposedFailure() + val nextDragListener = nextDragListener(spec) + if (currentState == OverlayState.CONFIGURED) { + if (spec == effectiveSpec) return success(changed = false) + accept(spec, nextDragListener) + return success(changed = true) + } + // Leaving DRAGGABLE ends the feedback here, because the listener that would have ended it + // is removed before the gesture's UP or CANCEL arrives. + val feedback = dragFeedback && spec.touchMode == OverlayTouchMode.DRAGGABLE + if (spec == effectiveSpec && feedback == windowHasDragFeedback) return success(changed = false) + val managedView = ownedView ?: return failure(OverlayFailure.WINDOW_MANAGER_REJECTED, null) + admitPassThroughOpacity(spec, managedView)?.let { return failure(it, null) } + val params = layoutParams(spec, feedback) + try { + backendOrThrow().update(managedView, params) + } catch (exception: Exception) { + if (isNotAttached(exception)) { + reconcileExternalDetach() + return OverlayResult(currentState, false, OverlayFailure.NOT_ATTACHED, exception) + } + return failure(classify(exception), exception) + } + appliedGravity = params.gravity + updatePassThroughOpacityRegistration(spec) + dragFeedback = feedback + windowHasDragFeedback = feedback + accept(spec, nextDragListener) + return success(changed = true) + } + + /** + * Applies a drag position with the translucent feedback. The feedback only changes the + * window's alpha, so [spec] keeps the caller's alpha throughout the gesture. + */ + @MainThread + @JvmSynthetic + internal fun updateDuringDrag(spec: OverlaySpec): OverlayResult { + val previous = dragFeedback + dragFeedback = true + val result = update(spec) + if (!result.isSuccess) dragFeedback = previous && currentState == OverlayState.ATTACHED + return result + } + + /** + * Ends the feedback when a gesture finishes. If the window rejects the restore, the failure is + * reported through [lastFailure] and the next [update] or gesture applies it again. + */ + @MainThread + @JvmSynthetic + internal fun endDragFeedback() { + dragFeedback = false + if (windowHasDragFeedback) update(effectiveSpec) + } + + /** + * Removes the view synchronously. A not-attached result is a successful reconciliation. + * + * The removal runs detach callbacks before it returns. A [hide] from one of them is a no-op, + * because the removal is already running. See [dispose] for a [dispose] from one of them. + */ + @MainThread + public fun hide(): OverlayResult { + requireMainThread() + if (currentState != OverlayState.ATTACHED || libraryRemovalInProgress) { + return success(changed = false, preserveDiagnostic = true) + } + val managedView = ownedView ?: return failure(OverlayFailure.WINDOW_MANAGER_REJECTED, null) + val exception = removeFromWindow(managedView) + if (currentState == OverlayState.DISPOSED) return resultAfterReentrantDispose(exception) + if (exception != null) { + if (isNotAttached(exception)) { + reconcileExternalDetach() + return successfulReconciliation() + } + return failure(classify(exception), exception) + } + currentState = OverlayState.CONFIGURED + removeAttachmentListeners(managedView) + clearDragFeedback() + PassThroughOpacityRegistry.unregister(this) + return success(changed = true) + } + + /** + * Releases owned resources after a successful synchronous removal. + * + * The removal runs detach callbacks before it returns. A [dispose] from one of them releases + * the handle at once without removing the view a second time, because the view is already + * leaving its window, and the handle stays [DISPOSED][OverlayState.DISPOSED]. If the running + * removal then fails, the operation that started it reports the failure; the handle is not + * reopened for a retry. + */ + @MainThread + public fun dispose(): OverlayResult { + requireMainThread() + if (currentState == OverlayState.DISPOSED) return success(changed = false, preserveDiagnostic = true) + if (libraryRemovalInProgress) { + ownedView?.let(::release) + return success(changed = true, preserveDiagnostic = true) + } + if (currentState == OverlayState.ATTACHED) { + val managedView = ownedView ?: return failure(OverlayFailure.WINDOW_MANAGER_REJECTED, null) + val exception = removeFromWindow(managedView) + if (currentState == OverlayState.DISPOSED) return resultAfterReentrantDispose(exception) + if (exception != null) { + if (isNotAttached(exception)) { + reconcileExternalDetach() + release(managedView) + return successfulReconciliation(OverlayState.DISPOSED) + } + return failure(classify(exception), exception) + } + release(managedView) + return success(changed = true) + } + ownedView?.let(::release) + return success(changed = true, preserveDiagnostic = true) + } + + /** + * Forced cleanup for the owning Activity's `onActivityDestroyed`. If [ATTACHED][OverlayState.ATTACHED], + * attempts exactly one `removeViewImmediate`; regardless of that outcome, releases every owned + * reference and transitions to [DISPOSED][OverlayState.DISPOSED]. A failed removal is classified + * with the existing [classify] mapping and retained as [lastFailure] -- the exception itself is + * never retained. `DISPOSED` here means library ownership is released, not proof that the + * framework removal succeeded. Idempotent: a no-op once already [DISPOSED][OverlayState.DISPOSED]. + * A later [show] or [update] reports [OverlayFailure.ACTIVITY_DESTROYED]. + */ + @MainThread + @JvmSynthetic + internal fun disposeForActivityDestruction() { + requireMainThread() + if (currentState == OverlayState.DISPOSED) return + disposedFailureKind = OverlayFailure.ACTIVITY_DESTROYED + val managedView = ownedView + if (currentState == OverlayState.ATTACHED && managedView != null && !libraryRemovalInProgress) { + removeFromWindow(managedView)?.let { exception -> + currentFailure = classify(exception) + Logger.w(exception, "Forced Activity-destruction removeViewImmediate failed; classified as %s", currentFailure) + } + } + managedView?.let(::release) + } + + /** Makes the one library removal, during which detach callbacks can re-enter this handle. */ + private fun removeFromWindow(managedView: T): Exception? { + libraryRemovalInProgress = true + return try { + backendOrThrow().hide(managedView) + null + } catch (exception: Exception) { + exception + } finally { + libraryRemovalInProgress = false + } + } + + /** The outcome of a removal whose detach callback already disposed this handle. */ + private fun resultAfterReentrantDispose(exception: Exception?): OverlayResult = when { + exception == null -> success(changed = true) + isNotAttached(exception) -> successfulReconciliation(OverlayState.DISPOSED) + else -> failure(classify(exception), exception) + } + + /** + * Re-applies the gravity if the first measure resolved a layout direction other than the one + * [show] and [update] had to estimate. See [OverlayGeometry.absoluteGravity]. No caller is + * waiting for this operation, so a failure is only reported through [lastFailure]. + * + * A view notifies a snapshot of its listeners, so a host listener that runs first can hide or + * dispose this handle and this one still runs, which is why it checks the state. + */ + private fun installGravityCorrection(managedView: T) { + if (managedView.isLayoutDirectionResolved) return + val listener = object : View.OnLayoutChangeListener { + override fun onLayoutChange( + v: View, + left: Int, + top: Int, + right: Int, + bottom: Int, + oldLeft: Int, + oldTop: Int, + oldRight: Int, + oldBottom: Int, + ) { + removeGravityCorrection(managedView) + if (currentState != OverlayState.ATTACHED) return + val params = layoutParams(effectiveSpec) + if (params.gravity == appliedGravity) return + try { + backendOrThrow().update(managedView, params) + appliedGravity = params.gravity + windowHasDragFeedback = dragFeedback + } catch (exception: Exception) { + Logger.w(exception, "Could not correct the gravity after the first layout") + if (isNotAttached(exception)) reconcileExternalDetach() else failure(classify(exception), exception) + } + } + } + gravityCorrection = listener + managedView.addOnLayoutChangeListener(listener) + } + + private fun removeGravityCorrection(managedView: T) { + gravityCorrection?.let(managedView::removeOnLayoutChangeListener) + gravityCorrection = null + } + + private fun installDetachListener(managedView: T) { + val listener = object : View.OnAttachStateChangeListener { + override fun onViewAttachedToWindow(v: View) = Unit + override fun onViewDetachedFromWindow(v: View) { + if (!libraryRemovalInProgress && currentState == OverlayState.ATTACHED) reconcileExternalDetach() + } + } + detachListener = listener + managedView.addOnAttachStateChangeListener(listener) + } + + private fun removeAttachmentListeners(managedView: T) { + detachListener?.let(managedView::removeOnAttachStateChangeListener) + detachListener = null + removeGravityCorrection(managedView) + } + + private fun reconcileExternalDetach() { + currentState = OverlayState.CONFIGURED + currentFailure = OverlayFailure.NOT_ATTACHED + ownedView?.let(::removeAttachmentListeners) + clearDragFeedback() + PassThroughOpacityRegistry.unregister(this) + } + + private fun clearDragFeedback() { + dragFeedback = false + windowHasDragFeedback = false + } + + private fun release(managedView: T) { + if (currentState == OverlayState.DISPOSED) return + removeAttachmentListeners(managedView) + clearDragFeedback() + applyTouchListener(null) + ownedView = null + backend = null + currentState = OverlayState.DISPOSED + PassThroughOpacityRegistry.unregister(this) + val activityRelease = onActivityRelease + onActivityRelease = null + activityRelease?.invoke() + } + + private fun accept(spec: OverlaySpec, dragListener: DraggableOnTouchListener?) { + effectiveSpec = spec + applyTouchListener(dragListener) + } + + private fun nextDragListener(spec: OverlaySpec): DraggableOnTouchListener? { + if (spec.touchMode != OverlayTouchMode.DRAGGABLE) return null + if (effectiveSpec.touchMode == OverlayTouchMode.DRAGGABLE && effectiveDragListener != null) { + return effectiveDragListener + } + return DraggableOnTouchListener(this) + } + + /** + * Changes the View's listener only when the library's own listener changes. A non-draggable + * handle therefore never touches the host's listener. + */ + private fun applyTouchListener(listener: DraggableOnTouchListener?) { + if (listener === effectiveDragListener) return + effectiveDragListener = listener + ownedView?.setOnTouchListener(listener) + } + + private fun layoutParams( + value: OverlaySpec, + withDragFeedback: Boolean = dragFeedback, + ): WindowManager.LayoutParams = WindowManager.LayoutParams().apply { + width = value.width + height = value.height + gravity = OverlayGeometry.absoluteGravity(value.gravity, view) + x = value.x + y = value.y + horizontalMargin = value.horizontalMargin + verticalMargin = value.verticalMargin + alpha = if (withDragFeedback) value.alpha * DRAG_FEEDBACK_ALPHA_FACTOR else value.alpha + format = android.graphics.PixelFormat.TRANSLUCENT + flags = WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE + if (value.allowOutsideBounds) flags = flags or WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS or WindowManager.LayoutParams.FLAG_LAYOUT_INSET_DECOR or WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN + if (value.touchMode == OverlayTouchMode.PASS_THROUGH) flags = flags or WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE + type = if (scope == OverlayScope.ACTIVITY) WindowManager.LayoutParams.TYPE_APPLICATION else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY else WindowManager.LayoutParams.TYPE_SYSTEM_ALERT + if (scope == OverlayScope.ACTIVITY && value.screenBrightness != null) screenBrightness = value.screenBrightness + } + + private fun success(changed: Boolean, preserveDiagnostic: Boolean = false): OverlayResult { + if (!preserveDiagnostic) currentFailure = null + return OverlayResult(currentState, changed, null, null) + } + + private fun successfulReconciliation(finalState: OverlayState = OverlayState.CONFIGURED): OverlayResult { + currentState = finalState + currentFailure = OverlayFailure.NOT_ATTACHED + return OverlayResult(finalState, false, null, null) + } + + private fun failure(kind: OverlayFailure, cause: Throwable?): OverlayResult { + currentFailure = kind + return OverlayResult(currentState, false, kind, cause) + } + + private fun disposedFailure(): OverlayResult = OverlayResult( + currentState, + false, + disposedFailureKind, + null, + ) + + private fun backendOrThrow(): OverlayWindowManager = checkNotNull(backend) { "OverlayView is disposed." } + + /** + * The Android 12+ (API 31+) opacity-budget admission check. Applicable only to an + * application-scope [OverlayTouchMode.PASS_THROUGH] candidate that opts into + * [CrossUidPassThrough.WHEN_SYSTEM_ALLOWS]. Runs on every [show]/[update] that reaches this + * point -- callers already skip a true no-op spec before calling here -- including an x/y, + * size, gravity, or margin-only change: the platform maximum can change between operations, so + * it is queried fresh every time rather than cached or skipped for a non-alpha change. Returns + * the failure to report, or `null` to proceed with the platform call. + */ + private fun admitPassThroughOpacity(candidate: OverlaySpec, managedView: T): OverlayFailure? { + if (scope != OverlayScope.APPLICATION) return null + if (candidate.touchMode != OverlayTouchMode.PASS_THROUGH) return null + if (candidate.crossUidPassThrough != CrossUidPassThrough.WHEN_SYSTEM_ALLOWS) return null + if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) return null + val maximum = try { + MaximumObscuringOpacity.get().maximumObscuringOpacityForTouch(managedView.context) + } catch (exception: Exception) { + null + } ?: return OverlayFailure.PASS_THROUGH_UNSUPPORTED + val combined = PassThroughOpacityRegistry.combinedOpacityExcluding(this, candidate.alpha) + return if (combined > maximum) OverlayFailure.PASS_THROUGH_OPACITY_EXCEEDED else null + } + + /** Registers or drops this handle's alpha in [PassThroughOpacityRegistry] after a successful backend call. */ + private fun updatePassThroughOpacityRegistration(spec: OverlaySpec) { + if (scope == OverlayScope.APPLICATION && spec.touchMode == OverlayTouchMode.PASS_THROUGH) { + PassThroughOpacityRegistry.register(this, spec.alpha) + } else { + PassThroughOpacityRegistry.unregister(this) + } + } + + private fun requireApplicationBrightnessIsAbsent(spec: OverlaySpec) { + require(scope != OverlayScope.APPLICATION || spec.screenBrightness == null) { + "screenBrightness is supported only for activity overlays." + } + } + + private fun classify(exception: Exception): OverlayFailure = when { + isNotAttached(exception) -> OverlayFailure.NOT_ATTACHED + exception is WindowManager.BadTokenException -> OverlayFailure.INVALID_WINDOW_TOKEN + exception is SecurityException -> OverlayFailure.PERMISSION_DENIED + else -> OverlayFailure.WINDOW_MANAGER_REJECTED + } + + /** + * AOSP's `WindowManagerGlobal.findViewLocked` reports an unknown view with an + * [IllegalArgumentException] saying "not attached to window manager". The platform has no + * dedicated exception type, so the message is the only signal. + */ + private fun isNotAttached(exception: Exception): Boolean = exception is IllegalArgumentException && exception.message?.contains("not attached", ignoreCase = true) == true + + private fun requireMainThread() { + val main = Looper.getMainLooper() + check(main != null && Looper.myLooper() === main) { "OverlayView must be used on the main thread." } + } + + internal companion object { + /** Scales the window's alpha while a drag is in progress. */ + private const val DRAG_FEEDBACK_ALPHA_FACTOR = 0.6f + + /** Library-internal factory; synthetic so that Java sources cannot call it. */ + @JvmSynthetic + internal fun create( + view: T, + scope: OverlayScope, + backend: OverlayWindowManager, + initialSpec: OverlaySpec, + permission: OverlayPermission = OverlayPermission(), + activityReleaseCallback: (() -> Unit)? = null, + ): OverlayView = OverlayView(view, scope, backend, initialSpec, permission, activityReleaseCallback) + } +} diff --git a/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/OverlayViewManager.kt b/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/OverlayViewManager.kt new file mode 100644 index 0000000..5fa7d80 --- /dev/null +++ b/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/OverlayViewManager.kt @@ -0,0 +1,116 @@ +/* + * Copyright 2026 75py + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.nagopy.android.overlayviewmanager + +import android.app.Activity +import android.app.Application +import android.content.Context +import android.os.Looper +import android.view.View +import android.view.WindowManager +import androidx.annotation.MainThread +import com.nagopy.android.overlayviewmanager.internal.ActivityOverlayRegistry +import com.nagopy.android.overlayviewmanager.internal.OverlayWindowManager +import com.nagopy.android.overlayviewmanager.internal.SimpleActivityLifecycleCallbacks + +/** Process-scoped factory for synchronous overlay handles. */ +public class OverlayViewManager private constructor(private val application: Application) { + private val windowManager: WindowManager = application.getSystemService(Context.WINDOW_SERVICE) as WindowManager + private val permission: OverlayPermission = OverlayPermission() + + init { + OverlayWindowManager.initApplicationInstance(windowManager) + } + + /** Creates an application-scoped overlay with default immutable configuration. */ + @MainThread public fun newOverlayView(view: T): OverlayView = newApplicationOverlay(view, OverlaySpec()) + /** Creates an application-scoped overlay with [spec]. */ + @MainThread public fun newOverlayView(view: T, spec: OverlaySpec): OverlayView = newApplicationOverlay(view, spec) + /** Creates an activity-scoped overlay with default immutable configuration. */ + @MainThread public fun newOverlayView(view: T, activity: Activity): OverlayView = newActivityOverlay(view, activity, OverlaySpec()) + /** Creates an activity-scoped overlay with [spec]. */ + @MainThread public fun newOverlayView(view: T, activity: Activity, spec: OverlaySpec): OverlayView = newActivityOverlay(view, activity, spec) + + /** Returns the immutable overlay permission helper. See [OverlayPermission]. */ + public fun overlayPermission(): OverlayPermission = permission + + private fun newApplicationOverlay(view: T, spec: OverlaySpec): OverlayView { + requireMainThread() + require(view.parent == null) { "The managed view must not already have a parent." } + require(spec.screenBrightness == null) { "screenBrightness is supported only for activity overlays." } + return OverlayView.create(view, OverlayScope.APPLICATION, OverlayWindowManager.getApplicationInstance(), spec, permission) + } + + private fun newActivityOverlay(view: T, activity: Activity, spec: OverlaySpec): OverlayView { + requireMainThread() + require(view.parent == null) { "The managed view must not already have a parent." } + require(!activity.isFinishing && !activity.isDestroyed) { "Activity is finishing or destroyed." } + lateinit var handle: OverlayView + handle = OverlayView.create( + view, + OverlayScope.ACTIVITY, + OverlayWindowManager.getActivityInstance(activity), + spec, + permission, + ) { ActivityOverlayRegistry.deregister(activity, handle) } + ActivityOverlayRegistry.register(activity, handle) + return handle + } + + private fun requireMainThread() { + val main = Looper.getMainLooper() + check(main != null && Looper.myLooper() === main) { "OverlayViewManager must be used on the main thread." } + } + + public companion object { + @Volatile private var instance: OverlayViewManager? = null + + /** + * Registered on the first successful [init], never again on a same-Application no-op init. + * Forces every live activity-scoped handle of the destroyed Activity to release and drops + * the Activity's entry from [OverlayWindowManager]'s per-Activity instance cache. + */ + private val activityDestructionCallbacks: Application.ActivityLifecycleCallbacks = + object : SimpleActivityLifecycleCallbacks() { + override fun onActivityDestroyed(activity: Activity) { + ActivityOverlayRegistry.disposeAll(activity) + OverlayWindowManager.removeActivityInstance(activity) + } + } + + /** Initializes the singleton. Repeating this with the same Application is harmless. */ + @JvmStatic @MainThread public fun init(application: Application) { + val main = Looper.getMainLooper() + check(main != null && Looper.myLooper() === main) { "OverlayViewManager must be initialized on the main thread." } + synchronized(this) { + val existing = instance + check(existing == null || existing.application === application) { "OverlayViewManager is already initialized for another Application." } + if (existing == null) { + instance = OverlayViewManager(application) + application.registerActivityLifecycleCallbacks(activityDestructionCallbacks) + } + } + } + + /** Returns the initialized process singleton. */ + @JvmStatic @MainThread public fun getInstance(): OverlayViewManager { + val main = Looper.getMainLooper() + check(main != null && Looper.myLooper() === main) { "OverlayViewManager must be accessed on the main thread." } + return instance ?: throw IllegalStateException("OverlayViewManager is not initialized. Call init(Application) first.") + } + + } +} diff --git a/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/internal/ActivityOverlayRegistry.kt b/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/internal/ActivityOverlayRegistry.kt new file mode 100644 index 0000000..6c5acc3 --- /dev/null +++ b/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/internal/ActivityOverlayRegistry.kt @@ -0,0 +1,40 @@ +/* Copyright 2026 75py. Licensed under the Apache License, Version 2.0. */ +package com.nagopy.android.overlayviewmanager.internal + +import android.app.Activity +import androidx.annotation.MainThread +import androidx.annotation.RestrictTo +import com.nagopy.android.overlayviewmanager.OverlayView +import java.util.WeakHashMap + +/** + * Main-thread-only, process-wide registry of the live activity-scoped [OverlayView] handles of + * every Activity, keyed weakly by [Activity]. A handle registers here at factory creation and + * deregisters on `dispose()`/forced disposal (see `OverlayView.disposeForActivityDestruction`); + * the registry's values reach the Activity only through those still-live handles, never through + * the weak key alone, so an Activity's entry is removed explicitly by [disposeAll] rather than + * left to key collection. + */ +@RestrictTo(RestrictTo.Scope.LIBRARY) +internal object ActivityOverlayRegistry { + private val handlesByActivity = WeakHashMap>>() + + @MainThread + internal fun register(activity: Activity, handle: OverlayView<*>) { + handlesByActivity.getOrPut(activity) { LinkedHashSet() }.add(handle) + } + + @MainThread + internal fun deregister(activity: Activity, handle: OverlayView<*>) { + val handles = handlesByActivity[activity] ?: return + handles.remove(handle) + if (handles.isEmpty()) handlesByActivity.remove(activity) + } + + /** Forces every live handle of [activity] to release, then removes its registry entry. */ + @MainThread + internal fun disposeAll(activity: Activity) { + val handles = handlesByActivity.remove(activity) ?: return + for (handle in ArrayList(handles)) handle.disposeForActivityDestruction() + } +} diff --git a/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/internal/MaximumObscuringOpacitySource.kt b/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/internal/MaximumObscuringOpacitySource.kt new file mode 100644 index 0000000..7e136f4 --- /dev/null +++ b/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/internal/MaximumObscuringOpacitySource.kt @@ -0,0 +1,45 @@ +/* Copyright 2026 75py. Licensed under the Apache License, Version 2.0. */ +package com.nagopy.android.overlayviewmanager.internal + +import android.content.Context +import android.hardware.input.InputManager +import android.os.Build +import androidx.annotation.MainThread +import androidx.annotation.RestrictTo + +/** + * Source of the platform's per-UID maximum obscuring opacity for touch + * (`InputManager.getMaximumObscuringOpacityForTouch()`, API 31+), injectable so Robolectric tests + * can supply a value without a shadow of `InputManager`. Returns `null` when the value cannot be + * obtained -- below API 31, when the system service is unavailable, or when the query throws -- + * so the caller fails closed with `PASS_THROUGH_UNSUPPORTED` rather than skipping the check. + */ +@RestrictTo(RestrictTo.Scope.LIBRARY) +internal fun interface MaximumObscuringOpacitySource { + @MainThread fun maximumObscuringOpacityForTouch(context: Context): Float? +} + +@RestrictTo(RestrictTo.Scope.LIBRARY) +internal object PlatformMaximumObscuringOpacitySource : MaximumObscuringOpacitySource { + override fun maximumObscuringOpacityForTouch(context: Context): Float? { + if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) return null + return try { + context.getSystemService(InputManager::class.java)?.maximumObscuringOpacityForTouch + } catch (exception: Exception) { + Logger.w(exception, "Failed to read the maximum obscuring opacity for touch.") + null + } + } +} + +/** Process-wide, test-replaceable holder for the active [MaximumObscuringOpacitySource]. */ +@RestrictTo(RestrictTo.Scope.LIBRARY) +internal object MaximumObscuringOpacity { + @Volatile private var source: MaximumObscuringOpacitySource? = null + + @MainThread + internal fun get(): MaximumObscuringOpacitySource = source ?: PlatformMaximumObscuringOpacitySource + + @RestrictTo(RestrictTo.Scope.TESTS) + internal fun setForTests(value: MaximumObscuringOpacitySource) { source = value } +} diff --git a/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/internal/OverlayGeometry.kt b/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/internal/OverlayGeometry.kt new file mode 100644 index 0000000..e194d3a --- /dev/null +++ b/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/internal/OverlayGeometry.kt @@ -0,0 +1,81 @@ +/* Copyright 2026 75py. Licensed under the Apache License, Version 2.0. */ +package com.nagopy.android.overlayviewmanager.internal + +import android.content.pm.ApplicationInfo +import android.view.Gravity +import android.view.View +import androidx.annotation.RestrictTo + +/** + * Coordinate conversion from screen space into a target window's layout space, for the drag + * gesture (see [com.nagopy.android.overlayviewmanager.DraggableOnTouchListener]). + * + * Apart from [absoluteGravity], every parameter here is a plain `Int`, not an + * `android.graphics.Rect`: under plain JUnit (no + * Robolectric), Android framework classes run against the SDK stub jar, where a constructed + * `Rect`'s fields silently read back as `0` instead of the values passed in. Taking ints keeps + * "no Android framework calls in these functions" a real, plain-JUnit-verifiable property instead + * of an unchecked claim; [com.nagopy.android.overlayviewmanager.internal.OverlayWindowFrame]'s + * caller extracts `left`/`top` from its `Rect` before calling in here. + * + * ## Coordinate model (drag path only) + * + * Without `allowOutsideBounds`, the drag gesture normalizes the window to an absolute `TOP|LEFT` + * gravity with zero margins (see + * [com.nagopy.android.overlayviewmanager.DraggableOnTouchListener.onActionMove]); this is a + * property of the drag path specifically, not a library-wide invariant -- + * [com.nagopy.android.overlayviewmanager.OverlaySpec.gravity] otherwise accepts any gravity, + * including `START`/`END`. Under that gravity, `x`/`y` are `screenX - frame.left` / + * `screenY - frame.top`, where `frame` is the [android.graphics.Rect] returned by + * [com.nagopy.android.overlayviewmanager.internal.OverlayWindowFrame]. Each new gesture converts + * from the window's real location, so a window the system clamped to its frame neither jumps nor + * leaves a dead zone. + * + * With `allowOutsideBounds`, the frame is only a placeholder rectangle (see + * [com.nagopy.android.overlayviewmanager.internal.OverlayWindowFrame]) and cannot give an origin. + * The system does not clamp such a window either, so the spec's offsets always describe its real + * position. The drag therefore keeps gravity and margins and adds the pointer's delta to `x`/`y` + * directly. Offsets are measured inward from the anchored edge, so they grow leftward under right + * gravity and upward under bottom gravity; [horizontalOffsetSign] and [verticalOffsetSign] invert + * the delta there. Fill gravity stretches the window, so an offset does not move it on this path. + * + * IME visibility and edge-to-edge are observable constraints on what the frame contains at query + * time, not behavior this function verifies or special-cases: this library does not itself clamp + * an out-of-frame `x`/`y`, and unit tests do not exercise real framework insets -- see + * [com.nagopy.android.overlayviewmanager.internal.OverlayWindowFrame]'s KDoc for what is and is + * not covered by the test suite versus deferred to device/instrumentation validation. + */ +@RestrictTo(RestrictTo.Scope.LIBRARY) +internal object OverlayGeometry { + + /** Converts a screen-space X coordinate into an X relative to the frame's left edge. */ + internal fun screenToWindowX(screenX: Int, frameLeft: Int): Int = screenX - frameLeft + + /** Converts a screen-space Y coordinate into a Y relative to the frame's top edge. */ + internal fun screenToWindowY(screenY: Int, frameTop: Int): Int = screenY - frameTop + + /** Returns the sign that turns a rightward pointer delta into a change of `x`. */ + internal fun horizontalOffsetSign(absoluteGravity: Int): Int = + if (absoluteGravity and Gravity.HORIZONTAL_GRAVITY_MASK == Gravity.RIGHT) -1 else 1 + + /** Returns the sign that turns a downward pointer delta into a change of `y`. */ + internal fun verticalOffsetSign(absoluteGravity: Int): Int = + if (absoluteGravity and Gravity.VERTICAL_GRAVITY_MASK == Gravity.BOTTOM) -1 else 1 + + /** + * Resolves [gravity] against [view]'s layout direction. A view that inherits its direction, or + * declares one in XML, has no resolved direction until it is measured, and + * `getLayoutDirection` then reports LTR. Before that, the direction the view would inherit is + * the best estimate available. A direction declared in XML cannot be read at all, so + * [com.nagopy.android.overlayviewmanager.OverlayView] corrects the estimate after the first + * layout. + */ + internal fun absoluteGravity(gravity: Int, view: View): Int = + Gravity.getAbsoluteGravity(gravity, layoutDirection(view)) + + private fun layoutDirection(view: View): Int = when { + view.isLayoutDirectionResolved -> view.layoutDirection + view.context.applicationInfo.flags and ApplicationInfo.FLAG_SUPPORTS_RTL == 0 -> View.LAYOUT_DIRECTION_LTR + else -> view.resources.configuration.layoutDirection + } +} diff --git a/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/internal/OverlayWindowFrame.kt b/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/internal/OverlayWindowFrame.kt new file mode 100644 index 0000000..e72011a --- /dev/null +++ b/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/internal/OverlayWindowFrame.kt @@ -0,0 +1,53 @@ +/* Copyright 2026 75py. Licensed under the Apache License, Version 2.0. */ +package com.nagopy.android.overlayviewmanager.internal + +import android.graphics.Rect +import android.view.View +import androidx.annotation.RestrictTo + +/** + * Obtains the visible frame of the window that currently hosts a managed [View], for use with + * [OverlayGeometry]'s drag-path coordinate model. [View.getWindowVisibleDisplayFrame] is the + * chosen positioning reference: it works against the view's own window without creating a second/ + * auxiliary window and without requiring `SYSTEM_ALERT_WINDOW` for the activity scope. + * + * It only applies without `allowOutsideBounds`. `FLAG_LAYOUT_NO_LIMITS` makes the framework report + * a placeholder rectangle of about 100000px in each direction, which would throw the window far + * off screen if it were used as an origin. The drag path does not query the frame in that mode; + * see [OverlayGeometry]. + * + * ## What is and is not verified by this module's unit tests + * + * Coverage is not one uniform setup: the frame-adapter and drag-path fixture tests + * (`OverlayWindowFrameTest`, `DraggableOnTouchListenerTest`) run under Robolectric SDK 28 with a + * supplied frame value (a fake `View.getWindowVisibleDisplayFrame`), not the real platform + * implementation; `OverlayGeometryTest` is plain JUnit over `Int`s, with no Android type involved + * at all; and `OverlayPermissionPreflightTest`, plus one `DraggableOnTouchListenerTest` case, run + * under Robolectric SDK 23. That proves the drag-path arithmetic (`OverlayGeometry`) and the + * listener/layout path correctly consume whatever frame this adapter returns; it does not prove + * that the real framework's `getWindowVisibleDisplayFrame` is itself equivalent across API 23, + * 26, 35, 36, multi-window/freeform, RTL, or edge-to-edge configurations. That real-framework + * equivalence is deferred to the T12 device/instrumentation validation matrix. + * + * ## Why not also cross-check with `WindowManager.getCurrentWindowMetrics()` (API 30+) + * + * `getCurrentWindowMetrics()` returns the *current window's own* bounds and + * [android.view.WindowInsets] -- not the display's -- so it is not inherently wrong as a source. + * It is deliberately not used here, even as an API 30+ cross-check, because it is obtained from a + * `WindowManager`, and which window that describes depends on which `Context` supplied it. This + * library's scope ([com.nagopy.android.overlayviewmanager.OverlayScope.ACTIVITY] vs + * [com.nagopy.android.overlayviewmanager.OverlayScope.APPLICATION]) does not constrain the + * concrete type of `view.context`, so which window `currentWindowMetrics` would describe is not + * something this library can verify from scope alone. A second derivation whose correctness would + * depend on unverified context identity is not a safe cross-check to add, so + * [View.getWindowVisibleDisplayFrame] remains the only source. + */ +@RestrictTo(RestrictTo.Scope.LIBRARY) +internal object OverlayWindowFrame { + /** Returns the visible frame, in screen coordinates, of the window hosting [view]. */ + internal fun of(view: View): Rect { + val frame = Rect() + view.getWindowVisibleDisplayFrame(frame) + return frame + } +} diff --git a/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/internal/OverlayWindowManager.kt b/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/internal/OverlayWindowManager.kt new file mode 100644 index 0000000..4f64930 --- /dev/null +++ b/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/internal/OverlayWindowManager.kt @@ -0,0 +1,37 @@ +/* Copyright 2026 75py. Licensed under the Apache License, Version 2.0. */ +package com.nagopy.android.overlayviewmanager.internal + +import android.app.Activity +import android.view.View +import android.view.WindowManager +import androidx.annotation.RestrictTo +import java.util.WeakHashMap + +/** + * Synchronous WindowManager adapter. Platform exceptions intentionally reach the handle. + */ +@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP) +public open class OverlayWindowManager @JvmOverloads constructor(private var windowManager: WindowManager? = null) { + public open fun show(view: View, params: WindowManager.LayoutParams) { requireWindowManager().addView(view, params) } + public open fun update(view: View, params: WindowManager.LayoutParams) { requireWindowManager().updateViewLayout(view, params) } + public open fun hide(view: View) { requireWindowManager().removeViewImmediate(view) } + private fun requireWindowManager(): WindowManager = windowManager ?: error("OverlayWindowManager is not initialized.") + + public companion object { + @Volatile private var applicationInstance: OverlayWindowManager = OverlayWindowManager() + private val activityInstances = WeakHashMap() + @JvmStatic public fun getApplicationInstance(): OverlayWindowManager = applicationInstance + @JvmStatic public fun initApplicationInstance(windowManager: WindowManager) { applicationInstance = OverlayWindowManager(windowManager) } + @JvmStatic public fun getActivityInstance(activity: Activity): OverlayWindowManager = synchronized(activityInstances) { activityInstances.getOrPut(activity) { OverlayWindowManager(activity.windowManager) } } + + /** + * Removes [activity]'s entry, called from `onActivityDestroyed`. The entry's value holds + * the Activity's [WindowManager], which strongly references the Activity, so the weak key + * alone is not sufficient to release it. + */ + internal fun removeActivityInstance(activity: Activity) { synchronized(activityInstances) { activityInstances.remove(activity) } } + + @JvmStatic @RestrictTo(RestrictTo.Scope.TESTS) public fun setApplicationInstance(instance: OverlayWindowManager) { applicationInstance = instance } + @JvmStatic @RestrictTo(RestrictTo.Scope.TESTS) public fun setActivityInstance(activity: Activity, instance: OverlayWindowManager) { synchronized(activityInstances) { activityInstances[activity] = instance } } + } +} diff --git a/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/internal/PassThroughOpacityRegistry.kt b/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/internal/PassThroughOpacityRegistry.kt new file mode 100644 index 0000000..2b23a0b --- /dev/null +++ b/core/src/main/kotlin/com/nagopy/android/overlayviewmanager/internal/PassThroughOpacityRegistry.kt @@ -0,0 +1,57 @@ +/* Copyright 2026 75py. Licensed under the Apache License, Version 2.0. */ +package com.nagopy.android.overlayviewmanager.internal + +import androidx.annotation.MainThread +import androidx.annotation.RestrictTo +import java.util.IdentityHashMap + +/** + * Main-thread-only, process-wide registry of the alpha of every currently attached, + * library-managed application-scope pass-through handle, used to compute the conservative + * combined opacity `1 - product(1 - alpha_i)` that Android 12+'s per-UID obscuring-opacity budget + * is checked against (see `OverlayView.admitPassThroughOpacity`). Every attached + * `OverlaySpec.touchMode == PASS_THROUGH` application handle registers here regardless of its own + * `CrossUidPassThrough` setting -- the platform's own budget for a UID is not aware of that + * per-handle opt-in, only of `FLAG_NOT_TOUCHABLE` application overlays and their alpha -- while + * only a `WHEN_SYSTEM_ALLOWS` handle ever triggers the admission check itself. + * + * Handles are keyed by identity, not by [Any.equals]/[Any.hashCode]: two distinct `OverlayView` + * instances with an otherwise-equal [com.nagopy.android.overlayviewmanager.OverlaySpec] must not + * collapse into one registry entry. + */ +@RestrictTo(RestrictTo.Scope.LIBRARY) +internal object PassThroughOpacityRegistry { + private val alphaByHandle = IdentityHashMap() + + @MainThread + internal fun register(handle: Any, alpha: Float) { + alphaByHandle[handle] = alpha + } + + @MainThread + internal fun unregister(handle: Any) { + alphaByHandle.remove(handle) + } + + /** + * The conservative combined opacity if [handle] were attached/updated at [candidateAlpha], + * covering every other currently registered handle plus this candidate -- never [handle]'s own + * prior registered value, so an update lowering its own alpha is judged on the new value only. + */ + @MainThread + internal fun combinedOpacityExcluding(handle: Any, candidateAlpha: Float): Float { + var product = 1f - candidateAlpha + for ((key, alpha) in alphaByHandle) { + if (key !== handle) product *= (1f - alpha) + } + return 1f - product + } + + @RestrictTo(RestrictTo.Scope.TESTS) + internal fun resetForTests() { + alphaByHandle.clear() + } + + @RestrictTo(RestrictTo.Scope.TESTS) + internal fun containsForTests(handle: Any): Boolean = alphaByHandle.containsKey(handle) +} diff --git a/core/src/main/res/values-ja/strings.xml b/core/src/main/res/values-ja/strings.xml deleted file mode 100644 index 2bc0f35..0000000 --- a/core/src/main/res/values-ja/strings.xml +++ /dev/null @@ -1,5 +0,0 @@ - - - %sは「他のアプリの上に重ねて表示」の許可が必要です。 - 許可する - \ No newline at end of file diff --git a/core/src/main/res/values/strings.xml b/core/src/main/res/values/strings.xml deleted file mode 100644 index 2946ef1..0000000 --- a/core/src/main/res/values/strings.xml +++ /dev/null @@ -1,21 +0,0 @@ - - - - - %s needs "Draw over other apps" permission. - Grant permission - \ No newline at end of file diff --git a/core/src/test/java/com/nagopy/android/overlayviewmanager/DraggableOnTouchListenerTest.java b/core/src/test/java/com/nagopy/android/overlayviewmanager/DraggableOnTouchListenerTest.java deleted file mode 100644 index 3046633..0000000 --- a/core/src/test/java/com/nagopy/android/overlayviewmanager/DraggableOnTouchListenerTest.java +++ /dev/null @@ -1,92 +0,0 @@ -package com.nagopy.android.overlayviewmanager; - -import android.view.MotionEvent; -import android.view.View; -import android.view.WindowManager; - -import com.nagopy.android.overlayviewmanager.internal.ScreenMonitor; - -import org.junit.After; -import org.junit.Before; -import org.junit.Test; -import org.mockito.Answers; -import org.mockito.Mock; -import org.mockito.MockitoAnnotations; - -import static org.hamcrest.CoreMatchers.equalTo; -import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertThat; -import static org.mockito.Mockito.times; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; - -public class DraggableOnTouchListenerTest { - - DraggableOnTouchListener draggableOnTouchListener; - - @Mock(answer = Answers.RETURNS_DEEP_STUBS) - OverlayView overlayView; - - @Mock - WindowManager.LayoutParams params; - - @Mock - View view; - - @Mock - ScreenMonitor screenMonitor; - - @Mock - MotionEvent motionEvent; - - @Before - public void setUp() throws Exception { - MockitoAnnotations.initMocks(this); - overlayView.params = params; - when(overlayView.getView()).thenReturn(view); - ScreenMonitor.setInstance(screenMonitor); - - draggableOnTouchListener = new DraggableOnTouchListener<>(overlayView); - } - - @After - public void tearDown() throws Exception { - } - - @Test - public void constructor() throws Exception { - overlayView.params.alpha = 0.5f; - DraggableOnTouchListener d = new DraggableOnTouchListener<>(overlayView); - - assertThat(d.overlayView, is(equalTo(overlayView))); - assertThat(d.screenMonitor, is(equalTo(screenMonitor))); - assertThat(d.backupAlpha, is(0.5f)); - } - - @Test - public void onTouch_up() throws Exception { - when(motionEvent.getActionMasked()).thenReturn(MotionEvent.ACTION_UP); - draggableOnTouchListener.backupAlpha = 0.5f; - when(overlayView.setAlpha(0.5f)).thenReturn(overlayView); - - draggableOnTouchListener.onTouch(view, motionEvent); - - verify(motionEvent, times(1)).getActionMasked(); - verify(overlayView, times(1)).setAlpha(0.5f); - verify(overlayView, times(1)).update(); - } - - @Test - public void onTouch_cancel() throws Exception { - when(motionEvent.getActionMasked()).thenReturn(MotionEvent.ACTION_CANCEL); - draggableOnTouchListener.backupAlpha = 0.5f; - when(overlayView.setAlpha(0.5f)).thenReturn(overlayView); - - draggableOnTouchListener.onTouch(view, motionEvent); - - verify(motionEvent, times(1)).getActionMasked(); - verify(overlayView, times(1)).setAlpha(0.5f); - verify(overlayView, times(1)).update(); - } - -} \ No newline at end of file diff --git a/core/src/test/java/com/nagopy/android/overlayviewmanager/OverlaySpecJavaConsumerTest.java b/core/src/test/java/com/nagopy/android/overlayviewmanager/OverlaySpecJavaConsumerTest.java new file mode 100644 index 0000000..f4fb7ba --- /dev/null +++ b/core/src/test/java/com/nagopy/android/overlayviewmanager/OverlaySpecJavaConsumerTest.java @@ -0,0 +1,169 @@ +/* + * Copyright 2026 75py + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.nagopy.android.overlayviewmanager; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertSame; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.assertThrows; + +import android.view.Gravity; +import android.view.ViewGroup; + +import org.junit.Test; + +public class OverlaySpecJavaConsumerTest { + + @Test + public void defaultConstructorAndAccessors_areAvailableToJava() { + OverlaySpec spec = new OverlaySpec(); + + assertEquals(ViewGroup.LayoutParams.WRAP_CONTENT, spec.getWidth()); + assertEquals(ViewGroup.LayoutParams.WRAP_CONTENT, spec.getHeight()); + assertEquals(Gravity.TOP | Gravity.START, spec.getGravity()); + assertEquals(0, spec.getX()); + assertEquals(0, spec.getY()); + assertEquals(0f, spec.getHorizontalMargin(), 0f); + assertEquals(0f, spec.getVerticalMargin(), 0f); + assertEquals(1f, spec.getAlpha(), 0f); + assertEquals(OverlayTouchMode.PASS_THROUGH, spec.getTouchMode()); + assertEquals(CrossUidPassThrough.SAME_UID_ONLY, spec.getCrossUidPassThrough()); + assertFalse(spec.getAllowOutsideBounds()); + assertNull(spec.getScreenBrightness()); + } + + @Test + public void builderAndToBuilder_preserveTheJavaSurface() { + OverlaySpec spec = new OverlaySpec.Builder() + .setWidth(12) + .setHeight(ViewGroup.LayoutParams.MATCH_PARENT) + .setGravity(Gravity.BOTTOM | Gravity.END) + .setX(1) + .setY(-2) + .setHorizontalMargin(0.1f) + .setVerticalMargin(0.2f) + .setAlpha(0.3f) + .setTouchMode(OverlayTouchMode.INTERACTIVE) + .setCrossUidPassThrough(CrossUidPassThrough.WHEN_SYSTEM_ALLOWS) + .setAllowOutsideBounds(true) + .setScreenBrightness(Float.valueOf(0.4f)) + .build(); + + assertEquals(12, spec.getWidth()); + assertEquals(ViewGroup.LayoutParams.MATCH_PARENT, spec.getHeight()); + assertEquals(Gravity.BOTTOM | Gravity.END, spec.getGravity()); + assertEquals(1, spec.getX()); + assertEquals(-2, spec.getY()); + assertEquals(0.1f, spec.getHorizontalMargin(), 0f); + assertEquals(0.2f, spec.getVerticalMargin(), 0f); + assertEquals(0.3f, spec.getAlpha(), 0f); + assertEquals(OverlayTouchMode.INTERACTIVE, spec.getTouchMode()); + assertEquals(CrossUidPassThrough.WHEN_SYSTEM_ALLOWS, spec.getCrossUidPassThrough()); + assertTrue(spec.getAllowOutsideBounds()); + assertEquals(Float.valueOf(0.4f), spec.getScreenBrightness()); + assertEquals(spec, spec.toBuilder().build()); + } + + @Test + public void builderAcceptsValidLayoutConstants() { + OverlaySpec spec = new OverlaySpec.Builder() + .setWidth(ViewGroup.LayoutParams.MATCH_PARENT) + .setHeight(ViewGroup.LayoutParams.WRAP_CONTENT) + .build(); + + assertEquals(ViewGroup.LayoutParams.MATCH_PARENT, spec.getWidth()); + assertEquals(ViewGroup.LayoutParams.WRAP_CONTENT, spec.getHeight()); + } + + @Test + public void builderRejectsInvalidDimensionsAndNormalizedValues() { + OverlaySpec.Builder builder = new OverlaySpec.Builder() + .setWidth(12) + .setHeight(24) + .setHorizontalMargin(0.2f) + .setVerticalMargin(0.3f) + .setAlpha(0.4f) + .setScreenBrightness(Float.valueOf(0.5f)); + + assertThrows(IllegalArgumentException.class, () -> builder.setWidth(-3)); + assertThrows(IllegalArgumentException.class, () -> builder.setHeight(-4)); + assertThrows(IllegalArgumentException.class, () -> builder.setHorizontalMargin(1.01f)); + assertThrows(IllegalArgumentException.class, () -> builder.setVerticalMargin(-0.01f)); + assertThrows(IllegalArgumentException.class, () -> builder.setAlpha(1.01f)); + assertThrows( + IllegalArgumentException.class, + () -> builder.setScreenBrightness(-0.01f)); + assertThrows( + IllegalArgumentException.class, + () -> builder.setHorizontalMargin(Float.NaN)); + assertThrows( + IllegalArgumentException.class, + () -> builder.setVerticalMargin(Float.POSITIVE_INFINITY)); + assertThrows(IllegalArgumentException.class, () -> builder.setAlpha(Float.NEGATIVE_INFINITY)); + assertThrows( + IllegalArgumentException.class, + () -> builder.setScreenBrightness(Float.NaN)); + + OverlaySpec spec = builder.build(); + assertEquals(12, spec.getWidth()); + assertEquals(24, spec.getHeight()); + assertEquals(0.2f, spec.getHorizontalMargin(), 0f); + assertEquals(0.3f, spec.getVerticalMargin(), 0f); + assertEquals(0.4f, spec.getAlpha(), 0f); + assertEquals(Float.valueOf(0.5f), spec.getScreenBrightness()); + } + + @Test + public void builderFromExistingSpec_isAnIndependentSnapshot() { + OverlaySpec source = new OverlaySpec.Builder() + .setWidth(16) + .setX(3) + .setY(-4) + .setAlpha(0.6f) + .setScreenBrightness(Float.valueOf(0.7f)) + .build(); + + OverlaySpec.Builder builder = new OverlaySpec.Builder(source); + assertEquals(source, builder.build()); + + OverlaySpec changed = builder.setX(8).setAlpha(0.9f).build(); + assertEquals(3, source.getX()); + assertEquals(0.6f, source.getAlpha(), 0f); + assertEquals(8, changed.getX()); + assertEquals(0.9f, changed.getAlpha(), 0f); + } + + @Test + public void resultAccessorsAndIsSuccess_areAvailableToJava() { + IllegalArgumentException cause = new IllegalArgumentException("denied"); + OverlayResult success = new OverlayResult(OverlayState.ATTACHED, true, null, null); + OverlayResult failure = new OverlayResult( + OverlayState.CONFIGURED, + false, + OverlayFailure.PERMISSION_DENIED, + cause); + + assertTrue(success.isSuccess()); + assertFalse(failure.isSuccess()); + assertEquals(OverlayState.CONFIGURED, failure.getState()); + assertFalse(failure.getChanged()); + assertEquals(OverlayFailure.PERMISSION_DENIED, failure.getFailure()); + assertSame(cause, failure.getCause()); + } +} diff --git a/core/src/test/java/com/nagopy/android/overlayviewmanager/OverlayViewManagerTest.java b/core/src/test/java/com/nagopy/android/overlayviewmanager/OverlayViewManagerTest.java index 57bdf46..d1e8fc1 100644 --- a/core/src/test/java/com/nagopy/android/overlayviewmanager/OverlayViewManagerTest.java +++ b/core/src/test/java/com/nagopy/android/overlayviewmanager/OverlayViewManagerTest.java @@ -1,133 +1,99 @@ package com.nagopy.android.overlayviewmanager; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertThrows; +import static org.junit.Assert.assertSame; + import android.app.Activity; import android.app.Application; -import android.content.Context; import android.os.Build; import android.view.View; +import android.widget.FrameLayout; import android.view.WindowManager; import org.junit.After; -import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; -import org.mockito.Mock; import org.mockito.Mockito; -import org.mockito.MockitoAnnotations; import org.robolectric.RobolectricTestRunner; import org.robolectric.RuntimeEnvironment; import org.robolectric.annotation.Config; -import static org.hamcrest.CoreMatchers.equalTo; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.CoreMatchers.notNullValue; -import static org.junit.Assert.assertThat; -import static org.junit.Assert.assertTrue; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.times; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; - -import com.nagopy.android.overlayviewmanager.internal.ScreenMonitor; +import java.lang.reflect.Field; @RunWith(RobolectricTestRunner.class) -@Config(sdk = Build.VERSION_CODES.LOLLIPOP - , manifest = Config.NONE -) +@Config(sdk = Build.VERSION_CODES.P, manifest = Config.NONE) public class OverlayViewManagerTest { - - @Mock - Application application; - - @Mock - WindowManager windowManager; - - @Mock - View view; - @Mock - View view2; - - @Mock - ScreenMonitor screenMonitor; - - OverlayViewManager overlayViewManager; - - @Before - public void setUp() throws Exception { - MockitoAnnotations.openMocks(this); - - ScreenMonitor.setInstance(screenMonitor); - - application = Mockito.spy(RuntimeEnvironment.application); - when(application.getSystemService(Context.WINDOW_SERVICE)).thenReturn(windowManager); - when(application.getApplicationContext()).thenReturn(application); + @After public void tearDown() throws Exception { managerInstanceField().set(null, null); } + @Test public void getInstanceBeforeInit_throws() { assertThrows(IllegalStateException.class, OverlayViewManager::getInstance); } + @Test public void sameApplicationInitIsIdempotentAndDifferentApplicationFails() { + Application application = RuntimeEnvironment.getApplication(); OverlayViewManager.init(application); - - overlayViewManager = new OverlayViewManager(); - OverlayViewManager.INSTANCE = overlayViewManager; - } - - @After - public void tearDown() throws Exception { + OverlayViewManager.init(application); + assertThrows(IllegalStateException.class, () -> OverlayViewManager.init(Mockito.mock(Application.class))); } + @Test public void repeatedInitRegistersExactlyOneLifecycleCallbackAndPreservesInstanceOnRejectedReinit() { + Application application = Mockito.spy(RuntimeEnvironment.getApplication()); + OverlayViewManager.init(application); + OverlayViewManager manager = OverlayViewManager.getInstance(); + OverlayViewManager.init(application); + Mockito.verify(application, Mockito.times(1)).registerActivityLifecycleCallbacks(Mockito.any()); + assertSame(manager, OverlayViewManager.getInstance()); + assertThrows(IllegalStateException.class, () -> OverlayViewManager.init(Mockito.mock(Application.class))); - @Test(expected = IllegalStateException.class) - public void getInstance_noContext() throws Exception { - OverlayViewManager.INSTANCE.applicationContext = null; - OverlayViewManager.getInstance(); - } - - @Test - public void getInstance() throws Exception { - OverlayViewManager.INSTANCE.applicationContext = application; - OverlayViewManager.getInstance(); + Mockito.verify(application, Mockito.times(1)).registerActivityLifecycleCallbacks(Mockito.any()); + assertSame(manager, OverlayViewManager.getInstance()); } - - @Test - public void init() throws Exception { - OverlayViewManager mock = mock(OverlayViewManager.class); - OverlayViewManager.INSTANCE = mock; + @Test public void explicitJavaFactoryOverloadsCreateBothScopes() { + Application application = RuntimeEnvironment.getApplication(); OverlayViewManager.init(application); - - verify(mock, times(1)).initialize(application); + Activity activity = Mockito.mock(Activity.class); + Mockito.when(activity.getWindowManager()).thenReturn(Mockito.mock(WindowManager.class)); + OverlayViewManager manager = OverlayViewManager.getInstance(); + assertNotNull(manager.newOverlayView(new View(application))); + assertNotNull(manager.newOverlayView(new View(application), new OverlaySpec())); + assertNotNull(manager.newOverlayView(new View(application), activity)); + assertNotNull(manager.newOverlayView(new View(application), activity, new OverlaySpec())); + + OverlayView handle = manager.newOverlayView(new View(application), activity); + OverlayResult configured = handle.update(handle.getSpec().toBuilder().setX(4).build()); + OverlayResult shown = handle.show(); + OverlayResult hidden = handle.hide(); + OverlayResult disposed = handle.dispose(); + assertNotNull(configured); + assertNotNull(shown); + assertNotNull(hidden); + assertNotNull(disposed); } - - @Test - public void initialize() throws Exception { - overlayViewManager.initialize(application); - - assertThat(overlayViewManager.applicationContext, is(equalTo(application.getApplicationContext()))); - assertThat(overlayViewManager.windowManager, is(notNullValue())); + @Test public void applicationBrightnessIsRejectedAtFactory() { + Application application = RuntimeEnvironment.getApplication(); + OverlayViewManager.init(application); + OverlaySpec spec = new OverlaySpec.Builder().setScreenBrightness(.5f).build(); + assertThrows(IllegalArgumentException.class, () -> OverlayViewManager.getInstance().newOverlayView(new View(application), spec)); } - - @Config(sdk = Build.VERSION_CODES.LOLLIPOP_MR1) - @Test - public void canDrawOverlays_22() throws Exception { + @Test public void factoryRejectsAnAlreadyParentedViewAndDestroyedActivity() { + Application application = RuntimeEnvironment.getApplication(); OverlayViewManager.init(application); - - assertTrue(OverlayViewManager.getInstance().canDrawOverlays()); + View child = new View(application); + new FrameLayout(application).addView(child); + assertThrows(IllegalArgumentException.class, () -> OverlayViewManager.getInstance().newOverlayView(child)); + Activity destroyed = Mockito.mock(Activity.class); + Mockito.when(destroyed.isDestroyed()).thenReturn(true); + assertThrows(IllegalArgumentException.class, () -> OverlayViewManager.getInstance().newOverlayView(new View(application), destroyed)); + assertThrows(IllegalArgumentException.class, () -> OverlayViewManager.getInstance().newOverlayView(new View(application), destroyed, new OverlaySpec())); } - - /* - @Config(sdk = Build.VERSION_CODES.M) - @Test - public void canDrawOverlays_23() throws Exception { - OverlayViewManager.applicationContext = applicationContext; - assertTrue(OverlayViewManager.canDrawOverlays()); + @Test public void factoryRejectsAFinishingActivityOnBothOverloadShapes() { + Application application = RuntimeEnvironment.getApplication(); + OverlayViewManager.init(application); + Activity finishing = Mockito.mock(Activity.class); + Mockito.when(finishing.isFinishing()).thenReturn(true); + assertThrows(IllegalArgumentException.class, () -> OverlayViewManager.getInstance().newOverlayView(new View(application), finishing)); + assertThrows(IllegalArgumentException.class, () -> OverlayViewManager.getInstance().newOverlayView(new View(application), finishing, new OverlaySpec())); } - */ - - @Test - public void newOverlayView() throws Exception { - OverlayView overlayView = overlayViewManager.newOverlayView(view); - assertThat(overlayView.getView(), is(view)); - assertThat(overlayView.viewScope, is(OverlayView.ViewScope.APPLICATION)); - - Activity activity = mock(Activity.class); - OverlayView overlayView2 = overlayViewManager.newOverlayView(view2, activity); - assertThat(overlayView2.getView(), is(view2)); - assertThat(overlayView2.viewScope, is(OverlayView.ViewScope.ACTIVITY)); + private static Field managerInstanceField() throws NoSuchFieldException { + Field field = OverlayViewManager.class.getDeclaredField("instance"); + field.setAccessible(true); + return field; } - -} \ No newline at end of file +} diff --git a/core/src/test/java/com/nagopy/android/overlayviewmanager/OverlayViewTest.java b/core/src/test/java/com/nagopy/android/overlayviewmanager/OverlayViewTest.java deleted file mode 100644 index 8e2e6c3..0000000 --- a/core/src/test/java/com/nagopy/android/overlayviewmanager/OverlayViewTest.java +++ /dev/null @@ -1,372 +0,0 @@ -package com.nagopy.android.overlayviewmanager; - -import android.os.Build; -import android.view.Gravity; -import android.view.View; - -import com.nagopy.android.overlayviewmanager.internal.OverlayWindowManager; -import com.nagopy.android.overlayviewmanager.internal.ScreenMonitor; - -import org.junit.After; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.Mock; -import org.mockito.MockitoAnnotations; -import org.robolectric.RobolectricTestRunner; -import org.robolectric.annotation.Config; - -import static android.view.ViewGroup.LayoutParams.WRAP_CONTENT; -import static android.view.WindowManager.LayoutParams.BRIGHTNESS_OVERRIDE_NONE; -import static android.view.WindowManager.LayoutParams.FLAG_LAYOUT_INSET_DECOR; -import static android.view.WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN; -import static android.view.WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS; -import static android.view.WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE; -import static android.view.WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE; -import static android.view.WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL; -import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY; -import static android.view.WindowManager.LayoutParams.TYPE_SYSTEM_ALERT; -import static android.view.WindowManager.LayoutParams.TYPE_SYSTEM_ERROR; -import static android.view.WindowManager.LayoutParams.TYPE_SYSTEM_OVERLAY; -import static org.hamcrest.CoreMatchers.equalTo; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.CoreMatchers.not; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertThat; -import static org.junit.Assert.assertTrue; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.never; -import static org.mockito.Mockito.times; -import static org.mockito.Mockito.verify; - -@RunWith(RobolectricTestRunner.class) -@Config(sdk = Build.VERSION_CODES.LOLLIPOP - , manifest = Config.NONE -) -public class OverlayViewTest { - - OverlayView overlayView; - - @Mock - OverlayWindowManager overlayWindowManager; - - @Mock - ScreenMonitor screenMonitor; - - @Mock - View view; - - @Before - public void setUp() throws Exception { - MockitoAnnotations.initMocks(this); - OverlayWindowManager.setApplicationInstance(overlayWindowManager); // set mock - ScreenMonitor.setInstance(screenMonitor); // set mock - overlayView = OverlayView.create(view); - } - - @After - public void tearDown() throws Exception { - } - - @Test - public void show_isVisibleTrue() throws Exception { - overlayView.isVisible = true; - overlayView.show(); - verify(overlayWindowManager, never()).show(overlayView.view, overlayView.params); - assertThat(overlayView.isVisible, is(true)); - } - - @Test - public void show_isVisibleFalse_isDraggableFalse() throws Exception { - overlayView.isVisible = false; - overlayView.isDraggable = false; - OverlayView retOverlayView = overlayView.show(); - assertThat(retOverlayView, is(equalTo(overlayView))); - verify(overlayWindowManager, times(1)).show(overlayView.view, overlayView.params); - assertThat(overlayView.isVisible, is(true)); - assertThat(overlayView.lastWindowType, is(equalTo(overlayView.params.type))); - verify(screenMonitor, never()).request(overlayView); - } - - @Test - public void show_isVisibleFalse_isDraggableTrue() throws Exception { - overlayView.isVisible = false; - overlayView.isDraggable = true; - OverlayView retOverlayView = overlayView.show(); - assertThat(retOverlayView, is(equalTo(overlayView))); - verify(overlayWindowManager, times(1)).show(overlayView.view, overlayView.params); - assertThat(overlayView.isVisible, is(true)); - assertThat(overlayView.lastWindowType, is(equalTo(overlayView.params.type))); - verify(screenMonitor, times(1)).request(overlayView); - } - - @Test - public void update_isVisibleFalse() throws Exception { - overlayView.isVisible = false; - overlayView.update(); - verify(overlayWindowManager, never()).update(overlayView.view, overlayView.params); - verify(screenMonitor, never()).request(overlayView); - verify(screenMonitor, never()).cancel(overlayView); - } - - @Test - public void update_isVisibleTrue_sameWindowType() throws Exception { - overlayView.lastWindowType = TYPE_SYSTEM_OVERLAY; - overlayView.isVisible = true; - overlayView.update(); - verify(overlayWindowManager, times(1)).update(overlayView.view, overlayView.params); - verify(overlayWindowManager, never()).hide(overlayView.view); - verify(overlayWindowManager, never()).show(overlayView.view, overlayView.params); - assertThat(overlayView.lastWindowType, is(equalTo(overlayView.params.type))); - } - - @Test - public void update_isVisibleTrue_differentWindowType() throws Exception { - overlayView.lastWindowType = TYPE_SYSTEM_ALERT; - overlayView.isVisible = true; - overlayView.update(); - verify(overlayWindowManager, never()).update(overlayView.view, overlayView.params); - verify(overlayWindowManager, times(1)).hide(overlayView.view); - verify(overlayWindowManager, times(1)).show(overlayView.view, overlayView.params); - assertThat(overlayView.lastWindowType, is(equalTo(overlayView.params.type))); - } - - @Test - public void update_isVisibleTrue_isDraggableTrue() throws Exception { - overlayView.isVisible = true; - overlayView.isDraggable = true; - overlayView.update(); - verify(screenMonitor, times(1)).request(overlayView); - verify(screenMonitor, never()).cancel(overlayView); - } - - @Test - public void update_isVisibleTrue_isDraggableFalse() throws Exception { - overlayView.isVisible = true; - overlayView.isDraggable = false; - overlayView.update(); - verify(screenMonitor, never()).request(overlayView); - verify(screenMonitor, times(1)).cancel(overlayView); - } - - @Test - public void hide_isVisibleTrue_isDraggableTrue() throws Exception { - overlayView.isVisible = true; - overlayView.isDraggable = true; - overlayView.hide(); - verify(overlayWindowManager, times(1)).hide(overlayView.view); - verify(screenMonitor, times(1)).cancel(overlayView); - } - - @Test - public void hide_isVisibleTrue_isDraggableFalse() throws Exception { - overlayView.isVisible = true; - overlayView.isDraggable = false; - overlayView.hide(); - verify(overlayWindowManager, times(1)).hide(overlayView.view); - verify(screenMonitor, never()).cancel(overlayView); - } - - @Test - public void hide_isVisibleFalse() throws Exception { - overlayView.isVisible = false; - overlayView.hide(); - verify(overlayWindowManager, never()).hide(overlayView.view); - } - - @Test - public void getView() throws Exception { - assertThat(overlayView.getView(), is(view)); - } - - @Test - public void setOnClickListener() throws Exception { - View.OnClickListener l = mock(View.OnClickListener.class); - overlayView.setOnClickListener(l); - verify(view, times(1)).setOnClickListener(l); - } - - @Test - public void setTouchable() throws Exception { - overlayView.isTouchable = false; - overlayView.setTouchable(true); - assertTrue(overlayView.isTouchable); - } - - @Test - public void setDraggable() throws Exception { - assertFalse(overlayView.isDraggable); - - overlayView.setDraggable(true); - assertTrue(overlayView.isDraggable); - } - - @Test - public void setWidth() throws Exception { - assertThat(overlayView.params.width, is(WRAP_CONTENT)); - - overlayView.setWidth(100); - assertThat(overlayView.params.width, is(100)); - } - - @Test - public void setHeight() throws Exception { - assertThat(overlayView.params.height, is(WRAP_CONTENT)); - - overlayView.setHeight(200); - assertThat(overlayView.params.height, is(200)); - } - - @Test - public void setGravity() throws Exception { - assertThat(overlayView.params.gravity, is(not(Gravity.BOTTOM))); - - overlayView.setGravity(Gravity.BOTTOM); - assertThat(overlayView.params.gravity, is(Gravity.BOTTOM)); - } - - @Test - public void setHorizontalMargin() throws Exception { - assertThat(overlayView.params.horizontalMargin, is(0f)); - - overlayView.setHorizontalMargin(0.5f); - assertThat(overlayView.params.horizontalMargin, is(0.5f)); - } - - @Test - public void setVerticalMargin() throws Exception { - assertThat(overlayView.params.verticalMargin, is(0f)); - - overlayView.setVerticalMargin(0.5f); - assertThat(overlayView.params.verticalMargin, is(0.5f)); - } - - @Test - public void setAlpha() throws Exception { - assertThat(overlayView.params.alpha, is(1f)); - - overlayView.setAlpha(0.5f); - assertThat(overlayView.params.alpha, is(0.5f)); - } - - @Test - public void setX() throws Exception { - assertThat(overlayView.params.x, is(0)); - - overlayView.setX(100); - assertThat(overlayView.params.x, is(100)); - } - - @Test - public void setY() throws Exception { - assertThat(overlayView.params.y, is(0)); - - overlayView.setY(200); - assertThat(overlayView.params.y, is(200)); - } - - @Test - public void getX() throws Exception { - assertThat(overlayView.params.x, is(0)); - - overlayView.params.x = 100; - assertThat(overlayView.getX(), is(100)); - } - - @Test - public void getY() throws Exception { - assertThat(overlayView.params.y, is(0)); - - overlayView.params.y = 200; - assertThat(overlayView.getY(), is(200)); - } - - @Test - public void setScreenBrightness() throws Exception { - assertThat(overlayView.params.screenBrightness, is(BRIGHTNESS_OVERRIDE_NONE)); - - overlayView.setScreenBrightness(0.5f); - assertThat(overlayView.params.screenBrightness, is(0.5f)); - } - - @Config(sdk = Build.VERSION_CODES.N_MR1) - @Test - public void updateParams_API25_default() throws Exception { - overlayView.isTouchable = false; - overlayView.allowViewToExtendOutsideScreen = false; - overlayView.isDraggable = false; - - overlayView.updateParams(); - assertThat(overlayView.params.type, is(TYPE_SYSTEM_OVERLAY)); - assertThat(overlayView.params.flags, - is(equalTo(FLAG_NOT_TOUCHABLE | FLAG_NOT_TOUCH_MODAL | FLAG_NOT_FOCUSABLE))); - } - - @Config(sdk = Build.VERSION_CODES.O) - @Test - public void updateParams_API26_default() throws Exception { - overlayView.isTouchable = false; - overlayView.allowViewToExtendOutsideScreen = false; - overlayView.isDraggable = false; - - overlayView.updateParams(); - assertThat(overlayView.params.type, is(TYPE_APPLICATION_OVERLAY)); - assertThat(overlayView.params.flags, - is(equalTo(FLAG_NOT_TOUCHABLE | FLAG_NOT_TOUCH_MODAL | FLAG_NOT_FOCUSABLE))); - } - - @Config(sdk = Build.VERSION_CODES.N_MR1) - @Test - public void updateParams_API25_touchable() throws Exception { - overlayView.isTouchable = true; - overlayView.allowViewToExtendOutsideScreen = false; - overlayView.isDraggable = false; - - overlayView.updateParams(); - assertThat(overlayView.params.type, is(TYPE_SYSTEM_ALERT)); - assertThat(overlayView.params.flags, - is(equalTo(FLAG_NOT_FOCUSABLE))); - } - - @Config(sdk = Build.VERSION_CODES.O) - @Test - public void updateParams_API26_touchable() throws Exception { - overlayView.isTouchable = true; - overlayView.allowViewToExtendOutsideScreen = false; - overlayView.isDraggable = false; - - overlayView.updateParams(); - assertThat(overlayView.params.type, is(TYPE_APPLICATION_OVERLAY)); - assertThat(overlayView.params.flags, - is(equalTo(FLAG_NOT_FOCUSABLE))); - } - - @Config(sdk = Build.VERSION_CODES.N_MR1) - @Test - public void updateParams_API25_touchable_aboveNavi() throws Exception { - overlayView.isTouchable = true; - overlayView.allowViewToExtendOutsideScreen = true; - overlayView.isDraggable = false; - - overlayView.updateParams(); - assertThat(overlayView.params.type, is(TYPE_SYSTEM_ERROR)); - assertThat(overlayView.params.flags, - is(equalTo(FLAG_NOT_FOCUSABLE - | FLAG_LAYOUT_NO_LIMITS | FLAG_LAYOUT_INSET_DECOR | FLAG_LAYOUT_IN_SCREEN))); - } - - @Config(sdk = Build.VERSION_CODES.O) - @Test - public void updateParams_API26_touchable_aboveNavi() throws Exception { - overlayView.isTouchable = true; - overlayView.allowViewToExtendOutsideScreen = true; - overlayView.isDraggable = false; - - overlayView.updateParams(); - assertThat(overlayView.params.type, is(TYPE_APPLICATION_OVERLAY)); - assertThat(overlayView.params.flags, - is(equalTo(FLAG_NOT_FOCUSABLE - | FLAG_LAYOUT_NO_LIMITS | FLAG_LAYOUT_INSET_DECOR | FLAG_LAYOUT_IN_SCREEN))); - } - -} \ No newline at end of file diff --git a/core/src/test/java/com/nagopy/android/overlayviewmanager/PermissionRequestDialogFragmentTest.java b/core/src/test/java/com/nagopy/android/overlayviewmanager/PermissionRequestDialogFragmentTest.java deleted file mode 100644 index 27a314c..0000000 --- a/core/src/test/java/com/nagopy/android/overlayviewmanager/PermissionRequestDialogFragmentTest.java +++ /dev/null @@ -1,57 +0,0 @@ -package com.nagopy.android.overlayviewmanager; - -import android.app.Dialog; -import android.os.Build; -import android.os.Bundle; -import androidx.fragment.app.FragmentActivity; -import android.view.Window; - -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.robolectric.Robolectric; -import org.robolectric.RobolectricTestRunner; -import org.robolectric.annotation.Config; -import org.robolectric.shadows.ShadowDialog; - -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.CoreMatchers.notNullValue; -import static org.junit.Assert.assertThat; - -@RunWith(RobolectricTestRunner.class) -@Config(sdk = Build.VERSION_CODES.LOLLIPOP -) -public class PermissionRequestDialogFragmentTest { - - public static class TestActivity extends FragmentActivity { - PermissionRequestDialogFragment dialogFragment; - - @Override - public void onCreate(Bundle savedInstanceState) { - super.onCreate(savedInstanceState); - requestWindowFeature(Window.FEATURE_NO_TITLE); - dialogFragment = PermissionRequestDialogFragment.newInstance(android.R.string.unknownName); - dialogFragment.show(getSupportFragmentManager(), "some_dialog"); - } - } - - @Before - public void setUp() throws Exception { - } - - @Test - public void newInstance() throws Exception { - PermissionRequestDialogFragment fragment = PermissionRequestDialogFragment.newInstance(75); - assertThat(fragment, is(notNullValue())); - assertThat(fragment.getArguments().getInt(PermissionRequestDialogFragment.KEY_APP_NAME_ID), - is(75)); - } - - @Test - public void onCreateDialog() throws Exception { - TestActivity testActivity = Robolectric.setupActivity(TestActivity.class); - Dialog dialog = ShadowDialog.getLatestDialog(); - assertThat(dialog, is(notNullValue())); - } - -} \ No newline at end of file diff --git a/core/src/test/java/com/nagopy/android/overlayviewmanager/internal/OverlayWindowManagerTest.java b/core/src/test/java/com/nagopy/android/overlayviewmanager/internal/OverlayWindowManagerTest.java index eb37468..1f89517 100644 --- a/core/src/test/java/com/nagopy/android/overlayviewmanager/internal/OverlayWindowManagerTest.java +++ b/core/src/test/java/com/nagopy/android/overlayviewmanager/internal/OverlayWindowManagerTest.java @@ -1,126 +1,43 @@ package com.nagopy.android.overlayviewmanager.internal; -import android.app.Activity; -import android.view.View; -import android.view.WindowManager; - -import org.junit.After; -import org.junit.Before; -import org.junit.Test; -import org.mockito.Mock; -import org.mockito.MockitoAnnotations; - -import static org.hamcrest.CoreMatchers.equalTo; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.CoreMatchers.notNullValue; -import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertSame; +import static org.junit.Assert.assertThrows; import static org.mockito.Mockito.doThrow; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; -public class OverlayWindowManagerTest { - - OverlayWindowManager overlayWindowManager; - - @Mock - WindowManager windowManager; - - @Mock - View view; - - @Mock - WindowManager.LayoutParams params; - - @Before - public void setUp() throws Exception { - MockitoAnnotations.initMocks(this); - - overlayWindowManager = new OverlayWindowManager(); - overlayWindowManager.windowManager = windowManager; - } - - @After - public void tearDown() throws Exception { - } - - @Test - public void getApplicationInstance() throws Exception { - OverlayWindowManager.initApplicationInstance(windowManager); - OverlayWindowManager instance = OverlayWindowManager.getApplicationInstance(); - assertThat(instance, is(notNullValue())); - assertThat(instance.windowManager, is(equalTo(windowManager))); - } - - @Test - public void getActivityInstance() throws Exception { - Activity activity1 = mock(Activity.class); - WindowManager windowManager1 = mock(WindowManager.class); - when(activity1.getWindowManager()).thenReturn(windowManager1); - Activity activity2 = mock(Activity.class); - WindowManager windowManager2 = mock(WindowManager.class); - when(activity2.getWindowManager()).thenReturn(windowManager2); - - OverlayWindowManager instance1 = OverlayWindowManager.getActivityInstance(activity1); - assertThat(instance1, is(notNullValue())); - assertThat(instance1.windowManager, is(equalTo(windowManager1))); - - OverlayWindowManager instance2 = OverlayWindowManager.getActivityInstance(activity2); - assertThat(instance2, is(notNullValue())); - assertThat(instance2.windowManager, is(equalTo(windowManager2))); - - OverlayWindowManager instance1_2 = OverlayWindowManager.getActivityInstance(activity1); - assertThat(instance1_2, is(notNullValue())); - assertThat(instance1_2.windowManager, is(equalTo(windowManager1))); - } - - @Test - public void show() throws Exception { - overlayWindowManager.show(view, params); - - verify(windowManager, times(1)).addView(view, params); - } - - @Test - public void show_fail() throws Exception { - doThrow(RuntimeException.class).when(windowManager).addView(view, params); - - overlayWindowManager.show(view, params); - - verify(windowManager, times(1)).addView(view, params); - } - - @Test - public void update() throws Exception { - overlayWindowManager.update(view, params); - - verify(windowManager, times(1)).updateViewLayout(view, params); - } - - @Test - public void update_fail() throws Exception { - doThrow(RuntimeException.class).when(windowManager).updateViewLayout(view, params); - - overlayWindowManager.update(view, params); - - verify(windowManager, times(1)).updateViewLayout(view, params); - } - - @Test - public void hide() throws Exception { - overlayWindowManager.hide(view); - - verify(windowManager, times(1)).removeViewImmediate(view); - } - - @Test - public void hide_fail() throws Exception { - doThrow(RuntimeException.class).when(windowManager).removeViewImmediate(view); - - overlayWindowManager.hide(view); +import android.app.Activity; +import android.view.View; +import android.view.WindowManager; - verify(windowManager, times(1)).removeViewImmediate(view); - } +import org.junit.Test; -} \ No newline at end of file +public class OverlayWindowManagerTest { + @Test public void instancesRetainTheirAssignedBackend() { + WindowManager windows = mock(WindowManager.class); + OverlayWindowManager.initApplicationInstance(windows); + assertNotNull(OverlayWindowManager.getApplicationInstance()); + Activity activity = mock(Activity.class); + WindowManager activityWindows = mock(WindowManager.class); + when(activity.getWindowManager()).thenReturn(activityWindows); + assertSame(OverlayWindowManager.getActivityInstance(activity), OverlayWindowManager.getActivityInstance(activity)); + } + + @Test public void backendCallsAreSynchronousAndFailuresPropagate() { + WindowManager windows = mock(WindowManager.class); + View view = mock(View.class); + WindowManager.LayoutParams params = mock(WindowManager.LayoutParams.class); + OverlayWindowManager backend = new OverlayWindowManager(windows); + backend.show(view, params); + backend.update(view, params); + backend.hide(view); + verify(windows, times(1)).addView(view, params); + verify(windows, times(1)).updateViewLayout(view, params); + verify(windows, times(1)).removeViewImmediate(view); + doThrow(new IllegalStateException("rejected")).when(windows).addView(view, params); + assertThrows(IllegalStateException.class, () -> backend.show(view, params)); + } +} diff --git a/core/src/test/java/com/nagopy/android/overlayviewmanager/internal/ScreenMonitorTest.java b/core/src/test/java/com/nagopy/android/overlayviewmanager/internal/ScreenMonitorTest.java deleted file mode 100644 index cb4a144..0000000 --- a/core/src/test/java/com/nagopy/android/overlayviewmanager/internal/ScreenMonitorTest.java +++ /dev/null @@ -1,145 +0,0 @@ -package com.nagopy.android.overlayviewmanager.internal; - -import android.os.Build; -import android.view.WindowManager; - -import com.nagopy.android.overlayviewmanager.OverlayView; - -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.Mock; -import org.mockito.MockitoAnnotations; -import org.robolectric.RobolectricTestRunner; -import org.robolectric.RuntimeEnvironment; -import org.robolectric.annotation.Config; - -import static android.view.ViewGroup.LayoutParams.MATCH_PARENT; -import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY; -import static android.view.WindowManager.LayoutParams.TYPE_SYSTEM_OVERLAY; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.CoreMatchers.notNullValue; -import static org.junit.Assert.assertThat; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.never; -import static org.mockito.Mockito.times; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; - - -@RunWith(RobolectricTestRunner.class) -@Config(sdk = Build.VERSION_CODES.LOLLIPOP - , manifest = Config.NONE -) -public class ScreenMonitorTest { - - ScreenMonitor screenMonitor; - - @Mock - ScreenMonitor.ScreenMonitorView monitorView; - - @Mock - WindowManager.LayoutParams params; - - @Mock - OverlayWindowManager overlayWindowManager; - - @Mock - WeakReferenceCache> requestedViews; - - @Before - public void setUp() throws Exception { - MockitoAnnotations.initMocks(this); - screenMonitor = new ScreenMonitor(); - ScreenMonitor.setInstance(screenMonitor); - screenMonitor.monitorView = monitorView; - screenMonitor.params = params; - screenMonitor.requestedViews = requestedViews; - screenMonitor.overlayWindowManager = overlayWindowManager; - OverlayWindowManager.setApplicationInstance(overlayWindowManager); - } - - @Config(sdk = Build.VERSION_CODES.O) - @Test - public void init_O() throws Exception { - screenMonitor.monitorView = null; - screenMonitor.params = null; - screenMonitor.requestedViews = null; - screenMonitor.overlayWindowManager = null; - - ScreenMonitor.init(RuntimeEnvironment.application); - - assertThat(screenMonitor.monitorView, is(notNullValue())); - assertThat(screenMonitor.params, is(notNullValue())); - assertThat(screenMonitor.requestedViews, is(notNullValue())); - assertThat(screenMonitor.overlayWindowManager, is(overlayWindowManager)); - - assertThat(screenMonitor.params.width, is(1)); - assertThat(screenMonitor.params.height, is(MATCH_PARENT)); - assertThat(screenMonitor.params.type, is(TYPE_APPLICATION_OVERLAY)); - } - - @Config(sdk = Build.VERSION_CODES.N) - @Test - public void init_N() throws Exception { - screenMonitor.monitorView = null; - screenMonitor.params = null; - screenMonitor.requestedViews = null; - - ScreenMonitor.init(RuntimeEnvironment.application); - assertThat(screenMonitor.monitorView, is(notNullValue())); - assertThat(screenMonitor.params, is(notNullValue())); - assertThat(screenMonitor.requestedViews, is(notNullValue())); - - assertThat(screenMonitor.params.width, is(1)); - assertThat(screenMonitor.params.height, is(MATCH_PARENT)); - assertThat(screenMonitor.params.type, is(TYPE_SYSTEM_OVERLAY)); - } - - @Test - public void request_first() throws Exception { - OverlayView overlayView1 = mock(OverlayView.class); - when(requestedViews.isEmpty()).thenReturn(true); - screenMonitor.request(overlayView1); - verify(overlayWindowManager, times(1)).show(monitorView, params); - verify(requestedViews, times(1)).isEmpty(); - verify(requestedViews, times(1)).add(overlayView1); - } - - @Test - public void request_second() throws Exception { - OverlayView overlayView1 = mock(OverlayView.class); - when(requestedViews.isEmpty()).thenReturn(false); - screenMonitor.request(overlayView1); - verify(overlayWindowManager, never()).show(monitorView, params); - verify(requestedViews, times(1)).isEmpty(); - verify(requestedViews, times(1)).add(overlayView1); - } - - @Test - public void cancel() throws Exception { - OverlayView overlayView1 = mock(OverlayView.class); - when(requestedViews.isEmpty()).thenReturn(false).thenReturn(true); - screenMonitor.cancel(overlayView1); - verify(overlayWindowManager, times(1)).hide(monitorView); - verify(requestedViews, times(2)).isEmpty(); - verify(requestedViews, times(1)).remove(overlayView1); - } - - @Test - public void cancel_doNothing() throws Exception { - OverlayView overlayView1 = mock(OverlayView.class); - when(requestedViews.isEmpty()).thenReturn(true); - screenMonitor.cancel(overlayView1); - verify(overlayWindowManager, never()).hide(monitorView); - verify(requestedViews, times(1)).isEmpty(); - verify(requestedViews, never()).remove(overlayView1); - } - - @Test - public void getStatusBarHeight() throws Exception { - screenMonitor.monitorView.statusBarHeight = 84; - assertThat(screenMonitor.getStatusBarHeight(), is(84)); - } - -} \ No newline at end of file diff --git a/core/src/test/java/com/nagopy/android/overlayviewmanager/internal/WeakReferenceCacheTest.java b/core/src/test/java/com/nagopy/android/overlayviewmanager/internal/WeakReferenceCacheTest.java deleted file mode 100644 index 0cb45f9..0000000 --- a/core/src/test/java/com/nagopy/android/overlayviewmanager/internal/WeakReferenceCacheTest.java +++ /dev/null @@ -1,119 +0,0 @@ -package com.nagopy.android.overlayviewmanager.internal; - -import org.junit.Before; -import org.junit.Test; -import org.mockito.Mock; -import org.mockito.MockitoAnnotations; - -import java.lang.ref.WeakReference; - -import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertThat; - -public class WeakReferenceCacheTest { - - WeakReferenceCache weakReferenceCache; - - @Mock - Object obj; - - WeakReference clearedRef; - - @Before - public void setUp() throws Exception { - MockitoAnnotations.initMocks(this); - clearedRef = new WeakReference<>(null); - weakReferenceCache = new WeakReferenceCache<>(); - } - - @Test - public void add() throws Exception { - assertThat(weakReferenceCache.cacheSet.isEmpty(), is(true)); - weakReferenceCache.cacheSet.add(clearedRef); - - weakReferenceCache.add(obj); - assertThat(weakReferenceCache.cacheSet.isEmpty(), is(false)); - assertThat(weakReferenceCache.cacheSet.size(), is(1)); - assertThat(weakReferenceCache.cacheSet.iterator().next().get(), is(obj)); - } - - @Test - public void add_alreadyAdded() throws Exception { - assertThat(weakReferenceCache.cacheSet.isEmpty(), is(true)); - weakReferenceCache.cacheSet.add(clearedRef); - weakReferenceCache.cacheSet.add(new WeakReference<>(obj)); - - weakReferenceCache.add(obj); - assertThat(weakReferenceCache.cacheSet.isEmpty(), is(false)); - assertThat(weakReferenceCache.cacheSet.size(), is(1)); - assertThat(weakReferenceCache.cacheSet.iterator().next().get(), is(obj)); - } - - @Test - public void remove() throws Exception { - assertThat(weakReferenceCache.cacheSet.isEmpty(), is(true)); - weakReferenceCache.cacheSet.add(clearedRef); - weakReferenceCache.cacheSet.add(new WeakReference<>(obj)); - - weakReferenceCache.remove(obj); - assertThat(weakReferenceCache.cacheSet.isEmpty(), is(true)); - } - - @Test - public void remove_notCached() throws Exception { - assertThat(weakReferenceCache.cacheSet.isEmpty(), is(true)); - - weakReferenceCache.remove(obj); - assertThat(weakReferenceCache.cacheSet.isEmpty(), is(true)); - } - - @Test - public void isEmpty() throws Exception { - assertThat(weakReferenceCache.cacheSet.isEmpty(), is(true)); - boolean ret = weakReferenceCache.isEmpty(); - assertThat(ret, is(true)); - } - - @Test - public void isEmpty_clearedAll() throws Exception { - assertThat(weakReferenceCache.cacheSet.isEmpty(), is(true)); - weakReferenceCache.cacheSet.add(clearedRef); - - boolean ret = weakReferenceCache.isEmpty(); - assertThat(ret, is(true)); - } - - @Test - public void isEmpty_notEmpty() throws Exception { - assertThat(weakReferenceCache.cacheSet.isEmpty(), is(true)); - weakReferenceCache.cacheSet.add(clearedRef); - weakReferenceCache.cacheSet.add(new WeakReference<>(obj)); - - boolean ret = weakReferenceCache.isEmpty(); - assertThat(ret, is(false)); - assertThat(weakReferenceCache.cacheSet.isEmpty(), is(false)); - assertThat(weakReferenceCache.cacheSet.size(), is(1)); - assertThat(weakReferenceCache.cacheSet.iterator().next().get(), is(obj)); - } - - @Test - public void contains() throws Exception { - assertThat(weakReferenceCache.cacheSet.isEmpty(), is(true)); - weakReferenceCache.cacheSet.add(new WeakReference<>(obj)); - - boolean ret = weakReferenceCache.contains(obj); - assertThat(ret, is(true)); - } - - - @Test - public void contains_2() throws Exception { - assertThat(weakReferenceCache.cacheSet.isEmpty(), is(true)); - weakReferenceCache.cacheSet.add(clearedRef); - weakReferenceCache.cacheSet.add(new WeakReference<>(obj)); - - boolean ret = weakReferenceCache.contains(this); - assertThat(ret, is(false)); - } - -} \ No newline at end of file diff --git a/core/src/test/kotlin/com/nagopy/android/overlayviewmanager/ActivityLifecycleCleanupTest.kt b/core/src/test/kotlin/com/nagopy/android/overlayviewmanager/ActivityLifecycleCleanupTest.kt new file mode 100644 index 0000000..5e1dbd9 --- /dev/null +++ b/core/src/test/kotlin/com/nagopy/android/overlayviewmanager/ActivityLifecycleCleanupTest.kt @@ -0,0 +1,337 @@ +/* + * Copyright 2026 75py + * Licensed under the Apache License, Version 2.0 (the "License"); + */ +package com.nagopy.android.overlayviewmanager + +import android.app.Activity +import android.os.Build +import android.view.View +import android.view.WindowManager +import com.nagopy.android.overlayviewmanager.internal.ActivityOverlayRegistry +import com.nagopy.android.overlayviewmanager.internal.OverlayWindowManager +import com.nagopy.android.overlayviewmanager.internal.PassThroughOpacityRegistry +import org.junit.After +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertNull +import org.junit.Assert.assertThrows +import org.junit.Assert.assertTrue +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.Robolectric +import org.robolectric.RuntimeEnvironment +import org.robolectric.annotation.Config +import org.robolectric.shadows.ShadowSettings +import java.lang.reflect.Field + +/** + * Covers the T08 Activity destruction terminal path (`OverlayViewManager.onActivityDestroyed` via + * a single process-wide `ActivityLifecycleCallbacks`) and the reference-release audit of + * `OverlayWindowManager.activityInstances`. Acceptance is the deterministic structural assertions + * below, per the FROZEN T08 CONTRACT F3 -- registry/instance-map membership, cleared handle + * references, and the classified diagnostic -- rather than a GC/WeakReference observation, which + * this suite intentionally omits: Robolectric's own `ActivityController`/shadow activity thread + * retains additional bookkeeping references to the Activity that this library does not own or + * control, so a GC-based pass/fail signal would reflect Robolectric's internals rather than this + * library's cleanup correctness (documented as a known limitation in PR_BODY_T08.md). + */ +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [Build.VERSION_CODES.P], manifest = Config.NONE) +class ActivityLifecycleCleanupTest { + + @Before fun setUp() { + ShadowSettings.setCanDrawOverlays(true) + clearActivityOverlayRegistry() + PassThroughOpacityRegistry.resetForTests() + } + + @After fun tearDown() { + managerInstanceField().set(null, null) + clearActivityOverlayRegistry() + PassThroughOpacityRegistry.resetForTests() + } + + @Test fun forcedDisposalOfAttachedHandleRemovesExactlyOnceAndClearsEveryReference() { + val application = RuntimeEnvironment.getApplication() + OverlayViewManager.init(application) + val controller = Robolectric.buildActivity(Activity::class.java).create().start().resume() + val activity = controller.get() + val backend = RecordingBackend() + OverlayWindowManager.setActivityInstance(activity, backend) + val handle = OverlayViewManager.getInstance().newOverlayView(View(activity), activity) + + assertTrue(handle.show().isSuccess) + assertEquals(OverlayState.ATTACHED, handle.state) + assertTrue(activityOverlayRegistryContains(activity)) + assertTrue(activityInstancesContains(activity)) + + controller.pause().stop().destroy() + + assertEquals(1, backend.hideCalls) + assertEquals(OverlayState.DISPOSED, handle.state) + assertNull(handle.lastFailure) + assertFalse(activityOverlayRegistryContains(activity)) + assertFalse(activityInstancesContains(activity)) + assertNull(privateField(handle, "ownedView")) + assertNull(privateField(handle, "backend")) + assertNull(privateField(handle, "detachListener")) + assertNull(privateField(handle, "onActivityRelease")) + assertThrows(IllegalStateException::class.java) { handle.view } + + // A repeated forced-disposal callback, a later show(), and a later dispose() are all no-ops + // that must not call the backend again. + handle.disposeForActivityDestruction() + handle.show() + handle.dispose() + assertEquals(1, backend.hideCalls) + } + + @Test fun forcedDisposalOfConfiguredHandleDisposesWithoutABackendCall() { + val application = RuntimeEnvironment.getApplication() + OverlayViewManager.init(application) + val controller = Robolectric.buildActivity(Activity::class.java).create().start().resume() + val activity = controller.get() + val backend = RecordingBackend() + OverlayWindowManager.setActivityInstance(activity, backend) + val handle = OverlayViewManager.getInstance().newOverlayView(View(activity), activity) + assertEquals(OverlayState.CONFIGURED, handle.state) + + controller.pause().stop().destroy() + + assertEquals(0, backend.hideCalls) + assertEquals(OverlayState.DISPOSED, handle.state) + assertNull(handle.lastFailure) + assertFalse(activityOverlayRegistryContains(activity)) + } + + @Test fun forcedDisposalClassifiesAFailedRemovalReleasesEveryReferenceAndDoesNotRetainTheException() { + val application = RuntimeEnvironment.getApplication() + OverlayViewManager.init(application) + val controller = Robolectric.buildActivity(Activity::class.java).create().start().resume() + val activity = controller.get() + val backend = RecordingBackend(hideFailure = WindowManager.BadTokenException("bad token")) + OverlayWindowManager.setActivityInstance(activity, backend) + val handle = OverlayViewManager.getInstance().newOverlayView(View(activity), activity) + assertTrue(handle.show().isSuccess) + + controller.pause().stop().destroy() + + assertEquals(1, backend.hideCalls) + assertEquals(OverlayState.DISPOSED, handle.state) + assertEquals(OverlayFailure.INVALID_WINDOW_TOKEN, handle.lastFailure) + // Same structural release as the success path: every reference cleared, both registries + // dropped, and no field on the handle retains the caught Throwable. + assertFalse(activityOverlayRegistryContains(activity)) + assertFalse(activityInstancesContains(activity)) + assertNull(privateField(handle, "ownedView")) + assertNull(privateField(handle, "backend")) + assertNull(privateField(handle, "detachListener")) + assertNull(privateField(handle, "onActivityRelease")) + assertThrows(IllegalStateException::class.java) { handle.view } + assertNoThrowableFieldRetained(handle) + } + + @Test fun afterForcedDisposalShowAndRepeatedDisposePreserveTheDiagnosticWithoutAFurtherBackendCall() { + val application = RuntimeEnvironment.getApplication() + OverlayViewManager.init(application) + val controller = Robolectric.buildActivity(Activity::class.java).create().start().resume() + val activity = controller.get() + val backend = RecordingBackend(hideFailure = IllegalStateException("busy")) + OverlayWindowManager.setActivityInstance(activity, backend) + val handle = OverlayViewManager.getInstance().newOverlayView(View(activity), activity) + handle.show() + + controller.pause().stop().destroy() + + assertEquals(1, backend.hideCalls) + assertEquals(OverlayFailure.WINDOW_MANAGER_REJECTED, handle.lastFailure) + + val showAfterDisposal = handle.show() + assertFalse(showAfterDisposal.isSuccess) + assertEquals(OverlayState.DISPOSED, handle.state) + assertEquals(OverlayFailure.WINDOW_MANAGER_REJECTED, handle.lastFailure) + + val updateAfterDisposal = handle.update(handle.spec) + assertFalse(updateAfterDisposal.isSuccess) + + val hideAfterDisposal = handle.hide() + assertTrue(hideAfterDisposal.isSuccess) + assertFalse(hideAfterDisposal.changed) + + val repeatedDispose = handle.dispose() + assertTrue(repeatedDispose.isSuccess) + assertFalse(repeatedDispose.changed) + assertEquals(OverlayFailure.WINDOW_MANAGER_REJECTED, handle.lastFailure) + + // None of show/update/hide/dispose after forced disposal may call the backend again. + assertEquals(1, backend.hideCalls) + } + + @Test fun showAndUpdateAfterActivityDestructionReportActivityDestroyed() { + val application = RuntimeEnvironment.getApplication() + OverlayViewManager.init(application) + val controller = Robolectric.buildActivity(Activity::class.java).create().start().resume() + val activity = controller.get() + val backend = RecordingBackend() + OverlayWindowManager.setActivityInstance(activity, backend) + val manager = OverlayViewManager.getInstance() + val attached = manager.newOverlayView(View(activity), activity) + val configured = manager.newOverlayView(View(activity), activity) + assertTrue(attached.show().isSuccess) + + controller.pause().stop().destroy() + + for (handle in listOf(attached, configured)) { + val shown = handle.show() + assertEquals(OverlayFailure.ACTIVITY_DESTROYED, shown.failure) + assertEquals(OverlayState.DISPOSED, shown.state) + assertEquals(OverlayFailure.ACTIVITY_DESTROYED, handle.update(handle.spec.copy(x = 8)).failure) + assertNull(handle.lastFailure) + } + assertEquals(1, backend.showCalls) + } + + @Test fun showAfterOrdinaryDisposeKeepsItsClassificationEvenOnceTheActivityIsDestroyed() { + val application = RuntimeEnvironment.getApplication() + OverlayViewManager.init(application) + val controller = Robolectric.buildActivity(Activity::class.java).create().start().resume() + val activity = controller.get() + val handle = OverlayViewManager.getInstance().newOverlayView(View(activity), activity) + assertTrue(handle.dispose().isSuccess) + + assertEquals(OverlayFailure.WINDOW_MANAGER_REJECTED, handle.show().failure) + assertEquals(OverlayFailure.WINDOW_MANAGER_REJECTED, handle.update(handle.spec.copy(x = 8)).failure) + + controller.pause().stop().destroy() + + assertEquals(OverlayFailure.WINDOW_MANAGER_REJECTED, handle.show().failure) + } + + @Test fun disposeReenteredDuringForcedDisposalRemovesOnce() { + val application = RuntimeEnvironment.getApplication() + OverlayViewManager.init(application) + val controller = Robolectric.buildActivity(Activity::class.java).create().start().resume() + val activity = controller.get() + val backend = RecordingBackend() + OverlayWindowManager.setActivityInstance(activity, backend) + val handle = OverlayViewManager.getInstance().newOverlayView(View(activity), activity) + assertTrue(handle.show().isSuccess) + backend.onHide = { backend.onHide = null; handle.dispose() } + + controller.pause().stop().destroy() + + assertEquals(1, backend.hideCalls) + assertEquals(OverlayState.DISPOSED, handle.state) + assertFalse(activityOverlayRegistryContains(activity)) + assertEquals(OverlayFailure.ACTIVITY_DESTROYED, handle.show().failure) + } + + @Test fun everyLiveHandleOfTheDestroyedActivityIsDisposed() { + val application = RuntimeEnvironment.getApplication() + OverlayViewManager.init(application) + val controller = Robolectric.buildActivity(Activity::class.java).create().start().resume() + val activity = controller.get() + val manager = OverlayViewManager.getInstance() + val attached = manager.newOverlayView(View(activity), activity) + val configured = manager.newOverlayView(View(activity), activity) + assertTrue(attached.show().isSuccess) + + controller.pause().stop().destroy() + + assertEquals(OverlayState.DISPOSED, attached.state) + assertEquals(OverlayState.DISPOSED, configured.state) + } + + @Test fun applicationScopedHandleIsUnaffectedByActivityDestruction() { + val application = RuntimeEnvironment.getApplication() + OverlayViewManager.init(application) + val controller = Robolectric.buildActivity(Activity::class.java).create().start().resume() + val activity = controller.get() + val manager = OverlayViewManager.getInstance() + val appHandle = manager.newOverlayView(View(application)) + assertTrue(appHandle.show().isSuccess) + + controller.pause().stop().destroy() + + assertEquals(OverlayState.ATTACHED, appHandle.state) + assertTrue(appHandle.dispose().isSuccess) + } + + @Test fun activityScopedHandleIsNeverInThePassThroughOpacityRegistry() { + val application = RuntimeEnvironment.getApplication() + OverlayViewManager.init(application) + val controller = Robolectric.buildActivity(Activity::class.java).create().start().resume() + val activity = controller.get() + val handle = OverlayViewManager.getInstance().newOverlayView( + View(activity), + activity, + OverlaySpec(touchMode = OverlayTouchMode.PASS_THROUGH), + ) + assertFalse(PassThroughOpacityRegistry.containsForTests(handle)) + + assertTrue(handle.show().isSuccess) + assertFalse(PassThroughOpacityRegistry.containsForTests(handle)) + + controller.pause().stop().destroy() + + assertFalse(PassThroughOpacityRegistry.containsForTests(handle)) + } + + private fun privateField(instance: Any, name: String): Any? = instance.javaClass.getDeclaredField(name).let { + it.isAccessible = true + it.get(instance) + } + + private fun managerInstanceField(): Field = OverlayViewManager::class.java.getDeclaredField("instance").also { it.isAccessible = true } + + /** Reflects into `ActivityOverlayRegistry`'s private `handlesByActivity` map (no test accessor exists). */ + private fun activityOverlayRegistryMap(): MutableMap { + val field = ActivityOverlayRegistry::class.java.getDeclaredField("handlesByActivity") + field.isAccessible = true + @Suppress("UNCHECKED_CAST") + return field.get(ActivityOverlayRegistry) as MutableMap + } + + private fun activityOverlayRegistryContains(activity: Activity): Boolean = activityOverlayRegistryMap().containsKey(activity) + + private fun clearActivityOverlayRegistry() = activityOverlayRegistryMap().clear() + + /** + * Reflects into the companion property `activityInstances` (no test accessor exists). Its + * backing field lives on the outer class [OverlayWindowManager], not on + * `OverlayWindowManager.Companion`, so it is read as a static field (`get(null)`). + */ + private fun activityInstancesContains(activity: Activity): Boolean { + val field = OverlayWindowManager::class.java.getDeclaredField("activityInstances") + field.isAccessible = true + @Suppress("UNCHECKED_CAST") + val map = field.get(null) as Map + return map.containsKey(activity) + } + + private fun assertNoThrowableFieldRetained(instance: Any) { + val retained = instance.javaClass.declaredFields.filter { field -> + field.isAccessible = true + field.get(instance) is Throwable + } + assertTrue("Expected no field to retain a Throwable, but found: $retained", retained.isEmpty()) + } + + /** Records `hide`/`removeViewImmediate` invocation counts so forced disposal's "exactly once" contract is verifiable. */ + private class RecordingBackend(private val hideFailure: Throwable? = null) : OverlayWindowManager() { + var showCalls = 0 + var hideCalls = 0 + /** Stands in for a host detach callback running inside `removeViewImmediate`. */ + var onHide: (() -> Unit)? = null + override fun show(view: View, params: WindowManager.LayoutParams) { showCalls++ } + override fun update(view: View, params: WindowManager.LayoutParams) = Unit + override fun hide(view: View) { + hideCalls++ + onHide?.invoke() + hideFailure?.let { throw it } + } + } +} diff --git a/core/src/test/kotlin/com/nagopy/android/overlayviewmanager/DraggableOnTouchListenerTest.kt b/core/src/test/kotlin/com/nagopy/android/overlayviewmanager/DraggableOnTouchListenerTest.kt new file mode 100644 index 0000000..a41dcd6 --- /dev/null +++ b/core/src/test/kotlin/com/nagopy/android/overlayviewmanager/DraggableOnTouchListenerTest.kt @@ -0,0 +1,879 @@ +package com.nagopy.android.overlayviewmanager + +import android.app.Activity +import android.content.pm.ApplicationInfo +import android.graphics.Rect +import android.os.Build +import android.os.Looper +import android.view.Gravity +import android.view.InputDevice +import android.view.MotionEvent +import android.view.View +import android.view.ViewConfiguration +import android.view.ViewGroup +import android.view.WindowManager +import com.nagopy.android.overlayviewmanager.internal.OverlayWindowManager +import java.time.Duration +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.Robolectric +import org.robolectric.RobolectricTestRunner +import org.robolectric.RuntimeEnvironment +import org.robolectric.Shadows.shadowOf +import org.robolectric.annotation.Config +import org.robolectric.shadows.ShadowSettings + +/** + * Covers the internal drag gesture: touch-slop-gated consumption, active-pointer tracking across + * a second finger, and alpha/effective-spec restoration on UP/CANCEL and on a rejected update. + * + * [dispatch] observes whether the *listener itself* consumed an event, not + * [View.dispatchTouchEvent]'s own return value: for a clickable/long-clickable fixture, the + * view's own [View.onTouchEvent] independently returns `true` once the listener declines an + * event, so `dispatchTouchEvent`'s result is `true` regardless of what the listener returned. It + * does so by wrapping the real, currently-installed [DraggableOnTouchListener] in a one-shot + * capturing delegate before dispatching -- the exact same listener instance and its internal + * gesture state are still exercised end to end, only the assertion observes a different signal. + */ +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [Build.VERSION_CODES.P], manifest = Config.NONE) +class DraggableOnTouchListenerTest { + + @Test fun tapBelowSlopFiresClickAndLeavesSpecUnchanged() { + val view = PositionedView(100, 240, 24) + val overlay = OverlayView.create( + view, + OverlayScope.ACTIVITY, + RecordingBackend(), + OverlaySpec(touchMode = OverlayTouchMode.DRAGGABLE), + ) + overlay.show() + // View.onTouchEvent(UP) delivers a click via post(mPerformClick); an unattached view has + // no real Handler, so that post is queued but never flushed. Attach to a real window and + // idle the looper afterward so the click actually runs. + attachToActivityContent(view) + var clicks = 0 + overlay.view.setOnClickListener { clicks++ } + val before = overlay.spec + val slop = touchSlop(view) + + assertFalse(dispatch(overlay, MotionEvent.ACTION_DOWN, 110f, 260f)) + assertFalse(dispatch(overlay, MotionEvent.ACTION_MOVE, 110f + slop - 1, 260f)) + assertFalse(dispatch(overlay, MotionEvent.ACTION_UP, 110f + slop - 1, 260f)) + shadowOf(Looper.getMainLooper()).idle() + + assertEquals(1, clicks) + assertEquals(before, overlay.spec) + } + + @Test fun moveBeyondSlopConsumesAndUpdatesXY() { + val view = PositionedView(100, 240, 24) + val backend = RecordingBackend() + val overlay = OverlayView.create( + view, + OverlayScope.ACTIVITY, + backend, + OverlaySpec(alpha = .8f, touchMode = OverlayTouchMode.DRAGGABLE), + ) + overlay.show() + val slop = touchSlop(view) + + val afterShow = overlay.spec + assertFalse(dispatch(overlay, MotionEvent.ACTION_DOWN, 110f, 260f)) + assertEquals(afterShow, overlay.spec) + assertEquals(.8f, overlay.spec.alpha, 0f) + + assertTrue(dispatch(overlay, MotionEvent.ACTION_MOVE, 110f + slop + 20, 260f)) + assertEquals(100 + slop + 20, overlay.spec.x) + assertEquals(216, overlay.spec.y) + // The translucent feedback belongs to the window; the caller's alpha stays in the spec. + assertEquals(.8f, overlay.spec.alpha, 0f) + assertEquals(.48f, backend.lastParams!!.alpha, .0001f) + + assertTrue(dispatch(overlay, MotionEvent.ACTION_MOVE, 110f + slop + 50, 290f)) + assertEquals(100 + slop + 50, overlay.spec.x) + assertEquals(246, overlay.spec.y) + assertEquals(.48f, backend.lastParams!!.alpha, .0001f) + + assertTrue(dispatch(overlay, MotionEvent.ACTION_UP, 110f + slop + 50, 290f)) + assertEquals(.8f, overlay.spec.alpha, 0f) + assertEquals(.8f, backend.lastParams!!.alpha, 0f) + assertEquals(100 + slop + 50, overlay.spec.x) + assertEquals(246, overlay.spec.y) + assertEquals(3, backend.updateCalls) + } + + @Test fun downMove_dragAcrossANonZeroWindowOriginIsWindowRelative() { + // The fake view's screen location is (300, 500); its stubbed visible frame starts at + // (120, 60) (e.g. a multi-window/freeform window), so the layout-space origin is (120, 60) + // rather than the display's (0, 0). Reuses the T05b PositionedView fixture: this proves + // the listener and OverlayView.layoutParams() correctly consume whatever frame + // OverlayWindowFrame returns, not that the real framework reports this shape on a device + // (see OverlayWindowFrame's KDoc). + val view = PositionedView(screenX = 300, screenY = 500, visibleFrameLeft = 120, visibleFrameTop = 60) + val backend = RecordingBackend() + val overlay = OverlayView.create( + view, + OverlayScope.ACTIVITY, + backend, + OverlaySpec(touchMode = OverlayTouchMode.DRAGGABLE), + ) + overlay.show() + val slop = touchSlop(view) + + assertFalse(dispatch(overlay, MotionEvent.ACTION_DOWN, 310f, 520f)) + assertTrue(dispatch(overlay, MotionEvent.ACTION_MOVE, 310f + slop + 20, 545f)) + assertEquals(180 + slop + 20, overlay.spec.x) + assertEquals(465, overlay.spec.y) + // Goes through the real WindowManager.LayoutParams built by OverlayView.layoutParams(), + // not just the immutable OverlaySpec snapshot. + assertEquals(180 + slop + 20, backend.lastParams!!.x) + assertEquals(465, backend.lastParams!!.y) + + assertTrue(dispatch(overlay, MotionEvent.ACTION_MOVE, 330f + slop + 20, 545f)) + assertEquals(200 + slop + 20, overlay.spec.x) + assertEquals(465, overlay.spec.y) + } + + @Test fun boundedDragNormalizesToTopLeftWithoutMargins() { + val view = PositionedView(screenX = 300, screenY = 500, visibleFrameTop = 60) + val overlay = OverlayView.create( + view, + OverlayScope.ACTIVITY, + RecordingBackend(), + OverlaySpec( + gravity = Gravity.BOTTOM or Gravity.RIGHT, + x = 40, + y = 80, + horizontalMargin = .1f, + verticalMargin = .2f, + touchMode = OverlayTouchMode.DRAGGABLE, + ), + ) + overlay.show() + val slop = touchSlop(view) + + assertFalse(dispatch(overlay, MotionEvent.ACTION_DOWN, 310f, 520f)) + assertTrue(dispatch(overlay, MotionEvent.ACTION_MOVE, 310f + slop + 20, 545f)) + + assertEquals(300 + slop + 20, overlay.spec.x) + assertEquals(465, overlay.spec.y) + assertEquals(Gravity.TOP or Gravity.LEFT, overlay.spec.gravity) + assertEquals(0f, overlay.spec.horizontalMargin, 0f) + assertEquals(0f, overlay.spec.verticalMargin, 0f) + } + + @Test fun newGestureRebasesOntoTheRealLocationOfAClampedWindow() { + // The spec asks for far left of the frame; the system clamped the window to x = 0. + val view = PositionedView(screenX = 0, screenY = 500, visibleFrameTop = 60) + val overlay = OverlayView.create( + view, + OverlayScope.ACTIVITY, + RecordingBackend(), + OverlaySpec(gravity = Gravity.TOP or Gravity.LEFT, x = -300, y = 440, touchMode = OverlayTouchMode.DRAGGABLE), + ) + overlay.show() + val slop = touchSlop(view) + + assertFalse(dispatch(overlay, MotionEvent.ACTION_DOWN, 10f, 520f)) + assertTrue(dispatch(overlay, MotionEvent.ACTION_MOVE, 10f + slop + 20, 520f)) + + assertEquals(slop + 20, overlay.spec.x) + } + + @Test fun allowOutsideBoundsDragKeepsGravityAndMarginsAndIgnoresThePlaceholderFrame() { + val view = PositionedView( + screenX = 300, + screenY = 500, + visibleFrameTop = NO_LIMITS_FRAME_ORIGIN, + visibleFrameLeft = NO_LIMITS_FRAME_ORIGIN, + ) + val backend = RecordingBackend() + val overlay = OverlayView.create( + view, + OverlayScope.ACTIVITY, + backend, + OverlaySpec( + gravity = Gravity.CENTER, + x = 10, + y = 20, + horizontalMargin = .1f, + verticalMargin = .2f, + allowOutsideBounds = true, + touchMode = OverlayTouchMode.DRAGGABLE, + ), + ) + overlay.show() + val slop = touchSlop(view) + + assertFalse(dispatch(overlay, MotionEvent.ACTION_DOWN, 310f, 520f)) + assertTrue(dispatch(overlay, MotionEvent.ACTION_MOVE, 310f + slop + 20, 545f)) + + assertEquals(10 + slop + 20, overlay.spec.x) + assertEquals(45, overlay.spec.y) + assertEquals(Gravity.CENTER, overlay.spec.gravity) + assertEquals(.1f, overlay.spec.horizontalMargin, 0f) + assertEquals(.2f, overlay.spec.verticalMargin, 0f) + // Goes through the real WindowManager.LayoutParams built by OverlayView.layoutParams(), + // not just the immutable OverlaySpec snapshot. + assertEquals(10 + slop + 20, backend.lastParams!!.x) + assertEquals(45, backend.lastParams!!.y) + } + + @Test fun allowOutsideBoundsDragInvertsTheDeltaForRightAndBottomGravity() { + val view = PositionedView(100, 240, NO_LIMITS_FRAME_ORIGIN, NO_LIMITS_FRAME_ORIGIN) + val overlay = OverlayView.create( + view, + OverlayScope.ACTIVITY, + RecordingBackend(), + OverlaySpec( + gravity = Gravity.BOTTOM or Gravity.RIGHT, + x = 100, + y = 200, + allowOutsideBounds = true, + touchMode = OverlayTouchMode.DRAGGABLE, + ), + ) + overlay.show() + val slop = touchSlop(view) + + assertFalse(dispatch(overlay, MotionEvent.ACTION_DOWN, 300f, 500f)) + assertTrue(dispatch(overlay, MotionEvent.ACTION_MOVE, 300f + slop + 20, 525f)) + assertEquals(100 - slop - 20, overlay.spec.x) + assertEquals(175, overlay.spec.y) + + assertTrue(dispatch(overlay, MotionEvent.ACTION_MOVE, 300f + slop + 10, 520f)) + assertEquals(100 - slop - 10, overlay.spec.x) + assertEquals(180, overlay.spec.y) + } + + @Test fun allowOutsideBoundsDragResolvesEndGravityAgainstTheLayoutDirection() { + val info = RuntimeEnvironment.getApplication().applicationInfo + info.flags = info.flags or ApplicationInfo.FLAG_SUPPORTS_RTL + val view = PositionedView(100, 240, NO_LIMITS_FRAME_ORIGIN, NO_LIMITS_FRAME_ORIGIN) + view.layoutDirection = View.LAYOUT_DIRECTION_RTL + val overlay = OverlayView.create( + view, + OverlayScope.ACTIVITY, + RecordingBackend(), + OverlaySpec( + gravity = Gravity.TOP or Gravity.END, + x = 100, + allowOutsideBounds = true, + touchMode = OverlayTouchMode.DRAGGABLE, + ), + ) + overlay.show() + val slop = touchSlop(view) + + // Under RTL, END is the left edge, so a rightward drag grows the offset. + assertFalse(dispatch(overlay, MotionEvent.ACTION_DOWN, 300f, 500f)) + assertTrue(dispatch(overlay, MotionEvent.ACTION_MOVE, 300f + slop + 20, 500f)) + assertEquals(100 + slop + 20, overlay.spec.x) + } + + @Test fun downMoveCancelRestoresOriginalAlphaWithoutResettingCoordinates() { + val view = PositionedView(50, 160, 20) + val backend = RecordingBackend() + val overlay = OverlayView.create( + view, + OverlayScope.ACTIVITY, + backend, + OverlaySpec(alpha = .75f, touchMode = OverlayTouchMode.DRAGGABLE), + ) + overlay.show() + val slop = touchSlop(view) + + assertFalse(dispatch(overlay, MotionEvent.ACTION_DOWN, 10f, 30f)) + assertTrue(dispatch(overlay, MotionEvent.ACTION_MOVE, 10f + slop + 10, 55f)) + assertEquals(.45f, backend.lastParams!!.alpha, .0001f) + val draggedX = overlay.spec.x + val draggedY = overlay.spec.y + assertTrue(dispatch(overlay, MotionEvent.ACTION_CANCEL, 10f + slop + 10, 55f)) + assertEquals(draggedX, overlay.spec.x) + assertEquals(draggedY, overlay.spec.y) + assertEquals(.75f, overlay.spec.alpha, 0f) + assertEquals(.75f, backend.lastParams!!.alpha, 0f) + } + + @Test fun cancelBelowSlopIsANoOpAndReturnsFalse() { + val view = PositionedView(50, 160, 20) + val overlay = OverlayView.create( + view, + OverlayScope.ACTIVITY, + RecordingBackend(), + OverlaySpec(alpha = .75f, touchMode = OverlayTouchMode.DRAGGABLE), + ) + overlay.show() + val before = overlay.spec + + assertFalse(dispatch(overlay, MotionEvent.ACTION_DOWN, 10f, 30f)) + assertFalse(dispatch(overlay, MotionEvent.ACTION_CANCEL, 11f, 31f)) + assertEquals(before, overlay.spec) + } + + @Test fun secondFingerPointerDownDoesNotMoveTheOverlayAndActivePointerKeepsDriving() { + val view = PositionedView(100, 240, 24) + val overlay = OverlayView.create( + view, + OverlayScope.ACTIVITY, + RecordingBackend(), + OverlaySpec(touchMode = OverlayTouchMode.DRAGGABLE), + ) + overlay.show() + val slop = touchSlop(view) + + assertFalse(dispatch(overlay, MotionEvent.ACTION_DOWN, 110f, 260f)) + assertTrue(dispatch(overlay, MotionEvent.ACTION_MOVE, 110f + slop + 20, 260f)) + val afterFirstMoveX = overlay.spec.x + val afterFirstMoveY = overlay.spec.y + + // A second finger touches down far away; the drag must not jump to it. + val pointerDown = obtainMultiTouch( + MotionEvent.ACTION_POINTER_DOWN, + listOf(Triple(0, 110f + slop + 20, 260f), Triple(1, 900f, 900f)), + actionIndex = 1, + ) + assertTrue(dispatch(overlay, pointerDown)) + assertEquals(afterFirstMoveX, overlay.spec.x) + assertEquals(afterFirstMoveY, overlay.spec.y) + + // Pointer 0 (still active) keeps moving; pointer 1 moving elsewhere must not affect it. + val move = obtainMultiTouch( + MotionEvent.ACTION_MOVE, + listOf(Triple(0, 110f + slop + 40, 260f), Triple(1, 20f, 20f)), + ) + assertTrue(dispatch(overlay, move)) + assertEquals(afterFirstMoveX + 20, overlay.spec.x) + assertEquals(afterFirstMoveY, overlay.spec.y) + } + + @Test fun activePointerLiftingRebasesToTheRemainingPointerWithoutAJump() { + val view = PositionedView(100, 240, 24) + val overlay = OverlayView.create( + view, + OverlayScope.ACTIVITY, + RecordingBackend(), + OverlaySpec(touchMode = OverlayTouchMode.DRAGGABLE), + ) + overlay.show() + val slop = touchSlop(view) + + assertFalse(dispatch(overlay, MotionEvent.ACTION_DOWN, 110f, 260f)) + assertTrue(dispatch(overlay, MotionEvent.ACTION_MOVE, 110f + slop + 20, 260f)) + val beforeLiftX = overlay.spec.x + val beforeLiftY = overlay.spec.y + + // Pointer 1 (far away) touches down, then the original pointer 0 lifts. Tracking must + // rebase onto pointer 1's current position, not jump to it based on a stale delta. + val pointerDown = obtainMultiTouch( + MotionEvent.ACTION_POINTER_DOWN, + listOf(Triple(0, 110f + slop + 20, 260f), Triple(1, 700f, 500f)), + actionIndex = 1, + ) + dispatch(overlay, pointerDown) + + val pointerUp = obtainMultiTouch( + MotionEvent.ACTION_POINTER_UP, + listOf(Triple(0, 110f + slop + 20, 260f), Triple(1, 700f, 500f)), + actionIndex = 0, + ) + assertTrue(dispatch(overlay, pointerUp)) + assertEquals(beforeLiftX, overlay.spec.x) + assertEquals(beforeLiftY, overlay.spec.y) + + // Only pointer 1 remains; its own subsequent delta must drive the drag without a jump. + val move = obtainMultiTouch(MotionEvent.ACTION_MOVE, listOf(Triple(1, 715f, 505f))) + assertTrue(dispatch(overlay, move)) + assertEquals(beforeLiftX + 15, overlay.spec.x) + assertEquals(beforeLiftY + 5, overlay.spec.y) + } + + @Test fun preDragPointerHandoffRebasesTheSlopOriginSoAStationaryMoveStartsNoDrag() { + val view = PositionedView(100, 240, 24) + val overlay = OverlayView.create( + view, + OverlayScope.ACTIVITY, + RecordingBackend(), + OverlaySpec(touchMode = OverlayTouchMode.DRAGGABLE), + ) + overlay.show() + attachToActivityContent(view) + var clicks = 0 + view.setOnClickListener { clicks++ } + val before = overlay.spec + + assertFalse(dispatch(overlay, MotionEvent.ACTION_DOWN, 0f, 0f)) + val pointerDown = obtainMultiTouch( + MotionEvent.ACTION_POINTER_DOWN, + listOf(Triple(0, 0f, 0f), Triple(1, 900f, 900f)), + actionIndex = 1, + ) + dispatch(overlay, pointerDown) + + // Pointer 0 (at the original slop origin) lifts before slop; pointer 1 becomes active. + val pointerUp = obtainMultiTouch( + MotionEvent.ACTION_POINTER_UP, + listOf(Triple(0, 0f, 0f), Triple(1, 900f, 900f)), + actionIndex = 0, + ) + dispatch(overlay, pointerUp) + + // A stationary move from the new active pointer must not be measured against pointer 0's + // original (0,0) down point -- which would spuriously already exceed slop -- so no drag + // starts and the spec/click state are untouched. + val move = obtainMultiTouch(MotionEvent.ACTION_MOVE, listOf(Triple(1, 900f, 900f))) + assertFalse(dispatch(overlay, move)) + assertEquals(before, overlay.spec) + + assertFalse(dispatch(overlay, MotionEvent.ACTION_UP, 900f, 900f)) + shadowOf(Looper.getMainLooper()).idle() + assertEquals(1, clicks) + } + + @Test fun preDragPointerHandoffThenMovingBeyondSlopStartsTheDragFromTheHandoffPosition() { + val view = PositionedView(100, 240, 24) + val overlay = OverlayView.create( + view, + OverlayScope.ACTIVITY, + RecordingBackend(), + OverlaySpec(touchMode = OverlayTouchMode.DRAGGABLE), + ) + overlay.show() + val slop = touchSlop(view) + + assertFalse(dispatch(overlay, MotionEvent.ACTION_DOWN, 0f, 0f)) + val pointerDown = obtainMultiTouch( + MotionEvent.ACTION_POINTER_DOWN, + listOf(Triple(0, 0f, 0f), Triple(1, 900f, 900f)), + actionIndex = 1, + ) + dispatch(overlay, pointerDown) + val pointerUp = obtainMultiTouch( + MotionEvent.ACTION_POINTER_UP, + listOf(Triple(0, 0f, 0f), Triple(1, 900f, 900f)), + actionIndex = 0, + ) + dispatch(overlay, pointerUp) + + // The new active pointer now moves beyond slop measured from the handoff position + // (900,900), not from pointer 0's original (0,0) down point. + val move = obtainMultiTouch(MotionEvent.ACTION_MOVE, listOf(Triple(1, 900f + slop + 20, 900f))) + assertTrue(dispatch(overlay, move)) + assertEquals(100 + slop + 20, overlay.spec.x) + assertEquals(216, overlay.spec.y) + } + + @Test fun dragWhileBackendUpdateThrowsPreservesEffectiveSpecAndContinuesFromLastAppliedPositionOnceItRecovers() { + val view = PositionedView(100, 240, 24) + val backend = RecordingBackend() + val overlay = OverlayView.create( + view, + OverlayScope.ACTIVITY, + backend, + OverlaySpec(alpha = .9f, touchMode = OverlayTouchMode.DRAGGABLE), + ) + overlay.show() + val afterShow = overlay.spec + val slop = touchSlop(view) + backend.updateFailure = IllegalStateException("rejected") + + assertFalse(dispatch(overlay, MotionEvent.ACTION_DOWN, 110f, 260f)) + assertTrue(dispatch(overlay, MotionEvent.ACTION_MOVE, 110f + slop + 20, 260f)) + assertEquals(afterShow, overlay.spec) + assertEquals(1, backend.updateCalls) + + // A second, still-failing move must retry the FULL cumulative delta since the down point, + // not compound on top of the previously rejected attempt. + assertTrue(dispatch(overlay, MotionEvent.ACTION_MOVE, 110f + slop + 50, 290f)) + assertEquals(afterShow, overlay.spec) + assertEquals(2, backend.updateCalls) + + // Once the backend recovers, the very next move must land exactly where the finger now is + // relative to the drag origin, not offset by the two failed attempts in between. + backend.updateFailure = null + assertTrue(dispatch(overlay, MotionEvent.ACTION_MOVE, 110f + slop + 60, 300f)) + assertEquals(100 + slop + 60, overlay.spec.x) + assertEquals(256, overlay.spec.y) + assertEquals(3, backend.updateCalls) + assertEquals(.54f, backend.lastParams!!.alpha, .0001f) + + assertTrue(dispatch(overlay, MotionEvent.ACTION_CANCEL, 110f + slop + 60, 300f)) + assertEquals(.9f, overlay.spec.alpha, 0f) + assertEquals(.9f, backend.lastParams!!.alpha, 0f) + assertEquals(100 + slop + 60, overlay.spec.x) + } + + @Test fun leavingDraggableMidDragToInteractiveRestoresTheAlpha() = assertModeChangeRestoresTheAlpha(OverlayTouchMode.INTERACTIVE) + + @Test fun leavingDraggableMidDragToPassThroughRestoresTheAlpha() = assertModeChangeRestoresTheAlpha(OverlayTouchMode.PASS_THROUGH) + + private fun assertModeChangeRestoresTheAlpha(mode: OverlayTouchMode) { + val backend = RecordingBackend() + val overlay = draggingOverlay(backend, alpha = 1f) + assertEquals(1f, overlay.spec.alpha, 0f) + assertEquals(.6f, backend.lastParams!!.alpha, .0001f) + + assertTrue(overlay.update(overlay.spec.copy(touchMode = mode)).isSuccess) + + assertEquals(mode, overlay.spec.touchMode) + assertEquals(1f, overlay.spec.alpha, 0f) + assertEquals(1f, backend.lastParams!!.alpha, 0f) + } + + @Test fun leavingDraggableMidDragKeepsAnExplicitAlpha() { + val backend = RecordingBackend() + val overlay = draggingOverlay(backend, alpha = .8f) + + assertTrue(overlay.update(overlay.spec.copy(touchMode = OverlayTouchMode.INTERACTIVE, alpha = .3f)).isSuccess) + + assertEquals(.3f, overlay.spec.alpha, 0f) + assertEquals(.3f, backend.lastParams!!.alpha, 0f) + } + + @Test fun explicitAlphaDuringADragSurvivesUp() = assertExplicitAlphaSurvives(MotionEvent.ACTION_UP) + + @Test fun explicitAlphaDuringADragSurvivesCancel() = assertExplicitAlphaSurvives(MotionEvent.ACTION_CANCEL) + + private fun assertExplicitAlphaSurvives(endAction: Int) { + val backend = RecordingBackend() + val overlay = draggingOverlay(backend, alpha = .8f) + val slop = touchSlop(overlay.view) + + assertTrue(overlay.update(overlay.spec.copy(alpha = .5f)).isSuccess) + assertEquals(.3f, backend.lastParams!!.alpha, .0001f) + assertTrue(dispatch(overlay, MotionEvent.ACTION_MOVE, 110f + slop + 40, 260f)) + assertEquals(.5f, overlay.spec.alpha, 0f) + assertEquals(.3f, backend.lastParams!!.alpha, .0001f) + assertTrue(dispatch(overlay, endAction, 110f + slop + 40, 260f)) + + assertEquals(.5f, overlay.spec.alpha, 0f) + assertEquals(.5f, backend.lastParams!!.alpha, 0f) + } + + @Test fun positionUpdateDuringADragStillRestoresTheAlphaOnUp() { + val backend = RecordingBackend() + val overlay = draggingOverlay(backend, alpha = .8f) + val slop = touchSlop(overlay.view) + + assertTrue(overlay.update(overlay.spec.copy(x = 4)).isSuccess) + assertEquals(4, overlay.spec.x) + assertTrue(dispatch(overlay, MotionEvent.ACTION_UP, 110f + slop + 20, 260f)) + + assertEquals(.8f, overlay.spec.alpha, 0f) + assertEquals(.8f, backend.lastParams!!.alpha, 0f) + } + + @Test fun failedModeChangeKeepsTheDragAndUpStillRestoresTheAlpha() { + val backend = RecordingBackend() + val overlay = draggingOverlay(backend, alpha = .8f) + val slop = touchSlop(overlay.view) + val dragged = overlay.spec + + backend.updateFailure = IllegalStateException("rejected") + assertFalse(overlay.update(overlay.spec.copy(touchMode = OverlayTouchMode.INTERACTIVE)).isSuccess) + assertEquals(dragged, overlay.spec) + assertEquals(.48f, backend.lastParams!!.alpha, .0001f) + + backend.updateFailure = null + assertTrue(dispatch(overlay, MotionEvent.ACTION_UP, 110f + slop + 20, 260f)) + assertEquals(OverlayTouchMode.DRAGGABLE, overlay.spec.touchMode) + assertEquals(.8f, overlay.spec.alpha, 0f) + assertEquals(.8f, backend.lastParams!!.alpha, 0f) + } + + @Test fun failedRestoreOnUpKeepsTheCallerAlphaAndDoesNotCompoundOnTheNextDrag() { + val backend = RecordingBackend() + val overlay = draggingOverlay(backend, alpha = .8f) + val slop = touchSlop(overlay.view) + + backend.updateFailure = IllegalStateException("rejected") + assertTrue(dispatch(overlay, MotionEvent.ACTION_UP, 110f + slop + 20, 260f)) + assertEquals(.8f, overlay.spec.alpha, 0f) + + backend.updateFailure = null + assertFalse(dispatch(overlay, MotionEvent.ACTION_DOWN, 110f, 260f)) + assertTrue(dispatch(overlay, MotionEvent.ACTION_MOVE, 110f + slop + 30, 260f)) + assertEquals(.48f, backend.lastParams!!.alpha, .0001f) + assertTrue(dispatch(overlay, MotionEvent.ACTION_UP, 110f + slop + 30, 260f)) + + assertEquals(.8f, overlay.spec.alpha, 0f) + assertEquals(.8f, backend.lastParams!!.alpha, 0f) + } + + @Test fun failedRestoreOnUpIsRecoveredByALaterEqualUpdate() { + val backend = RecordingBackend() + val overlay = draggingOverlay(backend, alpha = .8f) + val slop = touchSlop(overlay.view) + + backend.updateFailure = IllegalStateException("rejected") + assertTrue(dispatch(overlay, MotionEvent.ACTION_UP, 110f + slop + 20, 260f)) + assertEquals(.48f, backend.lastParams!!.alpha, .0001f) + + backend.updateFailure = null + assertTrue(overlay.update(overlay.spec).isSuccess) + + assertEquals(.8f, backend.lastParams!!.alpha, 0f) + } + + @Test fun failedRestoreOnUpIsRecoveredByALaterModeChange() { + val backend = RecordingBackend() + val overlay = draggingOverlay(backend, alpha = .8f) + val slop = touchSlop(overlay.view) + + backend.updateFailure = IllegalStateException("rejected") + assertTrue(dispatch(overlay, MotionEvent.ACTION_UP, 110f + slop + 20, 260f)) + + backend.updateFailure = null + assertTrue(overlay.update(overlay.spec.copy(touchMode = OverlayTouchMode.INTERACTIVE)).isSuccess) + + assertEquals(.8f, overlay.spec.alpha, 0f) + assertEquals(.8f, backend.lastParams!!.alpha, 0f) + } + + @Test fun hideDuringADragRestoresTheAlphaForTheNextShow() { + val backend = RecordingBackend() + val overlay = draggingOverlay(backend, alpha = .8f) + + assertTrue(overlay.hide().isSuccess) + assertEquals(.8f, overlay.spec.alpha, 0f) + + assertTrue(overlay.show().isSuccess) + assertEquals(.8f, backend.lastParams!!.alpha, 0f) + } + + @Test fun disposeDuringADragLeavesTheOriginalAlphaInTheFinalSpec() { + val overlay = draggingOverlay(RecordingBackend(), alpha = .8f) + + assertTrue(overlay.dispose().isSuccess) + + assertEquals(.8f, overlay.spec.alpha, 0f) + } + + private fun draggingOverlay(backend: RecordingBackend, alpha: Float): OverlayView { + val view = PositionedView(100, 240, 24) + val overlay = OverlayView.create( + view, + OverlayScope.ACTIVITY, + backend, + OverlaySpec(alpha = alpha, touchMode = OverlayTouchMode.DRAGGABLE), + ) + overlay.show() + assertFalse(dispatch(overlay, MotionEvent.ACTION_DOWN, 110f, 260f)) + assertTrue(dispatch(overlay, MotionEvent.ACTION_MOVE, 110f + touchSlop(view) + 20, 260f)) + return overlay + } + + @Test fun dragBeyondSlopCancelsPendingClickAndLongPressSoNeitherFiresOnUp() { + val view = PositionedView(100, 240, 24) + val overlay = OverlayView.create( + view, + OverlayScope.ACTIVITY, + RecordingBackend(), + OverlaySpec(touchMode = OverlayTouchMode.DRAGGABLE), + ) + overlay.show() + // Attached only so the real framework posts the long-press callback (and a click) through + // a real Handler (an unattached View queues posts until attachment instead of scheduling + // them); the library backend above is a no-op recorder, so this extra real parent does not + // interact with it. + attachToActivityContent(view) + var clicks = 0 + var longClicks = 0 + view.setOnClickListener { clicks++ } + view.setOnLongClickListener { longClicks++; true } + val slop = touchSlop(view) + + assertFalse(dispatch(overlay, MotionEvent.ACTION_DOWN, 110f, 260f)) + assertTrue(view.isPressed) // the view's own onTouchEvent(DOWN) ran and pressed it + // Crossing slop must cancel the pending long-press callback and clear the press state + // before either would fire. + assertTrue(dispatch(overlay, MotionEvent.ACTION_MOVE, 110f + slop + 20, 260f)) + assertFalse(view.isPressed) + shadowOf(Looper.getMainLooper()).idleFor(Duration.ofMillis(ViewConfiguration.getLongPressTimeout() + 50L)) + assertTrue(dispatch(overlay, MotionEvent.ACTION_UP, 110f + slop + 20, 260f)) + + assertEquals(0, clicks) + assertEquals(0, longClicks) + } + + @Test fun nonClickableViewConsumesFromDownAndTheDragStillWorks() { + val view = PositionedView(100, 240, 24) + view.isClickable = false + val overlay = OverlayView.create( + view, + OverlayScope.ACTIVITY, + RecordingBackend(), + OverlaySpec(touchMode = OverlayTouchMode.DRAGGABLE), + ) + overlay.show() + val slop = touchSlop(view) + + // DOWN is consumed immediately: there is no click to preserve on a non-clickable view. + assertTrue(dispatch(overlay, MotionEvent.ACTION_DOWN, 110f, 260f)) + // Still below slop, but the listener keeps consuming every event of this same gesture. + assertTrue(dispatch(overlay, MotionEvent.ACTION_MOVE, 110f + slop - 1, 260f)) + assertTrue(dispatch(overlay, MotionEvent.ACTION_MOVE, 110f + slop + 20, 260f)) + assertEquals(100 + slop + 20, overlay.spec.x) + assertEquals(216, overlay.spec.y) + assertTrue(dispatch(overlay, MotionEvent.ACTION_UP, 110f + slop + 20, 260f)) + } + + @Test + @Config(sdk = [Build.VERSION_CODES.M], manifest = Config.NONE) + fun deniedPermission_activityDraggableShowGestureAndHideUseOnlyItsTargetWindowManager() { + ShadowSettings.setCanDrawOverlays(false) + val view = PositionedView(100, 240, 24) + val backend = RecordingBackend() + val overlay = OverlayView.create( + view, + OverlayScope.ACTIVITY, + backend, + OverlaySpec(touchMode = OverlayTouchMode.DRAGGABLE), + ) + val slop = touchSlop(view) + + assertTrue(overlay.show().isSuccess) + dispatch(overlay, MotionEvent.ACTION_DOWN, 110f, 260f) + dispatch(overlay, MotionEvent.ACTION_MOVE, 110f + slop + 20, 260f) + dispatch(overlay, MotionEvent.ACTION_UP, 110f + slop + 20, 260f) + assertTrue(overlay.hide().isSuccess) + + assertEquals(1, backend.showCalls) + assertEquals(2, backend.updateCalls) + assertEquals(1, backend.hideCalls) + } + + private fun touchSlop(view: View): Int = ViewConfiguration.get(view.context).scaledTouchSlop + + /** + * Attaches [view] to a real Activity's content view. An unattached View has no real + * [android.os.Handler], so anything it `post()`s (a long-press callback, or the click that + * [View.onTouchEvent]'s `ACTION_UP` posts via `mPerformClick`) is queued and never flushed; + * a real window gives it a Handler tied to the main looper, which the caller can then idle. + * + * Also gives the view a concrete size via a direct measure/layout call, bypassing reliance on + * an async layout traversal: [View.onTouchEvent]'s `ACTION_MOVE`/`ACTION_UP` handling checks + * `pointInView(x, y, slop)` against the view's own laid-out width/height in the *view's local* + * coordinate frame (dispatching straight to this leaf view applies no parent offset, so a + * fixture's raw test coordinates double as local ones here); a never-laid-out view is 0x0, so + * every point reads as outside, clearing the pressed state before `ACTION_UP` can post a click + * -- with no effect on tests where the listener itself consumes `MOVE`/`UP` before + * `onTouchEvent` ever runs. 2000x2000 comfortably covers every coordinate this suite dispatches. + */ + private fun attachToActivityContent(view: View) { + val activity = Robolectric.buildActivity(Activity::class.java).setup().get() + activity.findViewById(android.R.id.content).addView(view) + val size = View.MeasureSpec.makeMeasureSpec(2000, View.MeasureSpec.EXACTLY) + view.measure(size, size) + view.layout(0, 0, 2000, 2000) + } + + /** + * Dispatches a synthesized single-pointer [action]/[x]/[y] event and reports whether the + * listener itself consumed it (see the class KDoc for why this differs from + * [View.dispatchTouchEvent]'s own return value). + */ + private fun dispatch(overlay: OverlayView<*>, action: Int, x: Float, y: Float): Boolean = + dispatch(overlay, MotionEvent.obtain(0, 0, action, x, y, 0)) + + /** Dispatches and recycles [event] (a single-use, freshly obtained event) and reports listener consumption. */ + private fun dispatch(overlay: OverlayView<*>, event: MotionEvent): Boolean { + val view = overlay.view + @Suppress("UNCHECKED_CAST") + val delegate = privateField(overlay, "effectiveDragListener") as View.OnTouchListener + var consumed = false + view.setOnTouchListener { v, ev -> consumed = delegate.onTouch(v, ev); consumed } + view.dispatchTouchEvent(event) + event.recycle() + return consumed + } + + private fun privateField(instance: Any, name: String): Any? = instance.javaClass.getDeclaredField(name).let { + it.isAccessible = true + it.get(instance) + } + + private fun obtainMultiTouch( + action: Int, + points: List>, + actionIndex: Int = 0, + ): MotionEvent { + val properties = points.map { (id, _, _) -> + MotionEvent.PointerProperties().apply { + this.id = id + toolType = MotionEvent.TOOL_TYPE_FINGER + } + }.toTypedArray() + val coords = points.map { (_, x, y) -> + MotionEvent.PointerCoords().apply { + this.x = x + this.y = y + pressure = 1f + size = 1f + } + }.toTypedArray() + val resolvedAction = action or (actionIndex shl MotionEvent.ACTION_POINTER_INDEX_SHIFT) + return MotionEvent.obtain( + 0, + 0, + resolvedAction, + points.size, + properties, + coords, + 0, + 0, + 1f, + 1f, + 0, + 0, + InputDevice.SOURCE_TOUCHSCREEN, + 0, + ) + } + + /** + * Clickable by default, matching the common case for a managed view and keeping most of this + * suite focused on drag mechanics rather than the click/long-press consumption policy; tests + * that specifically cover the non-clickable policy flip [View.setClickable] explicitly. + */ + private class PositionedView( + private val screenX: Int, + private val screenY: Int, + private val visibleFrameTop: Int, + private val visibleFrameLeft: Int = 0, + ) : View(RuntimeEnvironment.getApplication()) { + init { isClickable = true } + + override fun getLocationOnScreen(outLocation: IntArray) { + outLocation[0] = screenX + outLocation[1] = screenY + } + + override fun getWindowVisibleDisplayFrame(outRect: Rect) { + outRect.set(visibleFrameLeft, visibleFrameTop, 1080, 1920) + } + } + + private companion object { + /** The placeholder frame's origin under `FLAG_LAYOUT_NO_LIMITS`, as seen on API 35. */ + const val NO_LIMITS_FRAME_ORIGIN = -100000 + } + + private class RecordingBackend(var updateFailure: Throwable? = null) : OverlayWindowManager() { + var showCalls = 0 + var updateCalls = 0 + var hideCalls = 0 + var lastParams: WindowManager.LayoutParams? = null + override fun show(view: View, params: WindowManager.LayoutParams) { showCalls++; lastParams = WindowManager.LayoutParams().also { it.copyFrom(params) } } + override fun update(view: View, params: WindowManager.LayoutParams) { + updateCalls++ + updateFailure?.let { throw it } + lastParams = WindowManager.LayoutParams().also { it.copyFrom(params) } + } + override fun hide(view: View) { hideCalls++ } + } +} diff --git a/core/src/test/kotlin/com/nagopy/android/overlayviewmanager/OverlayPermissionPreflightTest.kt b/core/src/test/kotlin/com/nagopy/android/overlayviewmanager/OverlayPermissionPreflightTest.kt new file mode 100644 index 0000000..6a051ad --- /dev/null +++ b/core/src/test/kotlin/com/nagopy/android/overlayviewmanager/OverlayPermissionPreflightTest.kt @@ -0,0 +1,117 @@ +/* + * Copyright 2026 75py + * Licensed under the Apache License, Version 2.0 (the "License"); + */ +package com.nagopy.android.overlayviewmanager + +import android.os.Build +import android.view.View +import android.view.WindowManager +import com.nagopy.android.overlayviewmanager.internal.OverlayWindowManager +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.RuntimeEnvironment +import org.robolectric.annotation.Config +import org.robolectric.shadows.ShadowSettings + +/** + * Covers the T05b permission-preflight consolidation: [OverlayView.show] obtains its + * application-scope preflight through the injected [OverlayPermission] (which itself delegates to + * [android.provider.Settings.canDrawOverlays]); [OverlayView.update]/[OverlayView.hide]/ + * [OverlayView.dispose] perform no preflight of their own -- see the KDoc on + * [OverlayView.update]. + */ +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [Build.VERSION_CODES.M], manifest = Config.NONE) +class OverlayPermissionPreflightTest { + + @Test fun deniedShow_returnsPermissionDeniedWithConfiguredStateAndNoBackendCall() { + ShadowSettings.setCanDrawOverlays(false) + val backend = RecordingBackend() + val overlay = applicationOverlay(backend) + + val result = overlay.show() + + assertFalse(result.isSuccess) + assertEquals(OverlayFailure.PERMISSION_DENIED, result.failure) + assertEquals(OverlayState.CONFIGURED, overlay.state) + assertEquals(OverlayFailure.PERMISSION_DENIED, overlay.lastFailure) + assertEquals(0, backend.addCalls) + } + + @Test fun deniedThenGranted_explicitShowRetrySucceeds() { + ShadowSettings.setCanDrawOverlays(false) + val backend = RecordingBackend() + val overlay = applicationOverlay(backend) + assertFalse(overlay.show().isSuccess) + + ShadowSettings.setCanDrawOverlays(true) + val retry = overlay.show() + + assertTrue(retry.isSuccess) + assertTrue(retry.changed) + assertEquals(OverlayState.ATTACHED, overlay.state) + assertEquals(1, backend.addCalls) + assertNull(overlay.lastFailure) + } + + @Test fun grantedShowThenRevokedUpdate_backendSecurityExceptionKeepsAttachedAndLastEffectiveSpec() { + ShadowSettings.setCanDrawOverlays(true) + val backend = RecordingBackend() + val overlay = applicationOverlay(backend) + assertTrue(overlay.show().isSuccess) + val effectiveBeforeRevoke = overlay.spec + + // Permission is revoked while attached; the platform (not a preflight) reports this on the + // next window operation. + ShadowSettings.setCanDrawOverlays(false) + backend.updateFailure = SecurityException("permission revoked") + + val result = overlay.update(effectiveBeforeRevoke.copy(x = 42)) + + assertFalse(result.isSuccess) + assertEquals(OverlayFailure.PERMISSION_DENIED, result.failure) + assertEquals(OverlayState.ATTACHED, overlay.state) + assertEquals(OverlayFailure.PERMISSION_DENIED, overlay.lastFailure) + assertEquals(effectiveBeforeRevoke, overlay.spec) + } + + @Test fun revokedPermission_showOnAFreshHandleIsDenied() { + ShadowSettings.setCanDrawOverlays(false) + val overlay = applicationOverlay(RecordingBackend()) + + assertEquals(OverlayFailure.PERMISSION_DENIED, overlay.show().failure) + assertEquals(OverlayState.CONFIGURED, overlay.state) + } + + @Test fun activityScope_neverConsultsPermissionEvenWhenApplicationPermissionIsDenied() { + ShadowSettings.setCanDrawOverlays(false) + val backend = RecordingBackend() + val overlay = OverlayView.create(View(RuntimeEnvironment.getApplication()), OverlayScope.ACTIVITY, backend, OverlaySpec()) + + val result = overlay.show() + + assertTrue(result.isSuccess) + assertEquals(OverlayState.ATTACHED, overlay.state) + assertEquals(1, backend.addCalls) + } + + private fun applicationOverlay(backend: RecordingBackend): OverlayView = OverlayView.create( + View(RuntimeEnvironment.getApplication()), + OverlayScope.APPLICATION, + backend, + OverlaySpec(), + ) + + private class RecordingBackend(var updateFailure: Throwable? = null) : OverlayWindowManager() { + var addCalls = 0 + override fun show(view: View, params: WindowManager.LayoutParams) { addCalls++ } + override fun update(view: View, params: WindowManager.LayoutParams) { updateFailure?.let { throw it } } + override fun hide(view: View) = Unit + } +} diff --git a/core/src/test/kotlin/com/nagopy/android/overlayviewmanager/OverlayPermissionTest.kt b/core/src/test/kotlin/com/nagopy/android/overlayviewmanager/OverlayPermissionTest.kt new file mode 100644 index 0000000..cf2e8e0 --- /dev/null +++ b/core/src/test/kotlin/com/nagopy/android/overlayviewmanager/OverlayPermissionTest.kt @@ -0,0 +1,109 @@ +/* + * Copyright 2026 75py + * Licensed under the Apache License, Version 2.0 (the "License"); + */ +package com.nagopy.android.overlayviewmanager + +import android.os.Build +import android.provider.Settings +import org.junit.After +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertNotSame +import org.junit.Assert.assertSame +import org.junit.Assert.assertTrue +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.RuntimeEnvironment +import org.robolectric.annotation.Config +import org.robolectric.shadows.ShadowSettings +import java.util.concurrent.atomic.AtomicReference + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [Build.VERSION_CODES.VANILLA_ICE_CREAM], manifest = Config.NONE) +class OverlayPermissionTest { + @After + fun tearDown() { + managerInstanceField().set(null, null) + } + + @Test + @Config(sdk = [Build.VERSION_CODES.M], manifest = Config.NONE) + fun isGranted_reflectsDeniedAndGrantedStateAtApi23() { + val permission = permission() + val context = RuntimeEnvironment.getApplication() + + ShadowSettings.setCanDrawOverlays(false) + assertFalse(permission.isGranted(context)) + ShadowSettings.setCanDrawOverlays(true) + assertTrue(permission.isGranted(context)) + } + + @Test + @Config(sdk = [Build.VERSION_CODES.O], manifest = Config.NONE) + fun isGranted_reflectsDeniedAndGrantedStateAtApi26() { + val permission = permission() + val context = RuntimeEnvironment.getApplication() + + ShadowSettings.setCanDrawOverlays(false) + assertFalse(permission.isGranted(context)) + ShadowSettings.setCanDrawOverlays(true) + assertTrue(permission.isGranted(context)) + } + + @Test + fun isGranted_queriesTheCurrentPlatformStateFromWorkerThread() { + val permission = permission() + val context = RuntimeEnvironment.getApplication() + ShadowSettings.setCanDrawOverlays(false) + val result = AtomicReference() + val failure = AtomicReference() + + Thread { + try { + result.set(permission.isGranted(context)) + } catch (error: Throwable) { + failure.set(error) + } + }.apply { start(); join() } + + assertEquals(null, failure.get()) + assertFalse(result.get()) + ShadowSettings.setCanDrawOverlays(true) + assertTrue(permission.isGranted(context)) + } + + @Test + fun settingsIntent_hasPackageActionAndDataWithoutReusingAnIntent() { + val permission = permission() + val context = RuntimeEnvironment.getApplication() + val first = permission.settingsIntent(context) + val second = permission.settingsIntent(context) + + assertEquals(Settings.ACTION_MANAGE_OVERLAY_PERMISSION, first.action) + assertEquals("package:${context.packageName}", first.dataString) + assertNotSame(first, second) + assertEquals(first.action, second.action) + assertEquals(first.data, second.data) + assertEquals(0, first.flags) + } + + @Test + fun manager_returnsTheSameImmutablePermissionHelper() { + val manager = initializedManager() + + assertSame(manager.overlayPermission(), manager.overlayPermission()) + } + + private fun permission(): OverlayPermission = initializedManager().overlayPermission() + + private fun initializedManager(): OverlayViewManager { + OverlayViewManager.init(RuntimeEnvironment.getApplication()) + return OverlayViewManager.getInstance() + } + + private fun managerInstanceField() = OverlayViewManager::class.java.getDeclaredField("instance").apply { + isAccessible = true + } +} diff --git a/core/src/test/kotlin/com/nagopy/android/overlayviewmanager/OverlaySpecKotlinConsumerTest.kt b/core/src/test/kotlin/com/nagopy/android/overlayviewmanager/OverlaySpecKotlinConsumerTest.kt new file mode 100644 index 0000000..7ff0d27 --- /dev/null +++ b/core/src/test/kotlin/com/nagopy/android/overlayviewmanager/OverlaySpecKotlinConsumerTest.kt @@ -0,0 +1,163 @@ +/* + * Copyright 2026 75py + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.nagopy.android.overlayviewmanager + +import android.view.Gravity +import android.view.ViewGroup +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertNull +import org.junit.Assert.assertThrows +import org.junit.Assert.assertTrue +import org.junit.Test + +class OverlaySpecKotlinConsumerTest { + @Test + fun defaultConfiguration_hasApprovedValues() { + val spec = OverlaySpec() + + assertEquals(ViewGroup.LayoutParams.WRAP_CONTENT, spec.width) + assertEquals(ViewGroup.LayoutParams.WRAP_CONTENT, spec.height) + assertEquals(Gravity.TOP or Gravity.START, spec.gravity) + assertEquals(0, spec.x) + assertEquals(0, spec.y) + assertEquals(0f, spec.horizontalMargin, 0f) + assertEquals(0f, spec.verticalMargin, 0f) + assertEquals(1f, spec.alpha, 0f) + assertEquals(OverlayTouchMode.PASS_THROUGH, spec.touchMode) + assertEquals(CrossUidPassThrough.SAME_UID_ONLY, spec.crossUidPassThrough) + assertFalse(spec.allowOutsideBounds) + assertNull(spec.screenBrightness) + } + + @Test + fun namedArguments_acceptValidBoundaryValues() { + val spec = OverlaySpec( + width = ViewGroup.LayoutParams.MATCH_PARENT, + height = 0, + horizontalMargin = 1f, + verticalMargin = 1f, + alpha = 0f, + screenBrightness = 1f, + ) + + assertEquals(ViewGroup.LayoutParams.MATCH_PARENT, spec.width) + assertEquals(0, spec.height) + assertEquals(1f, spec.horizontalMargin, 0f) + assertEquals(1f, spec.verticalMargin, 0f) + assertEquals(0f, spec.alpha, 0f) + assertEquals(1f, spec.screenBrightness!!, 0f) + } + + @Test + fun directConstruction_rejectsInvalidNumericValuesAndDimensions() { + assertThrows(IllegalArgumentException::class.java) { OverlaySpec(width = -3) } + assertThrows(IllegalArgumentException::class.java) { OverlaySpec(height = -4) } + assertThrows(IllegalArgumentException::class.java) { OverlaySpec(alpha = Float.NaN) } + assertThrows(IllegalArgumentException::class.java) { + OverlaySpec(horizontalMargin = Float.POSITIVE_INFINITY) + } + assertThrows(IllegalArgumentException::class.java) { + OverlaySpec(verticalMargin = -0.01f) + } + assertThrows(IllegalArgumentException::class.java) { + OverlaySpec(screenBrightness = Float.NEGATIVE_INFINITY) + } + } + + @Test + fun copy_revalidatesChangedValuesAndCreatesIndependentValue() { + val original = OverlaySpec(x = 7, alpha = 0.5f) + val copied = original.copy(x = 8) + + assertEquals(7, original.x) + assertEquals(8, copied.x) + assertThrows(IllegalArgumentException::class.java) { + original.copy(alpha = 1.1f) + } + } + + @Test + fun builder_createsIndependentSnapshotsAndRejectsInvalidSetterValues() { + val builder = OverlaySpec.Builder().setX(10).setAlpha(0.25f) + val first = builder.build() + val second = builder.setX(20).setAlpha(0.75f).build() + + assertEquals(10, first.x) + assertEquals(0.25f, first.alpha, 0f) + assertEquals(20, second.x) + assertEquals(0.75f, second.alpha, 0f) + assertThrows(IllegalArgumentException::class.java) { + OverlaySpec.Builder().setWidth(-3) + } + assertThrows(IllegalArgumentException::class.java) { + OverlaySpec.Builder().setHorizontalMargin(Float.NaN) + } + assertThrows(IllegalArgumentException::class.java) { + OverlaySpec.Builder().setVerticalMargin(1.01f) + } + assertThrows(IllegalArgumentException::class.java) { + OverlaySpec.Builder().setAlpha(Float.NEGATIVE_INFINITY) + } + assertThrows(IllegalArgumentException::class.java) { + OverlaySpec.Builder().setScreenBrightness(-0.01f) + } + } + + @Test + fun toBuilder_preservesEveryPropertyAndNoOpValuesAreEqual() { + val original = OverlaySpec( + width = 24, + height = ViewGroup.LayoutParams.MATCH_PARENT, + gravity = Gravity.BOTTOM or Gravity.END, + x = 3, + y = -4, + horizontalMargin = 0.2f, + verticalMargin = 0.8f, + alpha = 0.6f, + touchMode = OverlayTouchMode.DRAGGABLE, + crossUidPassThrough = CrossUidPassThrough.WHEN_SYSTEM_ALLOWS, + allowOutsideBounds = true, + screenBrightness = 0.4f, + ) + + val rebuilt = original.toBuilder().build() + + assertEquals(original, rebuilt) + assertEquals(original.hashCode(), rebuilt.hashCode()) + assertEquals(original, original.copy()) + } + + @Test + fun resultProjection_isDerivedFromFailureOnly() { + val success = OverlayResult(OverlayState.ATTACHED, true, null, null) + val diagnostic = IllegalStateException("rejected") + val failure = OverlayResult( + OverlayState.CONFIGURED, + false, + OverlayFailure.WINDOW_MANAGER_REJECTED, + diagnostic, + ) + + assertTrue(success.isSuccess) + assertFalse(failure.isSuccess) + assertEquals(OverlayState.CONFIGURED, failure.state) + assertFalse(failure.changed) + assertEquals(OverlayFailure.WINDOW_MANAGER_REJECTED, failure.failure) + assertEquals(diagnostic, failure.cause) + } +} diff --git a/core/src/test/kotlin/com/nagopy/android/overlayviewmanager/OverlayViewGravityTest.kt b/core/src/test/kotlin/com/nagopy/android/overlayviewmanager/OverlayViewGravityTest.kt new file mode 100644 index 0000000..6ab2b06 --- /dev/null +++ b/core/src/test/kotlin/com/nagopy/android/overlayviewmanager/OverlayViewGravityTest.kt @@ -0,0 +1,277 @@ +/* + * Copyright 2026 75py + * Licensed under the Apache License, Version 2.0 (the "License"); + */ +package com.nagopy.android.overlayviewmanager + +import android.app.Activity +import android.content.Context +import android.content.pm.ApplicationInfo +import android.content.res.Configuration +import android.os.Build +import android.view.Gravity +import android.view.View +import android.view.ViewGroup +import android.view.WindowManager +import com.nagopy.android.overlayviewmanager.internal.OverlayWindowManager +import org.junit.Assert.assertEquals +import org.junit.Test +import java.util.Locale +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.Robolectric +import org.robolectric.RuntimeEnvironment +import org.robolectric.annotation.Config + +/** + * Verifies the coordinate model's "resolved gravity is always absolute" guarantee through + * [OverlayView]'s `layoutParams()`, which resolves gravity with `OverlayGeometry.absoluteGravity`. + * + * These tests use `manifest = Config.NONE`, like the rest of this suite, so the test `Application` + * has no manifest declaring `android:supportsRtl="true"`. `View`'s real layout-direction + * resolution (`resolveLayoutDirection()`) gates entirely on `ApplicationInfo.FLAG_SUPPORTS_RTL` + * (via `View.hasRtlSupport()`): without it, an explicit `layoutDirection` is silently ignored and + * resolution always reports LTR, regardless of what was requested. Each test sets that flag + * directly on the test `Application`'s `ApplicationInfo` before touching `layoutDirection`, which + * is the plain-field equivalent of what a real manifest's `android:supportsRtl="true"` provides. + */ +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [Build.VERSION_CODES.P], manifest = Config.NONE) +class OverlayViewGravityTest { + @Test fun rtlLayoutDirection_resolvesStartGravityToAbsoluteRight() { + enableRtlSupport() + val view = View(RuntimeEnvironment.getApplication()) + view.layoutDirection = View.LAYOUT_DIRECTION_RTL + val backend = RecordingBackend() + val overlay = OverlayView.create(view, OverlayScope.ACTIVITY, backend, OverlaySpec(gravity = Gravity.TOP or Gravity.START)) + + overlay.show() + + val params = backend.lastParams!! + assertEquals(Gravity.TOP or Gravity.RIGHT, params.gravity) + assertEquals(0, params.gravity and Gravity.RELATIVE_LAYOUT_DIRECTION) + } + + @Test fun ltrLayoutDirection_resolvesStartGravityToAbsoluteLeft() { + enableRtlSupport() + val view = View(RuntimeEnvironment.getApplication()) + view.layoutDirection = View.LAYOUT_DIRECTION_LTR + val backend = RecordingBackend() + val overlay = OverlayView.create(view, OverlayScope.ACTIVITY, backend, OverlaySpec(gravity = Gravity.TOP or Gravity.START)) + + overlay.show() + + val params = backend.lastParams!! + assertEquals(Gravity.TOP or Gravity.LEFT, params.gravity) + assertEquals(0, params.gravity and Gravity.RELATIVE_LAYOUT_DIRECTION) + } + + @Test fun inheritedRtlConfiguration_resolvesStartGravityBeforeTheViewIsAttached() { + enableRtlSupport() + val view = View(rtlContext()) + val backend = RecordingBackend() + val overlay = OverlayView.create(view, OverlayScope.ACTIVITY, backend, OverlaySpec(gravity = Gravity.TOP or Gravity.START)) + + overlay.show() + + assertEquals(Gravity.TOP or Gravity.RIGHT, backend.lastParams!!.gravity) + } + + @Test fun rtlConfiguration_isIgnoredWhenTheApplicationDoesNotSupportRtl() { + val view = View(rtlContext()) + val backend = RecordingBackend() + val overlay = OverlayView.create(view, OverlayScope.ACTIVITY, backend, OverlaySpec(gravity = Gravity.TOP or Gravity.START)) + + overlay.show() + + assertEquals(Gravity.TOP or Gravity.LEFT, backend.lastParams!!.gravity) + } + + @Test fun declaredLtrInAnRtlConfiguration_isCorrectedAfterTheFirstLayout() { + val view = viewDeclaringLtrInAnRtlConfiguration() + val backend = RecordingBackend() + val overlay = OverlayView.create(view, OverlayScope.ACTIVITY, backend, OverlaySpec(gravity = Gravity.TOP or Gravity.START)) + + overlay.show() + // The declared direction cannot be read yet, so the first show uses the configuration. + assertEquals(Gravity.TOP or Gravity.RIGHT, backend.lastParams!!.gravity) + + layOut(view) + + assertEquals(Gravity.TOP or Gravity.LEFT, backend.lastParams!!.gravity) + assertEquals(1, backend.updateCalls) + } + + @Test fun updateBeforeTheFirstLayout_isCorrectedFromTheLastAppliedGravity() { + val view = viewDeclaringLtrInAnRtlConfiguration() + val backend = RecordingBackend() + val overlay = OverlayView.create(view, OverlayScope.ACTIVITY, backend, OverlaySpec(gravity = Gravity.TOP or Gravity.START)) + + overlay.show() + overlay.update(overlay.spec.copy(gravity = Gravity.TOP or Gravity.END)) + // Both estimates use the RTL configuration, so START went right and END went left. + assertEquals(Gravity.TOP or Gravity.LEFT, backend.lastParams!!.gravity) + + layOut(view) + + assertEquals(Gravity.TOP or Gravity.RIGHT, backend.lastParams!!.gravity) + } + + @Test fun hostListenerHidingTheOverlayDuringTheFirstLayout_skipsTheCorrection() { + val view = viewDeclaringLtrInAnRtlConfiguration() + val backend = RecordingBackend() + val overlay = OverlayView.create(view, OverlayScope.ACTIVITY, backend, OverlaySpec(gravity = Gravity.TOP or Gravity.START)) + view.addOnLayoutChangeListener { _, _, _, _, _, _, _, _, _ -> overlay.hide() } + + overlay.show() + layOut(view) + + assertEquals(OverlayState.CONFIGURED, overlay.state) + assertEquals(0, backend.updateCalls) + } + + @Test fun hostListenerDisposingTheOverlayDuringTheFirstLayout_skipsTheCorrection() { + val view = viewDeclaringLtrInAnRtlConfiguration() + val backend = RecordingBackend() + val overlay = OverlayView.create(view, OverlayScope.ACTIVITY, backend, OverlaySpec(gravity = Gravity.TOP or Gravity.START)) + view.addOnLayoutChangeListener { _, _, _, _, _, _, _, _, _ -> overlay.dispose() } + + overlay.show() + layOut(view) + + assertEquals(OverlayState.DISPOSED, overlay.state) + assertEquals(0, backend.updateCalls) + } + + @Test fun hideBeforeTheFirstLayout_removesTheCorrection() { + val view = viewDeclaringLtrInAnRtlConfiguration() + val backend = RecordingBackend() + val overlay = OverlayView.create(view, OverlayScope.ACTIVITY, backend, OverlaySpec(gravity = Gravity.TOP or Gravity.START)) + + overlay.show() + overlay.hide() + layOut(view) + + assertEquals(0, backend.updateCalls) + } + + @Test fun disposeBeforeTheFirstLayout_removesTheCorrection() { + val view = viewDeclaringLtrInAnRtlConfiguration() + val backend = RecordingBackend() + val overlay = OverlayView.create(view, OverlayScope.ACTIVITY, backend, OverlaySpec(gravity = Gravity.TOP or Gravity.START)) + + overlay.show() + overlay.dispose() + layOut(view) + + assertEquals(0, backend.updateCalls) + } + + @Test fun showHideShow_appliesOneCorrection() { + val view = viewDeclaringLtrInAnRtlConfiguration() + val backend = RecordingBackend() + val overlay = OverlayView.create(view, OverlayScope.ACTIVITY, backend, OverlaySpec(gravity = Gravity.TOP or Gravity.START)) + + overlay.show() + overlay.hide() + overlay.show() + layOut(view) + + assertEquals(Gravity.TOP or Gravity.LEFT, backend.lastParams!!.gravity) + assertEquals(1, backend.updateCalls) + } + + @Test fun externalDetachBeforeTheFirstLayout_removesTheCorrection() { + val view = viewDeclaringLtrInAnRtlConfiguration() + val backend = RecordingBackend() + val overlay = OverlayView.create(view, OverlayScope.ACTIVITY, backend, OverlaySpec(gravity = Gravity.TOP or Gravity.START)) + overlay.show() + val activity = Robolectric.buildActivity(Activity::class.java).setup().get() + val content = activity.findViewById(android.R.id.content) + + content.addView(view) + content.removeView(view) + assertEquals(OverlayState.CONFIGURED, overlay.state) + layOut(view) + + assertEquals(0, backend.updateCalls) + } + + @Test fun failedCorrection_isClassifiedAndKeepsTheOverlayAttached() { + val view = viewDeclaringLtrInAnRtlConfiguration() + val backend = RecordingBackend() + val overlay = OverlayView.create(view, OverlayScope.ACTIVITY, backend, OverlaySpec(gravity = Gravity.TOP or Gravity.START)) + overlay.show() + backend.updateFailure = SecurityException("denied") + + layOut(view) + + assertEquals(OverlayFailure.PERMISSION_DENIED, overlay.lastFailure) + assertEquals(OverlayState.ATTACHED, overlay.state) + } + + @Test fun correctionOfADetachedWindow_reconcilesTheState() { + val view = viewDeclaringLtrInAnRtlConfiguration() + val backend = RecordingBackend() + val overlay = OverlayView.create(view, OverlayScope.ACTIVITY, backend, OverlaySpec(gravity = Gravity.TOP or Gravity.START)) + overlay.show() + backend.updateFailure = IllegalArgumentException("View not attached to window manager") + + layOut(view) + + assertEquals(OverlayFailure.NOT_ATTACHED, overlay.lastFailure) + assertEquals(OverlayState.CONFIGURED, overlay.state) + } + + @Test fun inheritedDirection_needsNoCorrectionAfterTheFirstLayout() { + enableRtlSupport() + val view = View(RuntimeEnvironment.getApplication()) + val backend = RecordingBackend() + val overlay = OverlayView.create(view, OverlayScope.ACTIVITY, backend, OverlaySpec(gravity = Gravity.TOP or Gravity.START)) + + overlay.show() + layOut(view) + + assertEquals(0, backend.updateCalls) + } + + private fun viewDeclaringLtrInAnRtlConfiguration(): View { + enableRtlSupport() + val attributes = Robolectric.buildAttributeSet() + .addAttribute(android.R.attr.layoutDirection, "ltr") + .build() + return View(rtlContext(), attributes) + } + + private fun rtlContext(): Context { + val application = RuntimeEnvironment.getApplication() + val rtl = Configuration(application.resources.configuration).apply { setLocale(Locale("ar")) } + return application.createConfigurationContext(rtl) + } + + private fun layOut(view: View) { + view.measure( + View.MeasureSpec.makeMeasureSpec(100, View.MeasureSpec.EXACTLY), + View.MeasureSpec.makeMeasureSpec(100, View.MeasureSpec.EXACTLY), + ) + view.layout(0, 0, 100, 100) + } + + private fun enableRtlSupport() { + val info = RuntimeEnvironment.getApplication().applicationInfo + info.flags = info.flags or ApplicationInfo.FLAG_SUPPORTS_RTL + } + + private class RecordingBackend : OverlayWindowManager() { + var updateCalls = 0 + var updateFailure: Exception? = null + var lastParams: WindowManager.LayoutParams? = null + override fun show(view: View, params: WindowManager.LayoutParams) { lastParams = WindowManager.LayoutParams().also { it.copyFrom(params) } } + override fun update(view: View, params: WindowManager.LayoutParams) { + updateCalls++ + updateFailure?.let { throw it } + lastParams = WindowManager.LayoutParams().also { it.copyFrom(params) } + } + override fun hide(view: View) = Unit + } +} diff --git a/core/src/test/kotlin/com/nagopy/android/overlayviewmanager/OverlayViewJvmVisibilityTest.kt b/core/src/test/kotlin/com/nagopy/android/overlayviewmanager/OverlayViewJvmVisibilityTest.kt new file mode 100644 index 0000000..d31d6a0 --- /dev/null +++ b/core/src/test/kotlin/com/nagopy/android/overlayviewmanager/OverlayViewJvmVisibilityTest.kt @@ -0,0 +1,50 @@ +/* + * Copyright 2026 75py + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.nagopy.android.overlayviewmanager + +import java.lang.reflect.Member +import java.lang.reflect.Modifier +import org.junit.Assert.assertTrue +import org.junit.Test + +/** + * Guards the Java-visible surface of [OverlayView]. Kotlin `internal` members compile to public + * JVM members, so library-only entry points must be private or synthetic to stay out of reach of + * Java sources. + */ +class OverlayViewJvmVisibilityTest { + @Test + fun constructors_areNotCallableFromJavaSources() { + val callable = OverlayView::class.java.declaredConstructors.filter(::isCallableFromJava) + + assertTrue("Java-callable constructors: $callable", callable.isEmpty()) + } + + @Test + fun libraryOnlyMembers_areNotCallableFromJavaSources() { + val libraryOnly = listOf("create", "disposeForActivityDestruction") + val members = (OverlayView::class.java.declaredMethods + OverlayView.Companion::class.java.declaredMethods) + .filter { method -> libraryOnly.any { method.name == it || method.name.startsWith(it + "$") } } + + assertTrue("Expected the factory and the forced-disposal hook to exist", members.size >= libraryOnly.size) + val callable = members.filter(::isCallableFromJava) + assertTrue("Java-callable library-only members: $callable", callable.isEmpty()) + } + + private fun isCallableFromJava(member: Member): Boolean = + !member.isSynthetic && !Modifier.isPrivate(member.modifiers) +} diff --git a/core/src/test/kotlin/com/nagopy/android/overlayviewmanager/OverlayViewStateMachineTest.kt b/core/src/test/kotlin/com/nagopy/android/overlayviewmanager/OverlayViewStateMachineTest.kt new file mode 100644 index 0000000..a8a9780 --- /dev/null +++ b/core/src/test/kotlin/com/nagopy/android/overlayviewmanager/OverlayViewStateMachineTest.kt @@ -0,0 +1,550 @@ +package com.nagopy.android.overlayviewmanager + +import android.os.Build +import android.view.View +import android.view.WindowManager +import android.widget.FrameLayout +import com.nagopy.android.overlayviewmanager.internal.OverlayWindowManager +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertNull +import org.junit.Assert.assertSame +import org.junit.Assert.assertThrows +import org.junit.Assert.assertTrue +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.RuntimeEnvironment +import org.robolectric.annotation.Config +import org.robolectric.shadows.ShadowSettings +import java.util.concurrent.atomic.AtomicReference + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [Build.VERSION_CODES.P], manifest = Config.NONE) +class OverlayViewStateMachineTest { + @Test fun showFailure_keepsConfiguredAndRetainsOnlyFailureEnum() { + val backend = RecordingBackend(addFailure = SecurityException("denied")) + val overlay = overlay(backend) + val result = overlay.show() + assertFalse(result.isSuccess) + assertEquals(OverlayFailure.PERMISSION_DENIED, result.failure) + assertEquals(OverlayState.CONFIGURED, overlay.state) + assertEquals(OverlayFailure.PERMISSION_DENIED, overlay.lastFailure) + assertSame(backend.addFailure, result.cause) + } + + @Test fun retryAfterFailedShow_isSynchronousAndAttachedOnlyAfterAddReturns() { + val backend = RecordingBackend(addFailure = IllegalStateException("temporary")) + val overlay = overlay(backend) + overlay.show() + backend.addFailure = null + val retry = overlay.show() + assertTrue(retry.isSuccess) + assertTrue(retry.changed) + assertEquals(2, backend.addCalls) + assertEquals(OverlayState.ATTACHED, overlay.state) + assertNull(overlay.lastFailure) + } + + @Test fun showWithParentedViewFailsBeforeTheBackendIsCalled() { + val backend = RecordingBackend() + val view = View(RuntimeEnvironment.getApplication()) + val overlay = OverlayView.create(view, OverlayScope.ACTIVITY, backend, OverlaySpec()) + FrameLayout(view.context).addView(view) + + val result = overlay.show() + + assertEquals(OverlayFailure.ALREADY_HAS_PARENT, result.failure) + assertEquals(OverlayState.CONFIGURED, overlay.state) + assertEquals(OverlayFailure.ALREADY_HAS_PARENT, overlay.lastFailure) + assertEquals(0, backend.addCalls) + } + + @Test fun badTokenFromShowIsClassifiedWithoutAttaching() { + val backend = RecordingBackend(addFailure = WindowManager.BadTokenException("bad token")) + val overlay = overlay(backend) + + val result = overlay.show() + + assertEquals(OverlayFailure.INVALID_WINDOW_TOKEN, result.failure) + assertSame(backend.addFailure, result.cause) + assertEquals(OverlayState.CONFIGURED, overlay.state) + assertEquals(OverlayFailure.INVALID_WINDOW_TOKEN, overlay.lastFailure) + } + + @Test fun backendErrorPropagatesWithoutClassification() { + val error = AssertionError("fatal") + val backend = RecordingBackend(addFailure = error) + val overlay = overlay(backend) + + assertSame(error, assertThrows(AssertionError::class.java) { overlay.show() }) + assertEquals(1, backend.addCalls) + assertEquals(OverlayState.CONFIGURED, overlay.state) + assertNull(overlay.lastFailure) + } + + @Test fun failedUpdate_keepsLastAppliedSpecAndLayoutSnapshot() { + val backend = RecordingBackend() + val overlay = overlay(backend) + overlay.show() + val applied = overlay.spec + backend.updateFailure = IllegalStateException("rejected") + val result = overlay.update(applied.copy(x = 24, alpha = .5f)) + assertFalse(result.isSuccess) + assertEquals(applied, overlay.spec) + assertEquals(applied.x, backend.lastSuccessfulParams!!.x) + assertEquals(applied.alpha, backend.lastSuccessfulParams!!.alpha, 0f) + } + + @Test fun equalUpdatesAndRepeatedShowAreNoOps() { + val backend = RecordingBackend() + val overlay = overlay(backend) + overlay.show() + assertFalse(overlay.show().changed) + assertFalse(overlay.update(overlay.spec).changed) + assertEquals(1, backend.addCalls) + assertEquals(0, backend.updateCalls) + } + + @Test fun notAttachedHide_reconcilesSuccessfullyAndRetainsDiagnostic() { + val backend = RecordingBackend(removeFailure = IllegalArgumentException("View not attached")) + val overlay = overlay(backend) + overlay.show() + val result = overlay.hide() + assertTrue(result.isSuccess) + assertFalse(result.changed) + assertEquals(OverlayState.CONFIGURED, overlay.state) + assertEquals(OverlayFailure.NOT_ATTACHED, overlay.lastFailure) + assertNull(result.failure) + } + + @Test fun notAttachedUpdateReconcilesButReportsTheDiagnosticFailure() { + val backend = RecordingBackend(updateFailure = IllegalArgumentException("View not attached")) + val overlay = overlay(backend) + overlay.show() + assertTrue(privateField(overlay, "detachListener") != null) + val result = overlay.update(overlay.spec.copy(x = 8)) + assertFalse(result.isSuccess) + assertEquals(OverlayFailure.NOT_ATTACHED, result.failure) + assertEquals(OverlayState.CONFIGURED, overlay.state) + assertEquals(OverlayFailure.NOT_ATTACHED, overlay.lastFailure) + assertNull(privateField(overlay, "detachListener")) + assertTrue(overlay.show().isSuccess) + assertTrue(privateField(overlay, "detachListener") != null) + } + + @Test fun configuredHideAndDisposeRetainAnExistingDiagnostic() { + val backend = RecordingBackend(addFailure = SecurityException("denied")) + val overlay = overlay(backend) + overlay.show() + assertEquals(OverlayFailure.PERMISSION_DENIED, overlay.lastFailure) + assertTrue(overlay.hide().isSuccess) + assertEquals(OverlayFailure.PERMISSION_DENIED, overlay.lastFailure) + assertTrue(overlay.dispose().isSuccess) + assertEquals(OverlayState.DISPOSED, overlay.state) + assertNull(privateField(overlay, "backend")) + assertEquals(OverlayFailure.PERMISSION_DENIED, overlay.lastFailure) + assertFalse(overlay.show().isSuccess) + assertEquals(OverlayFailure.PERMISSION_DENIED, overlay.lastFailure) + } + + @Test fun failedDisposeIsRetryableButSuccessfulDisposeReleasesView() { + val backend = RecordingBackend(removeFailure = IllegalStateException("busy")) + val overlay = overlay(backend) + overlay.show() + assertFalse(overlay.dispose().isSuccess) + assertEquals(OverlayState.ATTACHED, overlay.state) + backend.removeFailure = null + assertTrue(overlay.dispose().isSuccess) + assertEquals(OverlayState.DISPOSED, overlay.state) + assertThrows(IllegalStateException::class.java) { overlay.view } + assertEquals(overlay.spec, overlay.spec) + } + + @Test fun notAttachedDisposeReconcilesAndReleasesOwnedReferences() { + val backend = RecordingBackend(removeFailure = IllegalArgumentException("View not attached")) + val overlay = overlay(backend) + overlay.show() + + val result = overlay.dispose() + + assertTrue(result.isSuccess) + assertFalse(result.changed) + assertNull(result.failure) + assertEquals(OverlayState.DISPOSED, overlay.state) + assertEquals(OverlayFailure.NOT_ATTACHED, overlay.lastFailure) + assertNull(privateField(overlay, "backend")) + assertNull(privateField(overlay, "ownedView")) + assertThrows(IllegalStateException::class.java) { overlay.view } + } + + @Test fun backgroundMutationFailsBeforeCallingTheBackend() { + val backend = RecordingBackend() + val overlay = overlay(backend) + val thrown = AtomicReference() + Thread { try { overlay.show() } catch (error: Throwable) { thrown.set(error) } }.apply { start(); join() } + assertTrue(thrown.get() is IllegalStateException) + assertEquals(0, backend.addCalls) + assertEquals(OverlayState.CONFIGURED, overlay.state) + } + + @Test fun applicationBrightnessIsRejectedForUpdate() { + val overlay = OverlayView.create( + View(RuntimeEnvironment.getApplication()), OverlayScope.APPLICATION, RecordingBackend(), OverlaySpec(), + ) + assertThrows(IllegalArgumentException::class.java) { + overlay.update(OverlaySpec(screenBrightness = .4f)) + } + } + + @Test + @Config(sdk = [Build.VERSION_CODES.M], manifest = Config.NONE) + fun applicationPermissionPreflightPreventsAddAndAllowsRetryWhileActivityScopeWorksDenied() { + val application = RuntimeEnvironment.getApplication() + val applicationBackend = RecordingBackend() + ShadowSettings.setCanDrawOverlays(false) + val applicationOverlay = OverlayView.create(View(application), OverlayScope.APPLICATION, applicationBackend, OverlaySpec()) + + assertEquals(OverlayFailure.PERMISSION_DENIED, applicationOverlay.show().failure) + assertEquals(0, applicationBackend.addCalls) + ShadowSettings.setCanDrawOverlays(true) + assertTrue(applicationOverlay.show().isSuccess) + assertEquals(1, applicationBackend.addCalls) + + ShadowSettings.setCanDrawOverlays(false) + val activityBackend = RecordingBackend() + val activityOverlay = OverlayView.create(View(application), OverlayScope.ACTIVITY, activityBackend, OverlaySpec()) + assertTrue(activityOverlay.show().isSuccess) + assertEquals(1, activityBackend.addCalls) + } + + @Test + @Config(sdk = [Build.VERSION_CODES.M], manifest = Config.NONE) + fun windowTypesAndFlagsUseOnlyAllowedApplicationAndActivityValuesAtApi23Boundary() { + ShadowSettings.setCanDrawOverlays(true) + val application = RuntimeEnvironment.getApplication() + val applicationBackend = RecordingBackend() + val applicationOverlay = OverlayView.create(View(application), OverlayScope.APPLICATION, applicationBackend, OverlaySpec()) + applicationOverlay.show() + assertAllowedFlags(applicationBackend.lastSuccessfulParams!!, WindowManager.LayoutParams.TYPE_SYSTEM_ALERT, passThrough = true) + applicationOverlay.update(applicationOverlay.spec.copy(touchMode = OverlayTouchMode.INTERACTIVE)) + assertAllowedFlags(applicationBackend.lastSuccessfulParams!!, WindowManager.LayoutParams.TYPE_SYSTEM_ALERT, passThrough = false) + applicationOverlay.update(applicationOverlay.spec.copy(touchMode = OverlayTouchMode.DRAGGABLE)) + assertAllowedFlags(applicationBackend.lastSuccessfulParams!!, WindowManager.LayoutParams.TYPE_SYSTEM_ALERT, passThrough = false) + + val activityBackend = RecordingBackend() + val activityOverlay = OverlayView.create(View(application), OverlayScope.ACTIVITY, activityBackend, OverlaySpec()) + activityOverlay.show() + assertAllowedFlags(activityBackend.lastSuccessfulParams!!, WindowManager.LayoutParams.TYPE_APPLICATION, passThrough = true) + activityOverlay.update(activityOverlay.spec.copy(touchMode = OverlayTouchMode.INTERACTIVE)) + assertAllowedFlags(activityBackend.lastSuccessfulParams!!, WindowManager.LayoutParams.TYPE_APPLICATION, passThrough = false) + activityOverlay.update(activityOverlay.spec.copy(touchMode = OverlayTouchMode.DRAGGABLE)) + assertAllowedFlags(activityBackend.lastSuccessfulParams!!, WindowManager.LayoutParams.TYPE_APPLICATION, passThrough = false) + } + + @Test + @Config(sdk = [Build.VERSION_CODES.O], manifest = Config.NONE) + fun applicationWindowTypeUsesApplicationOverlayFromApi26() { + ShadowSettings.setCanDrawOverlays(true) + val backend = RecordingBackend() + val overlay = OverlayView.create(View(RuntimeEnvironment.getApplication()), OverlayScope.APPLICATION, backend, OverlaySpec()) + + assertTrue(overlay.show().isSuccess) + assertAllowedFlags(backend.lastSuccessfulParams!!, WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY, passThrough = true) + } + + @Test fun updateAppliesEveryLayoutFieldAndViewOwnsTheClickListener() { + val backend = RecordingBackend() + val view = View(RuntimeEnvironment.getApplication()) + val overlay = OverlayView.create(view, OverlayScope.ACTIVITY, backend, OverlaySpec()) + overlay.show() + var clicks = 0 + view.setOnClickListener { clicks++ } + overlay.update( + overlay.spec.copy( + width = 240, + height = 80, + gravity = android.view.Gravity.BOTTOM, + x = 12, + y = 34, + alpha = .7f, + horizontalMargin = .2f, + verticalMargin = .3f, + ), + ) + + assertEquals(240, overlay.spec.width) + assertEquals(80, backend.lastSuccessfulParams!!.height) + assertEquals(12, backend.lastSuccessfulParams!!.x) + assertEquals(.7f, backend.lastSuccessfulParams!!.alpha, 0f) + view.performClick() + assertEquals(1, clicks) + } + + @Test fun draggableSpecInstallsTheBridgeAndUpdatesOnlyAfterTheListenerRuns() { + val backend = RecordingBackend() + val view = View(RuntimeEnvironment.getApplication()) + val overlay = OverlayView.create(view, OverlayScope.ACTIVITY, backend, OverlaySpec(touchMode = OverlayTouchMode.DRAGGABLE)) + overlay.show() + val slop = android.view.ViewConfiguration.get(view.context).scaledTouchSlop + val down = android.view.MotionEvent.obtain(0, 0, android.view.MotionEvent.ACTION_DOWN, 12f, 20f, 0) + view.dispatchTouchEvent(down) + down.recycle() + // The bridge installs immediately, but T06 gates the first backend call on touch slop. + assertEquals(0, backend.updateCalls) + val move = android.view.MotionEvent.obtain(0, 0, android.view.MotionEvent.ACTION_MOVE, 12f + slop + 10, 20f, 0) + view.dispatchTouchEvent(move) + move.recycle() + assertEquals(1, backend.updateCalls) + assertEquals(OverlayTouchMode.DRAGGABLE, overlay.spec.touchMode) + } + + @Test fun failedDraggableUpdateKeepsThePriorEffectiveTouchState() { + val backend = RecordingBackend() + val view = View(RuntimeEnvironment.getApplication()) + val overlay = OverlayView.create(view, OverlayScope.ACTIVITY, backend, OverlaySpec(touchMode = OverlayTouchMode.INTERACTIVE)) + overlay.show() + backend.updateFailure = IllegalStateException("rejected") + assertFalse(overlay.update(overlay.spec.copy(touchMode = OverlayTouchMode.DRAGGABLE)).isSuccess) + assertEquals(OverlayTouchMode.INTERACTIVE, overlay.spec.touchMode) + val down = android.view.MotionEvent.obtain(0, 0, android.view.MotionEvent.ACTION_DOWN, 12f, 20f, 0) + view.dispatchTouchEvent(down) + down.recycle() + assertEquals(1, backend.updateCalls) + } + + @Test fun disposeReenteredFromHideRemovesOnceAndStaysDisposed() { + val backend = RecordingBackend() + val overlay = overlay(backend) + overlay.show() + var nested: OverlayResult? = null + backend.onHide = { backend.onHide = null; nested = overlay.dispose() } + + val result = overlay.hide() + + assertEquals(1, backend.hideCalls) + assertTrue(nested!!.isSuccess) + assertEquals(OverlayState.DISPOSED, nested!!.state) + assertTrue(result.isSuccess) + assertEquals(OverlayState.DISPOSED, result.state) + assertEquals(OverlayState.DISPOSED, overlay.state) + assertNull(privateField(overlay, "ownedView")) + assertThrows(IllegalStateException::class.java) { overlay.view } + } + + @Test fun disposeReenteredFromDisposeRemovesOnceAndReleasesOnce() { + val backend = RecordingBackend() + var releases = 0 + val overlay = OverlayView.create( + View(RuntimeEnvironment.getApplication()), OverlayScope.ACTIVITY, backend, OverlaySpec(), + activityReleaseCallback = { releases++ }, + ) + overlay.show() + backend.onHide = { backend.onHide = null; overlay.dispose() } + + val result = overlay.dispose() + + assertTrue(result.isSuccess) + assertEquals(1, backend.hideCalls) + assertEquals(1, releases) + assertEquals(OverlayState.DISPOSED, overlay.state) + } + + @Test fun hideReenteredFromDisposeDoesNotRemoveAgain() { + val backend = RecordingBackend() + val overlay = overlay(backend) + overlay.show() + backend.onHide = { backend.onHide = null; overlay.hide() } + + val result = overlay.dispose() + + assertTrue(result.isSuccess) + assertEquals(1, backend.hideCalls) + assertEquals(OverlayState.DISPOSED, overlay.state) + } + + @Test fun hideReenteredFromHideDoesNotRemoveAgain() { + val backend = RecordingBackend() + val overlay = overlay(backend) + overlay.show() + backend.onHide = { backend.onHide = null; overlay.hide() } + + val result = overlay.hide() + + assertTrue(result.isSuccess) + assertEquals(1, backend.hideCalls) + assertEquals(OverlayState.CONFIGURED, overlay.state) + } + + @Test fun removalFailureAfterAReenteredDisposeIsReportedWithoutReopeningTheHandle() { + val failure = IllegalStateException("busy") + val backend = RecordingBackend(removeFailure = failure) + val overlay = overlay(backend) + overlay.show() + backend.onHide = { backend.onHide = null; overlay.dispose() } + + val result = overlay.hide() + + assertEquals(OverlayFailure.WINDOW_MANAGER_REJECTED, result.failure) + assertSame(failure, result.cause) + assertEquals(OverlayState.DISPOSED, result.state) + assertEquals(OverlayState.DISPOSED, overlay.state) + assertEquals(OverlayFailure.WINDOW_MANAGER_REJECTED, overlay.lastFailure) + } + + @Test fun notAttachedAfterAReenteredDisposeStaysDisposed() { + val backend = RecordingBackend(removeFailure = IllegalArgumentException("View not attached")) + val overlay = overlay(backend) + overlay.show() + backend.onHide = { backend.onHide = null; overlay.dispose() } + + val result = overlay.hide() + + assertTrue(result.isSuccess) + assertEquals(OverlayState.DISPOSED, overlay.state) + assertEquals(OverlayFailure.NOT_ATTACHED, overlay.lastFailure) + } + + @Test fun failedHideWithoutReentryStaysAttachedAndCanBeRetried() { + val backend = RecordingBackend(removeFailure = IllegalStateException("busy")) + val overlay = overlay(backend) + overlay.show() + + assertFalse(overlay.hide().isSuccess) + assertEquals(OverlayState.ATTACHED, overlay.state) + + backend.removeFailure = null + assertTrue(overlay.hide().isSuccess) + assertEquals(2, backend.hideCalls) + assertEquals(OverlayState.CONFIGURED, overlay.state) + } + + @Test fun hostTouchListenerSetAfterInteractiveCreationSurvivesShowAndPositionUpdate() { + val backend = RecordingBackend() + val view = View(RuntimeEnvironment.getApplication()) + val overlay = OverlayView.create(view, OverlayScope.ACTIVITY, backend, OverlaySpec(touchMode = OverlayTouchMode.INTERACTIVE)) + var touches = 0 + view.setOnTouchListener { _, _ -> touches++; false } + + overlay.show() + touch(view) + overlay.update(overlay.spec.copy(x = 8)) + touch(view) + + assertEquals(2, touches) + } + + @Test fun hostTouchListenerSetBeforeCreationSurvivesEveryNonDragOperation() { + val backend = RecordingBackend() + val view = View(RuntimeEnvironment.getApplication()) + var touches = 0 + view.setOnTouchListener { _, _ -> touches++; false } + val overlay = OverlayView.create(view, OverlayScope.ACTIVITY, backend, OverlaySpec(touchMode = OverlayTouchMode.INTERACTIVE)) + + touch(view) + overlay.show() + touch(view) + overlay.update(overlay.spec.copy(x = 8)) + touch(view) + overlay.update(overlay.spec.copy(touchMode = OverlayTouchMode.PASS_THROUGH)) + touch(view) + overlay.hide() + touch(view) + overlay.update(overlay.spec.copy(x = 16)) + touch(view) + overlay.dispose() + touch(view) + + assertEquals(7, touches) + } + + @Test fun hostTouchListenerSetAfterLeavingDraggableSurvivesLaterOperations() { + val backend = RecordingBackend() + val view = View(RuntimeEnvironment.getApplication()) + val overlay = OverlayView.create(view, OverlayScope.ACTIVITY, backend, OverlaySpec(touchMode = OverlayTouchMode.DRAGGABLE)) + overlay.show() + overlay.update(overlay.spec.copy(touchMode = OverlayTouchMode.INTERACTIVE)) + var touches = 0 + view.setOnTouchListener { _, _ -> touches++; false } + + overlay.update(overlay.spec.copy(x = 8)) + touch(view) + overlay.dispose() + touch(view) + + assertEquals(2, touches) + } + + @Test fun leavingDraggableRemovesTheLibraryListener() { + val backend = RecordingBackend() + val view = View(RuntimeEnvironment.getApplication()) + val overlay = OverlayView.create(view, OverlayScope.ACTIVITY, backend, OverlaySpec(touchMode = OverlayTouchMode.DRAGGABLE)) + overlay.show() + overlay.update(overlay.spec.copy(touchMode = OverlayTouchMode.INTERACTIVE)) + val updates = backend.updateCalls + + dragPastSlop(view) + + assertEquals(updates, backend.updateCalls) + } + + @Test fun disposeRemovesTheLibraryListener() { + val backend = RecordingBackend() + val view = View(RuntimeEnvironment.getApplication()) + val overlay = OverlayView.create(view, OverlayScope.ACTIVITY, backend, OverlaySpec(touchMode = OverlayTouchMode.DRAGGABLE)) + overlay.show() + overlay.dispose() + + dragPastSlop(view) + + assertEquals(0, backend.updateCalls) + } + + private fun touch(view: View) { + val down = android.view.MotionEvent.obtain(0, 0, android.view.MotionEvent.ACTION_DOWN, 1f, 1f, 0) + view.dispatchTouchEvent(down) + down.recycle() + } + + private fun dragPastSlop(view: View) { + touch(view) + val slop = android.view.ViewConfiguration.get(view.context).scaledTouchSlop + val move = android.view.MotionEvent.obtain(0, 0, android.view.MotionEvent.ACTION_MOVE, 1f + slop + 10, 1f, 0) + view.dispatchTouchEvent(move) + move.recycle() + } + + private fun overlay(backend: RecordingBackend, spec: OverlaySpec = OverlaySpec()): OverlayView = OverlayView.create( + View(RuntimeEnvironment.getApplication()), OverlayScope.ACTIVITY, backend, spec, + ) + + private fun assertAllowedFlags(params: WindowManager.LayoutParams, type: Int, passThrough: Boolean) { + assertEquals(type, params.type) + val expectedFlags = WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE or + if (passThrough) WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE else 0 + assertEquals(expectedFlags, params.flags) + assertFalse(params.type == WindowManager.LayoutParams.TYPE_SYSTEM_ERROR) + assertFalse(params.type == WindowManager.LayoutParams.TYPE_SYSTEM_OVERLAY) + } + + private fun privateField(instance: Any, name: String): Any? = instance.javaClass.getDeclaredField(name).let { + it.isAccessible = true + it.get(instance) + } + + private class RecordingBackend( + var addFailure: Throwable? = null, + var updateFailure: Throwable? = null, + var removeFailure: Throwable? = null, + ) : OverlayWindowManager() { + var addCalls = 0 + var updateCalls = 0 + var hideCalls = 0 + /** Stands in for a host detach callback running inside `removeViewImmediate`. */ + var onHide: (() -> Unit)? = null + var lastSuccessfulParams: WindowManager.LayoutParams? = null + override fun show(view: View, params: WindowManager.LayoutParams) { addCalls++; addFailure?.let { throw it }; lastSuccessfulParams = WindowManager.LayoutParams().also { it.copyFrom(params) } } + override fun update(view: View, params: WindowManager.LayoutParams) { updateCalls++; updateFailure?.let { throw it }; lastSuccessfulParams = WindowManager.LayoutParams().also { it.copyFrom(params) } } + override fun hide(view: View) { hideCalls++; onHide?.invoke(); removeFailure?.let { throw it } } + } +} diff --git a/core/src/test/kotlin/com/nagopy/android/overlayviewmanager/PassThroughOpacityAdmissionTest.kt b/core/src/test/kotlin/com/nagopy/android/overlayviewmanager/PassThroughOpacityAdmissionTest.kt new file mode 100644 index 0000000..8d39932 --- /dev/null +++ b/core/src/test/kotlin/com/nagopy/android/overlayviewmanager/PassThroughOpacityAdmissionTest.kt @@ -0,0 +1,283 @@ +/* + * Copyright 2026 75py + * Licensed under the Apache License, Version 2.0 (the "License"); + */ +package com.nagopy.android.overlayviewmanager + +import android.os.Build +import android.view.View +import android.view.WindowManager +import com.nagopy.android.overlayviewmanager.internal.MaximumObscuringOpacity +import com.nagopy.android.overlayviewmanager.internal.OverlayWindowManager +import com.nagopy.android.overlayviewmanager.internal.PassThroughOpacityRegistry +import org.junit.After +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.RuntimeEnvironment +import org.robolectric.annotation.Config +import org.robolectric.shadows.ShadowSettings + +/** + * Covers the Android 12+ (API 31+) application-scope [OverlayTouchMode.PASS_THROUGH] opacity + * admission described in the T06 contract: the conservative combined opacity + * `1 - product(1 - alpha_i)` over every attached library-managed application pass-through handle + * of this process plus the candidate, checked only for the opt-in + * [CrossUidPassThrough.WHEN_SYSTEM_ALLOWS], on API 31+, against an injected + * [com.nagopy.android.overlayviewmanager.internal.MaximumObscuringOpacitySource] so no shadow of + * `InputManager` is required. + */ +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [Build.VERSION_CODES.S], manifest = Config.NONE) +class PassThroughOpacityAdmissionTest { + + @Before fun setUp() { + ShadowSettings.setCanDrawOverlays(true) + PassThroughOpacityRegistry.resetForTests() + } + + @After fun tearDown() { + PassThroughOpacityRegistry.resetForTests() + } + + @Test fun singleHandleBelowMaxIsAdmitted() { + MaximumObscuringOpacity.setForTests { 0.8f } + val result = handle(alpha = .7f).show() + assertTrue(result.isSuccess) + assertEquals(OverlayState.ATTACHED, result.state) + } + + @Test fun singleHandleAtMaxIsAdmitted() { + MaximumObscuringOpacity.setForTests { 0.8f } + val result = handle(alpha = .8f).show() + assertTrue(result.isSuccess) + } + + @Test fun singleHandleAboveMaxIsRejectedWithoutAPlatformCallAndStateUnchanged() { + MaximumObscuringOpacity.setForTests { 0.8f } + val backend = RecordingBackend() + val overlay = handle(alpha = .9f, backend = backend) + + val result = overlay.show() + + assertFalse(result.isSuccess) + assertEquals(OverlayFailure.PASS_THROUGH_OPACITY_EXCEEDED, result.failure) + assertNull(result.cause) + assertEquals(OverlayState.CONFIGURED, overlay.state) + assertEquals(0, backend.addCalls) + } + + @Test fun combinedOpacityOfTwoHandlesExceedsMaxWhileEachIsIndividuallyBelow() { + MaximumObscuringOpacity.setForTests { 0.8f } + val first = handle(alpha = .6f) + assertTrue(first.show().isSuccess) // .6 alone is below .8 + + val second = handle(alpha = .6f) + val result = second.show() // 1 - (.4 * .4) = .84 > .8 + + assertFalse(result.isSuccess) + assertEquals(OverlayFailure.PASS_THROUGH_OPACITY_EXCEEDED, result.failure) + assertEquals(OverlayState.CONFIGURED, second.state) + } + + @Test fun updateLoweringAlphaIsAdmittedAndTheRegistryReflectsTheLoweredValue() { + MaximumObscuringOpacity.setForTests { 0.8f } + val first = handle(alpha = .75f) + assertTrue(first.show().isSuccess) + + val lowered = first.update(first.spec.copy(alpha = .5f)) + assertTrue(lowered.isSuccess) + assertEquals(.5f, first.spec.alpha, 0f) + + // If the registry still held the pre-update .75, this would be 1-(.25*.5)=.875 > .8. + // With the lowered .5 on record it is 1-(.5*.5)=.75 <= .8, so the second handle is admitted. + val second = handle(alpha = .5f) + assertTrue(second.show().isSuccess) + } + + @Test fun hideFreesTheBudgetForAnotherHandle() { + MaximumObscuringOpacity.setForTests { 0.8f } + val first = handle(alpha = .6f) + assertTrue(first.show().isSuccess) + val second = handle(alpha = .6f) + assertFalse(second.show().isSuccess) + + assertTrue(first.hide().isSuccess) + assertTrue(second.show().isSuccess) + } + + @Test fun disposeFreesTheBudgetForAnotherHandle() { + MaximumObscuringOpacity.setForTests { 0.8f } + val first = handle(alpha = .6f) + assertTrue(first.show().isSuccess) + val second = handle(alpha = .6f) + assertFalse(second.show().isSuccess) + + assertTrue(first.dispose().isSuccess) + assertTrue(second.show().isSuccess) + } + + @Test fun unsupportedSourceFailsClosedWithoutAPlatformCall() { + MaximumObscuringOpacity.setForTests { null } + val backend = RecordingBackend() + val overlay = handle(alpha = .1f, backend = backend) + + val result = overlay.show() + + assertFalse(result.isSuccess) + assertEquals(OverlayFailure.PASS_THROUGH_UNSUPPORTED, result.failure) + assertNull(result.cause) + assertEquals(0, backend.addCalls) + } + + @Test fun sourceThrowingIsTreatedAsUnsupported() { + MaximumObscuringOpacity.setForTests { throw IllegalStateException("input service unavailable") } + val result = handle(alpha = .1f).show() + assertEquals(OverlayFailure.PASS_THROUGH_UNSUPPORTED, result.failure) + } + + @Test + @Config(sdk = [30], manifest = Config.NONE) + fun api30AcceptsTheOptionWithoutQueryingOrCheckingOpacity() { + MaximumObscuringOpacity.setForTests { throw AssertionError("must not query the platform below API 31") } + val result = handle(alpha = 1f).show() + assertTrue(result.isSuccess) + } + + @Test fun sameUidOnlyIsNeverAdmissionChecked() { + MaximumObscuringOpacity.setForTests { 0f } // would reject everything if ever consulted + val overlay = OverlayView.create( + View(RuntimeEnvironment.getApplication()), + OverlayScope.APPLICATION, + RecordingBackend(), + OverlaySpec(alpha = 1f, touchMode = OverlayTouchMode.PASS_THROUGH, crossUidPassThrough = CrossUidPassThrough.SAME_UID_ONLY), + ) + assertTrue(overlay.show().isSuccess) + } + + @Test fun sameUidOnlyHandleCountsInTheCombinedSumEvenThoughItIsNeverItselfGated() { + MaximumObscuringOpacity.setForTests { 0.8f } + val sameUidOnly = OverlayView.create( + View(RuntimeEnvironment.getApplication()), + OverlayScope.APPLICATION, + RecordingBackend(), + OverlaySpec(alpha = 1f, touchMode = OverlayTouchMode.PASS_THROUGH, crossUidPassThrough = CrossUidPassThrough.SAME_UID_ONLY), + ) + assertTrue(sameUidOnly.show().isSuccess) // never gated, so alpha = 1f is accepted + + // A WHEN_SYSTEM_ALLOWS candidate must still be judged against the combined sum that + // includes the ungated SAME_UID_ONLY handle's alpha. + val result = handle(alpha = .1f).show() // 1-((1-1)*(1-.1)) = 1 > .8 + assertFalse(result.isSuccess) + assertEquals(OverlayFailure.PASS_THROUGH_OPACITY_EXCEEDED, result.failure) + } + + @Test fun activityScopeIsNeverAdmissionChecked() { + MaximumObscuringOpacity.setForTests { 0f } // would reject everything if ever consulted + val overlay = OverlayView.create( + View(RuntimeEnvironment.getApplication()), + OverlayScope.ACTIVITY, + RecordingBackend(), + OverlaySpec(alpha = 1f, touchMode = OverlayTouchMode.PASS_THROUGH, crossUidPassThrough = CrossUidPassThrough.WHEN_SYSTEM_ALLOWS), + ) + assertTrue(overlay.show().isSuccess) + } + + @Test fun everyUpdateIncludingXyOnlyReQueriesTheOpacitySourceWithNoCaching() { + var queries = 0 + MaximumObscuringOpacity.setForTests { queries++; 0.8f } + val overlay = handle(alpha = .7f) + assertTrue(overlay.show().isSuccess) + assertEquals(1, queries) + + assertTrue(overlay.update(overlay.spec.copy(x = 42, y = 24)).isSuccess) + assertEquals(2, queries) + } + + @Test fun sourceMaxChangingAfterAttachIsReJudgedOnAnXOnlyUpdate() { + var maximum = 0.9f + MaximumObscuringOpacity.setForTests { maximum } + val overlay = handle(alpha = .7f) // .7 <= .9, admitted + assertTrue(overlay.show().isSuccess) + + // The platform maximum drops below the already-attached alpha; a later x-only update + // (no alpha change at all) must be judged against the new maximum, not the one at attach. + maximum = 0.5f + val result = overlay.update(overlay.spec.copy(x = 10)) + + assertFalse(result.isSuccess) + assertEquals(OverlayFailure.PASS_THROUGH_OPACITY_EXCEEDED, result.failure) + assertEquals(0, overlay.spec.x) // rejected: effective spec (including x) stays as attached + } + + @Test fun disposeRemovesTheHandleFromTheRegistryEntirely() { + MaximumObscuringOpacity.setForTests { 0.8f } + val overlay = handle(alpha = .6f) + assertTrue(overlay.show().isSuccess) + assertTrue(PassThroughOpacityRegistry.containsForTests(overlay)) + + assertTrue(overlay.dispose().isSuccess) + + assertFalse(PassThroughOpacityRegistry.containsForTests(overlay)) + } + + @Test fun failedHideLeavesTheRegistryEntryAndBudgetInPlace() { + MaximumObscuringOpacity.setForTests { 0.8f } + val backend = FailingHideBackend() + val overlay = OverlayView.create(View(RuntimeEnvironment.getApplication()), OverlayScope.APPLICATION, backend, OverlaySpec(alpha = .6f, touchMode = OverlayTouchMode.PASS_THROUGH, crossUidPassThrough = CrossUidPassThrough.WHEN_SYSTEM_ALLOWS)) + assertTrue(overlay.show().isSuccess) + assertTrue(PassThroughOpacityRegistry.containsForTests(overlay)) + + backend.hideFailure = IllegalStateException("rejected") + assertFalse(overlay.hide().isSuccess) + assertEquals(OverlayState.ATTACHED, overlay.state) + + // The budget the failed hide would have freed must still be spent: a second handle whose + // combined opacity only fits if the first one had actually been freed must still fail. + val second = handle(alpha = .6f) + assertFalse(second.show().isSuccess) + } + + @Test fun failedApplicationDisposeKeepsTheRegistryEntryAndASuccessfulRetryRemovesIt() { + MaximumObscuringOpacity.setForTests { 0.8f } + val backend = FailingHideBackend() + val overlay = OverlayView.create(View(RuntimeEnvironment.getApplication()), OverlayScope.APPLICATION, backend, OverlaySpec(alpha = .6f, touchMode = OverlayTouchMode.PASS_THROUGH, crossUidPassThrough = CrossUidPassThrough.WHEN_SYSTEM_ALLOWS)) + assertTrue(overlay.show().isSuccess) + assertTrue(PassThroughOpacityRegistry.containsForTests(overlay)) + + backend.hideFailure = IllegalStateException("rejected") + assertFalse(overlay.dispose().isSuccess) + assertEquals(OverlayState.ATTACHED, overlay.state) + assertTrue(PassThroughOpacityRegistry.containsForTests(overlay)) + + backend.hideFailure = null + assertTrue(overlay.dispose().isSuccess) + assertEquals(OverlayState.DISPOSED, overlay.state) + assertFalse(PassThroughOpacityRegistry.containsForTests(overlay)) + } + + private fun handle(alpha: Float, backend: OverlayWindowManager = RecordingBackend()): OverlayView = OverlayView.create( + View(RuntimeEnvironment.getApplication()), + OverlayScope.APPLICATION, + backend, + OverlaySpec(alpha = alpha, touchMode = OverlayTouchMode.PASS_THROUGH, crossUidPassThrough = CrossUidPassThrough.WHEN_SYSTEM_ALLOWS), + ) + + private class RecordingBackend : OverlayWindowManager() { + var addCalls = 0 + override fun show(view: View, params: WindowManager.LayoutParams) { addCalls++ } + override fun update(view: View, params: WindowManager.LayoutParams) = Unit + override fun hide(view: View) = Unit + } + + private class FailingHideBackend(var hideFailure: Throwable? = null) : OverlayWindowManager() { + override fun show(view: View, params: WindowManager.LayoutParams) = Unit + override fun update(view: View, params: WindowManager.LayoutParams) = Unit + override fun hide(view: View) { hideFailure?.let { throw it } } + } +} diff --git a/core/src/test/kotlin/com/nagopy/android/overlayviewmanager/internal/OverlayGeometryTest.kt b/core/src/test/kotlin/com/nagopy/android/overlayviewmanager/internal/OverlayGeometryTest.kt new file mode 100644 index 0000000..72f8d41 --- /dev/null +++ b/core/src/test/kotlin/com/nagopy/android/overlayviewmanager/internal/OverlayGeometryTest.kt @@ -0,0 +1,65 @@ +/* Copyright 2026 75py. Licensed under the Apache License, Version 2.0. */ +package com.nagopy.android.overlayviewmanager.internal + +import android.view.Gravity +import org.junit.Assert.assertEquals +import org.junit.Test + +/** + * Table-driven coverage of [OverlayGeometry]'s coordinate model. These are plain, Robolectric-free + * unit tests: every function under test takes only `Int` parameters, no `android.graphics.Rect` or + * other Android framework type, so there is no risk of the Android SDK stub jar silently zeroing a + * constructed framework object under plain JUnit. + */ +class OverlayGeometryTest { + + private data class FrameCase( + val name: String, + val frameLeft: Int, + val frameTop: Int, + val screenX: Int, + val screenY: Int, + val expectedWindowX: Int, + val expectedWindowY: Int, + ) + + @Test + fun screenToWindow_convertsUsingTheFramesOriginAcrossRepresentativeWindowShapes() { + val cases = listOf( + FrameCase("fullscreen frame origin (0,0)", frameLeft = 0, frameTop = 0, screenX = 100, screenY = 240, expectedWindowX = 100, expectedWindowY = 240), + FrameCase("status-bar top inset only (0,84)", frameLeft = 0, frameTop = 84, screenX = 100, screenY = 240, expectedWindowX = 100, expectedWindowY = 156), + FrameCase("multi-window/freeform, non-zero left AND top (120,60)", frameLeft = 120, frameTop = 60, screenX = 200, screenY = 300, expectedWindowX = 80, expectedWindowY = 240), + FrameCase("rotated landscape frame, non-zero left only (84,0)", frameLeft = 84, frameTop = 0, screenX = 300, screenY = 50, expectedWindowX = 216, expectedWindowY = 50), + FrameCase("edge-to-edge frame (top=0)", frameLeft = 0, frameTop = 0, screenX = 50, screenY = 2399, expectedWindowX = 50, expectedWindowY = 2399), + // A location outside the frame (screenX/Y before the frame's origin) is not clamped to + // 0: the result is negative, matching allowOutsideBounds=false's documented behavior + // of reporting rather than clamping an out-of-frame location. + FrameCase("outside-frame location is not clamped, result is negative", frameLeft = 120, frameTop = 60, screenX = 10, screenY = 5, expectedWindowX = -110, expectedWindowY = -55), + ) + + for (case in cases) { + assertEquals(case.name, case.expectedWindowX, OverlayGeometry.screenToWindowX(case.screenX, case.frameLeft)) + assertEquals(case.name, case.expectedWindowY, OverlayGeometry.screenToWindowY(case.screenY, case.frameTop)) + } + } + + @Test + fun horizontalOffsetSign_isNegativeOnlyForRightGravity() { + assertEquals(-1, OverlayGeometry.horizontalOffsetSign(Gravity.RIGHT)) + assertEquals(-1, OverlayGeometry.horizontalOffsetSign(Gravity.BOTTOM or Gravity.RIGHT)) + assertEquals(1, OverlayGeometry.horizontalOffsetSign(Gravity.LEFT)) + assertEquals(1, OverlayGeometry.horizontalOffsetSign(Gravity.CENTER_HORIZONTAL)) + assertEquals(1, OverlayGeometry.horizontalOffsetSign(Gravity.FILL_HORIZONTAL)) + assertEquals(1, OverlayGeometry.horizontalOffsetSign(Gravity.NO_GRAVITY)) + } + + @Test + fun verticalOffsetSign_isNegativeOnlyForBottomGravity() { + assertEquals(-1, OverlayGeometry.verticalOffsetSign(Gravity.BOTTOM)) + assertEquals(-1, OverlayGeometry.verticalOffsetSign(Gravity.BOTTOM or Gravity.RIGHT)) + assertEquals(1, OverlayGeometry.verticalOffsetSign(Gravity.TOP)) + assertEquals(1, OverlayGeometry.verticalOffsetSign(Gravity.CENTER_VERTICAL)) + assertEquals(1, OverlayGeometry.verticalOffsetSign(Gravity.FILL_VERTICAL)) + assertEquals(1, OverlayGeometry.verticalOffsetSign(Gravity.NO_GRAVITY)) + } +} diff --git a/core/src/test/kotlin/com/nagopy/android/overlayviewmanager/internal/OverlayWindowFrameTest.kt b/core/src/test/kotlin/com/nagopy/android/overlayviewmanager/internal/OverlayWindowFrameTest.kt new file mode 100644 index 0000000..d3baf1f --- /dev/null +++ b/core/src/test/kotlin/com/nagopy/android/overlayviewmanager/internal/OverlayWindowFrameTest.kt @@ -0,0 +1,35 @@ +/* Copyright 2026 75py. Licensed under the Apache License, Version 2.0. */ +package com.nagopy.android.overlayviewmanager.internal + +import android.graphics.Rect +import android.os.Build +import android.view.View +import org.junit.Assert.assertEquals +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.RuntimeEnvironment +import org.robolectric.annotation.Config + +/** + * Verifies [OverlayWindowFrame] faithfully forwards whatever frame `View.getWindowVisibleDisplayFrame` + * reports, using a stubbed override (a listener/layout path test with a stubbed frame, not proof + * that the real framework reports any particular shape -- see [OverlayWindowFrame]'s KDoc). + */ +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [Build.VERSION_CODES.P], manifest = Config.NONE) +class OverlayWindowFrameTest { + @Test + fun of_returnsTheViewsCurrentVisibleFrameWithoutCreatingAnAuxiliaryWindow() { + val expected = Rect(120, 60, 900, 1200) + val view = object : View(RuntimeEnvironment.getApplication()) { + override fun getWindowVisibleDisplayFrame(outRect: Rect) { + outRect.set(expected) + } + } + + val frame = OverlayWindowFrame.of(view) + + assertEquals(expected, frame) + } +} diff --git a/docs/coordination/3.0.0/2026-09-11-prep-instructions.md b/docs/coordination/3.0.0/2026-09-11-prep-instructions.md new file mode 100644 index 0000000..4a9cad1 --- /dev/null +++ b/docs/coordination/3.0.0/2026-09-11-prep-instructions.md @@ -0,0 +1,33 @@ +# 準備: ユーザー指示の反映 + +- 日付: 2026-09-11（Asia/Tokyo、発言の正確な時刻は未記録） +- 状態: **ユーザー指示を反映。司令塔間の協議は未開始。** +- 記録担当: Codex +- 関連タスク: 準備、T00〜T13 +- PR / Orca Run / Task / Dispatch: 未作成 + +## ユーザー指示（要旨） + +1. 3.0.0用の作業ブランチと計画書を先に用意し、実装はまだ開始しない。 +2. Codex（Astra / medium）とClaude（Fable 5.1 / high）が司令塔となり、それぞれサブエージェントを起動して分担する。 +3. お互いのPRをレビューし、相手のAPPROVEを得てからマージする。 +4. AGENTS.mdと必要なSerenaファイルは先にコミットしてよい。 +5. PRタイトル・本文とソースコメントは英語、ユーザーとの会話は日本語とする。 +6. サブエージェントはLuna、Terra、Sonnet 5を使い、司令塔がモデル・effortを判断する。GPT-5.5やHaikuは原則使用しない。 +7. 計画書を適宜更新し、司令塔間のやり取りと判断結果もMarkdownでGit管理する。 +8. 適宜Kotlinへ置き換える。 + +## 今回の反映内容と理由 + +- AGENTS.mdへ継続的に適用する指示を追加し、以前のサブエージェント選択方針より今回の指定を優先した。 +- 計画書の「AGENTS.mdとSerenaは含めない」という旧方針を、ユーザーが許可した先行コミットへ更新した。 +- `.serena/project.yml` はプロジェクト名・Java言語設定などの共有設定で、端末固有の絶対パスや認証情報を含まないことを確認した。既存 `.serena/.gitignore` と合わせて管理対象に選んだ。 +- Serenaのcacheとproject.local.ymlは既存ignore規則で除外する。Kotlin言語サーバー設定は移行・ツール準備の段階で見直し、今回起動やインストールを行わない。 +- Kotlin移行をT01の設計事項と各実装タスクの対象選定に追加した。Java consumerと公開APIへの影響を確認する方針にした。 +- ログの保管場所・テンプレート・更新契機・単独提案と双方合意の区別を定義した。 + +## 今後の相談事項 + +- 実装開始後に両司令塔が具体的な担当・モデル設定・Kotlin移行対象を合意する。 +- この文書はユーザー指示と準備内容の記録であり、Claudeとの相談や相互APPROVEが行われたことを示さない。 +- 今回はローカル準備コミットまで。実装、エージェント起動、push、PR、マージは未開始。 diff --git a/docs/coordination/3.0.0/2026-09-12-api-implementation.md b/docs/coordination/3.0.0/2026-09-12-api-implementation.md new file mode 100644 index 0000000..ce10c63 --- /dev/null +++ b/docs/coordination/3.0.0/2026-09-12-api-implementation.md @@ -0,0 +1,171 @@ +# T04段階移行の事前整理 + +- 状態: 双方合意 +- 記録担当: Codex（Astra / medium） +- 関連PR: #33、#34、#35、#36、#37 +- Codex Run: run_18f7185e91aa +- Claude Run: run_3ae778449744 +- 関連タスク: T04a、T04b、T04c、T05、T06、T07、T08、T10 +- 実装開始条件: T03・T04a統合済み。T04bを実装中。 + +## 独立した影響範囲調査 + +- Model/effort: gpt-5.6-luna / medium（launch.effective確認） +- Task / Dispatch: task_e5adce159111 / ctx_c2912737a6af +- Terminal: term_a750c908-ffd3-4bc6-bfc1-f1017854519e +- Worktree: codex-3.0.0-t03-final-check（T03でcore本番が未変更のため既存実装の読取に使用） +- Report: /private/tmp/overlay-t04b-migration-map.md +- worker_done: msg_75439ae19755（16:03:52 JST）。読取のみ、Gradle/実装なし。受領後releaseしtranscriptを保存した。 + +子のファイル・consumer一覧は準備資料として採用する。OverlayViewの可変params、内部OverlayWindowManagerのpost/catch、ScreenMonitor、旧drag listener、sample/Timberおよびテストの依存点を確認した。 + +## 司令塔が修正した提案 + +子の「結果を返す公開API・factoryをT04cまで遅らせる」案は採用しない。T07/T10が新APIへ移ってからT04cで一時互換APIを除去する合意済み依存と逆転し、循環が生じるためである。T04bで新しい同期・結果APIを提供し、旧setterや読み取り互換部分だけを一時的に保持する。未適用setter値と最後に成功したeffective specを分離する。 + +Codexは実ソースのSample2Activityでfactory...show()の戻り値をoverlayViewへ代入する1箇所を確認。この箇所はT04bで代入とshowを分ける最小修正が必要で、sample全体のKotlin化や表示説明の移行はT10に残す。単に返却値を無視する既存呼び出しは同じ理由で修正対象にはならない。 + +子の責務提案にあったinitの同一/異なるApplication契約はT04bのmanager契約に含め、opacity budgetはT06へ合わせる。T08はActivity寿命・強制破棄と参照解放を担当する。これらの訂正と最小consumer修正をmsg_c82bc658d500（16:05:23 JST）でClaudeへ相談。Claudeはmsg_bf7ddf364470（16:21:29 JST）で訂正・最小consumer修正・責務分担に合意した。調査報告の未採用案を公開契約として扱わない。 + +## T04a実装開始 + +T03統合を条件として、base00b45cb9fbc78d4911e164fc8c5109b936eafc16からTerra/high（launch.effective確認）を起動した。Task task_6ca5c3ca3e03 / Dispatch ctx_31dbaecdd7b2 / Terminal term_5969d6d8-366e-4c7d-b9ee-30d154b247f0 / Worktree codex-3.0.0-t04a-models。新規Kotlin型とそのテストのみ、既存coreクラスやbuild・plan/logを編集しない。Java Builder/gettersとKotlin named args/copyを実コンパイルし、範囲検証・不変性・結果を確認する。ローカルGradleを専有し、終了チェックポイントで共有する。msg_0e69e2bb1da0（16:10:30 JST）でClaudeへ通知。 + +## T04a完了と復旧時の並行操作 + +- T04a worker_done msg_b5c88cd44fe3（16:16:46 JST）を受領しrelease、transcriptを保存。候補3224165e015c4c95db54c3e4d6eeda517cc276c5、実装報告 /private/tmp/overlay-t04a-implementation-report.md。新規型・consumerテストのみで既存表示処理は変更しない。 +- PR33はClaude側独立Sonnet5/highレビュー、exact-head APPROVE 5644524714とCI34680272503成功後、復旧対応端末 term_07348d72-aa3d-4f16-8b39-16701c3a947b がmerge997a958d0e13b35f1a7b1d5eeba267e4a0708a07へ統合した。当司令塔自身のmerge操作とは記録しない。 +- 同端末はT07 f86c40fをpush済みだった。当司令塔の同SHA pushはreference already existsで失敗したが、remoteが期待SHAと一致することを確認し、再push/forceは行わなかった。msg_04b6e9bc9617で限定引き継ぎと以後のmutation停止を依頼し、msg_9117c4605dd6でClaudeへ一本化を通知した。17:00頃の同端末screenは通知送信の承認待ちで、引き継ぎ返答は未受信。 +- PR33の非ブロッキング指摘はJava異常系・既定値・Builder(source) snapshotテスト補足、不要な12引数constructorのJvmOverloads削減。別小変更で検証・相互レビューする。Kotlin生成nullability annotationを基本としAndroidX明示はconsumer/lint根拠がある箇所に限定する案をmsg_44fa28c940e9で相談した。Claudeはmsg_0d126c52c1e6（17:02:50 JST）でannotation方針にも合意した。 + +## T07段階2の検証・統合 + +Claude担当のhead f86c40fec07845a91dead130cee175407a7a84f9はthresholdをvolatileにし、別スレッドから設定した閾値でログを絞るテストを追加。PR34、CI34681799560成功はmsg_73efff7d535eで共有された。 + +Codexは独立Terra/high（launch.effective確認）task_0f937a90d7eb / ctx_e954a5fd2d52をcodex-3.0.0-t07-threshold-reviewへ配置した。worker_done msg_9005d4fcec08（16:57:16 JST）、報告 /private/tmp/overlay-t07-stage2-review.md。blockingなし、実JUnit XMLは25 tests・失敗/エラー/skipなし、opt-timber lintエラー0。既定compileSdk36への更新通知は既存合意どおり非ブロッキング。受領後releaseしtranscriptを保存した。 + +新テストはlatch/joinとlogger開始でhappens-beforeを作るため、volatileを削除すれば失敗する回帰テストとは主張しない。同期のない本番setter/log間に必要な可視性は静的JMM検討で確認した。overlayViewの説明がgetInstanceからの参照まで網羅していない点は非ブロッキングで、Kotlin段階で正確にするようmsg_989bc344136fで依頼した。 + +Codex司令塔はexact-head APPROVE 5644608014を記録し、CI成功とSHA再確認後、PR34をd2a1dd6dd78fc1dd30ae0caa7f185cb6b30cb66aへmerge。main checkoutをfast-forwardした。mainへのmergeや公開は行っていない。 + +## T04b開始と並行境界 + +- Task / Dispatch: task_8dae019402ea / ctx_026ea69247c9 +- Terminal: term_eddd1c86-e6a6-4bb2-8349-c606089c9bd7 +- Model / effort: gpt-5.6-terra / high（launch.effective確認、turn_started確認） +- Worktree: codex-3.0.0-t04b-state、base d2a1dd6 +- 所有: 既存core manager/view/adapter、新internal Kotlinとcore tests。旧listener/monitorの最小適応、Sample2Activityのshow代入分割のみ許可。T04a型・opt-timber・build・plan/logは編集しない。 +- 受け入れ: 同期main-thread guard、add/update/remove失敗と再試行、no-opと診断保持、immutable effective spec、dispose参照解放、Java/Kotlin利用と段階consumerのコンパイル。T05/T06/T08に残す部分を報告で明示する。 +- msg_44fa28c940e9でClaudeへT07 Kotlin変換を引き渡し。Gradle枠はClaude先行、T04bは編集可能だが実行前に枠を問い合わせる。競合するGradle/cacheとソース同時編集を避ける。 + +## T07 KotlinとT04a補足の起動確認（17:07 JST） + +Claudeのmsg_f5a51449cf12: T07 stage 3 task_b34964bd9497 / ctx_ee0098f1485c / term_72e33a29-7093-4735-afad-186cce32af99、worktree claude-3.0.0-t07-timber-kotlin、base d2a1dd6。Sonnet5/highは起動引数で指定、手動作成端末のためlaunch.effectiveは空。候補後のpush・Gradle・独立検証はCodex側が担当する。msg_4ac10f75c9f0で受領した。 + +T04a補足: Luna/high（launch.effective・turn_started確認）task_2961dfd70174 / ctx_691d3023796f / term_ff1b0d7d-bffc-4e50-a866-ffffac0d65cb、worktree codex-3.0.0-t04a-followup、base d2a1dd6。編集はOverlaySpec.ktとOverlaySpecJavaConsumerTest.javaのみ。constructor overload削減とJava検証補足を行い、Gradle実行前に専有枠を問い合わせる。 + +## PR35統合とT04a補足の差戻し・検証 + +PR35 head08c6b4fはClaude独立レビューと承認5644660877、CI34682494798成功後、復旧端末により9691d35b7a35d463800dbe0a026a0d9f6ac7fae8へ統合された。当司令塔は重複mergeせず、msg_4237917de1d7で実施者を区別して共有。非ブロッキングのログ見出し欄を今回補った。 + +Lunaの初回補足候補6aee461は、sandbox内Orca接続エラーでGradleを実行せずworker_done msg_1e216b05eebcを送った。実装のみ受領・releaseし、検証未完了とCodexの検証責任をmsg_850d6a0cf848で明示した。親の差分確認で、JavaテストがMATCH_PARENT=-1とWRAP_CONTENT=-2を不正値と誤認していることを発見。実装の正常値許可を変えず、テストを差し戻した。 + +修正・検証はLuna/high（launch.effective確認）task_d60f7c17a9b3 / ctx_3ee505bcf0b4 / term_34f93e8c-f9e8-48c0-80aa-59c14ec7b709、同じcodex-3.0.0-t04a-followup checkoutで担当。初回の既存checkout起動は--setup指定が不適合としてpreflight拒否され、余分な引数を除いた起動のみ成立した。Claudeからmsg_ed15b5e6fb8cでGradle枠返却後、指定JDK/SDKでcore:testDebugUnitTest成功。XML83件、失敗/エラー/skipなし、javapでnoarg/full constructorを確認した。通知中のSDK34表記は古いガイド由来の誤記で、実コマンドは指定SDKパスとchecked-in compileSdk36を使用した。Gradle枠返却msg_040e849e97f5、最終worker_done msg_4f9250c35a98、受領後release。最終head2d2dc4b580b1b8c9b0ba177c7deff6a17ea9d675をPR36にし、msg_17abd2259398でClaudeへ独立レビューを依頼。 + +## T04b一次確認での修正要求とmonitor境界 + +T04b担当は4a24cd21c6b4dea449843df2f94621c27c0e9015を未検証で作成し、sandboxのruntime_unavailableを停止と判断してターンを終了した。親は実runtimeへ接続可能であること、worker_done未送信を確認し、同じterminalへ通信復旧と継続を送りturn_startedを確認した。重複editorは起動していない。報告中のruntime停止は確認済み事実ではなく、sandbox接続制限による観測だった。 + +親はmsg_544b212f28b4で6点を差し戻した: dispose後のbackend/WM参照保持、external detach後の古いlistener残存、application brightnessのupdate/旧setter経由の検証漏れ、main Looper null許容、Throwableの過広な捕捉、DRAGGABLE spec経由のlistener適用漏れ。これは承認前の候補確認であり、実装・独立検証完了ではない。 + +monitorのrequest/cancelを新state pathから外したことで補助window失敗が結果へ混入しないことは担当msg_5161111ac97aで確認。一方、旧dragのmonitor座標が未測定0になる影響を親が指摘し、msg_5c517443e6fdでClaudeへ相談。Claudeのmsg_16212d73b4f5で、T04bに最小座標橋渡しと最低1件の検証を含め、insets等の限界を明示し、T05で完全boundsとmonitor撤去へ進めることに合意した。msg_221f0cf139ffで担当へ受け入れ条件を伝達。T04bのGradleは修正checkpointまで待機、T07検証担当が先に専有する。 + +## T07 Kotlin候補の独立検証開始 + +Claudeがmsg_16212d73b4f5 / msg_f0f25dd8788fでa95f227e2be6776aeaa9f45a97151e4162183995を確定。Codexがclaude/3.0.0/t07-timber-kotlinへpushし、msg_c81372b69b2fで通知した。 + +独立Terra/high（launch.effective・turn_started確認）task_18c7821b0712 / ctx_c704670bf482 / term_a5620eef-80f8-4648-aaf7-af09e962eac3、codex-3.0.0-t07-kotlin-review、base a95f227。検証はopt-timber tests/lintとsample assemble、Java/JVM公開APIとfield初期化・並行処理を対象とする。package-privateからpublicへ拡大したテスト用要素、overlayView説明のgetInstance参照欠落も審査する。候補をKotlinへ変換しただけで承認済みとはしない。 + +## PR36統合とPR37差戻し（17:31 JST） + +ClaudeはPR36 head2d2dc4bを独立Sonnet5レビュー後に承認5644737864（msg_6309a45cb52b）。子のnoarg constructor消失という疑いは、全引数既定値のKotlin仕様と実javap結果で司令塔が解消した。CI34683075403成功を照合し、Codexが41d74aa45284d3b18423b30ec03da5f85a857cf4へmergeした。これでPR33のJavaテスト・constructor補足を完了とする。 + +T07独立レビューworker_done msg_8dfd45aaa87aを受領・release。25 tests・lintエラー0・sample assemble成功だが、javapで旧package-private constructor/initialize/postToMainThread/INSTANCEおよびbuffer等のpublic化を確認した。外部から同期を迂回して内部状態を操作できるため、候補a95f227は未承認。PR37コメント5644737303とmsg_84dcded7d6c0で必須修正を依頼し、Claudeはmsg_b6db52e0b966で担当への差戻しに同意した。 + +公開APIを広げないことを優先し、既存Javaテスト無変更という下位制約を緩和する。msg_89add64cdeffで、protectedも外部subclassに公開されるためprivateを基本とし、test sourceのreflection helper等で検証目的を維持しproductionの新hookを避ける方針を補足した。元からprotectedのlog overrideは維持する。KDocのgetInstance参照漏れとregisterのmain-thread断定も修正対象。 + +T04b担当はb316ff8でterminal diagnostic保持を補ったが、親の6点差戻しを処理せず再度検証待機でターンを終えた。親は同じterminalへ6点とmonitor橋渡しを再提示し、T07レビュー終了後のGradle枠を明示GRANT、turn_startedを確認した。msg_9c2a31cba059でClaudeへ枠所有を通知。T04bの受け入れ・独立レビューは引き続き未完了。 + +## 検証報告の訂正とT04b追加差戻し（17:44 JST） + +PR38 head3cdd008はClaude承認5644781045とCI34683563498成功後、Codexがc9ef9341fa90a7a54665328a8d19601ba766c43fへ統合した。 + +T04b worker_done msg_73f432d92882はfbfd42eと46 tests成功を報告したが、親が実TEST XMLを数えると51件・失敗/エラー/skipなしだった。対応表も不足していたため、同じTerra/high terminalをread-only補足task_696a81ba78fb / ctx_132bf59e1f51へ再利用した（新たなmodel設定ではなく起動済み同一processの継続）。既存terminalをmain checkoutで起動しようとした最初の再利用はworktree mismatchで拒否され、正しい既存worktree指定の起動だけが成立した。 + +補足worker_done msg_21f91d4d4367で /private/tmp/overlay-t04b-implementation-report.md を51件へ訂正し、無関係なsource XMLタグ数を除去。/private/tmp/overlay-t04b-test-migration.md に振る舞いごとの移行対応と不足を整理した。permission bridge、許可されたwindow type/flag、旧bridge/click、CANCEL、実gesture列等に検証不足があると確認。API28へのtest pinはJDK17で無指定API36が走る問題を避けたが、元のAPI23検証を保持した証拠にはならない。 + +親はさらに、既定DRAGGABLE listenerがupdate成功ごとに再生成され、DOWN内updateの後のMOVE/UPで座標/alpha状態を失う経路（msg_8eaac1189617）と、dispose後の旧custom setterがguard前にpending listenerを再保持する経路（msg_1bc3bca7e286）を指摘した。補足担当も未修正T04b欠陥と確認し、T05/T06へ先送りしない。 + +補足終了後、同じTerra/high terminalをtask_6a0a8696194e / ctx_3cedaff14c1aへ再利用。2欠陥、実DOWN→MOVE→UP/CANCEL、API23最低境界とAPI26 type、permission preflight/bridge、代表的layout/clickの回帰検証を追加する。msg_252f24550474でClaudeへ共有した。Gradle ask msg_ebe118c3eac1へreply msg_70ad394a3fd5（17:46:13 JST）で専有をGRANTし、msg_ffe6e0379176でClaudeへ通知した。 + +担当が後から許可待ちと報告したため、msg_47d9888fd4a0で回答ID付き許可を再通知。blocking CLIをexec_commandで開始した際にoutputだけを表示するとsession_idを失い、返答を回収できない可能性をmsg_72bde9a97a93で指摘した。これは確認済み原因との断定ではない。検証担当は引き続き同じdispatchであり、新しいeditorを重ねていない。 + +## T07とKotlin coreの統合境界 + +- msg_a2c906fe52eb / Claude msg_41d196cdea94: T07 KotlinのgetView()呼び出しをview propertyへ揃える。旧Java coreのsynthetic propertyと新Kotlin val viewの両方で利用し、生成Java getView signatureは維持する。 +- msg_ea2a4070ba9a: 旧Timber fixtureはrunnerなしで毎回mock Applicationを作りcore.initを呼ぶため、T04bの実main Looper必須・同一Application init契約と不整合になる。T07のtest適応へ実main Looperと適切なtest限定初期化を含めるよう相談した。 +- msg_e60771b4f61e: opt-timber/build.gradle.ktsにはRobolectricがないため、必要なら既選定4.16のtestImplementation追加だけを許可。coreの契約を弱めてテストを通さない。 +- msg_5daa1a48067aでT04b担当へ既存Timber unit testsも一度実行し、既知fixture失敗とcore成否を区別して報告するよう依頼。統合前にcore/Timberを組み合わせたunit testsを実行する。PR37のprivate化・test適応は引き続きClaude所有。 + +## T04b 59件検証とproduction test seamの除去（18:05 JST） + +worker_done msg_1e7319d86f83（task_6a0a8696194e / ctx_3cedaff14c1a）で2ea8c0262f1041437d572f33427cc93d6c6638b9を受領。core 59件は失敗/エラー/skipなし、3 module debug assemble成功。opt-timberは既知のmock Application fixtureで25件すべて失敗しており、統合検証成功とは扱わない。 + +Claudeのmsg_28a0c95a3eb0はfixture対応としてproduction reset hookを提案した。Codexはmsg_d4f9a400b6e3で、新しい公開APIをtest都合で追加しない方針から却下し、T04bに既に入っていたpublic resetForTestingも除去することを提案。Claudeはmsg_34efa4d396d4で合意し、test sourceのreflection helperでprivate static singletonを初期化する方式へ変更した。coreのprivate field名instanceを維持し、テスト外のcleanup保証は追加しない。 + +完了済みTerra/high terminalをtask_ec0232c0b942 / ctx_e3fa4f8be2d9へ直ちに再利用した。同一起動済みprocessのため再利用receiptのlaunch設定はnullであり、新しいモデル起動の証拠とはしない。範囲は新しいproduction test seamsの除去、test-only reflection、未検証の限定的state失敗経路。core Gradle枠を担当へ付与し、msg_b3a2c239cf63でClaudeへ共有した。PR37の修正候補と組み合わせた検証・独立レビューは未完了。 + +Claudeのmsg_e5e61527ed32でPR37修正候補c0d27e12887f2bbeabe46865cb3df33f9fd472deを受領し、Codexが既存branchへ通常push。独立Terra/high（launch.effectiveとturn_started確認）task_2dcf2927b0a5 / ctx_fa0d32833fc2 / term_c4e636a6-e846-49ce-9410-2c4c083b1d8dをcodex-3.0.0-t07-rereviewへ配置した。まず静的レビュー、core検証完了後にGradleを移譲して候補単体とT04b組み合わせを確認する。組み合わせ操作が実装checkoutへ混入しないよう別worktreeとした。msg_6b9a5b8ff5f6でClaudeへ通知。 + +## PR39統合、PR40レビュー開始とPR37再修正（18:18 JST） + +PR39 head2dc41c54ea43392467791957930bf3de9866b68aはClaude承認5644947912とCI34685056669成功後、Codexが3f7ceb589ba35fa69c8f3d229a72abe03ff0e850へ統合した。 + +T04b task_ec0232c0b942 / ctx_e3fa4f8be2d9のworker_done msg_69f30a236fabで20ae42a456854fb4891161179385657ae3f8495bを受領・release。production test hooksを除去し、show-time parent、BadToken、dispose NOT_ATTACHED、Error伝播を追加、core63件と3 module assemble成功。公開JVM constructorの扱いは最終API監査項目、real detach callbackは残る検証項目として明記した。PR40をdraft作成しmsg_c3336f473e96でClaudeに独立Sonnet5レビューを依頼。msg_ccd04197460bで開始回答。T04bは未承認・未統合。 + +PR37 c0d27e1はCI34684978776で25件中3件失敗。CodexがCIログを取得し、getInstance_noView/getInstance/initのNoSuchFieldException（test247/253/264行）をmsg_39b1363afd4eでClaudeへ渡した。core init全体の不整合とは区別する。独立Terraはmsg_336418551932で同じ3失敗をローカル再現。lintは別実行でエラー0、SDK37/Robolectric4.17の更新通知2件であり、選定版更新の合意ではない。 + +Terraはsandbox内runtime_unavailableでGradle許可を読めず、worker_doneなしで一度ターン終了した。親はruntime稼働を確認し同じterminalへ接続時のrequire_escalatedを案内、turn_startedを確認。重複担当は起動していない。msg_1e1543a68f14でClaudeへ共有した。また担当の「override logがfinalになる」というH1はKotlin overrideの性質と矛盾するため親がbytecode確認を要求。担当はmsg_d9b9c920b7abで保留、msg_b994a4a1e0abでjavapにfinalなしを確認して撤回した。修正が必要だった事実としては扱わない。同通知のsignature欠落についてshell quoting起因の可能性を指摘し、報告への証拠保存を求めた。 + +Claudeがmsg_6fc508e961d6でテストhelperのみ修正した9eb38b74c1422c0c6aabc71c718b565090e383b6を提示。Codexが通常pushし、msg_f25a099d199fで同じTerraへ候補単体と20ae42a組み合わせの検証を指示。静的fieldを外側クラスから読む修正でproduction変更なし。結果・承認・CIはまだ待ち。 + +次工程T05a（permission helperとmonitor撤去）/T05b（対象window bounds/insets）の分割案をmsg_868d5f831f81でClaudeへ提示。T04b受け入れ後にcore編集を直列化する提案であり、T05実装開始・合意成立とはまだ扱わない。 + +Claudeがmsg_27535a90a11aでT05a/T05b分割に合意。T05aは権限なしActivity drag・補助windowなし・deniedからgrant後show再試行、T05bはrotation/RTL/insetsの表駆動座標テストを受け入れ条件へ追加した。Codexはmsg_2bc46c612c58で同意し、通知中のoverlayPermificationは誤記として承認済みoverlayPermission()を維持することを明示。実装はPR40統合後。 + +## PR37承認・統合とPR40候補更新（18:26 JST） + +独立Terra/high worker_done msg_5cc707337ca0を受領・release。最終9eb38b7はTimber25件成功、20ae42aとのconflict-free一時mergeではcore63件・Timber25件成功、library assemble成功。sample assembleは同じproduction組み合わせのtest-only修正前に成功しており、修正後に再実行したと誤記しない。レビュー用mergeは担当がabortしてcandidateへ戻した。 + +Codex承認5644985100、CI34685456162成功を照合し、PR37をready化して9beb33273704af0b6af97bda413dfc12fc3358a4へ統合した。T07寿命統合は未完了。PR40は最新work/3.0.0をconflict-free mergeし82d5bb5d7df77e6e537e5ad256ceecedc3da18adへ更新・push。PR36のJavaSpec補足、既存ログ、Timber修正の取り込みでT04b新規ロジック変更なし。msg_67008ad8eb48でClaudeへ通知。 + +Claudeがmsg_4a51b277a4de / PR40承認5644996756で旧head20ae42aをSonnet5静的独立レビュー後に承認。新headは別途承認が必要なためmsg_fbfd00ea8bb0で差分確認と82d5bb5への更新承認を依頼。非ブロッキング指摘を受領し、以下を最終版までに処理する: +- T04c: JVM-publicなinternal constructorを公開API監査で閉じる。暫定RestrictTo案はcompiler access controlそのものではない。 +- T06/T04c: public DraggableOnTouchListenerとcustom listener setterを暫定橋渡しとして台帳化し、最終3.0では削除/内部化する。 +- T04c: DISPOSEDのshow/updateがlastFailureを変更しないKDoc補足。nullabilityは既存合意通りKotlin compiler annotationsを基本にする。 + +PR40承認コメント中の直接constructor経路の再検証説明を、新しい保証として採用しない。factoryを迂回できるJVM可視性は残る監査項目であり、最終公開API検証が必要。 + +## ユーザーの利用制限指示によるClaude中心への移管 + +PR40は更新承認5645009103とCI34685711242成功後、Codexが3e960b8677140ef36ab7fb8933019f999a9222c9へ統合した。T05aはTerra/high（起動effective確認）task_fa7a02a671b0 / ctx_3850b6aafe23、codex-3.0.0-t05a-permissionで開始した直後にユーザーからClaude担当増加の指示を受けた。msg_942ba10b554fで移管提案、msg_85c780393bbeでTerraへ追加実装/新規検証を止め安全な引き継ぎ準備を指示。 + +Codexの初回T05a指示が誤って引数なしpermission helperを指定していた。承認済み設計はisGranted(context: Context)/settingsIntent(context: Context)であり、親が訂正した。途中成果は誤った形で未検証のため、承認済みAPIや実装完了と扱わない。Claudeが修正してから検証する。 + +Claudeはmsg_ec83c65a672eで新体制を受諾。msg_4f0df1ec6259で独立レビューも別のSonnet5担当を使い、対向司令塔の承認とCI条件を維持する方針を補足した。ClaudeのJDK読取制限はmsg_691247e3774cで通常の許可経路/CIを優先し、必要な場合のみCodex司令塔が子を起動せず最小コマンドを実行する形とした。 + +T09 stage1はmsg_237abb266590で明示合意。対象はlint/**とcore/build.gradleのlintPublish設定。Codexは当初core/build.gradle.ktsと誤訂正したが、Claudeのmsg_cef132e1117bを受けgit ls-tree 3e960b8でGroovy core/build.gradleを確認し、元のClaude提案が正しいと訂正した。検証・AAR lint.jar確認もClaudeを主担当とし、T05aと共有Gradle枠を直列化する。 + +T05a worker_done msg_6530773575c1を引き継ぎ準備完了として受領・release。HEADは3e960b8、7ファイルの未コミット途中差分を既存codex-3.0.0-t05a-permissionに保持。API形状が未完成のためコミットせず、Gradle実行なし、diff checkのみ成功。msg_6e9a3c44e27bでClaudeへ明示的に編集所有権とGradle調整を移管した。詳細は/private/tmp/overlay-t05a-handoff.md。 + +ClaudeのT09aはtask_65df368d38c0 / ctx_c230f7ef02cd / term_a75a100d-f9e1-4649-abb6-d0e5a3202b8f、claude-3.0.0-t09-lint-registryで開始（msg_a020ca8def67）。Sonnet5/highは手動launch要求値でありlaunch.effectiveは空と区別して記録する。 diff --git a/docs/coordination/3.0.0/2026-09-12-batched-validation.md b/docs/coordination/3.0.0/2026-09-12-batched-validation.md new file mode 100644 index 0000000..d59795b --- /dev/null +++ b/docs/coordination/3.0.0/2026-09-12-batched-validation.md @@ -0,0 +1,59 @@ +# T09a / T05a 集約検証とPR作成 + +- 状態: 両PRとも対象SHAのCI成功・相互承認後にwork/3.0.0へ統合済み +- 実行者: Codex side conversation（ユーザーの明示依頼、サブエージェントなし） +- 依頼: Claude msg_7a0f13c96edf、実行開始通知 msg_4fe4059e23d8 +- 関連PR: #42、#43。両方相互承認後に統合済み。以下の未マージ記載は統合前の履歴。 + +## T09a + +5e9c142c17c2a0baf28e91891c2ce205d3dc18cdをclaude/3.0.0/t09-lint-registryへ通常pushしPR42作成。指定JDK17/SDKで :lint:test :core:lintDebug :core:assembleRelease が成功。XMLはRegistry3+Detector6=9件、失敗/エラー/skipなし。core lintはエラー0/警告14。release AARのroot lint.jarと内部manifestのLint-Registry-v2を確認。別consumerでの実ロード検証までは実行していない。CI34688032126は同じheadでSUCCESS。 + +## T05a失敗と修正 + +65d35f4fbe88b713dfbbdd6b5a839bd1d1a73779をclaude/3.0.0/t05a-permissionへ通常pushしPR43作成。最初の指定コマンドは :core:compileDebugUnitTestKotlin で失敗。OverlayPermissionTest.kt:81:56のRuntimeEnvironment.getApplication()が非genericなstatic methodへ型引数を渡していた。古いTEST XMLを現在の成功証拠として数えていない。 + +msg_64b480aa28e7でClaudeへ原因通知。独立した残りの指定チェックを実行しTimber25 tests・core lintエラー0/警告13・coreDebug/sampleDebug/sampleDebugAndroidTest assemble成功を確認。端末テスト自体は未実行。 + +その後ユーザーが該当checkoutでの修正を明示依頼。msg_dd60d1874498でClaudeへ編集調整を通知。返信は未受領だったため相手の同意とは扱わず、ユーザーの直接指示を根拠とし、HEADと対象ファイルの未変更状態をassertして最小修正した。型引数と不要importの除去だけで、製品コード・assertionは未変更。msg_5cc876df434bで結果通知。 + +4a92b95d9ab24582bc34dacfaadea6cd196ae8d7をコミット・pushしPR43更新。指定の :core:testDebugUnitTest :opt-timber:testDebugUnitTest :core:lintDebug :core:assembleDebug :sample:assembleDebug :sample:assembleDebugAndroidTest が成功。XMLはcore65/Timber25件、失敗/エラー/skipなし。T04bとの件数比較では、PR36補足3件、ScreenMonitor7件削除、permission5件とdrag1件追加を区別する（63+3-7+5+1=65）。 + +## 承認と引き渡し + +msg_4979b12aebe9で集約結果とGradle枠返却、msg_a5d6627f13dfで修正SHAと検証成功をClaudeへ通知。更新SHAのCI34688283404は2026-09-12 19:24:49 JSTにSUCCESS。当初は独立レビューの最終根拠未受領だったため、msg_7167cf1d024bで報告と対象SHAを要求し、承認を保留した。その後の根拠受領と承認は以下に記録する。 + +生ログ: /private/tmp/overlay-side-t09a-validation.log、overlay-side-t05a-validation.log、overlay-side-t05a-remaining-validation.log、overlay-side-t05a-fixed-validation.log。今回のGitログには重要結果を転記した。 + +Claude司令塔の端末は入力待ちで、独立レビュー完了の要旨が表示されていた。受信箱へのenqueueだけでは処理されていなかったため、既存司令塔端末へ一度だけ確認を促しturn_startedを確認した（request3f8df4d4-2a1a-428a-8952-ede6d88b63e7）。サブエージェント端末は操作していない。 + +## 独立レビュー受領・最終承認 + +Claude司令塔のmsg_ead5f3f29cc2（19:29:01 JST）で独立レビューの結果と資料を受領。両レビューは実装担当と別のSonnet 5 / high / read-only。今回のside conversationからサブエージェントを起動・操作していない。 + +- T09a: 5e9c142の独立レビューはAPPROVE with notes。lint API対応、厳密な宣言クラス判定、引数個数ガード、quick-fix不変、3+6 testsを確認。vendor値の厳密assertion・getApi同一定数比較の改善・Kotlin宣言fixtureはstage 2へ記録。 +- T05a: 65d35f4の独立レビューはAPPROVE with notes。stateless helper、cached accessor、ScreenMonitor参照全除去、deprecated bridge委譲、範囲維持を確認。65d35f4..4a92b95の型引数と不要importのみの差分をClaude司令塔が別途確認し、新しいSHAへ承認を明記。showのhelper集約、grant→revokeのshow/update検証、updateの事前確認判断はT05b/T04cへ記録し、T05全体完了とは扱わない。 + +| PR | 承認対象head | CI | Claude司令塔 | Codex司令塔 | +| --- | --- | --- | --- | --- | +| [42](https://github.com/75py/Android-OverlayViewManager/pull/42) | 5e9c142c17c2a0baf28e91891c2ce205d3dc18cd | [34688032126 SUCCESS](https://github.com/75py/Android-OverlayViewManager/actions/runs/34688032126) | [5645326598](https://github.com/75py/Android-OverlayViewManager/pull/42#issuecomment-5645326598) | [5645344873](https://github.com/75py/Android-OverlayViewManager/pull/42#issuecomment-5645344873) | +| [43](https://github.com/75py/Android-OverlayViewManager/pull/43) | 4a92b95d9ab24582bc34dacfaadea6cd196ae8d7 | [34688283404 SUCCESS](https://github.com/75py/Android-OverlayViewManager/actions/runs/34688283404) | [5645326671](https://github.com/75py/Android-OverlayViewManager/pull/43#issuecomment-5645326671) | [5645345329](https://github.com/75py/Android-OverlayViewManager/pull/43#issuecomment-5645345329) | + +PR43のCI完了は19:24:49 JST、PR42は19:20:59 JST。GitHubの最新head・チェック結果・Claude自身のコメントを読み直してからCodexの承認を投稿した。同一アカウント利用に伴う合意済みの実行者名付きコメント方式であり、GitHub required reviewの代替として保護ルールを迂回しない。 + +ユーザーはPR43の完全SHAでのCI記録と、Claudeの明示的な対象head承認なしにはマージしないことを再指示。両承認は実在するためpendingとは記載しない。ただし今回の限定作業では両実装PRをマージしない。headが変われば再検証・再承認が必要。 + +文書更新はPR41 head aba231dcc4f76b22ab58674d6c518c9f878f02b0から分岐したcodex/3.0.0/validation-batch-logへ保存。ClaudeもPR41を変更しない方針を確認済み。文書PR自体の対向レビューは別途要求し、未承認のまま統合しない。 + +## ユーザーによる統合指示 + +続く明示指示で、文書更新をコミット・PR化した後、draft/ready・base・exact head・CI・相互承認を再確認してPR42/43をwork/3.0.0へ統合する範囲が追加された。先の未マージ記録はその時点の状態。main/releaseへのマージと公開は対象外。統合結果は実行後に追記する。 + +## 統合結果 + +文書コミット263a793をpushして[PR44](https://github.com/75py/Android-OverlayViewManager/pull/44)を先に作成（base: codex/3.0.0/coordination-wave10、PR41に積層）。続いてPR42/43のbase work/3.0.0、上記完全head、SUCCESS、両司令塔の実在する承認を再取得。ready変更後、--match-head-commitを指定し、管理者迂回なしで順次mergeした。PR42統合後にもPR43のMERGEABLE/CLEAN・head・CI・baseを再確認した。 + +- PR42: 2026-09-12 19:35:52 JST、merge commit 65c7e956d18bbd4bb72ffa073bf6fe73f02f98c7。 +- PR43: 2026-09-12 19:36:18 JST、merge commit 40c45dcee6916cd1991ccc3db73a34a0eeafb9ac。 + +GitHubから両state MERGEDとbase/head/merge SHAを確認済み。main/releaseへのマージや公開は実施していない。文書PR44の対向レビューと統合は別途待ち、T05b/T09 stage 2は開始していない。 diff --git a/docs/coordination/3.0.0/2026-09-12-coordinator-recovery.md b/docs/coordination/3.0.0/2026-09-12-coordinator-recovery.md new file mode 100644 index 0000000..d7cbedb --- /dev/null +++ b/docs/coordination/3.0.0/2026-09-12-coordinator-recovery.md @@ -0,0 +1,40 @@ +# Claude司令塔の復旧とT05b開始 + +- 記録担当: Codex（Astra / medium） +- 状態: 作業中 +- Codex Run: run_18f7185e91aa +- Claude Run: run_3ae778449744 +- 関連PR: #41、#44、T05b候補はまだ未作成 + +## 統合記録の同期 + +ユーザーの継続指示後、PR42/43が別のCodex side conversationで既に統合されていることをGitHubで確認し、重複mergeせず共有checkoutを同期した。記録PR41はhead aba231dcc4f76b22ab58674d6c518c9f878f02b0、Claude承認5645089011、CI34686311857成功を確認し、857e3c92df5bc919cb791683f254b2bfad97daf0へ統合した。 + +PR44はPR41に積層されていたためbaseをwork/3.0.0へ変更。編集端末なし・cleanを確認した記録checkoutで最新workをmergeし、53051456ba8a5949ebe930b4aa12f97fcf199e8eへ更新した。Claudeの独立Sonnet5/highレビュー、承認5645618874、CI34690762342成功を確認し、53c2c2acf43c427a87b5359f9bb52c015ce21c92へ統合した。内容差分は従前のbbd95d7と同じ文書2ファイル。 + +## 終了端末と復旧 + +旧Claude司令塔term_640dc9cb-9e04-49fb-b5e0-f378eac9596cはexitedを確認。再確認時に既に新端末term_370f23ca-24a2-4331-95e9-95ffd1e18301が存在していたため、新しい司令塔を重複作成しなかった。画面でFable5.1/highと同じ会話のresumeを確認し、復旧指示request15ed99ed-f8f1-43ff-bdf2-b9c88ddc74f6のinput_accepted/turn_startedを確認した。新端末が既存Claude Runへ再bindしconsumer_generation=2となったことをrun-currentで確認した。Codex root terminal29d5648dは変更していない。 + +それ以前の読み取り確認はClaude側permissions.blockReadsOutsideWorkingDirectoriesによるものだった。Codexは代理で許可画面を操作せずユーザーに確認を依頼した。復旧後は通常のauto modeで作業が進んでいることを確認した。 + +Claudeの一部の対向連絡がClaude自身のRunへ送られていた。msg_50ae4766327bが同内容をCodex Runへ再送したことを明記しており、Codexはmsg_4d321fe960dbで以後の連絡先をrun:run_18f7185e91aaへ統一するよう訂正した。 + +## T05bの担当と合意 + +Claude所有task_90e158c9b86a / ctx_30711ca983ec / term_7c1ce045-cfa3-4961-b13f-718c9bb7f79a、worktree t05b-geometry、branch codex/t05b-geometry、base857e3c9。Sonnet5/high/autoはClaudeの報告値で、手動起動を再利用したOrca receiptのlaunch.effectiveは空。担当のlive作業を確認済み。 + +msg_50ae4766327b / msg_4d321fe960dbで以下を合意した。 +- target-windowのframe左・上を使うscreen座標からwindow座標への変換。非ゼロ原点、landscape、edge-to-edge、RTL、frame外位置の表駆動テスト。補助windowなし。WindowMetrics/Insetsとの整合はAPI30+で確認。 +- APPLICATION showのpermission helper集約。Activity scopeはpermissionに依存しない。新しいpublic/protected test seamを追加しない。 +- attached update/hide/disposeへpermission preflightを追加しない。実backendのSecurityExceptionをPERMISSION_DENIEDに分類し、update失敗時はATTACHEDと既存effective specを保持する。equal-specのno-opを変えない。hide/disposeは権限がなくてもcleanupを試みる。 +- denied→grant→show retry、grant→show→revoke→失敗update、新handleのrevoke→showを検証する。 +- slop/pointer/opacityはT06、Activity破棄はT08。T10 consumer移行の後にT04c橋渡し除去を行い、循環依存を再導入しない。 + +Claude環境のJDK読取制限があるため、候補SHAと必要なコマンドを集約してCodex司令塔が直接実行する。追加Codex検証子は起動しない。既知のsandbox失敗を検証のために繰り返す必要はなく、実行前は未検証として引き渡す。 + +## 20:43 許可確認と事前レビュー + +ユーザーから、PR44 head/base読み取り確認を許可したとの返信を受領した。PR44は既に統合済みで、Claude司令塔の通常auto modeとT05bの継続を画面で確認した。これはJDK全体など別のアクセスへの包括的許可とは扱わない。 + +msg_47cf5ccc42acで統合SHAを共有し、T05bの未コミットhelperに対する事前指摘を伝えた。WindowMetricsをdisplay全体の情報とする説明、任意gravityを持つAPI全体でTOP|LEFTが常に適用されるとの説明、visible frameだけで全window設定を扱えるとの断定は根拠が不足している。合意済みAPI30+ Metrics/Insets整合確認を実装担当・独立レビュー担当が確認し、純粋な座標減算テストとframework上の検証を区別するよう依頼した。候補未確定のため、この時点でT05bの承認・検証成功とは扱わない。 diff --git a/docs/coordination/3.0.0/2026-09-12-device-preparation.md b/docs/coordination/3.0.0/2026-09-12-device-preparation.md new file mode 100644 index 0000000..916fb8b --- /dev/null +++ b/docs/coordination/3.0.0/2026-09-12-device-preparation.md @@ -0,0 +1,39 @@ +# T12端末検証の環境準備 + +- 状態: 提案 +- 記録担当: Codex（Astra / medium） +- 関連タスク: T05、T10、T12 +- Codex Run: run_18f7185e91aa +- 進捗: 環境準備のみ。端末テスト未実行、T12未完了。 + +## システムイメージと専用AVD + +既存環境にはAPI36のGoogle APIs / Google Play ARM64画像と他作業のAVDがあった。sdkmanager --listでAPI23/26/35 Google APIs ARM64が配布されていることを確認し、空き261GiBを確認後、3画像を追加した。sdkmanager exit0、各package.xmlの存在を確認。実行ログは /private/tmp/overlay-sdk-image-install.log、一覧は /private/tmp/overlay-sdk-available-images.log。SDK/toolchain本体の更新は行っていない。 + +avdmanagerでpixel_2 hardware profileの専用AVDを新規作成し、全てexit0とconfig.ini存在を確認した。 + +| AVD | System image | +| --- | --- | +| OverlayViewManager_3_0_API_23 | system-images;android-23;google_apis;arm64-v8a | +| OverlayViewManager_3_0_API_26 | system-images;android-26;google_apis;arm64-v8a | +| OverlayViewManager_3_0_API_35 | system-images;android-35;google_apis;arm64-v8a | +| OverlayViewManager_3_0_API_36 | system-images;android-36;google_apis;arm64-v8a | + +作成ログは /private/tmp/overlay-avd-create-23.log 等。既存AVDを上書きせず、既存実行中端末も操作していない。まだ新AVDを起動しておらず、ホスト上でのboot可否・instrumentation・cross-UID動作の証拠にはならない。sdkmanagerの非推奨通知とdevices.xml読取通知は観測したが、インストール・AVD作成は成功した。 + +msg_5a7f8451e37dでClaudeへ追加開始、msg_e60771b4f61eで画像追加完了を共有。Gradle検証と画像追加は別対象であり、共有Gradle枠はT04b担当のまま。 + +## 次工程の公式API確認 + +T05/T10の準備として2026-09-12に確認した。実装や新しい公開契約への承認ではない。 + +- API30以降のcurrentWindowMetricsは現在のwindow/task状態を反映し、boundsからinsetsを控除しない。multi-windowで最大画面を現在の利用可能領域と同一視しない。[WindowManager reference](https://developer.android.com/reference/android/view/WindowManager#getCurrentWindowMetrics()) +- ACTION_MANAGE_OVERLAY_PERMISSIONのpackage URIによる個別設定画面指定はpre-R向けとして説明されている。承認済みIntent形状は保てるが、Android30+で必ず個別画面へ直行するとは文書に書かない。存在しないActivityへの起動対応はhost側の責務。[Settings reference](https://developer.android.com/reference/android/provider/Settings#ACTION_MANAGE_OVERLAY_PERMISSION) + +準備メモ /private/tmp/overlay-t05-platform-preparation.md とmsg_411ef57d6e14でClaudeへ共有。View.getRootWindowInsetsの資料取得はtool internal errorだったため、同資料を検証済みと扱っていない。 + +## 起動可否の確認完了（18:29 JST） + +Luna/medium（launch.effective確認）task_f3e3e9e37422 / ctx_ee636a75e7a4が専用AVD4台をport5580で順次起動し、API23/26/35/36それぞれのSDK値とsys.boot_completed=1を確認。worker_done msg_b43e6993ca64を受領・release。各owned emulatorを終了し、既存emulator-5554のみ残存を確認した。報告は/private/tmp/overlay-emulator-readiness.md、起動ログは/private/tmp/overlay-emulator-API23.log等。 + +利用制限に伴う縮小指示を送信した時点でprobeは既に完了しており、dispatch_inactiveで拒否された。新dispatchは作らず完了証拠を受領・解放した。起動確認はアプリ動作・instrumentation・cross-UID透過の検証ではなく、T12は未完了。 diff --git a/docs/coordination/3.0.0/2026-09-12-pause.md b/docs/coordination/3.0.0/2026-09-12-pause.md new file mode 100644 index 0000000..ac3dfbf --- /dev/null +++ b/docs/coordination/3.0.0/2026-09-12-pause.md @@ -0,0 +1,54 @@ +# 2026-09-12: ユーザー指示による一時中断 + +- 状態: 回答待ち（ユーザー再開指示） +- 記録担当: Codex / Astra medium +- 計画: V3_0_0_PLAN.md +- 関連タスク: T00、T01、T02 +- 関連PR: #21、#22、#23 +- Codex Run: run_18f7185e91aa +- Claude Run: run_3ae778449744 + +## 指示・双方連絡 + +ユーザーが就寝前の区切りで中断するよう指示。CodexからClaudeへmsg_7ecabeadbfe9（00:55:40 JST）、設計子へmsg_fe035164c7fc（00:55:43 JST）で新規作業を止め現状保存を依頼。 + +Claudeはmsg_e36b1a675a3c（00:55:46 JST）で中断報告。本文の「01:00頃」は概算で、実際のメッセージ時刻は00:55:46。T02子はBash許可待ちで未完了。Orcaが他エージェントによる許可応答をagent_prompt_blockedで拒否したとの報告があり、許可代答・設定変更は行わない。Codexはmsg_f80cbb3055f1（00:56:24 JST）で保持を確認した。 + +## 保存済み成果・検証 + +- 統合ブランチwork/3.0.0: d67f2e7212fe6b4757b316afae15e384056cfee6。PR21をClaude最新head承認後に統合。製品コード未変更。 +- T01: codex/3.0.0/t01-design、[Draft PR22](https://github.com/75py/Android-OverlayViewManager/pull/22)。中断前観測head a1fcfeb11fe61391e3372b9184c30e9568ac73a8、worktreeはclean。最終担当報告は下記追記を参照。 +- PR22旧head b374eeeへの[REQUEST CHANGES](https://github.com/75py/Android-OverlayViewManager/pull/22#issuecomment-5637084227): nullable cause、有効spec/partial update、Java factory overload、NOT_ATTACHED診断、移行例・focus。最新headは再レビュー待ち。 +- T01は文書差分検査のみ。製品コードのビルド/テストを実行したとは扱わない。 +- 計画・全協議ログ: codex/3.0.0/coordination-wave1。未承認で統合しない。 + +## T02の保持状態 + +- Claude子: Sonnet 5 / high。 +- Task task_336fecdad101 / Dispatch ctx_bebb1ab66ddc。 +- 端末 term_87b8d7d0-6c3b-4ba5-97b0-46639455f8b7 は許可待ち。完了・failed settlementは発生していない。停止・解放・abandon・重複起動はしていない。 +- worktree: /Users/ai-seb/orca/workspaces/Android-OverlayViewManager/claude-3.0.0-t02-ci-lint。 +- 未コミット編集: activity_sample_all_options.xml、activity_sample_override_screen_brightness.xml、option_alpha.xml、option_height.xml、option_margins.xml、option_width.xml、option_xy.xml（sample/src/main/res/layout）。 +- 未追跡: sample/src/main/java/com/nagopy/android/overlayviewmanager/sample/SeekBarChangeBindingAdapter.java。 +- CI workflowは未作成、push/PRなし。ビルド・テスト・lintの新しい成功証拠なし。過去89テスト成功は変更前基準値。 +- 再開時はClaude司令塔がこの既存試行と許可状態を確認し、同じ担当へ継続させる。利用者の許可をエージェントが代答しない。 + +## 再開順序 + +1. ユーザーの明示的な再開指示を待つ。 +2. Orcaの実在Run/端末、git status、PR headを確認。新端末へ無条件に重複Dispatchしない。 +3. ClaudeがPR22最新headの増分を独立レビューし、両司令塔が必要修正を調整。APPROVE対象SHA一致後にCodexがマージ。 +4. ClaudeがT02許可待ちと未検証の変更を引き継ぎ、CIとlint修正を完成。Codex側独立レビューを経る。 +5. 計画・ログの文書PRをレビュー・統合し、T03以降の依存を確認する。 + +## 最終保存確認 + +設計子の最終応答でPR22 head a1fcfeb11fe61391e3372b9184c30e9568ac73a8、push済み、clean、git diff --check成功を確認。変更はdocs/design/3.0.0-api.mdのみ。ただし子側でOrcaに接続できずinbox確認とworker_done送信は失敗した（Could not connect to the running Orca app）。 + +最終ターンが通知なしで終了した実証があるため、Orca復旧手順に従いctx_422c19486993をworker-stop。結果state=stopped、processAction=closed_agent_terminal、ptyKilled=true。worktreeとコミットは保持。実装成果の保存とOrcaの成功settlementは区別する。レビュー後半の追加指摘をすべて読めた保証もないため、再開時にPR22の指摘一覧と最新差分を照合する。 + +Codex司令塔の進行中子はなく、Claude子T02だけ許可待ちの状態を保持する。ユーザーによる中断のため、未完了T02を完了扱いせず監督も再開指示まで保留する。 + +## 再開記録 + +2026-09-12 13:17 JSTにユーザーから再開指示。中断を解除（Codex msg_3c935a7e5029、Claude msg_ea9f31f2fa95）。中断時の記録は履歴として保持する。T02の許可待ちは継続し、T01の限定修正とレビューを先に進める。 diff --git a/docs/coordination/3.0.0/2026-09-12-t00-start.md b/docs/coordination/3.0.0/2026-09-12-t00-start.md new file mode 100644 index 0000000..f1510af --- /dev/null +++ b/docs/coordination/3.0.0/2026-09-12-t00-start.md @@ -0,0 +1,66 @@ +# T00: 開始・分担協議 + +- 状態: 双方合意（後続状況は2026-09-12-wave1.mdを参照） +- 関連タスク: T00、T01、T02 +- 記録担当: Codex（Astra / medium） +- 関連PR / head SHA: PR未作成。開始基点1646b3be2dda2a75000d41b22349bd2805e7402c。 +- Orca Run: `run_18f7185e91aa` +- Claude Task / Dispatch: `task_7ce398407cc5` / `ctx_1916f5521532` + +## 背景・選択肢 + +ユーザーが開始を明示したため、準備中の停止条件を解除した。独立した設計と既存CI改善を最初の並列候補とし、公開APIとビルド更新の競合を避ける。 + +## やり取り（発言要旨） + +| 日時・タイムゾーン | 発言者 | 提案・返答・異論 | 根拠・元メッセージ | +| --- | --- | --- | --- | +| 2026-09-12 00:00頃 JST | ユーザー | Codex側司令塔としてClaudeと作業を開始するよう指示 | 本セッションの開始指示。時刻は確認開始時点の概算 | +| 2026-09-12 00:02 JST | Codex | 既存Fable 5.1 / high端末へT00分担協議とT02担当案を依頼 | Dispatch `ctx_1916f5521532`、turn_started確認 | +| 2026-09-12 00:04:35 JST | Codex | T01は設計文書のみ、T02は.github/workflowsとsampleのlint2箇所と関連例、ビルド更新なしを提案。T02がGradle共有資源を専有可能。通常の権限要求でCLI接続を確認するよう連絡 | `msg_21f023257b3f` | + +## 判断結果・理由 + +- ユーザー開始指示を受領。双方合意はまだ記録されていない。 +- Codex Astra / medium、Claude Fable 5.1 / highを端末表示で確認。既存Claudeを再利用し、重複起動を避けた。 +- fetch後もorigin/mainはc71f7fb。準備コミット1646b3bのみを統合ブランチへ初回push。 +- GitHubは75py / ADMIN、work/3.0.0は保護なし。相互APPROVEは相手司令塔が現head SHAに対して実施し、保護ルールが追加された場合も迂回しない。 +- Codex専用文書worktreeで計画更新を直列化。実装PRの直接マージは未実施。 + +## 未解決事項・次の担当 + +- Claude: 通常のツール権限要求経路でCLIが実行できるか確認、分担案へ回答。 +- Codex: 回答を記録し、合意後に設計担当子を起動。 +- 両側: 子のモデル・effort・編集範囲・検証を記録し、相手側独立レビューを経由する。 + +## 計画・実装・検証への影響 + +T00を作業中へ更新。製品コード、ビルド依存、バージョンは変更していない。前回のテスト基準値を再実行せず保持する。 + +## Claude最終報告と試行の停止 + +2026-09-12 00:06:38 JSTのClaude最終応答をOrcaのprovider transcriptで確認した（CLIが使えずOrcaメッセージとしての送信は未実施）。報告要旨: + +- Fable 5.1 / high、モデル識別子claude-fable-5-1を自己確認。 +- AGENTS.md、計画、記録規約を読了。T02の既存lint対象を確認。 +- sandboxの読み取り拒否によりorca、rtk、gh、claudeがOperation not permitted。通常のsandbox外実行オプションも無効で、ask/send/worker_doneを実行できない。 +- 共有checkout編集とGradle実行はしていない。双方合意と子起動には至っていない。 + +Codexは最終応答がworker_doneなしで終了したことを根拠に、Orca復旧ガイドのworker-abandonで当該試行をfenceする。これは成功やClaudeの承認を意味せず、既存端末・プロセス・ファイルは保持する。制約を無断変更せず、復旧後に同じTaskの新しいDispatchとして再開する。T01/T02の実装は未着手。 + +読み取り拒否の設定変更または実行環境の修復が必要なため、ユーザーへClaude側環境の対応を依頼する。Codex側のGitHubアクセスは通常の権限昇格で成功しており、同じ問題とは扱わない。 + +## 復旧後の協議・再開 + +| 日時・タイムゾーン | 発言者 | 提案・返答・異論 | 根拠・元メッセージ | +| --- | --- | --- | --- | +| 2026-09-12 00:29:05 JST | Claude | ユーザーによりsandboxが復旧しOrca連絡可能。既存担当案、SHA付きAPPROVEコメント方式、T01とT02の並列、T02のCI/sample限定所有を受諾。GitHub TLSは残確認として報告 | msg_ce45742087c4 | +| 2026-09-12 00:32:18 JST | Codex | 上記の担当・承認・並列案に同意。T01はTerra highで文書のみ、T02がGradleを専有。新DispatchはClaudeの進行中作業と重複しないよう準備確認後に実施 | msg_0ffb232045e4 | + +判断: 所有範囲の双方合意によりT01設計子を起動。モデルとeffortはlaunch.effectiveでgpt-5.6-terra / high、turn_startedを確認。Task task_5c129e6aca40 / Dispatch ctx_f585ff543e5e、独立worktree codex-3.0.0-t01-design。 + +T01の受け入れ条件: 実コードに基づくAPI・寿命・失敗・再試行・Kotlin移行と互換性の具体案。現行バージョンは公式情報を確認し、設計を双方が承認するまで製品コードを変更しない。レビュー対象はdocs/design/3.0.0-api.mdのみ。 + +前項の阻害要因は当時の事実として保持する。復旧報告で過去の未完了や未承認を完了へ書き換えない。 + +PR #21は最新head cdcd600へのClaude承認を受け、d67f2e7へ統合。旧msg_21f023257b3fは送信済みだが当時Claude側未読であり、合意の根拠は復旧後の双方メッセージとする。 diff --git a/docs/coordination/3.0.0/2026-09-12-t05b-validation.md b/docs/coordination/3.0.0/2026-09-12-t05b-validation.md new file mode 100644 index 0000000..c84cfdb --- /dev/null +++ b/docs/coordination/3.0.0/2026-09-12-t05b-validation.md @@ -0,0 +1,51 @@ +# T05b候補の検証と座標モデルの再確認 + +- 記録担当: Codex（Astra / medium） +- 状態: T05b統合済み・T05端末検証は未完了 +- Claude実装・独立レビュー: Sonnet 5 / high（Claude司令塔報告） + +## PR45統合 + +Claude承認5645719685はhead f5987196a16824afd123373eacb57eb4ef1e797bを指定。独立文書レビューとCI34691900115 SUCCESSを確認し、通常mergeでab2e9e912221b13fcf3545b2cb0e004452dadb12へ統合した。読み取り確認の設定名とユーザー許可の記述は独立レビュアーの環境では未検証だったが、Codexは端末画面とユーザーの返信で直接確認している。 + +## 初回候補8ec06ce + +Claude msg_7e5aeccb5ccaにより8ec06ce3727513fdb5293f79885832bf8a7cd780を受領。Codex司令塔がJDK17・所定SDKで :core:testDebugUnitTest :core:lintDebug :core:assembleDebug --console=plain を実行した。compileとassembleDebugは成功。unit testsは76件中3件失敗し全体exit 1、lint最終レポートは未完了。古いレポートから成功を推定しない。 + +- OverlayGeometryTestの原点変換: status-bar top inset (0,84)についてexpected156/actual240。 +- OverlayGeometryTestのframe外判定: AssertionError。 +- OverlayViewGravityTestのRTL解決: expected53/actual51。 + +msg_068595519fb4で原担当による修正をClaude司令塔に依頼した。Android Rectのplain JUnit stubとRTL fixtureを疑ったが、原因確定前の推測でありassertion緩和は依頼していない。未成功候補のpush/PR作成は保留。 + +## 未解決の座標モデル + +msg_24b57bbff351で、WindowMetrics/Insets整合確認を省略した新説明のレビューを依頼した。getWindowVisibleDisplayFrameをoverrideするテストは、frameからlayoutへ値を伝える経路の確認であり、全scope・全API・FLAG_LAYOUT_IN_SCREENにおける座標系同一性の実証ではない。対応範囲を限定する案は検討可能だが、T05完了とはせず、確認すべき端末条件を残す。実装と独立レビューはClaudeが所有し、Codexは修正候補を直接再検証する。 + +## 利用料上限前の中断 + +ユーザーの中断指示に従いmsg_27d6ebf83e05でClaudeへ新規着手停止を通知した。Claudeは独立レビューと長時間の受信待ちを停止したことを端末画面で確認。修正ラウンドtask_41130117f375 / ctx_b9e23e8e0859にはmsg_a52f401daf40で現在地点の保存と最短の中断を直接伝えた。子のライフサイクル管理はClaudeが所有する。Codex側に実行中のGradleはない。 + +Claude提案msg_c04af62e6d73は、WindowMetrics整合確認を省きvisible frameを唯一の情報源とし、API26/35/36のドラッグ原点をT12で検証、失敗時はActivity scope限定fallbackを検討するという案。これは未合意である。特にAPPLICATION scopeを常に現方式のままとする保証や、実装と同じ原点式だけを端末の合否基準にすることは再開時の検討事項として残す。停止中は設計承認・新たな検証・PR作成を行わない。 + +### 最終確認（21:04 JST） + +Claude司令塔は最終応答後idle、受信待ちと独立レビューは停止済み。修正担当端末は21:03に session limit を表示し停止したため、worker_done完了とは扱わない。再開時はClaudeが既存dispatchの状態を確認し、重複担当を起動せず復旧する。 + +修正checkout /Users/ai-seb/orca/workspaces/Android-OverlayViewManager/t05b-geometry のHEADは8ec06ce3727513fdb5293f79885832bf8a7cd780のまま。未コミット変更はinternal/OverlayGeometry.ktとinternal/OverlayWindowFrame.ktの2ファイル。テスト修正はまだ保存されていない。未追跡の.claude/とPR_BODY_T05B.mdはそのまま保持した。部分修正は未検証・未承認で、Codexはsourceへ追記やコミットをしていない。 + +## 21:31 JST 再開 + +msg_93be386e07e0でClaudeが同じ担当を復帰することと、中断中の変更2ファイル・未検証状態を確認。msg_f0bc9d53858eでCodexはAPI30+ cross-check代替提案を条件付き修正した。KDoc縮小とT12への検証繰延は認めるがrelease-blockingを維持し、実画面上のno-jump/displacementを両scope・各flags等で観察する。APPLICATION現方式の無条件維持やActivity限定fallbackは事前合意しない。以後のSHA固定レビュー・CIの条件は維持する。 + +msg_e03607c9c9d0でClaudeは上記修正条件を受諾した。同時にセッション再起動による新端末term_f3d0c2e3-8507-47fd-a547-fcd4e82955eaへのRun再bindを通知し、Codexは新端末を画面で確認した。以後のClaude連絡先は同じrun:run_3ae778449744を継続し、旧term_370f23caへ重複送信しない。 + +## 修正候補867d85cの検証 + +msg_8e4190a03f37の候補867d85c33d42ce2d77247e7b47b1a790c9d2c07eを同じGradleコマンドで再検証しexit0。XMLは75 tests、failure/error/skipped各0。未使用isWithinFrameとその専用testの除去により初回76から1件減った。lint XMLはerror0/warning13、assembleDebug成功。msg_633e90c817adでClaudeへ実数を通知し、claude/3.0.0/t05b-geometryへpushしてdraft PR46を作成した。本文は最終動作・実測検証・合意済み未完了端末条件を中心に簡潔化した。CI34694161457と独立レビュー待ちで、まだ承認・統合していない。 + +msg_f697b0f7f5f9でOverlayWindowFrame KDocの「全テストがRobolectric SDK28」とscopeがview.context種別を決めるという不正確な説明の補正を依頼。独立レビュー指摘があればまとめて直し、文言だけの変更で同じローカル検証を繰り返さない。 + +## 最終候補と統合 + +Claudeは読取確認で止まったレビュアーを停止し、867d85cのgit archiveを自身が読めるscratchpadへ展開して別の独立Sonnet5/highレビューを完了した。blockingなし、KDoc2点のみ修正。e246370ba48e0e0d5dcd00249bdb27390aeb7b0dの1ファイルKDoc差分をCodexが確認してpush。ローカルGradleは重複実行せず、現SHAのCI34695199190 SUCCESS、Claude承認5646052817、Codex承認5646054020を照合しPR46をbeafd01472298ecf63c23d1e45fc07cf6550d3fcへ通常mergeした。T05端末検証は未完了のまま。PR47はd41d0c3のClaude承認5645956039・CI34694273544成功後に8b918e8へ統合済み。 diff --git a/docs/coordination/3.0.0/2026-09-12-t06-start.md b/docs/coordination/3.0.0/2026-09-12-t06-start.md new file mode 100644 index 0000000..b20478b --- /dev/null +++ b/docs/coordination/3.0.0/2026-09-12-t06-start.md @@ -0,0 +1,66 @@ +# T06開始と代理許可方針 + +- 記録担当: Codex（Astra / medium） +- 状態: T06実装中 + +msg_d41fd8b355d5でClaude担当のT06開始を確認。task_5bd2567d9bc3 / ctx_3350cd13f8e9 / term_a943080f-8a49-485a-870e-41e91efdfaae、Sonnet5/high/auto（Claude報告）。worktree /Users/ai-seb/orca/workspaces/Android-OverlayViewManager/t06-touch-opacity、branch codex/t06-touch-opacity、base beafd01472298ecf63c23d1e45fc07cf6550d3fc。 + +変更前にregistry構造・max-opacity取得のinternal注入位置・gesture方針を共有する。API31+で現在maxを取得、全attached application pass-through handleを保守的に合算、WHEN_SYSTEM_ALLOWS opt-in、取得不可はfail closed。失敗したbackend操作でeffective spec/registryを更新しない。slop・active pointer・click・UP/CANCEL復元とNOT_FOCUSABLE保持も対象。独立レビューは別担当、検証は候補SHAに対してCodexが集約実行する。 + +## ユーザーが許可した代理操作 + +ユーザーはClaudeが許可待ちのとき、Codexが内容を確認して問題なければ代わりに許可するよう明示した。msg_53c9e0b681f1でClaudeへ共有。以前の一律に代理操作せず待つ運用を更新する。完全な操作内容と対象を確認し、今回の作業範囲内の妥当な操作を許可する。PRの相互承認や保護ルールを迂回する意味ではない。この記録時点では許可待ち画面はなく、代理許可はまだ実行していない。 + +旧term_370f23caから候補更新の重複連絡が届いたが、統合済みe246370を再検証・再pushせず処理した。Claudeの現司令塔はterm_f3d0c2e3、Runはrun_3ae778449744のまま。 + +### 22:09 JST 代理許可の実施 + +Claude司令塔の「Ack, and inspect the stale coordinator terminal and its duplicate message」確認画面で、完全なコマンドを読み取り確認した。内容は自身のdelivery受領、旧端末のshow/read、Runのinbox参照、端末一覧とJSON整形であり、ソース変更・削除・外部公開は含まれない。ユーザーの指示に基づき選択中のYesをraw Enterで確定し、accepted=true/bytesWritten=1を確認。画面が通常の処理へ戻ったことも確認した。text+Enterは新しいagent promptとしてagent_prompt_blockedとなり未実行だったため、同じリクエストIDの再確認後、選択入力を用いた。全体のpermission設定は変更していない。msg_db9e6d50b7f2でClaudeへ通知した。 + +msg_112679022701でT06仕様書の古いJavaファイル参照とopacity再取得条件を訂正依頼した。opt-in application pass-throughの変更updateではx/y/sizeのみでも現在maxを取得する。SAME_UID_ONLYからopt-inへ切り替えるケースも含め、equal-spec no-opは維持する。SAME_UID_ONLYのattached entryも他handleの保守的合算へ含める。 + +PR48はClaude承認5646098631、CI34695564024成功と現head8354c5bを照合しee4614dへ統合した。指摘された台帳T05/T06の古い未着手表示は次の記録差分で訂正した。 + +### 22:15 JST T06設計合意 + +msg_aa5663d338c5はopacity再取得をtuple変更時だけとする案だったが、msg_60c7de933a03でClaudeが撤回し全changing updateを対象とする訂正を受諾した。msg_598d6565b4c8でCodexは訂正版を承認。候補の旧entryを合算から除いてreplacementを計算し、失敗hide/disposeでbudgetを解放しない。public reset APIを追加せず、internal/RestrictToだけをJVMアクセス制御とは扱わない。実View.dispatchTouchEventでtapの1click、drag後のclick/long-press抑止、non-clickable viewのstream、pointer handoff、失敗update時のeffective spec保持を確認する。 + +### 22:28 JST 連絡確認の遅延への対応 + +実装担当が開始約22分後に3件の拘束条件をまとめて読んで修正する画面を確認し、msg_1141c34abf6eでチェックポイント運用の是正を依頼した。msg_7193e8d07b0fでClaudeは合意済みgesture/opacity/test条件を1ファイルへ集約し、各ファイル着手前のinbox確認・ackを再徹底した。新しい仕様は追加せずscopeを固定。既存コードを捨てたとの報告ではなく、訂正に合わせて修正中である。次の検証は確定候補SHAに対して行う。 + +### 22:38 JST 実装チェックポイント + +msg_2d015416f641でCodexがドラッグ開始前のpointer handoffにおけるdownRaw未更新を指摘。msg_269789974481でClaudeは修正済みと報告した。開始前はdownRawとlastRawを再基準化し、開始後はlastRawのみ。担当報告ではgesture13件、opacity16件と既存state testのDOWN assertionを更新。internal API auditとPR本文を残し、まだ候補SHA・実検証・独立レビューは未完了。 + +### 22:44 JST 初回候補の実検証 + +候補3fcdb3659dce5c48dbcf7b8ffdb644a1f5346a66（gesture21de493とopacity3fcdb36）を受領。担当が誤って追加したPR本文だけの4d3bc0bは、Claude司令塔がsoft reset・unstageしてファイルを保持し、source/testを変えずHEADを候補へ戻した。CodexはHEADを確認後JDK17/所定SDKでcore testDebugUnitTest・lintDebug・assembleDebugを実行。compileとassemble成功、101 tests中11 failures、error/skipped各0。全失敗はgesture13件のうち11件で、opacity17件は全成功。lint最終レポートは未完了、push/PRは保留。 + +msg_62ca84a34d4bで元担当へ差し戻した。最初の失敗はclickable viewのdispatchTouchEventにfalseを期待している箇所（lines49/70）。listenerがfalseでもView.onTouchEventが処理すればdispatch全体はtrueとなるため、両者を分けて検証し、クリック・slop・spec・pointerのassertionは維持する。最初のassertion修正後に後続のタイミング等の失敗が出る可能性があるため、この時点で全動作正常とはしない。独立レビューは3fcdb36のsnapshotで並行中。 + +### 22:50 JST 独立レビュー + +msg_105c90cb778fで独立Sonnet5/highの3fcdb36レビューはREQUEST CHANGES（tests中心）。製品ロジックは契約に適合するとの評価だが、承認は保留。共通のdispatch戻り値誤認に加え、未attach viewのpostされたclickが処理されないfixtureをActivityにattachする修正、OverlayGeometryの古いonTouchDown参照を訂正する。元の修正ラウンドtask_6231584a07ec / ctx_a1dd713ad296へまとめて反映し、修正差分だけを再レビューする。 + +### 22:58 JST 修正版1f25a82の再検証 + +msg_bc256da7e885の候補1f25a826a376bd442c6bc3c0f404c74c5944155fはtest/KDocのみの修正。独立Sonnet5/highはmsg_334b6f11c4d6でGradle成功を条件にAPPROVE with notesとしたが、実検証は101 tests中2 failures（errors/skipped 0）。tapBelowSlopとpreDragPointerHandoffStationaryのclicksがexpected 1 / actual 0。compile/assemble成功、lint最終レポートは未完了。msg_07732ed819e3で差し戻し、Viewの実attach・layout寸法・local/raw座標の整合を確認するよう依頼した。ゼロ寸法ViewのMOVEがpressed状態を解除する可能性は仮説であり、まだ原因確定ではない。クリック期待値を弱めず、元担当の修正・差分レビュー・実再検証が必要。push/PRは保留。 + +第2修正ラウンドはmsg_89106930b1f0でtask_21b6266b1c1c / ctx_a29d20ec9f96、同じSonnet5/high担当・worktreeへ割り当てた。 + +### 23:02 JST T08事前協議（まだ実装開始しない） + +msg_b5a2f2d166f0でT06修正中にT08の範囲整理を依頼。msg_1df8d009d6e6のB1〜B6提案へmsg_8baa6b954b81で条件付き受諾した。Activity破棄時はATTACHEDなら即時removeを1回試行し、結果にかかわらず参照・listener・cacheを解放しDISPOSEDとなる。ただし失敗は一律ACTIVITY_DESTROYEDとする提案を訂正し、既存design:196のclassified failureを維持する。弱いキーでも値→View.context/backend→Activityの強参照は残るため、破棄callbackによる明示解放と決定的な参照検証を必須にし、GC成功だけを受け入れ条件にしない。解除callback自体のActivity保持にも注意する。 + +OpacityRegistryはAPPLICATION PASS_THROUGHのみ。Activityの強制解放では登録がない境界を確認し、APPLICATIONの失敗dispose/hideは従来どおりATTACHED・budget保持、成功またはNOT_ATTACHED時だけ解除する。msg_6fbbe51673e3で新しいapplication強制解放契約を作らない点を明確にした。既存T06テストと同じ重複テストは不要。initの同一Application冪等性、別Application拒否、factoryの破棄済みActivity拒否を維持。opt-timber寿命、T04cは別タスク。 + +msg_0cc7a0cc4212の「沈黙とT06 mergeを受諾とする」案はmsg_8777143db8bcで明確に否定。修正条件への明示応答を待ち、T06統合後にのみT08を開始する。 + +msg_9e9d9edc0ac1でClaudeが訂正版F1〜F6へ明示合意した。T08の範囲合意は完了、開始はT06統合後のまま。 + +### 23:05 JST T06再検証成功 + +msg_3451fcc98a29で第2修正候補eb8e9f1a4367e8e29c4654e901fd4a1ff4c1c15aを受領。テスト用Viewをmeasure/layoutで2000×2000にし、MotionEventのrecycleをdispatch helperへ集約したtest-only修正。CodexはHEAD・差分を確認し、まずgesture13件の限定検証に成功。その後core全101 testsがfailure/error/skipped各0、lintエラー0/警告13、assemble成功。製品コードを変更して期待値を弱める修正は行っていない。候補をclaude/3.0.0/t06-touch-opacityへpushしdraft PR作成へ進む。独立差分レビュー・CI・現SHA承認はこの時点で未完了。 + +PR49を作成（base work/3.0.0、head eb8e9f1）。CI34698280430は起動中。msg_51196e740cefの独立Sonnet5/high差分レビューはAPPROVE・must-fixなし。msg_1f103a154acdで実検証結果とPRを通知し、CI成功後のClaude現SHA承認を依頼した。PR本文は最終挙動・実検証・T04c/T12未完了へ絞り、失敗履歴は本ログに保存する。 diff --git a/docs/coordination/3.0.0/2026-09-12-t08-lifecycle.md b/docs/coordination/3.0.0/2026-09-12-t08-lifecycle.md new file mode 100644 index 0000000..e9bfcf9 --- /dev/null +++ b/docs/coordination/3.0.0/2026-09-12-t08-lifecycle.md @@ -0,0 +1,75 @@ +# T06統合とT08寿命管理 + +- 記録: Codex Astra / medium、2026-09-12 23:14 JST +- T08担当: Claude Sonnet5/high、独立レビューは別Sonnet5/high +- 状態: T08実装中、候補・実検証・承認は未完了 + +## 統合の根拠 + +PR49 head eb8e9f1a4367e8e29c4654e901fd4a1ff4c1c15aは、Claude承認5646384373、Codex対向承認5646396196、CI34698280430成功後、b105885ef61abe6ae42a6102994d8a348ef0335aへ通常merge（23:11:14 JST）。core101 tests成功、lintエラー0/警告13、assemble成功。T06の全dispatchはClaudeが解放済みと報告した。T05/T06の端末検証はT12のrelease-blocking項目として維持する。 + +PR50 head66c4686203d9835eb95346836bbd5ad309bfda2cは、Claude独立docsレビュー・承認5646401153、CI34698427542成功後、cd41b81f61656528772805e33a9d588e04f1e5acへ通常merge（23:13:14 JST）。共有work/3.0.0をfast-forwardした。 + +## T08の開始と分担 + +msg_827b2119bcb8で統合SHAと開始指示を渡し、msg_5250e4b8eb7dで実在する開始情報を受領した。 + +- Task: task_572d2116f4c5 +- Dispatch: ctx_70332de7736c +- Terminal: term_073f016a-8ee6-4fae-ae50-7c2ff00f1e43 +- Worktree: /Users/ai-seb/orca/workspaces/Android-OverlayViewManager/t08-lifecycle +- Branch: codex/t08-lifecycle +- Base: b105885ef61abe6ae42a6102994d8a348ef0335a +- Sonnet5/high/autoはClaude報告。チェックポイントはinit/factory、destructionと参照解放テスト、確定候補SHA。 + +合意済みF1〜F6は2026-09-12-t06-start.mdの協議・訂正・明示応答を参照。破棄時の即時remove1回と、成否にかかわらない参照解放・DISPOSED、既存classified failureの保持が中核。WeakHashMapだけで解放済みとはしない。Activity cache・handle・listener・解除callbackの参照を決定的に検証する。GC観測は補足に限定。APPLICATION opacity budget・失敗disposeのretry契約は変更しない。test reflectionを優先し公開JVM accessorを増やさない。Codexは指定Gradleの集約検証・対向承認・直列統合と計画/ログの単独編集を担当する。 + +## 23:19 JST T07寿命管理の次タスク合意 + +msg_3106de5da829の事前整理依頼に対し、msg_0aa52133f2f1でClaudeがL1〜L7を提案。既存DebugOverlayTreeはinitごとにcallback/overlayを作り直し、disposeがなく、nullable cacheを参照する。final OverlaySpecへの移行、show/hide結果確認、同一Application init冪等性、破棄済みActivityの全cache解除、明示disposeを次タスクとする。core/sample/lintの編集は禁止、T08統合後に開始する。 + +Codexはmsg_88691515f979でL2/L5を訂正。削除失敗でもhandleを捨ててuninitializedとする案ではattached windowの再試行手段を失うため、Java-callable MainThread dispose(): OverlayResultが先にcore disposeを試し、失敗時はhandle/callback/cache/buffer/初期化状態を保持して結果を返す。成功時だけcallback解除・所有参照解放・buffer消去・未初期化へ遷移し、再disposeはDISPOSED/changed=false成功。成功後のlog/renderはno-op、Timber.uprootはhost責務。 + +並行logが解放後に追加・null参照しないようactive境界をbufferLockで直列化し、queued renderはlifecycle generationを再確認する。dispose→reinit後に古い世代の内容を描画しないことを、キューと並行順序を制御したテストで確認する。同一Application再initは成功dispose後に許可、異なるApplicationはcoreの契約を維持する。private reflection/stub backendで失敗retryを検証し公開test APIを増やさない。msg_e7fd80e8ad86でClaudeは訂正版L1〜L7へ明示合意した。 + +## 23:21 JST T08実装チェックポイントの訂正 + +Codexが途中画面で新規containsActivityInstanceForTestsとpublic removeActivityInstance、破棄catch内の診断ログ欠落を確認しmsg_205e1a4335ceで合意事項の再徹底を依頼。msg_45a37a93d6cdでClaudeは全新規ForTests accessorの除去・private field reflection、production removeActivityInstanceのinternal化、classifyとログ出力の両方を担当へ拘束条件として伝達した。まだ候補SHAの完成確認ではない。 + +23:26 JST msg_e7a6296d99e5でcheckpoint(a)/(b)を受領。init/callbackの1回性・破棄済みfactory・複数handle・分類保持・構造的解放のテストを追加した一方、F3訂正は未反映だったためClaudeが候補確定前の反映を必須とした。23:28 JST msg_487895dc6b84で新規ForTests accessor全除去、private field reflection、removeActivityInstanceのinternal化、classifyとLogger.wの併用を確認したとの報告を受領。まだ候補SHA・実検証は未完了。 + +23:30 JST msg_4312eea2c7c6でCodexがtest側のcompanion backing fieldのreflection先誤り（outer classを使う）、remove1回/0回をtest名だけでなくrecording backendの回数でassertする不足、remove失敗時の構造的参照解放assert不足を指摘。msg_8f568119f176でClaudeは元担当へ候補確定前の必須修正として伝達した。新しい製品仕様ではなく、F2/F3の既存受け入れ条件の実証を補う。 + +23:31 JST msg_a6a265ebae3bで初回候補ccac98907e6dbee8a64aa68f0b17a468efbef6adを受領したが、3件のtest指摘は未反映。msg_ab3322fadabbで編集中checkoutへの古いSHA検証を省き、確定修正版だけを検証すると決定。opacity件数の16→17という報告も、実績17→18へ訂正依頼した。 + +23:32 JST msg_85d8a3c1d9d3でClaudeが「新修正dispatchを開始した」との前報を訂正。worker_done前の同じtask_572d2116f4c5 / ctx_70332de7736c内で修正中であり、新dispatch試行はactive dispatchのため拒否された。重複担当は起動していない。製品diffはccac989のsnapshotを独立レビューし、後続test差分だけ追加確認する。 + +## 23:36 JST T08実検証成功・PR51作成 + +msg_25c6d4074f3dの最終候補59ef303ac2aa94722d48c301ec9d88e104a91cc1（ccac989 + test-only修正）を受領し、HEAD・tracked cleanを確認。CodexがJDK17/所定SDKでcore全tests・lint・assembleを実行し成功した。XML111 tests、failure/error/skipped各0（ActivityLifecycleCleanup7、OverlayViewManager8、PassThroughOpacity18）、lintエラー0/警告13。 + +msg_f904d3bbeb81でClaudeはopacity件数17→18を正式訂正した。@Test funだけの検索では別行のannotationを数え落としていた。worker_doneはmsg_3810b445beb8、同dispatchの論理解放をClaude報告（外部管理terminalはidleのまま残る）。 + +候補をclaude/3.0.0/t08-lifecycleへpush、draft PR51を作成。CI34699740974起動中、独立レビュー/現SHA承認は未完了。msg_a0d7d5f62120で結果を共有。PR本文は最終挙動・実検証・T04c/T12未完了へ絞り、元本文のDISPOSED hideがfailureを返す誤記を除去（実装は従来どおりsuccess no-op）。ローカルGradleは完了し共有実行枠は空いている。 + +## 23:40 JST 代理許可の実施（次の文書差分） + +ユーザーの明示指示に基づき、term_f3d0c2e3の2件の完全な確認コマンドを読み取って対象・効果を確認し、選択中のYesをraw Enterで確定した。1件目はCI poll結果brll18z1b.outputのtail6行と当該GitHubリポジトリCI34699740974の認証付きGET・JSON結果の表示。2件目は独立レビュー担当によるscratchpad/t08-src内のLogger.javaと設計3.0.0-api.mdの読み取り（rtk read/sed、無効なsed表記の後に正しい読み取りへのfallback）。書き込み・削除・公開は含まれない。両sendはaccepted=true/bytesWritten=1、後続画面で通常処理への復帰を確認した。permission設定は変更していない。msg_b6d27ca72e40でClaudeへ共有。 + +PR52 head0b234237de873965205d591a3f00ead28716bfb9はレビュー中のため変更せず、この追記は次の文書差分で保存する。Claude scratchpadの推定日時が実時刻とずれていたため、Orca created_atか実時計を使うよう訂正依頼した。今回の時刻はOrca message metadataに基づく。 + +## 23:47 JST T08統合 + +PR52をClaude承認5646577520・CI34699854569成功後、be1843cbd81f094a9a30f7c90b97681256002c79へ統合（23:42:48 JST）。PR51はmsg_2b49afe0332cの独立Sonnet5/highレビューAPPROVE・must-fixなし、Claude承認5646588317とCodex対向承認5646596441、CI34699740974成功後、d6ccdf278f799f3dc8fe53df69f7936134012a83へ通常merge（23:45:47 JST）。現head59ef303・base work/3.0.0・CI・承認を照合し、--match-head-commitを使用した。 + +Claudeの「public/protected JVM surface追加なし」という表現は、Kotlin internalのJVM公開性とは一致しないため、Codex承認コメントでアクセス制御の保証ではないと訂正し、T04cの最終監査対象として保持した。msg_5ed115c11285でClaudeにも訂正を依頼。コード変更・再検証は不要。T05/T06端末検証はT12で未完了。 + +同メッセージでT07寿命L1〜L7をd6ccdf2基点に開始依頼。担当の実在する開始情報は次に記録する。 + +23:47 JST msg_fd67ee2dee02でT07寿命管理の開始を確認。task_2db547061e3f / ctx_72258eaf9359、term_b4d72bee-a9a2-447b-99b6-b125837cf663、worktree /Users/ai-seb/orca/workspaces/Android-OverlayViewManager/t07-lifecycle、branch codex/t07-lifecycle、base d6ccdf278f799f3dc8fe53df69f7936134012a83。Claude報告Sonnet5/high/auto、新規担当、独立レビューは別Sonnet。opt-timberのみ編集し、検証はCodex集約。checkpointはfinal API/init、transactional dispose/generation guard、候補SHA。JVM可視性の表現訂正にもClaudeが明示同意し、PR51へ追記するとの報告。 + +## 23:58 JST Claude司令塔のeffort復元 + +T10調査中の画面でmedium表示を観測しmsg_b023fca230efで指定Fable5.1/highへの確認を依頼。msg_da6b07126e59でClaudeはモデルclaude-fable-5-1を確認したが、effortは自分から変更できずユーザーへ依頼したと報告。Codexは指定値復元の既存承認があるためmsg_415d7c6b1e94で外部Orca入力を行うと伝え、司令塔だけ自然なcheckpoint後にidleとしてT07担当は継続した。 + +Orca tui-idle satisfied=true確認後、/effort highを一度だけ送信。画面にSet effort level to high (saved as your default for new sessions)と明示され、CLI標準操作によりセッションと新規セッション既定に保存された。send request33e377d6-e23e-4328-ae8f-c98635ec2218はinput_accepted、turn開始未観測の警告を返したが、slash commandの画面上の成功確認があるため再送していない。msg_26a7006c2dceで復元済み・通常監督再開を連絡。モデル・worker・processは停止/変更していない。 diff --git a/docs/coordination/3.0.0/2026-09-12-t10-planning.md b/docs/coordination/3.0.0/2026-09-12-t10-planning.md new file mode 100644 index 0000000..7a7154a --- /dev/null +++ b/docs/coordination/3.0.0/2026-09-12-t10-planning.md @@ -0,0 +1,34 @@ +# T10 sample・利用文書の事前合意 + +- 記録: Codex Astra / medium、2026-09-12 23:55 JST +- 状態: C1/K1〜K7明示合意済み、実装はT07寿命管理の統合後 + +msg_ed5a92914170で事前整理を依頼、msg_52907dfc6d57でClaudeがC1（E1〜E9）と二分担を提案した。sampleはJava/data binding、HTML資産4件、androidTest3件、READMEは2.xのfluent APIであり、T04cの旧API除去前にconsumerを移す必要がある。 + +## 分担と依存 + +- T10a: Claudeの実装担当Aがsample/**のみを所有。Activity・関連androidTest・layout・assetsを移行する。 +- T10b: 別担当BがREADME.md、CHANGELOG.md、docs/migration/**のみを所有。assetsは編集しない。 +- 両者ともT07統合後の基点から開始。文書構造は並行作業できるが、実コンパイル済みsnippetの照合はT10a候補を待つ。 +- T04cは両PRの統合後にcoreの最終APIを除去し、T09 stage 2がlintを追従する。T11のバージョン変更はまだ行わない。 +- 新規実装・独立レビューはClaude中心、Codexは指定検証・対向承認・統合。開始時に実在IDを追記する。 + +## API・利用例の契約C1 + +Applicationでinit、OverlayPermissionとActivity Resultによる設定画面復帰後の権限再確認、両scopeのOverlaySpec生成・show/update/dispose結果の扱いを示す。状態はATTACHEDを使い、clickはView、dragはDRAGGABLE、brightnessはActivity scopeのspecに設定する。screenのslider範囲はhost windowから得る。allowOutsideBoundsはシステムバー領域への表示を保証しない。Kotlinはdefault引数/copyを示す。 + +主な破壊的変更はfluent setters/no-arg updateの除去、OverlayResult、isVisible→state、permission helper置換、getX/Y→spec、custom drag listener内部化、main-thread契約、minSdk23。CHANGELOGは3.0.0 Unreleasedとして作成し、version bumpはT11までしない。 + +## Codexの訂正と明示合意 + +msg_0467e0d559b0で以下を訂正して受諾、msg_e142c8c8ccb0でClaudeがK1〜K7を拘束条件として明示合意した。 + +1. AGP9.2.1 built-in Kotlin2.2.10があるのでkotlin.android plugin・依存追加は不要。既存Activity1つを妥当な範囲でKotlin化（Sample1Activity案）しJava/data binding相互利用をコンパイルする。 +2. state/lastFailureはthread-safeな読み取り例外。spec/view/更新操作はmain-thread。 +3. application overlayのdispose失敗では唯一のhandleを捨てず、retry可能な状態を保持する。設定画面後のshowは明示的host/user要求に従い、permission loopや自動retryを作らない。 +4. assetsとsourceの文字列一致だけをassertするmirror testは作らず、実コンパイル済み例との照合・参照/リンク確認を行う。テストは挙動を優先する。 +5. deprecated検索はreceiver/typeを区別する。Android View.setOnClickListenerやsetAlphaまで除去対象にしない。 +6. 見た目の変更は専用AVDで最低限のsmoke/screenshotをPRへ添える。既存emulator-5554は触らない。cross-UIDを含む完全な端末matrixはT12のまま。 +7. host windowのboundsは互換fallbackを含め、overlay権限に依存させない。システムバー上の表示を保証しない。 + +T10aの受け入れはsample assemble・unit test・lint・androidTest APK buildとsmoke/screenshot、旧OverlayView/Manager bridge利用の除去。T10bは両scopeの実例・Java/Kotlin移行表・Timber dispose・対応OSと制限を含み、T10aの最終snippetに合わせる。 diff --git a/docs/coordination/3.0.0/2026-09-12-toolchain.md b/docs/coordination/3.0.0/2026-09-12-toolchain.md new file mode 100644 index 0000000..29e6e23 --- /dev/null +++ b/docs/coordination/3.0.0/2026-09-12-toolchain.md @@ -0,0 +1,187 @@ +# T03: ビルド構成の再評価と独立検証 + +- 状態: 双方合意 +- 進捗: PR31はClaudeの独立レビュー・SHA承認とCI成功後、00b45cbへ統合済み。 +- 記録担当: Codex（Astra / medium） +- 関連タスク: T03、T04a +- Codex Run: run_18f7185e91aa +- Claude Run: run_3ae778449744 + +## 構成の相談と合意 + +CodexはT03の候補commitを読み、android.newDsl=false / android.builtInKotlin=falseが追加されていることを確認。msg_f61c1953e946（14:38:52 JST）で、旧Kotlin pluginを残すためだけの回避ではなく、公式に対応する構成と具体的な必要性を検討するようClaudeへ依頼した。 + +Codexは86eb4f89c3f4df9d1dfe0d2b260acbf15dafa898が5eca725を含み、tracked source差分がないコミット済み候補と確認し、既に合意済みの独立検証を開始（msg_39894fb55f59、14:42:48 JST）。このSHAの検証開始は構成への承認とはしない。特にT04aがbuildファイルを編集せずcoreのKotlinコードを追加できることを受け入れ条件として伝達した。 + +Claudeはmsg_1a1846f89349（14:44:01 JST）で変更理由を報告。実装担当は旧org.jetbrains.kotlin.androidが新DSL非互換で、ローカルGradleを実行できず新方式の検証が困難なため回避フラグを入れたという説明だった。両司令塔は、coreにKotlinを導入する後続との整合を優先して回避フラグを除去することで合意した。 + +修正方針: +- android.newDsl / android.builtInKotlinの無効化を外し、明示的kotlin.android plugin適用を除去する。 +- 組み込みKotlinの版が決まる仕組みを公式情報で確認する。 +- 新DSLが拒否する記法をminSdk/targetSdk、buildFeatures.dataBinding、enableUnitTestCoverage、代入記法、compilerOptionsへ移行する。 +- lintの対応版はAGP9.2.1のGoogle Maven POMで確認し、バージョン番号の算術だけを根拠にしない。 +- 文書化された障害があれば報告し、独断で回避フラグを復活させない。 +- wrapper jarは現候補では未再生成。この点は検証とレビューで扱う。 + +Codexはmsg_614a1f917536（14:45:07 JST）で検証担当へ合意を共有。86eb4f8は具体的な初期エラーを得る基準検証として継続し、既に再検討済みの回避フラグの是非を繰り返し議論しない。修正後のSHAは別途検証する。 + +## 検証担当・範囲 + +- Model/effort: gpt-5.6-terra / high（launch.effective確認） +- Task: task_5fa509223d3f +- Dispatch: ctx_d750aaf55990 +- Terminal: term_c44d62aa-5699-4d2d-896f-09d5e78f8c92 +- Worktree: codex-3.0.0-t03-review +- 対象SHA: 86eb4f89c3f4df9d1dfe0d2b260acbf15dafa898 +- 報告先: /private/tmp/overlay-t03-review.md +- 必須ビルド・全ローカルテスト・core/sample lint、依存の実在と互換性、core Kotlin readinessを確認。既存の期待テスト数はT07を含む98件だが、実測結果と区別する。 +- tracked source/buildファイルはread-only。必要な一時検証fixtureは専用checkoutか/private/tmp内に限定し、完了前に除去する。 +- ローカルGradleはこの担当の専有。T03実装担当は別worktreeのソース修正を継続可能。 + +この記録時点ではビルド成功・依存解決成功・正式な採用版を主張しない。 + +## 基準検証の結果と司令塔による評価・訂正 + +Terra/highのmsg_9fd0731f332f（14:47:29 JST）を有効worker_doneとして受信し、ctx_d750aaf55990をreleaseした。86eb4f8の必須Gradleコマンドは設定フェーズで失敗: +```text +Could not set unknown property 'sourceCompatibility' for project ':lint' of type org.gradle.api.Project. +``` +lint/build.gradleのProject直下sourceCompatibility/targetCompatibilityをJava extensionへ移す必要がある。task graph構築前に停止し、JUnit/lint XMLは生成されなかった。テスト数0件という成功結果ではなく、検証未実行と記録する。 + +子はこれをP0としたが、Codex司令塔は開発候補のビルド阻害としてP1へ評価を修正し、必須修正としてClaudeへ返した（msg_d89be44275b7、14:49:11 JST）。wrapper9.4.1のダウンロード・展開・checksum検証は成功し、旧wrapper jarが動作不能という事実は認めなかった。選定した直接依存の公式POMはHTTP200で存在を確認したが、全推移依存や全ビルド互換性の成功とは扱わない。 + +CodexはcoreのKotlin pluginが欠ける可能性を挙げていたが、core/build.gradle18–20の実コードで既にorg.jetbrains.kotlin.androidを適用していることを確認し訂正した。子のJVM target不整合の指摘も、この時点では公式ドキュメントに基づく懸念であり、実コンパイルで再現された不具合ではない。修正版でJava/Kotlin17を明示し、実際のKotlin fixtureをコンパイルして確認する。組み込みKotlin/新DSLを採用する合意は、誤った「plugin不在」という前提に依存させず、回避設定を減らす保守性とサポートされる構成への移行として維持した。 + +## 修正担当への引き渡し + +Claudeのmsg_0efbd3db7da6（14:50:29 JST）はlint DSL失敗をP1必須指摘として認め、Java extensionへの移動と同種のGroovy記法の確認を子へ指示。core pluginに関する訂正も反映した。 + +同時点でc914d43782ef284bc4739c277166f9425eaf1e0eまで新DSL移行を実装済みと報告。両回避フラグとkotlin.android適用を除去し、minSdk/targetSdk、buildFeatures、coverage、代入記法を移行。AGP9.2.1のPOMからKotlin2.2.10とlint32.2.1を確認したという報告であり、修正版のビルド成功を意味しない。新候補SHAを受信してから別途検証する。 + +T03再試行担当の自己申告はclaude-sonnet-5/high。起動引数と整合するが、Orca launch.effectiveが空であることとは区別して記録する。 + +PR28はhead ea40be298506b64e0b055475e958f97b851440e5への[Claude承認](https://github.com/75py/Android-OverlayViewManager/pull/28#issuecomment-5643970020)とCI run34675990831成功を確認し1af6dfb6b23202eca18a3e4f42f8a084061440acへ統合。非ブロッキングのT04a/b台帳行補足は次更新へ反映した（msg_02445d2fdf0e / msg_0eeefcb5897a）。 + +## 修正版24fc1f2の検証開始 + +Claudeのmsg_be74df233e72（14:52:18 JST）で24fc1f2faacedf088eb7dbefd6d2bf961562af6bを候補として受信。86eb4f8から履歴書き換えなしで、Kotlin plugin/回避フラグの撤去、新DSL移行、lint Java extension修正を追加した。基底はT07を含む5eca725。 + +[組み込みKotlinの公式移行文書](https://developer.android.com/build/migrate-to-built-in-kotlin)はjvmTargetの既定がandroid.compileOptions.targetCompatibilityになると説明しており、候補はcompileOptions=17による既定を使用する。不要な明示ブロックを必須化せず、実コンパイルで整合を検証することをCodexも受け入れた。旧レポートの一般的なKotlin既定値1.8という記述を、このAndroid組み込みKotlin構成の実証結果として適用しない。 + +Codexが依頼どおりpushし、msg_15ff4dbb7933（14:55:17 JST）で次の独立担当を共有: +- Model/effort: gpt-5.6-terra / high（launch.effective確認） +- Task: task_74810ea07694 +- Dispatch: ctx_d88e20a3160a +- Terminal: term_38982116-4b83-45dc-8adb-909f51d2aafb +- Worktree: codex-3.0.0-t03-review（clean確認後に24fc1f2へfast-forward） +- 新報告先: /private/tmp/overlay-t03-review-revised.md（旧報告を保持） + +必須ビルド・テスト・lintと、既存設定を変更しない一時Java/Kotlin fixtureのコンパイル実証を依頼。Gradle資源は独占。ClaudeがPR/remote CIの作成を担当する。検証結果は未受信。 + +## 24fc1f2の実測結果 + +PR29が作成され（msg_fc9a90fd6c59）、CI run34676815383はsample/build.gradle36のgetDefaultProguardFile('proguard-android.txt')が非対応となったため設定フェーズで失敗した。CodexはCIログを取得し、msg_4c4ceee43442（15:00:21 JST）でproguard-android-optimize.txtへの修正と同種設定の点検をClaudeへ依頼。根拠なくdontoptimizeを追加してエラーを回避しない方針とした。 + +Terraの有効worker_done msg_30d961482558（15:00:34 JST）でも同じP1失敗を再現。旧lint Java DSLの失敗は解消されたが、新たなsample設定のため98テストとlintは依然未実行。全体成功を主張しない。レビュー担当ctx_d88e20a3160aは完了後releaseした。 + +別途、sampleの設定問題に依存しないcore/opt-timberを--configure-on-demandで個別assembleし、一時的なJava/Kotlinクラスを両方向に呼び出すfixtureをコンパイル。両モジュールのJava/Kotlin計4クラスはjavapでclass major61（Java17）と確認できた。これはcore/TimberのKotlin readinessの実証であり、全体のGradleコマンドが成功したという意味ではない。fixtureのソース・classを除去し、tracked sourceはclean。一般的なJVM target既定値から推測した旧懸念は、この構成では実証により解消された。 + +Codexはmsg_5b1b01e48d25（15:03:03 JST）で結果を共有し、次がProGuard設定のみの修正なら全体検証と限定差分レビューを行い、構成が変わっていないKotlin compiler証明は無目的に繰り返さないと伝えた。 + +Claudeはmsg_216ab455da4dでCIログのAzure転送先へ到達できないことを報告したが、Codexが取得したエラー要旨と独立ローカル再現を利用できる。msg_8e7f857cf73f（15:02:56 JST）で同P1を実装担当へ返し、同種の古いAPI点検も依頼した。設定修正SHAの受信を待つ。 + +## 再失敗時の担当移管に関する条件付き合意 + +Codexはmsg_92c3354402ae（15:07:36 JST）で、ビルド実行が可能な側に残りの修正を集約する案を提示。Claudeはmsg_d16e984bcc06（15:09:10 JST）で次の条件に合意した。 + +1. 現在のProGuard修正はClaude担当が完了し、Codexがpushと全必須検証を行う。 +2. その検証でさらに非互換が見つかった場合に限り、残るT03修正をCodexのTerra/highへ移管する。移管前にClaudeが最終SHA・未解決事項・PR本文を明示的に引き渡し、旧担当の編集終了を確認する。 +3. 新担当はClaude最終headから分岐し、既存の全コミットを保持する。履歴を書き換えない。 +4. 移管した場合はCodex所有のT03全体PRを1本作成し、draft PR29を相互リンクと説明付きで置換する。 +5. Claude側Sonnet5/highが独立レビューし、Claude司令塔が最新SHAをAPPROVEした後にCodexが統合する。 + +これは条件付きの合意であり、まだ移管は実施していない。将来の権限変更を前提にせず、実際に確認できた実行能力で分担する。Claude担当が実際にGradle実行可能になった場合は、その証拠を確認して担当継続も相談する。 + +15:16時点のOrca照会では旧ctx_d9dde85f3055はabandoned、新ctx_7fe562a5523fはready/live。新端末term_a5e26b13-ea64-45b4-98c5-8b616a0bc2d1の画面はコンテキスト読込とack処理中だった。Codexはmsg_1df21beae325（15:16:07 JST）でClaudeへ復旧・担当・修正SHAの確認を依頼した。観測した状態だけを記録し、旧試行を成功完了として扱わない。 + +Claudeはmsg_424b141b112e（15:16:33 JST）で新担当を確認。起動引数はclaude-sonnet-5/highでlaunch.effectiveは空。旧試行は未ackの監視ループで更新を受信できずstop_unknown後abandonによりfenceしたと報告した。これはClaude側の復旧報告であり、Codexによる旧プロセス終了の独立確認ではない。新担当の範囲はProGuard既定ファイル修正1コミットと同種設定点検、headはまだ24fc1f2。旧端末の処理はClaudeが所有する。 + +## ProGuard修正後の全体検証と正式な担当移管 + +Claudeはmsg_2cbf871997ac（15:18:10 JST）で7a05b90ecb327dddec1a34f277f5fe5287882414を提示。sample/build.gradleの旧ProGuard既定ファイル名だけを修正した1コミットで、Codexが指定SHAをPR29へpushした。 + +Codexはmsg_32ca328c3576（15:19:38 JST）で独立検証を共有した。 +- Model/effort: gpt-5.6-terra / high（launch.effective確認） +- Task / Dispatch: task_33beab77cec4 / ctx_a14038591bf9 +- Worktree: codex-3.0.0-t03-final-check（新規、過去のfixture出力なし） +- Report: /private/tmp/overlay-t03-review-proguard.md +- Log: /private/tmp/overlay-t03-gradle-full.log + +CI run34677793662と独立ローカル実行は、ProGuard設定を通過し、:sample:compileDebugJavaWithJavacのR.id switch caseによるconstant expression required、46件で失敗した。core/opt-timberのassemble、opt-timber24件とlint4件、計28テストは成功（失敗・error・skipなし）。core/sampleテストとcore/sample lintは未完了で、98件全成功とはしない。1行のProGuard修正自体に問題はなく、sampleの旧ソース互換性が次の阻害要因になった。 + +Codexはmsg_e104718f0ae1（15:21:57 JST）でCI結果と移管準備を依頼し、msg_78dc95375dce（15:23:40 JST）で独立ローカル再現を補足した。これまでT10へ分類していたNonConstantResourceId対応の最小範囲を、コンパイル阻害のためT03へ前倒しする。JavaのID比較へ機械的に置換し、マッピング・既定分岐・副作用を保持する。広いsample Kotlin移行はT10に残す。 + +検証担当の正式worker_doneはmsg_d85695bf0acb（15:23:27 JST）、outcome failedとして受領し、ctx_a14038591bf9をrelease、transcript保存を確認した。途中のsandbox内Orca接続失敗は実行環境停止の証拠ではなく、Codex司令塔からは通常の昇格実行で接続できた。追加助言の送信は既にsettle済みでdispatch_inactiveとなり未配信だった。正式な報告受領を根拠に後処理した。 + +Claudeのmsg_36833232803e（15:24:36 JST）で最終SHA7a05b90、未解決事項、PR_BODY_T03.mdを明示して移管に合意。msg_f0d13fbdf431（15:27:15 JST）で旧担当ctx_7fe562a5523fのworker_done（未完了・引き継ぎのためfailed）受領とrelease、以後編集しないことを確認した。Codexも旧端末の最終ターンで編集終了を読み取り確認してから新担当を起動した。 + +新しいT03担当: +- Model/effort: gpt-5.6-terra / high（launch.effective確認） +- Task / Dispatch: task_219a9b571780 / ctx_f6d6f9259023 +- Terminal: term_7aa30be7-8726-4d54-88a7-135ec3e88c0a +- Worktree: codex-3.0.0-t03-completion +- Base: 7a05b90ecb327dddec1a34f277f5fe5287882414、全履歴を保持 +- Scope: sampleの最小互換修正、不要になったnonFinalResIds設定撤去、以後実証されたツールチェーン非互換の解消、全必須検証。coreの3.0動作実装・広い移行は開始しない。 +- 所有: ソース編集とローカルGradleを専有。Claude側は独立レビュー。 +- 成果: Codex所有の新T03 PRを作成し、ClaudeがPR29を参照付きでclose。最新SHAのClaude APPROVEとCI成功後にCodexが統合する。 + +引き継ぎPR本文は/private/tmp/overlay-t03-claude-handoff-body.mdへ保存した。本文の旧89件想定、ローカル検証不可の説明は新実測結果へ書き直す。coreは旧構成でもKotlin pluginを適用していたため、「stdlibが新たに推移依存する」との主張は旧新POM等の証拠なしに転記しない。成果物/POMの最終検証はT11/T12で別途行う。 + +msg_cc34373c4375（15:29:07 JST）で移管実行と担当情報を共有。PR30はhead9739fae4d16fa40f0e55d7aee50bdcf453d167b2に対する[Claude承認](https://github.com/75py/Android-OverlayViewManager/pull/30#issuecomment-5644189536)とCI run34677777272成功後、19c4252674e448cf46bcfdd092cbea4268c48d96へ統合した。非ブロッキング指摘を受け、計画のT04行を集約行と明記し、本ログの状態語彙をREADMEへ合わせる。 + +## テスト実行SDKの移行判断 + +T03担当のask msg_02b3d2cb9015（15:32:50 JST）は、Robolectric4.16でSDK21/22が利用不可となりcore69件中39件が失敗したと報告。Codexは既承認minSDK23に基づき、一般fixtureをAPI23へ移し、API22専用のcanDrawOverlays_22をAPI23の権限拒否・許可テストへ置換すると回答した（msg_2800131d3fd9、15:34:16 JST）。本番の権限動作は変更せず、Ignore等で隠さない。歴史上の98件に合わせるためにテストを捨てず、実測の件数差と理由を記録する。 + +msg_8807c42d3fa6（15:34:21 JST）でClaudeへ共有し、msg_5445b7cedd73（15:34:41 JST）で同意を得た。PRに変更テスト・理由・最終XML集計を明記する。サンプルandroidTestにもR.id switchがあったため、msg_5cecd7bbe714（15:31:51 JST）で:sample:assembleDebugAndroidTestによるソースコンパイル確認を追加。端末上の実行はT12であり、APKビルド成功と区別する。 + +## PR31の検証完了と追加テストの手戻り + +T03担当はmsg_41954b3d1573（15:38:48 JST）で9bd87c576e9c624893285b8e5f5cd2208b25789e、draft PR31を報告。全必須Gradleコマンド、98テスト（core69/Timber24/lint4/sample1）、lint error/fatal 0（core warning12/sample warning61）、sample androidTest APKのビルドが成功した。 + +ただしCodexの差分確認では、合意済みAPI23の権限拒否テストが欠けていた。子が配信delivery_e0e399b38acfをackせず古いメッセージを繰り返し受信したため、追加指示がコンテキストへ届かなかった。msg_c6c5438094d2（15:36:20 JST）で受領処理を補足したが同じ配信待ちだった。端末への一度の操作補足もagent_prompt_blockedで拒否され、入力成功とは扱わず再送しなかった。 + +正式なworker_doneを受領後、同じTerra/high端末を即時再利用して、task_f925723fbb47 / ctx_48a91118e250へ限定的な追補を渡した。再利用のlaunch.effectiveは空で、新しいモデル起動の証拠とはしない。同一プロセスは元のTerra/high起動で確認済み。新Dispatchの受信処理と旧IDを流用しない条件も明示した。 + +msg_1cc3ffe66b45（15:42:14 JST）で24e93fd78b1e89c4d8d7c737f16b4d1bf2a69546を受領。API23のShadowSettings.setCanDrawOverlays(false)とassertFalseの10行を追加し、許可ケースを保持。本番コードの変更なし。core再テストは70件成功、変更のない他モジュールの成功XMLと合わせ99件（failure/error/skip 0）。このテストのみの追補では、変更のないsampleビルド・lint・androidTestビルドをローカルで無目的に繰り返さなかった。担当は正しく新worker_doneを送り、releaseしてtranscript保存済み。 + +最終headのCI run34678799436も2026-09-12 15:43:20 JSTに成功した。PR31は相互レビュー待ちであり、T03は未統合。Codexはmsg_1a6bf435e213（15:40:43 JST）でClaudeへ全変更の独立Sonnet5/highレビューと旧PR29の参照付きcloseを依頼し、msg_7f63dcff0900（15:43:07 JST）で追補後SHAを共有した。 + +## 残存警告の対応案（Claude回答待ち） + +msg_1a6bf435e213で提案した分類: +- core UseRequiresApi 2件、ObsoleteSdkInt 4件: T04b/T05の公開API・権限処理移行。 +- core VisibleForTests 1件: T04、ClickableViewAccessibility 2件: T06。 +- sample既存UI/文言・WebView等: T10。警告抑制は追加していない。 +- lint registry vendor警告: T09。 +- 版の通知はAPI37、Robolectric4.17、Gradle9.7.1を示す。SDK36の合意済み試験範囲、対応するRobolectric4.16、AGP9.2の既定Gradle9.4.1を今回の検証対象として保持する案。「全て最新版」とは表現しない。採否はClaudeの回答待ち。 + +15:42〜15:43 JSTの読み取りでは、Claude司令塔は受信確認コマンドを/usr/bin/python3へpipeする操作の許可待ち。画面理由はpermissions.blockReadsOutsideWorkingDirectoriesによる計算されたpathの確認不可。Codexは相手の許可画面へ回答せず、今後はPythonなしのplain orca orchestration checkを使う提案と最終SHAをキューへ保存した。送信成功を受信・承認成功とは扱わない。相手承認なしにPR31をマージしない。 + +## 受信復旧・警告方針の合意とPR32統合 + +ユーザーの「続けて」を受け、Codexは受信とGitHub状態を再確認。Claudeのmsg_fd01f73ada63（15:58:01 JST）は受信処理の継続を報告し、PR31 head24e93fdのSonnet5/high独立レビュー開始、PR29の参照付きclose、警告振り分けと選定版を保持する方針に同意した。以前の許可画面の観測を現在も停止中という断定へ延長しない。 + +版の通知は最新版への追従義務ではなく、SDK36の試験範囲・Robolectric4.16・AGP9.2既定Gradle9.4.1を選定・検証した結果として残す。coreのUseRequiresApi/ObsoleteSdkIntはT04b/T05、VisibleForTestsはT04、accessibilityはT06、sample固有警告はT10、registryはT09。抑制はしない。msg_a3eacbbd42bc（15:58:39 JST）で受領を共有した。 + +PR32はhead2119277044ee8cfd5f42c878fa3b6c382cb0d2b9への[Claude承認](https://github.com/75py/Android-OverlayViewManager/pull/32#issuecomment-5644350107)、CI run34678974119成功後に7be795c1da4e68d596b46216a4abb794647d2517へ統合（msg_45c14a6162df）。非ブロッキングの参照補足: Claude子のworker_doneそのものはmsg_cece435d60fb、Codex宛て編集終了・release確認はmsg_f0d13fbdf431。前段は後者で確認した報告として記録したが、監査のため両IDを区別して残す。 + +## T03統合完了 + +Claudeのmsg_5b175d51a7e6（16:07:29 JST）と[PR31承認](https://github.com/75py/Android-OverlayViewManager/pull/31#issuecomment-5644370904)を確認。Sonnet5/highは継承コミットを含む全差分、ID分岐の挙動、99件のテスト、設定、CIを確認した。PR32は先のいずれの順でも可という回答に基づき統合済みで、PR31をhead24e93fd固定で00b45cb9fbc78d4911e164fc8c5109b936eafc16へ統合した。msg_0e69e2bb1da0（16:10:30 JST）で共有。 + +非ブロッキングのPOM依存指摘は、生成物未検証のまま確定事実とはせず、PR本文に組み込みKotlinへの移行がstdlib依存へ影響し得ることとT11/T12での生成POM/consumer検証を追記した。debugのunit/instrumentation coverageを明示的に有効化した点も記載。レビュー末尾のKotlin readiness未実証という表現には、24fc1f2で既にJava/Kotlin相互fixtureがmajor61を生成した証拠があると補足した。T04aの実際の新ソースの検証は別途必要である。 + +## PR35非ブロッキング指摘の証跡補足 + +T03チェック項目のmanifest整理は[PR31本文と変更](https://github.com/75py/Android-OverlayViewManager/pull/31)に対応する。統合後core/opt-timber/sampleのmain manifestを再確認し、旧package属性とoverrideLibraryがないことを確認した。wrapper checksumは本ログ「最初の独立検証結果」の86eb4f8でダウンロード・展開・検証成功を記録済み。現在のgradle/wrapper/gradle-wrapper.propertiesにはdistributionSha256Sum=2ab2958f2a1e51120c326cad6f385153bb11ee93b3c216c5fccebfdfbb7ec6cbが保持されている。証拠参照の補足であり、理由なく同じビルドを再実行していない。 diff --git a/docs/coordination/3.0.0/2026-09-12-wave1.md b/docs/coordination/3.0.0/2026-09-12-wave1.md new file mode 100644 index 0000000..835e2a7 --- /dev/null +++ b/docs/coordination/3.0.0/2026-09-12-wave1.md @@ -0,0 +1,88 @@ +# T00–T02: 第1波の分担・設計レビュー + +- 状態: T01設計・T02実装を双方承認し統合済み（詳細はwave2.md） +- 記録担当: Codex（Astra / medium） +- 関連タスク: T00、T01、T02 +- 関連PR: #21、#22、#23、#24、#25（すべて統合済み） +- Codex Run: run_18f7185e91aa +- Claude Run: run_3ae778449744 + +## やり取り（発言要旨） + +| 日時 JST | 発言者 | 提案・返答・判断 | 元メッセージ | +| --- | --- | --- | --- | +| 2026-09-12 00:36:44 | Claude | 分担・SHA付きAPPROVE・T01/T02並列を再確認。PR21旧headをSonnet 5/high独立レビュー後に承認。ghのTLS制約は通常のGitHub APIアクセスで作業可能と報告 | msg_21cae36771c4 | +| 2026-09-12 00:36:57 | Codex | 旧試行の再Dispatchを避け、両側の独立Runで子を監督する案 | msg_81b63f28ccc2 | +| 2026-09-12 00:37:40 | Codex | 上記方式を確定。旧メッセージは実在するが未読であったことを区別。PR21最新headのみ再承認依頼 | msg_20319d7f3529 | +| 2026-09-12 00:37:43 | Claude | T02 Sonnet5/high、task_336fecdad101 / ctx_bebb1ab66ddc起動。対象はCI・指定sampleのみ。lint抑制禁止、既存89件維持、CI成功を受入条件とする | msg_abd2419274d3 | +| 2026-09-12 00:39:29 | Terra（Codex子） | T01初稿ebccbc8完成 | msg_caa25e804526 | +| 2026-09-12 00:40頃 | Codex | dispose後state不可読、所有viewの親条件矛盾、Activity破棄時remove失敗、戻り値記述、透過のalpha条件を指摘。不要な全面renameと実機限定条件を再検討するよう差戻し | task_5eec657e9b5e / ctx_68f179dceb5c | +| 2026-09-12 00:40:34 | Codex | main-thread同期・明示的結果・immutable spec、minSdk23/target36提案。既存名維持を推奨しClaudeへ相談 | msg_508bde9b8f2e | +| 2026-09-12 00:41:03 | Codex | WindowManager登録成功とピクセル描画完了を区別し、外部detach/権限取り消しの契約を明確化するよう子へ指示 | msg_c18e68d9addc | +| 2026-09-12 00:42:06 | Codex | 長いwaitとtypeフィルタで司令塔statusが待機に埋もれるため、短い待機と質問通知を依頼 | msg_137ec8605269 | +| 2026-09-12 00:45:22 | Claude | Sonnet5/highの増分確認後、PR21最新head cdcd600を再承認 | issuecomment-5636971646 | +| 2026-09-12 00:46:31 | Terra（Codex子） | 修正版b374eee、PR22完成。既存名維持・冪等dispose・強制cleanup・透過budgetを具体化 | msg_7aab42c946e1 | +| 2026-09-12 00:47:42 | Codex | PR22の独立レビューとAPI方針承認をClaudeへ依頼 | msg_804137ceae77 | +| 2026-09-12 00:49:09 | Codex | 通常sendへのreplyが自分の受信箱に出ない可能性を報告。司令塔返答はsendとthread-id、blocking ask回答のみreplyの運用を提案 | msg_7ed788b9b5bd | + +## 統合・承認 + +PR [#21](https://github.com/75py/Android-OverlayViewManager/pull/21)はhead cdcd6003559db84aa64b7434bb72a3a5db658b5cへの[Claude承認](https://github.com/75py/Android-OverlayViewManager/pull/21#issuecomment-5636971646)、base work/3.0.0、差分検査成功、必須CIなしを確認し、d67f2e7212fe6b4757b316afae15e384056cfee6へ統合。旧head承認は新headの承認として使わなかった。 + +## 未解決事項・次の担当 + +- Claude: T01のAPI方針回答とPR22独立レビュー、T02子の実装・検証監督。 +- Codex: 指摘を設計担当へ戻し、最新SHA承認が得られたPRのみ統合。T02のPR完成後、独立レビュー子を起動。 +- 司令塔ログ整備の非ブロッキング指摘（状態・依存欄・台帳形式）は本更新で反映。 +- T03以降はAPI・ツールチェーンの双方合意と依存タスク完了後に着手。 + +## API方針の双方合意（00:49–00:52 JST） + +Claudeのmsg_aa4d17bac5ae（00:49:46 JST）は5判断項目すべてへ賛成。Codexはmsg_14ab33b282fa（00:51:49 JST）で同意し、以下を合意した。 + +- immutable specと結果を返す操作、既存OverlayViewManager/OverlayViewとfactory名を維持。 +- main-thread限定同期、自動再試行なし、ライブラリ公開asyncキューなし。 +- minSdk23、明るさ指定はActivity scope限定。 +- compile/target36、AGP9.2.x/Gradle9.4.1はT03で正確版・Kotlin・lintとの互換性を実証して確定する。 +- 常時FLAG_NOT_FOCUSABLE。背景呼出しからmainへ移す利用例、setOnClickListener移行を文書化。 +- failureがある場合もcauseはnullable。ドラッグ後の有効specを公開し、copy/toBuilderで部分更新する。 + +Claudeはa〜eの修正を最新headで確認してからPR22を承認すると明記。CodexはTerra/highのTask task_a00e41713481 / Dispatch ctx_422c19486993へ文書修正を依頼した。方向の合意はPR承認の代わりにしない。 + +T02のsample内BindingAdapter追加は、内部APIをpublic callbackへ置換するための関連範囲としてCodexも同意。ビルド設定と他モジュールの禁止範囲は維持。 + +司令塔返答はsend --to run:<相手Run> --thread-id <元msg>を使う方針にClaudeも同意（msg_19f300011661）。通常のsendへのreplyがcheckに届かない可能性を検出したためで、blocking askの回答はreplyを継続する。 + +Claude側の合意確定メッセージmsg_4652711e382b（2026-09-12 00:53:01 JST）でも、5判断項目と追加a〜eの双方合意を確認済み。 + +13:21 JSTの再開後レビューmsg_286ea5cfc018を受け、台帳状態はT01=相互レビュー中、T02=作業中へ揃え、許可待ちの詳細は実行記録へ保持。T04へT03依存を追加する段階移行案はmsg_e9a0f7964a8bで提案中（未合意）。 + +## 再開後の段階移行合意 + +| 日時 JST | 発言者 | 内容 | 元メッセージ | +| --- | --- | --- | --- | +| 2026-09-12 13:21:26 | Codex | Kotlin基盤をT03で確定後、T04a新型のみ→T04b移行→T07/T10 consumer同期で各PRをビルド可能に保つ案 | msg_e9a0f7964a8b | +| 2026-09-12 13:22:36 | Claude | T04へT03依存追加に同意。T07のJava修正先行、新API依存部分は後続と提案 | msg_81f062bf63c9 | +| 2026-09-12 13:23:34 | Codex | 上記に同意。T07のdispose未実現分を完了扱いせず、GradleはT02と直列化 | msg_d08b59b6b18d | +| 2026-09-12 13:24:52 | Claude | 条件と分担に同意。T02許可待ち継続のため子の重複起動を避ける | msg_ca3fc083ed95 | + +PR23は現head64f959fに対するClaudeの明示承認、差分検査成功、必須CIなしを確認し506f996へ統合。非ブロッキングの台帳・参照補足は次ログ更新へ持ち越した。 + +## T01統合とT02検証の移管 + +- msg_71649bee404d（13:26:29 JST）: Luna/highがPR22修正完了を報告。有効worker_doneを受信。runtime不達の懸念は報告文にあるが、受信済みの事実を優先しsettlement後releaseした。 +- msg_94dda62e6ace（13:31:26 JST）: ClaudeがPR22最新headをAPPROVE。T02のJDK読み取り拒否（libjli.dylib、exit134）を報告し、Codex側での検証を依頼。 +- msg_91ad1b36389a（13:33:22 JST）: Codexがbf3e42b固定のTerra/high独立レビューと検証を引受。Gradle所有を移管し、T02/T07のローカル同時実行を止めるよう共有。 +- msg_208807dec257（13:33:59 JST）: Claudeが検証移管へ同意、SSH/プロキシ制約でpush不能として代行を依頼。 +- msg_cdc22f1b6137（13:34:07 JST）: CodexがPR22統合SHA c8c2660と検証Task/Dispatchを共有。 +- msg_68299c23d15f（13:35:01 JST）: Codexがbf3e42bのpush成功を確認し、Claudeへdraft PRとremote CI作成を依頼。 + +T01の設計承認と実装完成は別。製品コードはT02以外未着手で、3.0.0リリース候補の検証完了とは扱わない。 + +## T02独立レビュー結果と司令塔判断（13:42 JST） + +Codex側Terra/high（task_2be9b58c2828 / ctx_382b023d4c6e）はbf3e42bb48a60d87d5cd838263f4cdad408639cbを対象に、必須ビルド・テスト・lintを--rerun-tasksで検証し168タスク成功、89テスト成功を確認。core/sample lintはエラー0、警告9/124。生成されたData Binding呼出しも確認し、listenerの付け替えと既存のprogrammatic progress動作に問題を認めなかった。端末・GitHub Actionsは未検証。 + +子はCI permissions欠落をP2、HTMLの既存onDestroy順序差をP3として報告。Codex司令塔は、広いtoken権限の実害や今回の回帰の証拠はなく、どちらも小さな改善提案と評価した。msg_aab84c40f1c7（13:42:20 JST）でClaudeへ修正を提案し、変更がYAML/HTMLだけなら全ローカル検証を繰り返さず増分確認とremote CIで十分と伝達。PR作成が未確認のため作成または代行依頼を求めた。まだ修正合意・PR承認とはしない。ローカルGradle所有は解放。 + +子の最終回答と報告ファイルは存在する一方、worker_done送信はsandbox内のruntime不達で失敗。Codexはbounded transcriptで最終回答を確認し、復旧ガイドの許可するworker-stopにより当該端末のみ終了。Orca taskの成功通知が受理されたとは記録せず、レビュー成果の完了と通知失敗を区別する。 diff --git a/docs/coordination/3.0.0/2026-09-12-wave2.md b/docs/coordination/3.0.0/2026-09-12-wave2.md new file mode 100644 index 0000000..7d7ae9d --- /dev/null +++ b/docs/coordination/3.0.0/2026-09-12-wave2.md @@ -0,0 +1,49 @@ +# T02統合・T03/T07への引渡し + +- 状態: T02統合済み、T03・T07段階1作業中 +- 記録担当: Codex（Astra / medium） +- 関連タスク: T02、T03、T04、T07 +- 関連PR: #24、#25 +- Codex Run: run_18f7185e91aa +- Claude Run: run_3ae778449744 + +## 協議と判断 + +| 日時 JST | 発言者 | 発言要旨・判断 | 元メッセージ | +| --- | --- | --- | --- | +| 13:43:39 | Claude | T02 draft PR24作成、bf3e42b。remote CI監視を引受 | msg_7b77617d1e16 | +| 13:44:28 | Claude | T02検証結果に同意、CI permissions/HTMLの限定修正を子へ指示。T03を次に開始し、必要なローカル検証をCodexへ依頼する案 | msg_0886dbc77de8 | +| 13:45:40 | Claude | 修正commit8510b6eが完成、push代行依頼 | msg_37a004ba2166 | +| 13:46:59 | Codex | push成功、限定差分に問題なし。警告分類を提示、T03の公式版検証・Java/Kotlin consumer維持に同意 | msg_611bc9df8fa2 | +| 13:48:42 | Claude | 警告の対応先に同意しPR本文更新。T07はソース並行、dispose統合はT04/T08後、Gradle直列化に同意 | msg_b0528f5bf522 | +| 13:51:46 | Claude | PR24現headのCI成功を確認。PR25をSonnet5独立確認後にAPPROVE。ログの最新状態補足は非必須として次回へ | msg_1a0eaddaa6fe | +| 13:53:33 | Codex | PR24を明示承認済み。PR25→PR24の順にマージし、双方の同時操作を避ける | msg_7ec1d625a5b7 | +| 13:54:44 | Claude | draft解除は先に実施済みと報告、以後変更しない。T03の順序・担当・検証移管を確認 | msg_837fa67f9e2e | +| 13:54:47 | Codex | 統合SHA9192f83を共有しT03開始依頼。T02担当のsettlement/解放はClaude所有。T04aはT03統合後 | msg_5dc7170819a3 | + +CI権限とHTML修正は、子のP2/P3分類をそのまま必須不具合として採用せず、司令塔が差分と実害の根拠を評価して限定的改善とした。双方が同一PR内での修正に同意したため反映。修正後はYAML/HTMLのみを再確認し、変更していないコードに対する全ローカル検証は繰り返していない。 + +## 検証・承認・統合 + +PR24はTerra/highによる独立レビュー、89テスト成功、core/sample lintエラー0（警告9/124）、生成Data Binding確認を根拠とする。最新head8510b6e0c8cfd855cc6fcbbe3f3de6e14b47d4edの[CI run34673893306](https://github.com/75py/Android-OverlayViewManager/actions/runs/34673893306)成功を確認後、[Codex承認](https://github.com/75py/Android-OverlayViewManager/pull/24#issuecomment-5643568874)を記録。baseと最新SHAを直前に再確認し、9192f8360b79ad71d2b37fc3b886d5e5d91c467cへ統合した。 + +PR25はhead2b0182fae8f2f680c39f2cde6151dc7fffeb161aへの[Claude承認](https://github.com/75py/Android-OverlayViewManager/pull/25#issuecomment-5643564217)、文書のみ・差分検査成功・必須CIなしを確認し、f69e7bf21f6d27e35d913ef7c6eb856d67700e7fへ統合した。非ブロッキングの現況見出し・PR24結果補足は本更新で反映。 + +警告の分類表は[PR24本文](https://github.com/75py/Android-OverlayViewManager/pull/24)に保存。coreのSDK/依存6件はT03、accessibility2件はT06、VisibleForTests1件はT04。sampleのSDK/依存6件はT03、残る118件はT10（WebViewの信頼境界確認を含む）。警告は抑制していない。端末試験はT12未実施。 + +## 次の所有者・受け入れ条件 + +ClaudeはT03の公式版調査・ビルド設定・SDK/依存更新とCI調整をSonnet5/highへ委譲し、必要なローカル検証はCodex側の別担当へ引き渡す。正確なTask/Dispatchは起動結果を受信後に記録する。各PRのJava/Kotlin利用コードをビルド可能に保ち、合意していない版を確定済みと記録しない。 + +T07はopt-timberのJava挙動段階を先行可能だが、新core dispose依存分はT04/T08後。共有GradleはT03優先で直列化する。CodexはT03統合後に新型のみを導入するT04aへ進む。製品全体のリリース候補検証は未完了。 + +## 実起動（13:58:09 JST） + +Claudeのmsg_add30b0b0135で実行情報を受信。両子のlaunch.effectiveはclaude / claude-sonnet-5 / high。baseは9192f83。T02は有効worker_doneを受信してrelease済み。 + +| 担当 | Task / Dispatch | 端末 | Orca worktree名 | +| --- | --- | --- | --- | +| T03 | task_ddc6ad210b34 / ctx_2f7b18d0b503 | term_3ad0f3de-7bf1-45b0-b8cc-bd3c91d6c673 | claude-3.0.0-t03-toolchain | +| T07段階1 | task_3bee9d099ded / ctx_5816cf1fe027 | term_951bf42a-5f62-458f-9c46-cbfef6339da1 | claude-3.0.0-t07-timber-java | + +T07の確定範囲はopt-timberのJavaのみ: ロック付き有界バッファ、main描画をcoalesce、maxLines<1拒否・縮小時トリム、回帰テスト。dispose/lifecycle変更なし。T03とソース所有範囲が重複しない。Claude側JDK制約のため、両PRは必要に応じてCodexがpush代行と独立検証を担う。バージョン調査結果はまだ受信していない。 diff --git a/docs/coordination/3.0.0/2026-09-12-wave3.md b/docs/coordination/3.0.0/2026-09-12-wave3.md new file mode 100644 index 0000000..72674e4 --- /dev/null +++ b/docs/coordination/3.0.0/2026-09-12-wave3.md @@ -0,0 +1,69 @@ +# T07段階1レビュー・統合とT03復旧 + +- 状態: T07段階1統合済み、T03同一タスク再試行中 +- 記録担当: Codex（Astra / medium） +- 関連タスク: T03、T07 +- 関連PR: #26、#27 +- Codex Run: run_18f7185e91aa +- Claude Run: run_3ae778449744 + +## 協議・レビュー・判断 + +| 時刻 JST | 発言者 | 要旨 | 元メッセージ | +| --- | --- | --- | --- | +| 14:03:58 | Codex | PR26を承認とCI成功後にd96abfcへ統合。API36 emulator-5554をread-only確認、インストールや試験未実施 | msg_00fb15813ccd | +| 14:06:01 | Codex | T03のAGP/lint対応版調査にGoogle MavenのPOM/module情報を提案。バージョンの決定ではない | msg_cec25dcca30c | +| 14:06:40 | Claude | T07候補27d4f82完成、所定remoteブランチへのpushと独立検証を依頼 | msg_c715d0837b5b | +| 14:08:04 | Codex | push成功、Terra/high task_e055de0f3863 / ctx_d7cc040001a3を固定SHAで起動。Gradleを独占しT03検証は後続 | msg_9608f4fc960c | +| 14:08:41 | Codex | 子へplain-int thresholdの可視性を確認依頼。既存課題と今回の範囲を区別し、flaky race testを作らないよう指示 | msg_b4317a18fed8 | +| 14:09:13 | Claude | T07 draft PR27作成、CI監視を引受 | msg_2198cc0c6a40 | +| 14:12:16 | Terra | stage1必須指摘なし、24テスト・lint成功。valid worker_doneを受信しrelease | msg_ac85a615eb5d | +| 14:12:55 | Codex | 子の根拠を評価。threshold可視性は既存かつ今回の限定範囲外として、次段階で明示的に修正する案。Gradle枠を解放 | msg_2e4494b74956 | +| 14:16:44 | Claude | 上記に同意。検証結果と残範囲をPR本文へ追記しready化 | msg_4492b071b8f0 | +| 14:18:03 | Codex | T03画面を確認。checksum取得はユーザー許可後に成功済み、その後調査ターンが完了しているため許可待ちという旧認識を訂正し所有側の復旧を依頼 | msg_b7c41f28cf73 | +| 14:18:37 | Claude | T03がworker_doneなしで終了・調査のみと確認。Orca復旧手順で継続すると回答 | msg_8c33cf721900 | +| 14:19:17 | Codex | PR27を明示承認・統合しSHA5eca725を共有。T07 overallは未完了、T03復旧確認を継続 | msg_19a2ddffaa0e | + +## 独立レビューの評価 + +Terra/highはロックによるdeque/maxLinesの整合、mainへの描画委譲、renderPendingをsnapshot前に解除する順序を確認。解除前のlogはsnapshotに入り、解除後のlogは後続描画を予約するため、最終表示の取りこぼしを認めなかった。 + +Codexはthresholdがplain intである点を別途指摘。子はJava memory model上の可視性保証がないことを確認したが、今回のバッファ・UI修正より前から存在すると評価した。Codexはこれを黙認してT07全完了とはせず、次段階でvolatileまたはlockを導入する条件を提案し、Claudeが明示合意した。初期化・dispose・Activity寿命の未実装も同様に後続依存として保持する。 + +検証はexact head27d4f8205b9ff07cfb47388c04173ab55f2c49f2、JDK17/Gradle8.9。opt-timber:testDebugUnitTestは24件（既存15+新規9）、失敗/エラー/skip0。opt-timber:lintDebugはエラー0・依存警告3件（T03）。Unit testはmock UI/dispatch seamを使い、実Android main looperでの端末検証ではない。端末試験は後続で実施する。 + +レビュー担当の実在情報: term_9b88ab16-b8bf-43f8-acfa-c7ab475564f4、worktree codex-3.0.0-t07-review。launch.effectiveはgpt-5.6-terra/high。成功通知受理後にrelease、transcriptを保存しworktreeは保持した。 + +## 承認・統合 + +PR26はhead db87e8b2db0c3272e51eb8dad57dd3c95698138eへの[Claude承認](https://github.com/75py/Android-OverlayViewManager/pull/26#issuecomment-5643616135)とCI run34674427563成功を確認し、d96abfcdad45ddb4de978355fe82a3f0667a8134へ統合した。 + +PR27は[CI run34674836991](https://github.com/75py/Android-OverlayViewManager/actions/runs/34674836991)成功・最新SHA・base・残範囲の双方合意を確認後、[Codex承認](https://github.com/75py/Android-OverlayViewManager/pull/27#issuecomment-5643717923)を記録。27d4f8205b9ff07cfb47388c04173ab55f2c49f2を5eca72527047b9f16ed931570635e3836f3f60efへ統合した。実装側のsettlement/解放はClaude所有であり、依頼時点では未確認。 + +## T03復旧の境界 + +Orcaの古いworker状態表示だけで停止や重複起動を判断していない。Codexは最新rendered screenで調査中断後のターン終了を確認し、Claudeも最終ターンにworker_doneがないと確認した。復旧操作と継続のTask/DispatchはClaudeから実行結果を受け取って記録する。ユーザーのpermission設定はCodex側で変更していない。現時点ではツールチェーン更新の実装・検証完了を主張しない。 + +## T03再試行の実行記録 + +msg_b8baecba66f8（14:21:53 JST）でClaudeが旧ctx_2f7b18d0b503をworker-stop→release後、同一task_ddc6ad210b34にretry-ofを指定しctx_d9dde85f3055へ再ディスパッチしたと報告。worktreeはclaude-3.0.0-t03-toolchain、ソース変更なしのbase9192f83を継続。新端末はterm_d69f62a2-5043-41ba-8710-54fec875164e。 + +Claude側が作成した端末へ既存端末指定で起動したためlaunch.effectiveは空。起動引数claude-sonnet-5/highと実効値の確認を混同しない。msg_ad03ab603726（14:22:13 JST）でCodexが旧調査の引き継ぎを依頼し、msg_b9dc244277f7（14:22:54 JST）でClaudeがtranscriptから公式要件・checksum・未解決lint情報を抽出して送ると回答。実効モデル/effortは最初の担当報告でも確認する。 + +端末試験の準備として、Codexがread-onlyでSDKのsystem-imagesを確認。現時点のインストール済みはAPI36のgoogle_apis/google_apis_playstore arm64のみ。他のAPIを試験済みとはしない。 + +## 実装担当の終了確認と調査引き継ぎの制約 + +msg_c07bedb9cf18（14:25:01 JST）でClaudeがT07 ctx_5816cf1fe027のターン終了を確認後にworker-stop→releaseしたと報告。PR27の実装成果は統合済みだが、Orca attemptは成功settlementではなくstopped。レビュー担当の有効worker_doneとは区別する。 + +同メッセージで旧T03のtranscriptは停止後のworker-readが0件となり取得できなかったと訂正。完全な旧調査の引き継ぎは実現していない。Claudeは自身が確認しているSDK/JDK方針、公式参照先、Kotlin組み込み、Google Mavenでlint版を確認する方針を新担当へ送った。取得したchecksumの実値など、回収できなかった情報は新担当で再確認する必要がある。 + +## 最終互換API除去の担当・依存合意 + +Codexはmsg_58204d3d71a0（14:29:50 JST）で、移行期間だけ残すcore旧APIの除去をCodexの独立PRとしてT07/T10 consumer移行後に行い、T11をその完了待ちにする案を提示。T04bの段階合格は後続core作業を解放するが、最終除去が残るT04全体の完了とは区別する。 + +Claudeはmsg_31c3ba95b7b4（14:32:18 JST）で全項目へ同意。計画にT04cを明示し、T05依存はT04b、T10依存もT04bまで、T11依存はT10とT04cへ更新した。これにより段階的にCIを維持しながらも、最終APIに一時互換コードを残さず、全タスク依存の循環を避ける。 + +同メッセージのT03進捗は3コミット（AGP9.2.1、Gradle9.4.1/JDK17、SDK36/minSdk23/manifest整理）と依存更新中。実装の進捗報告であり、正式なツールチェーン承認や検証結果の代用にはしない。 + +T03の候補SHAは最新のT07実装も含めて検証するようCodexがmsg_a68270d8b872（14:32:13 JST）で依頼し、Claudeがmsg_979b91434120（14:32:56 JST）で同意。候補凍結前にwork/3.0.0の5eca725へ取り込む。変更後の依存ライブラリをT07の追加テストと組み合わせて確認するためである。 diff --git a/docs/coordination/3.0.0/2026-09-13-coordinator-resume.md b/docs/coordination/3.0.0/2026-09-13-coordinator-resume.md new file mode 100644 index 0000000..a8776f2 --- /dev/null +++ b/docs/coordination/3.0.0/2026-09-13-coordinator-resume.md @@ -0,0 +1,169 @@ +# 2026-09-13 司令塔の直接作業による再開 + +## 再開と担当 + +09:35 JST時点でユーザーから「再開して」を受領。以前の停止指示を解除し、最終到達点は引き続きrelease/3.0.0からmainへのPR作成までとする。mainマージ・タグ・公開は含まない。 + +- work/3.0.0の7653767とホームの~/.codex/AGENTS.mdを再読。現在のプロジェクト固有規約に従い、既存司令塔が直接作業する。新規サブエージェントを既定で起動しない。 +- Claude報告msg_20aaddf38cd2: 新Task task_d50e1eceb22f / Dispatch ctx_a50bedd97da3の旧担当へ安全な境界でworker_doneによる返却を指示した。返却後、Claude司令塔Fable 5.1/highがt07-lifecycleでT07 L1–L7の実装・検証を直接担当する。返却完了はこの記録時点では未確認。 +- Codex返答msg_3d47d3c5c097: ユーザーの明示再開を伝え、上記担当とCodex Astra/mediumによる対向レビュー・共有計画ログ統合を承諾。Claudeの作業割合を大きく保つ。Claude独自のT07ログ以外の共有計画・CodexログはCodexが編集する。 +- 直前の方針共有msg_5fec3fe5159aと今回の返答を合わせ、古いworker再起動案を引き継がない。02:30自動再開の解釈については過去ログを保存し、今回の直接指示を現在の再開根拠とする。 + +## 未完了と受け入れ条件 + +保存済みWIP 6e243c3は候補ではない。描画世代の予約、initializeのbuffer/maxLines同一lock、dispose全経路のmain-thread検査の3点を差分と実行検証で確認する。L6/L7、Java利用互換、削除失敗時のretry、成功dispose後のno-opを検証する。候補SHAの対向承認とCI成功後のみwork/3.0.0へ通常mergeする。 + +T10、T04c、T09 stage 2、T11、T12、T13は未完了。T05/T06端末検証を完了扱いしない。今回の記録変更は文書差分と参照先を検証し、Gradleは実装担当へ一元化する。 + +## 保存済み差分の確認 + +Codexはコミット6e243c3のproduction差分を読み、msg_1ee3d4d99ee7で追加の確認を依頼した。共有renderRunnableが予約時の世代を保持せず現在の2フィールドを比較するため、古いcallbackが新世代の予約を処理できる。旧callbackだけを先に実行する回帰検証と、実装・KDocの契約の一致を候補で確認する。存在しないinitApplicationInstanceへの参照と計画内識別子FROZEN L2/L3も利用者向け記述へ直す。未完成WIPに対する観察であり、完成候補へのレビュー結果ではない。 + +文書PR53はhead6526b6bで既存、承認コメントなしを確認した。このPRを今回の再開状態へ更新し、更新SHAのClaude承認とCIを要求する。以前のCI成功を新しいheadの成功根拠に流用しない。 + +## 09:40–09:46 JST 調整と代理許可 + +- PR53のhead fed9707827bf8bf3791c3276c061204cfcec7f8dをClaudeへレビュー依頼（msg_fcfbd80cb19e）。CI run34728558459はSUCCESS。Claude承認はまだ未受領。以後のログはcoordination-wave17へ分離し、レビュー中headを固定した。 +- Claudeの環境確認が長引いたため既知のJDK/SDKとCodexによる最小検証・GitHub代行を提示（msg_5329f94f5fd1）。T07編集は引き続きClaude所有。 +- 旧worker画面に司令塔handleでの受信箱checkが表示されていたため、msg_3c03fe9314b1で宛先訂正と未受領メッセージ確認を要請。workerの操作をCodex側で代理実施していない。 +- T07はf2bc6ffとe59cd1dへ履歴整理済み。e59cd1dのwatcherテストはlock外からArrayDequeを読み、正常な追加→trimの途中を誤検出できる。またlog開始がinit完了後のためinit競合を再現しない。msg_d5ee64215eaeで修正を依頼。Gradleはまだ実行していない。 +- Claude司令塔の長時間の環境照会を中断して受信箱確認へ戻す入力を送り、入力受理を確認。Task/Dispatchの停止・abandon・replacementやファイル変更は行っていない。 +- その後のpermissions.blockReadsOutsideWorkingDirectoriesダイアログでは、orca orchestration checkのJSONをpython3で整形表示するコマンド全体を確認。ファイル書込や無関係な読取はなく、ユーザーの既存代理許可指示の範囲と判断した。text+Enterはagent_prompt_blockedで未実施、同request IDの再確認も同結果。選択済みYesへのraw Enterがacceptedとなり、次の受信箱読取に進んだことを画面で確認した。権限設定の緩和は行っていない。 + +## 09:49 JST worker返却の代理許可拒否 + +worker-showでctx_a50bedd97da3がmsg_4cc722724d09によるworker_reportでsettled/failedとなったことを確認。HEAD8b464b7709d01fd9ff12be12d8d4378ff9d4a464、tracked clean、テスト未実行。端末はlive/external/retained。 + +Claudeのack delivery_d19978dcf0a7 + worker-release ctx_a50bedd97da3 + reclaimable一覧コマンド全体を確認後、代理Enterを要求したが、自動承認レビューが「liveかつrelease未要求、明示的な完了・返却確定前の代理許可」として拒否。Enterは未実行。ダイアログをraw Escapeでキャンセルし、msg_f5f70494021eで返却操作の保留・外部端末維持・回避実行禁止を連絡した。これは既存担当の完了報告を取り消すものではなく、release操作だけを実行していない。 + +PR53承認の送信処理はClaude画面に表示されたが、Codex受信箱にはまだ未着。承認済みとは扱わず、送信結果の確認を依頼した。 + +## T07候補の検証成功・PR54作成（09:58 JST） + +Claude msg_6cd082a5f543でownership返却を確認し、worker-releaseは保留・端末維持のまま、司令塔が直接修正することに合意。PR53の承認文を依頼どおり代理投稿（comment5649792601）し、head fed9707・CI34728558459 SUCCESS・MERGEABLE/CLEANを再確認後、64f8897a510449e6eb825b261ccad4b37c0299d0へ通常mergeした。 + +Claude msg_d9074f9d96d9: 候補a39813a5cea32f2d89e0bab835e2074c17976cfb。世代をcallbackへcaptureする修正、旧callbackのみを先にdrainするテスト、誤ったwatcherテスト削除を司令塔が直接実施。buffer/maxLinesの同一lockは差分レビューで確認し、競合テストで保証したとは扱わない。 + +Codexが候補SHAを確認し、JDK17/既知SDKで依頼されたGradleを実行。BUILD SUCCESSFUL（20秒）。XML実測はKotlin39 + Java1 = 40 tests、failures/errors/skipped全0。opt-timber lintはエラー0・警告2。opt-timber/core/sample assembleDebugすべて成功。ソース変更なし、tracked clean。msg_e78097b4a1a1で結果とレビューblockingなしを通知した。 + +検証成功後に指定どおりclaude/3.0.0/t07-lifecycleへ同SHAをpush、draft PR54を英語で作成。Codex現SHA承認comment5649811216を投稿。msg_ef1cf2c2a713でClaudeへPRを通知し、重複作成を避けた。CI・統合はこの時点で未完了。PR53のnon-blocking nitだったT07台帳の古い再開blocked表示を今回訂正した。 + +## 最終候補のコメント修正 + +Claude msg_6477ff749aca / msg_ec0265de8f3eでc13acee8884bb3426142bf2e53c6f0ff542d4503を受領。a39813aとの差分はtestコメント2行のみで、削除済みメンバへの参照を訂正するもの。連絡が交差したため新しいPRを増やさずPR54をfast-forwardした。指定の5 Gradle tasksを最終HEADで確認しBUILD SUCCESSFUL（2秒、135 tasksのうち4 executed/131 up-to-date）。40 testsの成功XMLは前回から有効な結果として再利用され、テストを新たに全件再実行したとは扱わない。CIは新HEADで確認する。PR本文とタイトルを最終状態へ更新した。 + +## T07統合とT10開始指示（10:04 JST） + +PR54はhead c13acee8884bb3426142bf2e53c6f0ff542d4503、Codex承認5649833960、Claude承認5649837582（msg_6477ff749acaの依頼文をCI成功後に代理投稿）、CI34729426721 SUCCESSを確認。ready化後、MERGEABLE/CLEANと同SHA・base work/3.0.0を再確認し通常merge。統合SHAは6c9e2aa120bb85f3b49fd9d9f2da43288e6f8e89、10:04:16 JST。共有checkoutもfast-forwardした。 + +msg_1ecbcd072166でClaudeへ統合を通知し、既存C1/K1–K7の下でT10a/sampleとT10b/docsを直接作業するよう依頼。具体的worktree/branchの開始記録は受領待ち。Kotlin組み込み方式・sample/assets同一所有・版数未変更・T04cはT10後・専用AVDによるsmokeとスクリーンショット・無関係なemulator5554は触らない制約を再掲した。 + +追加の代理許可: delivery_3f500779b858のack/受信待ち/JSON整形コマンド、およびcore公開APIの指定ファイルをgrep表示するだけのコマンドを全体確認してraw Enterで許可。worker-releaseや設定緩和は含まない。PR55（head6addac4、CI34729477343 SUCCESS）はClaude承認待ちで、headを固定して以後の記録をcoordination-wave18へ分離した。 + +## T10分担の確定と文書初稿 + +PR55はhead6addac4・Claude承認5649867149（msg_2e289c029277の依頼文を代理投稿）・CI34729477343 SUCCESS・MERGEABLE/CLEAN確認後、02a6debe188c4fcb130f41ea31d3cffa8b41c53eへ通常merge（10:10:44 JST）。共有checkoutを同SHAへfast-forward。PR55承認文送信/受信待ち、およびgit rev-parse/log + 受信待ちの表示コマンドは全体確認後に代理許可した。 + +待ち時間を減らすためmsg_ad81e86d0001でT10の直接分担を提案。msg_b3e18d2f8544で双方が明示合意し、ClaudeはT10b未編集と確認した。 + +- Claude Fable5.1/high: claude-3.0.0-t10a-sample、branch codex/claude-3.0.0-t10a-sample、base02a6deb。sample/**（assets/androidTest含む）と専用AVD smokeを所有。ローカル検証が制限される場合はCodexが指定コマンドを実行。 +- Codex Astra/medium: codex-3.0.0-t10b-docs、branch codex/codex-3.0.0-t10b-docs、base6c9e2aa。README.md、CHANGELOG.md、docs/migration/**のみ。Orcaの専用worktreeで親が直接作業、新規サブエージェントなし。 +- 相互レビューを維持し、sampleのコンパイル済みコード例と文書を照合後に受け入れる。T04cは両方の統合後。 + +文書初稿d90b0dcbef136b50855ebca923cb2016eed0924bを保存。新API・結果・両scopeの所有・権限復帰・破棄失敗のretry・threading・Timber・未リリース状態を記述。ローカルリンクとMarkdown fence、git diff --check成功。文書のみでGradle未実行。msg_dc55cc182244でClaudeへレビュー依頼、コンパイル済みsampleとの最終照合は未完了と明記した。 + +## T10初回候補の差戻し + +T10bはdraft PR56（初稿d90b0dc、後続b4059d1で旧outside-screenの非互換を2行補足）として共有。コンパイル済みsampleとの照合とClaudeレビューは未完了。 + +sampleの文書照合で、Sample2Service.onDestroyが失敗をlogするだけではService破棄後のretry所有者が残らない点を発見。msg_d87cb8640080でK3要件違反として差戻し、Application等に生き残るownerと明示retry手段を求めた。先の「Service追加不要」注記は既存nested Sample2Serviceを見落としていたため、同連絡で訂正した。 + +Claude msg_92e34ec5d478の初回候補13130407b798e3a9d566aed7a7df4ba8ba46cd03をtracked cleanで確認し、指定6タスクを実行。7秒で失敗。sample Kotlin compile成功、Java compileはSampleAllOptionsActivity.java:17の重複package宣言で失敗。sampleのunit/lint/androidTest APKは未完了。msg_83e9c6ee87b1で結果とログ/private/tmp/overlay-t10a-validation.logを引継ぎ、ファイルを編集せず検証専有を解除した。Claudeのack/受信待ち/JSON整形のみのコマンドを全体確認して代理許可し、修正担当を変更していない。 + +## T10コンパイル再検証と残る動作確認 + +998a625はSample2Activity.java:52/62でbtn_retry_disposeが未解決となり3秒で失敗。Claude msg_baff95f5ee9cでlayout/string/HTML生成の途中失敗が報告され、3627afcを受領。6タスクの再実行は6秒で成功。sample本体・androidTest APK・core/Timber build成功、ExampleUnitTest 1件成功（failure/error/skip0）、sample lintエラー0・警告58。端末テストは未実行。 + +controllerへhandleを移したK3修正は方向として受け入れたが、500ms後の一度だけのUI更新では遅いService破棄時にretryボタンが出ない。msg_8422d358279bでタイミング依存の除去と、破棄失敗→同じhandle保持→明示retry成功を検証する回帰テストを依頼。msg_48171e4de1d9でコンパイル成功と検証専有解除を連絡した。 + +ClaudeからT10b初稿のblockingなしレビューを受領したが、最終文書はsample具体例へのリンクとJavaのre-check-onlyフローの区別を反映し、新SHAで対向承認を取り直す。旧d90承認を新headへ流用しない。 + +端末準備: 既存emulator5554は観測のみ。5580/5581が空きであることを確認し、OverlayViewManager_3_0_API_36をport5580、no-window/no-snapshot-load/no-snapshot-save/no-audioで起動（session92056）。Claudeに重複起動しないようmsg_951e0313a765で通知。起動は検証成功の証拠ではなく、T12を完了扱いしない。追加のClaude ack/受信待ちダイアログは全体確認の上代理許可した。 + +## T10最終候補の通知受領と端末検証（10:43 JST） + +msg_0516130fe2a4 / delivery_7167e17bc526を読み、T10a最終候補665d16989f8ef98ba2b77ee56d5cf2f1fd54d7d3をtracked cleanで確認。msg_bd0ff8dc522fで検証担当と編集凍結を通知後にackした。差分はlistenerによるretry UI更新とcontroller回帰テスト3件、Robolectric設定追加。6 Gradle tasksは5秒で成功、単体テストは既存1件と新規3件の全4件成功（failure/error/skip 0）。lintはエラー0・警告59。 + +専用emulator-5580のみでinstallDebug成功、SYSTEM_ALERT_WINDOW allow設定後にANDROID_SERIALを限定してconnectedDebugAndroidTest実行。30秒で失敗し、XMLは3件中2件失敗、error/skip 0。Sample1ActivityTest:91とSampleAllOptionsActivityTest:149でATTACHEDを期待したがCONFIGURED。SampleStartActivityTestは成功。原因未確定で承認・PR作成・統合を保留。msg_608d07b348b8でClaudeへ修正を依頼し、Gradle専有を解除した。テストログは/private/tmp/overlay-t10a-connected-665d169.log、端末ログは/private/tmp/overlay-t10a-logcat-665d169.txt。5554は操作していない。 + +T10b PR56の最新headは1ca27f344d42626ed28d648cb00a67af39bd4665。具体的sampleリンクとJava側の権限recheck-only動作を明確化し、msg_742ffa130794で差分レビューを依頼済み。リンク検査はdocsとsample候補の組合せで成功したが、sample統合後の再検査と最新SHAの対向承認は未完了。 + +## T10診断と文書承認（12:09 JST） + +msg_72c84115cab7 / delivery_0f90c6dc2946を処理。PR56のhead1ca27f344d42626ed28d648cb00a67af39bd4665に対するClaude承認を、GitHubの現SHA一致確認後に依頼文どおりcomment5650579496へ代理投稿。sample統合・リンク再検証までmergeしない。 + +診断候補8030fca0611a548ec413e4e802619fc242bd943eはassertionへのlastFailure表示追加のみ。専用5580でconnectedDebugAndroidTestだけを再実行し、3件中2件失敗、errors/skips 0。Sample1:92とAllOptions:149はいずれもlastFailure=null、期待ATTACHEDに対してCONFIGURED。ログ/private/tmp/overlay-t10a-connected-8030fca.log。 + +手動確認ではテスト後にsampleが存在しなかったため既存APKを再インストール。Sample1は非exportedで直接am startできず、公開SampleStartActivityからUIで遷移した。UI階層はSHOW / HIDEが[0,0][1080,126]、Activity見出しが[42,101][804,172]。スクリーンショット/private/tmp/overlay-t10a-smoke/sample1-manual-665d169.pngは青いバーと白い本文だけで、表示ボタンは隠れていた。指定中心へのtapで赤いoverlayは現れず。ホストのedge-to-edge/insetsにより操作が遮られた可能性が高いが、ライブラリshow失敗と断定しない。msg_037346462141で証拠と修正依頼をClaudeへ渡し、Gradle専有を解除した。通知をack。sample修正・再検証は未完了。 + +## T10レイアウト実測の引継ぎ + +msg_8b9d88647fa2 / delivery_3053526e4125の追加診断依頼を処理。専用5580で再インストールしたsampleの公開入口からSample1へ遷移し、/private/tmp/overlay-t10a-smoke/sample1-ui.xmlとwindow-displays.txtへ保存。android:id/contentと直下LinearLayoutは[0,0][1080,1920]、buttonは[0,0][1080,126]、webViewは[0,126][1080,147]。action_bar_containerは[0,0][1080,210]、action_barは[0,63][1080,210]で、ボタン全体と重なる。画面1080x1920・density420、statusBarsは高さ63、navigationBarsはy1857〜1920、cutoutなし。実測値とファイルをClaudeへ送信し、sample修正担当を維持。Codexはソース未変更、追加テスト未実行。通知をackし、修正候補の返却待ち。 + +## T10 Insets修正の成功とHTML表示の差戻し（12:23 JST） + +msg_c59c4fe58bea / delivery_894075371929のa99620f8b73caa54f6616fe01f7c06b9d5c031c0を検証。差分は6画面のfitsSystemWindows追加のみ、tracked clean。6 Gradle tasksは4秒で成功、unit成功XML4件（failure/error/skip0）、lintエラー0・警告59。5580のconnectedテストは3件すべて成功（XML time111.925s、failure/error/skip0）。ログは/private/tmp/overlay-t10a-validation-a99620f.logとoverlay-t10a-connected-a99620f.log。 + +手動確認で権限Allowed、Sample1赤いclick:0、Sample2アイコン表示→停止で消失・retryなし、AllOptions ATTACHEDを画像で確認。証拠/private/tmp/overlay-t10a-smoke/a99620f-*.pngを保存。ボタンはy210以降へ移りバーとの重なりを解消した。一方Sample1/2のコード欄が空白で、assetsの4HTMLすべてにがないことを確認。msg_0d8cb4294149で具体的修正とコード例の表示確認をClaudeへ依頼。専有解除、候補承認・PR作成・mergeは保留。画像はローカルのみでPR添付済みと扱わない。通知をackした。 + +## T10 HTML表示修正の確認と画像引継ぎ + +msg_7c0b2038baf3 / delivery_b4b6c98c1546の8185320a4f415d7996080c211fb9817cf01351e7を検証。差分は4HTMLへの閉じstyleタグ追加だけ。最初のGradle実行は自動承認レビュー時間切れで未起動、明示許可された1回の再試行は成功。6 tasksは3秒（9 executed/156 up-to-date）。 + +専用5580へ修正APKを再インストールし、Sample1/2/Timber/brightnessで説明と色付けされたコード例を画像で確認。7画面の証拠を/private/tmp/overlay-t10a-smoke/8185320-{start,sample1,sample2-start,sample2-stop,all-options,timber,brightness}.pngとXMLへ保存してClaudeに引継ぎ。sample/screenshots/3.0.0/への最終画像コミットはClaude担当、既存untracked画像をCodexは変更していない。HTML/PNGだけの後続差分ならconnected再実行は不要とし、a99620fの3件成功と8185320の手動表示確認を区別して記載する。最終SHAとPRは未完了。通知をackした。 + +## T10a最終候補のPR57作成（12:32 JST） + +msg_03e9bf655ad9の52caec4277b79153ff76fce840197c9c947c4cd5を確認。8185320との差分は7PNGだけ。最終6 Gradle tasks成功（819ms、1 executed/164 up-to-date）。指定remote branchへ同SHAをpushし、英語draft PR57を作成。本文に不変SHAの画像リンクと検証実施SHAを明記した。Codex対向承認comment5650802093を投稿、CI34735697110は実行中。Claudeの依頼文の代理投稿とmergeはCI成功後。msg_038444f2dc9bで現状を通知し、delivery_803b9896bcc8をackした。PR56は承認SHA1ca27f3のCI34730952948成功、sample統合・リンク再確認待ち。 + +## T10統合完了とT04c開始依頼（13:16 JST） + +ユーザーの継続指示後、PR57のhead52caec4/base work/3.0.0/CI34735697110 SUCCESS/CLEANを確認。Claude依頼文をcomment5651082255へ代理投稿し、Codex対向承認5650802093と合わせてready化・通常merge。統合SHA c298798789c0b9788e90ac732f5b11b2e5fcae8e（13:14:50 JST）。 + +共有workをfast-forwardし、文書PR56のローカルリンクを統合済みsampleと提案文書へ照合して成功。現head1ca27f3・Claude承認5650579496・CI34730952948 SUCCESSを確認し、本文のdraft依存記述を検証済み状態へ改訂。ready化後に通常mergeし、97080616f4ccc4b796799fba5b8998c4283e4d5dへ統合（13:16:13 JST）。main/tag/publishは未実行。 + +T10を完了扱いとし、ClaudeへT04cの開始を依頼。最新workから新しい隔離worktree、暫定2.x API除去、JVM可視性監査、Java/Kotlin consumer検証、影響範囲のcore/sample/Timber/lint確認が対象。具体的branch/worktree/検証計画は返答待ち。共有plan/logはCodex所有、lint stage2を無断で混在させない。T12の全端末matrixは引き続きrelease-blocking。 + +## Claude受領未確認のチェックポイント + +計画・ログのdraft PR58をhead48c1da0で共有し、msg_a623a8fdc53aで対向レビューを依頼。Orca受信箱は空。term_57cc4804-a813-4bd9-a03b-f8a7fc9c92b3のterminal readはstatus exited、tailなしを返した。端末一覧には以前のClaude端末が残るが、別の監視端末にも実処理停止済みとの表示があり、稼働する司令塔やT04c受領を確認できない。メッセージのenqueueを着手確認と誤認しない。T04cとPR58レビューは返答待ち、旧端末を無断で再利用・停止していない。PR58のレビュー対象SHAは変更せず、本記録をwave19へ分離した。 + +## Claude司令塔の復旧とmediumへの変更 + +ユーザーが司令塔起動と継続を明示指示し、続いてhighではなくmediumへ訂正。新端末term_66423650-ee22-4e09-a6ba-65ed19561512を作成。最初の起動文字列はモデル名の角括弧がzsh glob解釈され未起動だったため、同端末で引用を修正してclaude --model 'claude-fable-5-1[1m]' --effort mediumを実行。画面にFable5.1 with medium effortを確認。権限回避オプションは追加していない。 + +統合済みT07/T10、PR58の現SHAレビュー、T04cの隔離worktree・API整理・検証計画、所有境界、main/tag/publish禁止を引き継いだ。request62df7078-6f04-417e-bce6-2e82485896d7はinput_acceptedとturn_startedを確認。新しい調整Runと作業受領の返信は待ち。最新のmedium指示は古いhigh記述を上書きする。 + +## 復旧司令塔の受領確認 + +msg_c27a6649eba8 / delivery_7b155cb10022で、新端末term_66423650が既存run_3ae778449744へrun-useで再結合（consumer_generation5）したとの報告を受領。Fable5.1/medium、PR58レビューとT04c inventory開始を明示受諾した。PR58の対象SHAに関する質問には48c1da0ea08cf2c622215b3d93ec089b42ef32c0のままと回答。後続wave19のb2445ee/16bac48は意図的に分離しており、レビュー対象を変更しない。T04cの具体的worktree/branch/検証計画は返答待ち。通知をackした。 + +## PR58統合とT04cの範囲合意（13:47 JST） + +msg_8e3b6f207facでPR58のhead48c1da0ea08cf2c622215b3d93ec089b42ef32c0へのClaude承認を受領。指定文をcomment5651211614へ代理投稿し、CI34737580394 SUCCESS確認後、通常mergeでb4dff8f27b20aefb7e192b1e1518d0af0235eef1へ統合。共有workもfast-forward。T10行の「作業中。完了」のnon-blocking nitを次の計画更新で訂正する。 + +msg_5ec55fdf68e9でT04c開始報告を受領し、msg_7c6eaee7c67eで合意。worktree /Users/ai-seb/orca/workspaces/Android-OverlayViewManager/claude-3.0.0-t04c-api-cleanup、branch codex/claude-3.0.0-t04c-api-cleanup、base97080616。Claude Fable5.1/mediumが直接作業。対象はOverlayViewの18旧bridgeとpending/custom listener管理、managerの旧権限/表示サイズAPI、旧permission dialogとstrings/fragment依存、drag内部旧API呼出し。private constructorとfactory、JvmSyntheticを含むJVM可視性監査。内部public/RestrictToテスト接点の残存理由を明記し、syntheticをアクセス制御と説明しない。意味のある旧テストの振る舞いは新APIで維持する。 + +予定検証はcore assemble/unit/lint/androidTest APK、Timber assemble/unit、sample assemble/unit/lint、lint:testとjavap。lint stage2の新API対応はT04cに混ぜず、移行文書の暫定bridge説明は統合後Codexが変更する。T12はAPI23/26/35/36、別UID透過、両scope/非ゼロ原点/RTL/edge-to-edge/画面外配置でDOWN時no-jumpと実画面移動量の未完了検証を維持する。開始報告をack、候補SHA・検証結果待ち。 + +## 来週まで中断（ユーザー明示指示、13:50 JST） + +msg_dba35bee09abで新規作業停止・安全な保存を依頼。msg_a3c564d0fd0dでClaudeが停止報告。T04c worktreeのHEADは93b0423121419c758032d79c51b537a10b96e898、branch codex/claude-3.0.0-t04c-api-cleanup、tracked cleanをCodexも確認。commit1はOverlayView旧bridge/pending/custom listener状態除去、drag内部を新updateへ置換、state machineテスト移行。未push、PR未作成。ClaudeはJDK17/既知SDK/--offlineでcompileとcore:testDebugUnitTest成功を報告。CodexがXML実測108 tests・failure/error/skip0を確認した。全module/lint/公開API最終検証は未完了で、T04c完了とは扱わない。 + +来週の再開順: Claudeが同worktreeからmanager旧permission/display API・dialog/strings/fragment依存整理、次に可視性hardeningを続ける。新APIのJava/Kotlin consumer確認、javap残存公開surface監査、合意済み全チェック、対向レビュー・CI後にPR統合する。Codexは移行文書の暫定bridge説明をT04c統合後に訂正。続いてlint stage2、T11成果物、T12全端末matrix、T13 release/3.0.0→main PR。main merge/tag/publishは行わない。 + +Claude司令塔term_66423650と完了済みGradle端末term_1639d1fcは保持。新作業は開始しない。所有するemulator5580はadb emu killのOKを確認して停止、5554は操作していない。共有workはb4dff8f（PR58統合済み）。wave19の復旧・中断記録はローカル保存し、未承認のままworkへ統合しない。 + +### 最終停止報告の補足（作業再開なし） + +msg_5829f3b818daでClaudeから最終確認。93b0423はclean、build実行中なし。実行済みは--offlineのcore:compileDebugKotlin / compileDebugUnitTestKotlin / compileDebugUnitTestJavaWithJavac（6秒、build/t04c-compile1.log）、core:testDebugUnitTest（11秒、build/t04c-test1.log、108件成功）。未実行はTimber/sample/lint、lintDebug、androidTest compile、javap、connected。旧pending-spec失敗テストは既存failedUpdateテストが対応、custom-listener2件は機能削除に伴い廃止、setter chainはlayoutUpdateReachesTheBackendSnapshotAndClicksStayOnTheViewへ移行。Claudeは5580/5554未使用で、来週のユーザー再開指示までidle。中断状態を維持して通知だけ処理した。 diff --git a/docs/coordination/3.0.0/2026-09-13-pause.md b/docs/coordination/3.0.0/2026-09-13-pause.md new file mode 100644 index 0000000..cabb18f --- /dev/null +++ b/docs/coordination/3.0.0/2026-09-13-pause.md @@ -0,0 +1,79 @@ +# 2026-09-13 JST 一時停止チェックポイント + +## 指示と確認 + +ユーザー: 「claudeが制限到達で止まっちゃったので、一時停止してください」。Codexは新規作業を停止し、保存と引き継ぎ記録のみ実施した。 + +Orca端末を再読し、Claude司令塔 `term_f3d0c2e3-8507-47fd-a547-fcd4e82955ea` とT07担当 `term_b4d72bee-a9a2-447b-99b6-b125837cf663` の双方が session limit の表示後に入力待ちであることを確認。端末プロセスは保持し、再起動・追加入力・新規dispatchは行わない。司令塔への停止通知は送信したが、制限中の受領・実行確認は得られていない。制限解除だけでは再開しない。 + +## 保存状態 + +- 統合ブランチ `work/3.0.0`: `d6ccdf278f799f3dc8fe53df69f7936134012a83`。PR #51（T08）および #52（記録）まで統合済み。 +- T08の統合前検証: core 111 tests、失敗・エラーなし、lint/build成功。T07の検証結果ではない。 +- T07: branch `codex/t07-lifecycle`、worktree `/Users/ai-seb/orca/workspaces/Android-OverlayViewManager/t07-lifecycle`。Task `task_2db547061e3f`、Dispatch `ctx_72258eaf9359`。 +- T07の未コミット変更は `opt-timber/src/main/kotlin/com/nagopy/android/overlayviewmanager/opt/timber/DebugOverlayTree.kt` のみ。作業ツリーに保持。候補コミット・PR・検証完了・承認なし。`.claude/` はユーザー所有として触れない。 +- 計画・司令塔ログは `codex/3.0.0/coordination-wave16` に保存。停止中はこの文書のPRも作成・統合しない。 +- T10はC1/K1–K7の分担合意のみ。実装未着手。詳細は `2026-09-12-t10-planning.md`。 +- main、release branch、tag、公開処理に変更なし。 + +## 再開時に引き継ぐ未解決指摘 + +Codex送信 `msg_27806d0956af`（2026-09-12 14:59:47 UTC）。Claudeからの確認・修正完了は未受領。以下は未検証の途中コードへの指摘であり、修正済みと扱わない。 + +1. 古い世代のrenderがpendingのままdispose→reinitialize→新しいlogとなると、新世代のrender予約が抑止され、古いcallbackも世代不一致で破棄するため新ログが表示されない可能性。世代別pending管理を見直し、新ログを古いRunnableのdrain前に投入する回帰テストが必要。 +2. initialize時のbufferと `maxLines` 初期化を同じlock内で行い、並行logが旧上限を使う競合を防ぐ。 +3. 新規 `dispose()` の未初期化/no-op経路も含め、入口でmain-thread制約を検査する。 + +## 再開手順 + +ユーザーの再開指示を受け、既存Task/Dispatchと作業ツリーを確認して同じ担当へ引き継ぐ。重複workerを起動しない。T07の指摘修正・回帰テスト・最小ビルドを完了し、別担当レビュー、対向司令塔のexact-head承認、CIを経て通常のPR統合を行う。その後T10a（sample）/T10b（移行文書）へ進む。T04c、T09 stage 2、T11、T12端末検証、T13 release/3.0.0→main PRは未完了。T05/T06の実機受け入れ条件はrelease-blockingのまま。 + +## モデルと役割 + +Codex Astra/mediumが調整・指摘・停止記録を担当。Claude司令塔はFable 5.1/high（直前に `/effort high` で復元、詳細はT08ログ）。T07実装はClaude側Sonnet 5/high、独立レビューはまだ未着手。この停止処理で新規サブエージェントは起動していない。 + +## 制限解除後の意図しない再開に対する停止再通知 + +Claude連絡 `msg_ea2582ab7b16`（2026-09-13 02:36 JST）で、T07担当が02:34に自動的に再開し、ClaudeがCodexの3指摘を転送したとの報告を受領。先の入力待ち確認は当該時点の観測であり、制限解除後の停止継続を保証していなかった。ユーザーの再開指示はないため、Codexは停止継続を明示し、安全な境界で直ちに中断・現状保存・idleとし、修正や検証を続けないようClaudeへ再通知した。PR・承認・マージ・新規dispatchなし、T10未着手とのClaude報告。今回の通知時点では担当の再停止確認と最新checkpoint SHAは未受領。 + +## 2026-09-13 02:30 JST 明示再開 + +ユーザーの「02:30 JSTに再開」指示を受け、停止記録の再開手順に従った。Orca runtimeを起動して既存状態を再確認し、T07担当の同じTask `task_2db547061e3f`、Dispatch `ctx_72258eaf9359`、Terminal `term_b4d72bee-a9a2-447b-99b6-b125837cf663`、worktree `/Users/ai-seb/orca/workspaces/Android-OverlayViewManager/t07-lifecycle`、branch `codex/t07-lifecycle` を引き継いだ。新規worker・worktree・Dispatchは作成していない。 + +Orca terminal send request `72e6aca0-8864-4248-8902-32209a1fa595` は `accepted: true`、`input_accepted` と `turn_started` を返した。再開方針のDispatch宛てメッセージは `msg_3336a2f54803` としてdurable enqueueされ、active worktreeコメントも再開状態へ更新した。これは入力の受理と状態記録の証拠であり、実装完了や検証成功を意味しない。 + +再開時の読み取りでは、担当worktreeに `opt-timber/src/main/kotlin/com/nagopy/android/overlayviewmanager/opt/timber/DebugOverlayTree.kt` の未コミット変更（+192/-37）のみがあり、`.claude/`はユーザー所有として触れない。担当は既存差分から3件の未解決指摘（世代別render予約、initialize時のlock、dispose入口のmain-thread制約）と回帰テストを継続中。候補SHA、PR、検証、独立レビュー、exact-head承認、CI、統合は未完了であり、T07を完了扱いしない。 + +## 02:49 JST authority blocker と保存 + +再開後、T07担当は世代別render回帰テストなどを追加したが、古い停止操作が再度適用された。担当はopt-timberのみをWIP `6e243c3`（`WIP 3: T07 paused (regression test in progress; not a candidate)`）へ保存し、tracked差分なし、`.claude/`のみ未追跡の状態で停止した。 + +Orcaの照会では、既存Dispatch `ctx_72258eaf9359` は capability revoked 後に `stop_unknown` を経て `abandoned/failed`、terminal `term_b4d72bee-a9a2-447b-99b6-b125837cf663` は外部管理のまま `live` である。これはプロセス終了の証拠ではなく、同じT07を安全にretryできる状態でもない。Orca recovery規約に従い、replacement workerの起動、旧terminalの強制停止、worktreeの削除・上書きを行わず、authority blockerとして保存する。 + +### 次の安全な再開条件 + +- `t07-lifecycle` terminalの停止をOrcaでpositiveに確認する、または現在のterminal ownershipを明示的に移管できること。 +- その後、WIP `6e243c3` を基点に、3指摘の最終確認、テスト、自己レビュー、独立レビュー、exact-head承認、CIを順序どおり再開する。 +- T07のcandidate SHA／PR／検証／承認が揃うまで、T10・T04c・T09 stage 2へ進まない。 + +## 停止完了報告（02:43 JST） + +Claudeの一回限りの報告 `msg_a2a4a9c5ea49` を受領。T07担当は安全な境界で停止し、`codex/t07-lifecycle` にWIP checkpoint `4c080f89453981493078eb0aae61ff037851de3e` をコミットしてidle。未push、候補コミットではない。変更はopt-timberの `DebugOverlayTree.kt`、`DebugOverlayTreeTest.kt`、新規 `DebugOverlayTreeJavaConsumerTest.java` のみとの報告。司令塔もidle、明示的なユーザー再開指示まで作業・pollingなし。 + +先の未コミット保存状態をこの報告で更新する。Kotlin約40件とJava consumerのテストコードは作成されたが、Gradle未実行のため合否不明。報告内の「unit-tested」は検証成功として扱わない。Codexの3指摘はすべて未対応で、再開時の最初の修正対象。L7未着手、T10も未着手。再開後に修正・実行検証・独立レビュー・相互承認の通常手順へ戻す。 + +## 停止報告の訂正（02:46 JST） + +Claude連絡 `msg_0df1dfe57eac`: 02:42のidle報告後、担当が02:45に再び3指摘への対応を開始したとの訂正。Claudeは停止前の「apply now」連絡が後から実行された可能性を報告し、dispatchと端末の双方へ停止を再通知した。追加編集はWIP 2として保存し、明示的な `RESUME T07` 件名の指示までidleを維持するよう指示済みとのこと。最新checkpointと停止完了は再確認待ちであり、先のidle報告を現在の停止保証として扱わない。 + +Codexは古い実装指示が停止指示で失効していることを再通知。修正・テスト完了を待たず保存と停止のみを行い、idle維持ができなければ文書化されたworker-stop手順でcheckoutとコミットを保持して停止するよう要請。ユーザーから再開指示はなく、Codexは再開を許可していない。 + +## 最終停止報告（02:47 JST） + +Claude連絡 `msg_6a2d2f8ea0c5`: 担当が再停止指示に従い、`codex/t07-lifecycle` にWIP 2 `8aa29f5bfa6bdd3c8eeb68aa46ada77850ae0351` を保存。`4c080f89` の上に `DebugOverlayTree.kt` のみ変更。候補ではなく未push。担当・司令塔ともidleとの報告で、担当は司令塔からの `RESUME T07` 件名の明示指示のみで再開する。ユーザーの再開指示は引き続き未受領。 + +3指摘はproduction codeへ適用したとの担当報告だが、Codexは差分レビュー・実行検証していない。指摘1の決定的な回帰テストは未作成、全テスト未実行。したがって解決確認済みとは扱わず、再開時はWIP 2の差分確認、旧renderをdrainする前に新世代logを投入する回帰テスト、必要な実行検証から行う。PR・承認・マージ・新規dispatch・pollingなし。 + +02:48 JSTの追加報告 `msg_22aabbdfe713`: Claudeが `worker-stop` を実施し、古い指示からの再起動を防いだとのこと。報告されたdispatch statusの文字列は `dispatched` であり、Codexによる独立確認は未実施。worktreeはHEAD `8aa29f5bfa6bdd3c8eeb68aa46ada77850ae0351`、tracked clean、`.claude/` のみuntracked、未pushとして保存。端末は保持。再開時は旧dispatchの実状態を確認した上で、同worktreeに新しいtaskを起動する方針へ更新（停止中は起動しない）。司令塔はidle、polling停止との報告。 + +02:49 JSTの訂正 `msg_bf5180cbe3ed` が直前報告を置き換える。worker-stop後にも編集が続いたためClaudeが端末の実行ターンをinterruptし、最終WIP保存後にdispatchをabandonしたとの報告。dispatch `ctx_72258eaf9359` は `failed`、端末はidle。最新HEADは **`6e243c3b98d33a7cab9911f461020997f1f6f567`（WIP 3、回帰テスト作成途中）**。tracked clean、`.claude/` のみuntracked、未push、未検証・候補ではない。再開時はこのHEADを使用し、新taskで回帰テストと残りL6/L7を完了する。ユーザー再開指示までは新taskを起動しない。 diff --git a/docs/coordination/3.0.0/2026-09-14-t04c-resume.md b/docs/coordination/3.0.0/2026-09-14-t04c-resume.md new file mode 100644 index 0000000..1a5b38c --- /dev/null +++ b/docs/coordination/3.0.0/2026-09-14-t04c-resume.md @@ -0,0 +1,61 @@ +# T04c: 02:30 JST再開 + +- 状態: 再開指示受領、Claudeの今回の受領確認待ち +- 記録担当: Codex Astra / medium（直接作業、子起動なし） +- 既存合意: 2026-09-13-coordinator-resume.md の13:47 JST範囲合意と最終停止報告 + +## 2026-09-14 02:31–02:34 JSTの確認と連絡 + +今回のユーザー指示で前回の「来週まで中断」を解除。共有workはb4dff8f、未追跡.claude/のみで触れていない。既存T04c worktreeは93b0423121419c758032d79c51b537a10b96e898、tracked clean。既存調整worktreeはcodex/3.0.0/coordination-wave19の446389359fe08088fbb86c40de42546ae2918927、cleanで稼働端末なし。過去の未統合記録を保持する。GitHubのopen PRは0件。 + +Orcaへの通常アクセスはruntime_unavailable、openはruntime_open_timeout。サンドボックス外のstatusでruntime480a55de-4444-4d5d-9545-3792a13ecb97がready/reachableと確認でき、接続制約は解消。GitHub照会のForbiddenもサンドボックス外の読み取りで解消。 + +Orca runtimeで今回のClaude端末term_3993ef7f-7724-4b53-9ab2-2266f9722054が同じユーザー依頼を処理中と判明。msg_e8574064582e / msg_e092f9fd2ca3でT04cとGradleのClaude所有、plan/logと対向レビューのCodex所有を再通知し、モデル・effort・受領確認を依頼。旧Claude端末は起動・操作していない。最新の記録上のClaude指定はFable5.1/mediumであり、旧high記述を流用しない。今回の実際の設定は返信待ち。 + +Codexはterm_e747143e-93e9-4930-897f-06e7e129305cからrun_18f7185e91aaへrun-useしconsumer_generation2で再結合。旧Codexは中断済み、worker/Dispatchの起動・停止・releaseは行っていない。端末宛て送信はenqueueのみの証拠であり合意済みと扱わない。 + +代理許可は全体確認済みの4件: Orca環境変数と端末一覧の表示、今回Codex端末のreadとJSON整形、旧Claude端末のreadとJSON整形、今回Codex端末JSONの追加読取。各raw Enterはaccepted。恒久的な許可やauto modeへの切替は行っていない。 + +## 検証と次の担当 + +保存済み93b0423の差分3ファイルを読取確認。旧bridgeとpending/custom listener除去、新updateへのdrag呼出し置換、回帰テスト移行が対象。前回のcore108 tests成功を今回の再実行とは扱わず、新しいGradle実行なし。 + +Claudeが同worktreeでmanager旧permission/display API、dialog/strings/fragment依存整理、可視性hardeningを継続する。新APIのJava/Kotlin consumer、javap、core/Timber/sample/lintの合意済みチェックと候補SHAの対向承認・CIは未完了。T12の端末matrixはrelease-blockingのまま。CodexはT04c統合後の移行文書更新も担当する。main merge/tag/publishは対象外。 + +02:36 JST: msg_9c000ba387b5を既存Claude Run run_3ae778449744にもdurable enqueue。返信は未受領。 + +## 02:37–02:41 JST: 記録PRとClaude Run再結合 + +PR59 head429b9685fa7d2b684be474bf0bd68a1666b6fe14をdraftで作成。CI34772264915は実行中。最初のpushは自動承認レビューが未確認originへの送信として拒否した。git remote -vで既存宛先git@github.com:75py/Android-OverlayViewManager.gitを確認し、ユーザーの記録更新依頼とタスクPR運用の根拠を提示した再審査は許可され、push成功。迂回送信はしていない。 + +追加の代理許可2件は旧Claude端末JSONの追加読取とプロジェクト端末一覧のみ。これにより合計6件。Python整形付きinbox確認の別要求はコマンド先頭が画面外で全体確認できず、許可せずEscapeでキャンセルした。msg_e811aacc1b68で平文のinbox確認を依頼。 + +注意喚起のterminal sendはagent_prompt_blocked後、同じrequest93a4efa2-1898-4f15-99ce-d925b5f7484aでinput_accepted/turn_startedを確認。新しいrequestで重複送信していない。Claudeはrun_3ae778449744を今回端末へconsumer_generation6で再結合済み。受領・実装着手・モデル/effortの返答は未確認。 + +PR59のheadを固定するため、以後の記録は同じ所有worktreeのcodex/3.0.0/coordination-wave20へ分離した。PR59は対向承認前で未マージ。 + +02:42 JST: PR59のCI34772264915 SUCCESSを確認。T04c worktreeは引き続きclean。Claudeの現在画面にhigh effortが表示され、前回の明示指定mediumと不一致のためmsg_b94524596a39で実装前の設定確認・整合を依頼。現在設定がmediumになったとは扱わない。 + +02:43 JST: inbox --fullの読取でmsg_0515b70d1f37 / msg_359767654e6bを発見。Claudeは02:40に既存T04cの直接所有、Gradle再準備、commit2→可視性整理→全検証、PR59レビューを明示受諾していた。replyがClaude Run内のCodex端末宛てに保存され、Codex Runのcheckへ届かなかったことが遅延原因。今後はsend --to run:run_18f7185e91aaとするよう訂正。担当範囲は双方合意、実際のeffort整合だけは未確認。新規worker起動なし。 + +02:45 JST: msg_40c9597a3845 / delivery_b63083baca3dのPR59承認を受領。現full SHA429b9685fa7d2b684be474bf0bd68a1666b6fe14・base work/3.0.0・MERGEABLE/CLEAN・CI34772264915 SUCCESSを確認し、Claude指定どおり承認comment5654969385を代理投稿。ready化後、--match-head-commit付き通常mergeで213a7d00d6a561b810021669d108cd3607475c45へ統合（02:45:52 JST）。共有checkoutをfast-forward、通知をack。msg_f16fbdc7b16eでClaudeへ統合を通知。 + +Claude報告: commit2のmanager旧API、permission dialogと旧テスト・strings、fragment-ktx依存整理の編集済み。Gradleは新しいT04C-GRADLE端末で実行。offlineでannotation-experimental 1.3.0未キャッシュの失敗を報告し、後続compile2.logのCodex読取ではcollection1.0.0未キャッシュを確認。成功とは扱わない。msg_27d8dc132990で単なるcache都合の版数選択を避け、既存解決版の維持とオンライン解決を依頼。Claudeはeffortを内側から観測できないと回答したが、Codexの画面にはhighが明示されているため実設定mediumとは記録せず、安全なidle境界での設定復元を依頼中。 + +02:49–02:50 JST: msg_7b1049590a26 / delivery_74332f2c716aを受領・ack。Claudeは従前のfragment-ktxで解決されていたcore1.9.0を維持したと依存レポートの根拠を報告。オンラインcompile成功。次のcore unit online実行を代理許可する前に、term_3e8fc750-c7b6-46d5-95b3-6687350498e6がT04c専用worktreeの待機シェルであるとshow/readで確認した。所有権/依存/effort報告送信+ackコマンドもセッションの直近Bash入力で全体確認して代理許可（追加2件、合計8件）。 + +effortを変更できる保存済み境界というClaudeの報告に従い、既存端末へ/effort mediumを送信。request7fcb819c-4b6e-4cef-a68f-87d64a5e0472はagent_prompt_blocked後、同IDの再確認でoperation_unknown（到達した可能性があり再送しない）となった。画面はdraftとして/effort mediumを保持し、設定適用の証拠なし。別ID・raw Enterによる代替再送はしていない。msg_641fa5fc58f4で現在の検証・保存の区切りとidleを依頼した。これは製品成果を破棄する指示やworker終了ではない。 + +差分レビューで、変更対象androidTestの既存timeout比較が逆（deadline > nowで例外）と判明し、msg_932070d7089bで修正を依頼。端末動作は依然未検証。 + +02:52–02:53 JST: T04c commit2を7d5af7bdbc35cf2f18ddd4cdf2668c4d8444c261へ保存したことを確認。worktreeはtracked clean。core本体/unit/androidTestのcompileはオンライン依存解決後に成功、core unitログBUILD SUCCESSFUL（10秒）とXML105件・failures/errors/skipped全0をCodexも実測。XML集計の読み取りを全体確認して代理許可（合計9件）。旧manager API/permission dialog削除と依存整理、端末テスト移行とtimeout比較修正まで保存済み。JVM可視性hardening、Java/Kotlin最終consumer監査、全module検証と端末matrix、実装PRは未完了。 + +msg_37c610a774d1で成果確認と、operation_unknownの設定操作を別入力で重複させず現在の保存済み地点でidle報告するよう依頼。実装所有権はClaudeに維持し、Codexは成果を変更しない。 + +## 02:54 JST: 設定操作の不確実性で保存・待機 + +Claudeは受信箱の待機依頼を処理する前にcommit3の一部編集を進めた。新しいfactory書換えとGradle実行を含む許可要求を承認せずEscapeでキャンセルし、Ctrl-Cで現在ターンだけを中断。画面にInterrupted / done 2:54 AMを確認し、プロセスと端末は保持。idle後も同一requestの/effort mediumはoperation_unknownで、設定適用を確認できない。ユーザー操作によるmediumへの設定確認が必要なblockerとして保存する。 + +T04cのHEADは7d5af7bdbc35cf2f18ddd4cdf2668c4d8444c261。保存後のcommit3途中差分は7ファイル（DraggableOnTouchListener.kt、OverlayViewManager.kt、DraggableOnTouchListenerTest.kt、OverlayPermissionPreflightTest.kt、OverlayViewGravityTest.kt、OverlayViewStateMachineTest.kt、PassThroughOpacityAdmissionTest.kt）に未コミットで残る。OverlayView側factory書換え要求はキャンセルされたため途中状態であり、最新working treeのコンパイルは未検証。既存7d5af7bの105 tests成功をこのWIPの成功と扱わない。差分を/private/tmp/overlay-t04c-commit3-wip-20260914.patch（21332 bytes）にも読取保存した。所有権はClaudeのまま、Codexは製品ファイルを編集・復元・削除していない。 + +次の担当: ユーザーが既存Claude端末のeffortをmediumへ設定して確認後、同じClaude担当が7ファイルのWIPとfactory適用の残りから再開する。commit3のコンパイル、全module検証、javap/Java/Kotlin consumer、相互レビュー・CIは未完了。T12端末matrixも未完了。 diff --git a/docs/coordination/3.0.0/2026-09-15-t04c-resume.md b/docs/coordination/3.0.0/2026-09-15-t04c-resume.md new file mode 100644 index 0000000..bc62c8e --- /dev/null +++ b/docs/coordination/3.0.0/2026-09-15-t04c-resume.md @@ -0,0 +1,33 @@ +# T04c: 2026-09-15 02:30 JST再開 + +- 状態: blocked（実effort不一致とterminal入力operation_unknown）、成果保持 +- 記録担当: Codex Astra / medium、直接作業 +- 実装所有者: Claude。新規worker・Dispatchを起動していない。 + +## 確認した保存状態 + +共有work/3.0.0は213a7d00d6a561b810021669d108cd3607475c45。未追跡.claude/は保持。既存調整worktreeはcoordination-wave20のd88ce69de798144b29c5afaa20ae3e641fde6574、clean・端末なし。PR60はdraft、旧headのCI成功、承認なし。 + +T04cは7d5af7bdbc35cf2f18ddd4cdf2668c4d8444c261と7ファイルの未コミット差分（37追加/37削除）を保持。manager/testのOverlayView.create呼出し移行に対するfactory本体は未適用。前回のcore105 tests成功は保存済みcommit2の証拠であり、現在WIPは未コンパイル。製品ファイルの変更・復元・削除やGradle実行はしていない。 + +## Orca連携 + +通常接続はruntime_unavailable、openはruntime_open_timeout。サンドボックス外から同じorcaでruntime480a55de-4444-4d5d-9545-3792a13ecb97のready/reachableを確認し接続できた。 + +今回Codexはterm_be417eeb-675e-4dba-889a-e49ccad27182、Claudeはterm_c93a8afa-51ac-40e3-aa80-6eb8f1121f91で同じ再開依頼を調査中。msg_9b65fc9795e0でT04c/GradleはClaude、plan/log/対向レビューはCodexと通知。enqueueは受諾証拠ではない。Claudeの画面はhigh effortで、計画末尾の最新指定mediumと不一致。後続ユーザー指示の有無、または安全なidle境界での設定整合を確認依頼した。旧operation_unknownを再送していない。 + +旧Claude Runへの追加通知はrun_not_foundで失敗。実在端末への通知は成功しており、Runを推測して再作成していない。 + +代理許可2件: T04c既存シェル3端末の読取確認、および T04c GradleログのtailとOverlayView constructor検索。完全な読取コマンドを確認して今回のみEnterで許可し、acceptedを確認。auto modeや恒久許可には変更していない。 + +## 未完了と次の担当 + +Claudeの設定整合・所有権受領確認後、同じ所有者がcommit3 WIPから継続する。Codexは候補差分の対向レビューを担当。全module検証、Java/Kotlin consumer、javap、現head対向承認、CIは未完了。T12端末matrixはrelease-blockingのまま。詳細な前回経緯は2026-09-14-t04c-resume.mdを参照。 + +02:35 JST: run-listでClaude Runの存在と今回端末への結合generation7を確認。Codex Runも旧端末不在確認後generation3で今回端末へ再結合した。msg_ca57c2709d29をClaude Runへ送信成功。先のrun_not_foundはその試行の結果として保存し、恒久的なRun消失とは扱わない。 + +## 02:37 JST: blocker保存 + +Claudeの通知・ack許可要求は先頭が画面外で完全確認できず、承認せずEscapeでキャンセル。注意喚起request b7228ebd-1a62-4ade-88a8-7e9834a7f3b6はagent_prompt_blocked後、指定どおり同IDで確認するとoperation_unknown。再送せず、画面のInterrupted / done 2:36 AMと未送信draftを確認した。プロセスは保持し、新規起動や製品編集を行っていない。実effortはhighの観測のみでmediumへの整合は未確認。ユーザーがClaudeのmedium設定と端末入力状態を確認することが次の解除条件。Orca通知の受諾・相互承認は未完了。 + +文書差分と相対リンクを確認しgit diff --check成功。製品の新しい検証は実行していない。PR60に今回記録を追加し、対向承認前のため統合しない。 diff --git a/docs/coordination/3.0.0/2026-10-18-pr61-integration.md b/docs/coordination/3.0.0/2026-10-18-pr61-integration.md new file mode 100644 index 0000000..36c205d --- /dev/null +++ b/docs/coordination/3.0.0/2026-10-18-pr61-integration.md @@ -0,0 +1,86 @@ +# T04c/T09/T11/T12: PR61の採用と統合 + +- 状態: PR61/62/60は統合済み。配布はJitPack継続。10月25日の別UID試験は受信Activity方式の結果で置換（末尾参照）。T12全体とT13は最終検証記録で管理 +- 関連タスク: T04c, T09 stage 2, T11, T12 +- 記録担当: Claude司令塔（Opus 5.5 / Claude Code、サブエージェントなし） +- 関連PR / head SHA: PR61 `99c918e720c93f20663eef379e4d2bcb63bc6888` → merge `2c256a83d5e41d9deaa6541c350d55bce1f7b108`、PR62 `96bf3fed06cdaf66c760d9eb32070a5fccf70bb6` → merge `208588f4fba70d16d69f154f95615785fd08cfba`、PR60 `9432a900dc625838705080e71e4350280629047f` → merge `9776926d28ad5577279d59a77f9f03a1aa231414` +- Orcaメッセージ / Task / Dispatch: なし。サンドボックスの許可ソケットが古いソケットのままで、Orca runtimeへ接続できなかった（EPERM）。Codex司令塔とは今回やり取りしていない。 + +## 背景・選択肢 + +2026-09-15 02:54 JSTの中断時点では、T04cはClaude worktreeでcommit2 `7d5af7b` まで保存し、commit3の7ファイルWIPが未コミットだった。2026-09-20にユーザー依頼のDevinが、`213a7d0` から `work/3.0.0-devin` を作り、PR61でT04cの再実装、T09 stage 2、T11、T12の端末テスト追加を行った。その後ユーザーがCIからAndroid SDK setup手順を外す2コミットを追加。PR61はレビューなし・未マージのまま、CIは成功していた。 + +選択肢は、(a) PR61を採用する、(b) 旧Claude worktreeのcommit3を完成させる、の2つ。Claudeは(a)を推奨した。理由はT04c〜T12をまとめてカバーしてCIも成功している一方、(b)はcommit3が未完成で全module検証も未実施だったため。 + +## やり取り（発言要旨） + +| 日時・タイムゾーン | 発言者 | 提案・返答・異論 | 根拠・元メッセージ | +| --- | --- | --- | --- | +| 2026-10-10 JST | ユーザー | 進捗の確認 | 対話 | +| 2026-10-10 JST | Claude | 状態を報告し、PR61の採用を推奨 | git refs、`gh pr view 61` | +| 2026-10-10 JST | ユーザー | 「それで進めて」 | 対話 | +| 2026-10-10 13:43 JST | Claude | 全差分をレビューし、承認コメントを投稿。マージは自動許可の判定が拒否 | issuecomment-6093875504 | +| 2026-10-18 15:38 JST | Claude | レビュー指摘1・2をPR62で修正し、draftで作成。CI run 39104750420が成功 | PR62 | +| 2026-10-18 16:34 JST | ユーザー | マージを許可。ClaudeがPR61をマージ。PR62はClaudeのready化が拒否されたため、ユーザーが自分でready化・マージ | 対話 | +| 2026-10-18 JST | ユーザー | PR60は推奨どおり統合、端末確認を許可、配布はJitPackをやめMaven Centralを検討 | 対話 | +| 2026-10-18 JST | ユーザー | 需要を検討した結果、JitPack継続・mainへ実績として公開・その後は最小限の保守（案B）を選択。Maven Central移行は見送り | 対話 | +| 2026-10-25 JST | ユーザー | API36エミュレータで端末テストを実行。初回1件失敗 | b2a927e、`build/t12-connected.log` | +| 2026-10-25 JST | ユーザー | `SAME_UID_ONLY`の列挙名は変えず、説明を直す案を選択 | 対話 | +| 2026-10-25 JST | ユーザー | 修正版を再実行し、sample 9/9成功 | b2c484e、PR64 | + +## 判断結果・理由 + +PR61のレビューで、差分そのものにマージを止める欠陥はなかった。確認した内容は次のとおり。 +- 削除したAPIの参照が残っていない。 +- `update(OverlaySpec)`だけの変更経路で、DRAGGABLE→DRAGGABLEのときdrag listenerを再利用する。 +- lint detectorが宣言クラス・引数数・定数評価を確認している。 +- version/jitpack設定がpublicationと整合している。 +- 追加された端末テストが空振りにならない（再生成と透過の反証つき）。 + +リリース前のフォローアップとして4点を指摘した。 + +1. `OverlayView`の`internal constructor`がJVMでpublicで、`disposeForActivityDestruction$core`も同様。旧ビルドの`javap`で実証した。→ PR62で、private constructor、`@JvmSynthetic`のinternal companion `create()`、`@JvmSynthetic disposeForActivityDestruction`、`OverlayViewJvmVisibilityTest`を追加。 +2. CHANGELOGと移行ガイドに、互換APIが残る旨の古い記述があり、lint IDの変更も未記載。→ PR62で修正。 +3. lintがKotlinのconstructor/`copy`の名前付き引数を検出しない。→ 移行ガイドに既知の制限として記載した。detectorの拡張は未対応。 +4. 別UIDアプリへのタッチ透過は未確認で、release-blocking。JitPackビルドは、ユーザーがJitPack廃止を検討しているため不要になる見込み。 + +PR62はClaude側のPRで、規約上はCodexの対向承認が必要だった。Codex司令塔が稼働していなかったため承認はなく、ユーザーの明示許可とCI成功を根拠にユーザー自身がマージした。PR60はCodex作成の記録PRで、Claudeがhead `9432a90`へ承認コメントを付けて統合した。記録内容の時点（T04c途中）はPR61で置き換えられたが、経緯の記録として残す。 + +## 検証 + +- PR61 CI run 35492821736 (`99c918e`)、PR62 CI run 39104750420 (`96bf3fe`): assemble、unit test 4 module、lintすべて成功。 +- サンドボックス内ではGradleが起動しない（ローカルbind不可でFileLockContentionHandlerがEPERM）。adb serverも同じ理由で起動しない。PR61の161 tests、publishToMavenLocal、R8 consumer、API23/26/35/36の端末テストはDevin申告のままで、未再現。 + +## 未解決事項・次の担当 + +- T12: 別UIDアプリへのPASS_THROUGH透過と不透明度上限の拒否を、API35/36のエミュレータで確認する。ユーザーは実施を許可済み。サンドボックスの`allowLocalBinding`を許可してもらう必要がある。担当はClaude。 +- T11: 配布をMaven Centralへ移す。必要な作業は次のとおり。 + - groupIdとnamespaceを決める。 + - 署名・POM情報・sources/javadocのpublish設定を入れる。 + - `jitpack.yml`を削除し、READMEと移行ガイドの導入手順を書き換える。 + - 実公開は計画の範囲外のまま。 +- T09: Kotlinの名前付き引数をlintで検出するかは任意の改善で、未決定。 +- 旧worktree `claude-3.0.0-t04c-api-cleanup`（7d5af7bと未コミットWIP）は不要になったが、削除はユーザー確認後。 +- T13はT12完了後。 + +## 計画・実装・検証への影響 + +T04、T04c、T09は統合済みに更新した。T11は一部統合（配布方法の変更待ち）、T12は作業中（端末確認待ち）とした。T04c/T06のPR40フォローアップ3件のうち、可視性と暫定listenerの2件を完了扱いにした。DISPOSED診断KDocの件は未確認のまま残す。 + +## 2026-10-25追記: T12の別UID透過確認と配布方針 + +### 配布 + +ユーザーはライブラリの需要を検討し、案Bを選んだ。3.0.0は実績としてmainへ出し、配布は設定済みのJitPackを続け、その後は最小限の保守とする。上記「未解決事項」のT11（Maven Central移行）と指摘4の「JitPackビルドは不要になる見込み」は、この判断で取り消す。JitPackビルドはタグ作成後に確認する。 + +### 別UIDアプリへのタッチ透過（後続レビューを反映） + +初期のPR64はSettingsの検索バーをタップする方式で、API36のsample 9/9成功を報告した。しかしCodexの後続検証で、Settingsは非システムoverlayを非表示にするため、タッチ透過の証拠として不適切と判明した。この旧結果から別UID透過を完了扱いにしない。 + +Claudeはtest APK内の別UID受信Activityへ置き換え、表示中overlayの入力windowとタップ点の包含、受信側UID、実際のタップ回数をassertした。CodexがAPI31初期r02、API31更新r03、API36で各3/3成功を確認した。API31ではalpha 1.0で遮断、API36では約0.8へ補正され到達した。公開列挙名はユーザー選択どおり維持し、補正の有無はビルドに依存する説明へ更新した。 + +正確な候補SHA、fingerprint、実行コマンド、相互レビュー、CIは[PR64再検証記録](2026-10-25-pr64-device-validation.md)を参照する。上の10月18日時点のMaven Central案は、ユーザーのJitPack継続判断で取り消された。 + +### 残り + +T12の他の端末条件、成果物/consumerの最終照合、PR63/64の現head承認・CI・統合を経てT13へ進む。API31/36の3テストだけで全体の完了とは扱わない。[10月31日の最終検証記録](2026-10-31-release-validation.md)へ引き継ぐ。 diff --git a/docs/coordination/3.0.0/2026-10-25-pr64-device-validation.md b/docs/coordination/3.0.0/2026-10-25-pr64-device-validation.md new file mode 100644 index 0000000..72bcf58 --- /dev/null +++ b/docs/coordination/3.0.0/2026-10-25-pr64-device-validation.md @@ -0,0 +1,76 @@ +# T12: PR64の別UIDタップ透過を再検証 + +- 状態: receiver方式・所有範囲は双方合意。候補の端末検証成功。最終headの対向承認・統合はこの記録時点では未完了。 +- 記録担当: Codex。既存Claude司令塔がコードと利用文書を修正、CodexがSDK・端末検証と計画・ログ更新を担当。新規サブエージェントは起動していない。 +- PR: [#64](https://github.com/75py/Android-OverlayViewManager/pull/64)。base `9776926d28ad5577279d59a77f9f03a1aa231414`、検証候補 `c9d8334f358a72217419947ddc3bc2bb57c61e9a`。 +- 独立検証worktree: `codex-pr64-device-validation` / branch `orca/codex-pr64-device-validation`。実装worktree: `claude-3.0.0-t12-cross-uid` / branch `claude/3.0.0/t12-cross-uid`。 + +## 背景と判断 + +ユーザーはPR64レビュー、レビューコメントの投稿、その後のAPI31/36検証を依頼した。最初の指摘は、Android 12初期版には2022年3月のWindowManagerによる不透明度補正がないため、API31以上を一律に「alphaを上限へ補正して通す」と扱えない点だった。 + +- [当初のレビュー](https://github.com/75py/Android-OverlayViewManager/pull/64#issuecomment-6396264825) +- [AOSPの不透明度補正](https://android.googlesource.com/platform/frameworks/base/+/a451d5bae2e2fb1e75152c596a6f476d6f7ac1ec) + +再検証で、旧テストのSettings画面が非システムのオーバーレイを隠すことが判明した。API31のwindow dumpは `mForceHideNonSystemOverlayWindow=true`、`mPolicyVisibility=false`、`isReadyForDisplay()=false`、`mLastAlpha=0.0`。Viewのattachmentと座標の包含だけでは、タップ時に表示されている証拠にならない。**Settingsを用いた以前のsample 9/9成功は、別UID透過の証拠として採用しない。** + +- [Settingsのoverlay非表示処理](https://android.googlesource.com/platform/packages/apps/Settings/+/a74060c1b7002edcc6d2747addc1dfb61aa98cbb) +- 途中でAPI31の検索欄がEditTextではなくAutoCompleteTextViewである点も修正したが、Settings自体が不適切と判明したため、最終方式ではそのselectorを使わない。 + +## 調整の要旨（2026-10-25 JST） + +1. CodexはAPI31イメージとAPI36の検証を専有し、Claudeはテストと利用文書を所有することで合意。Gradle・SDKの競合を避けた。 +2. CodexがSettingsの非表示証拠と、未初期化の同UID input layer（type UNKNOWN / visible=false）を誤採用する問題を報告。Claudeはvisibleなoverlay input windowを待つ方式へ変更した。 +3. Codexが「既存androidTest APKに受信Activityを置く」方式を提案。Claudeが同意し、`c9d8334`で実装。新moduleやproduction behaviorの変更は不要と判断した。受信Activityはoverlay非表示やobscured-touch拒否を設定しない。 +4. 受信側のpackage UIDとsample UIDが異なること、画面上の実行UIDがtest APKのUIDであること、表示中overlayがタップ点を覆うことをassertする。タップ後の画面上の回数を検証する。 +5. 計画・調整ログはCodexだけが編集し、Claudeがそのcommitを確認してPR64へ取り込むことで合意。最終文書は「多くのビルド」等の普及率の推測を避け、補正の有無に依存する説明にするよう依頼した。 + +Orca: 既存Claude端末 `term_de4fd3ba-d1a1-458a-8184-a64c4403a379`。所有権連絡 `8350f35c-5924-4ca4-9ee2-b37ea628d3df`、selector報告 `0cd904ad-f6f0-42ef-b89b-9f5f47db90d8`、非表示証拠 `f53087c2-0f0f-40b8-81c4-bbf3d5e5208e`、再検証結果送信 `cfb3b052-cd9f-444e-8cba-c98887b8ef63`。受信・応答が確認できた合意と、結果送信のreceiptは区別する。永続の結果報告は[PRコメント](https://github.com/75py/Android-OverlayViewManager/pull/64#issuecomment-6396450325)にも保存した。 + +代理許可: ユーザーが許可した範囲で、Codexが完全なコマンド・対象・効果を確認し、4ファイルのcommit/通常push（`3d7ae4a`）と、test manifest/CrossUidPassThroughTestだけを変えるPython/sedスクリプトを許可した。前者の通常送信はpermission promptに拒否されたため、画面のYesをbare Enterで選択（receipt `ce3a790d-6215-4f90-84b5-3ff305274c2f`）。後者は完全なスクリプトを確認して同様に許可（`570a73da-a480-4770-a42b-f789267fddea`）。merge・release・公開は許可も実行もしていない。 + +## 検証結果 + +JDK17、Gradle9.4.1、Android SDK36 / Build Tools36.0.0、emulator37.1.11を使用。各環境で同じ候補 `c9d8334f358a72217419947ddc3bc2bb57c61e9a` を順次実行した。 + +```sh +ANDROID_SERIAL= ./gradlew :sample:connectedDebugAndroidTest \ + -Pandroid.testInstrumentationRunnerArguments.class=com.nagopy.android.overlayviewmanager.sample.CrossUidPassThroughTest \ + --console=plain +``` + +実行時には上記コマンドを `rtk proxy env` 経由で呼び出した。 + +| 環境 | serial | 結果 | alpha=1要求時の表示中input alpha / タップ | +| --- | --- | --- | --- | +| API31 initial arm64 r02 | emulator-5584 | 3/3成功、failure/error/skip 0 | 1.00 / 遮断（InputDispatcherのdropログあり） | +| API31 default arm64 r03（SDK repository revision4） | emulator-5582 | 3/3成功、failure/error/skip 0 | 1.00 / 遮断（InputDispatcherのdropログあり） | +| API36 Google APIs arm64 | emulator-5554 | 3/3成功、failure/error/skip 0 | 0.799805 / 受信側tap countが1 | + +3件の内訳は、上限の半分のalphaで別UIDへタップ到達、上限超過のWHEN_SYSTEM_ALLOWSをattach前に拒否、不透明SAME_UID_ONLYがOSの実際のalphaに応じて通過/遮断すること。上限は全環境で0.8。低alphaはAPI31で0.40、API36で0.399902。API31はvisible=true/type2038、API36はNOT_VISIBLEを含まないNOT_TOUCHABLEのinput windowを確認した。各ケースのUID assertionsも成功した。 + +Build fingerprints: + +- API31 r02: `Android/sdk_phone64_arm64/emulator64_arm64:12/SC/7752726:userdebug/test-keys` +- API31 r03: `Android/sdk_phone64_arm64/emulator64_arm64:12/SE1A.220621.001/8752307:userdebug/test-keys` +- API36: `google/sdk_gphone64_arm64/emu64a:16/BE2A.250530.026.F3/13894323:userdebug/dev-keys` + +初期イメージは[Google公式arm64-v8a-31_r02.zip](https://dl.google.com/android/repository/sys-img/android/arm64-v8a-31_r02.zip)（Last-Modified 2021-10-04、636979726 bytes、SHA256 `2124286179ce00b613fa109009eba06985bb6ec7c799d57173489842587e4864`）。専用AVDから別ディレクトリのimageを参照し、通常SDKのAPI31 imageは置換していない。 + +ローカル証跡: `/private/tmp/ovm-pr64-evidence/c9d8334-api31-r02-results`、`c9d8334-api31-r03-results`、`c9d8334-api36-results` に各XMLとtest logcat、同prefixの `*-gradle.log` にビルド結果を保存。Settings非表示のdumpは `api31-r03-window-observation.txt`。一時ディレクトリの保存は永続保証ではないため、本ログにもfingerprint・SHA・コマンド・観測値を記載した。 + +候補の[CI run 40184221635](https://github.com/75py/Android-OverlayViewManager/actions/runs/40184221635)も成功。その後の `43b1b3b47fa543595f015983dfa955ca028079d7` はREADME・KDoc・移行ガイドだけを修正し、androidTestは `c9d8334` と同一であることをCodexとClaudeが差分で確認した。[43b1b3bのCI run 40184685971](https://github.com/75py/Android-OverlayViewManager/actions/runs/40184685971)も成功。端末検証は上記3テストのみで、sample全体やrelease matrixの再実行とは区別する。 + +## 残るゲートと記録の整合 + +- 最終の説明修正と本記録を含むheadに対して、差分確認・ClaudeによるCodex文書の確認・CodexのPR64承認・CI確認が必要。mergeは実行していない。 +- PR63 head `f1627229a60b302923379dc480c622063a2fd42d` の「Settingsで端末確認済み／次はT13」は上記発見より前の記録。今回のreceiver結果で置き換え、PR63/64統合時には新しい履歴を失わず計画を整合する。配布をJitPack継続とするユーザー判断は変更しない。 +- 本作業はAPI31/36の別UID透過に限定。合意済みAPI23/26/35を含むT12全体、T05/T06の権限・drag・座標等のrelease-blocking試験や最終consumer/成果物検証を完了扱いにしない。未実施ゲートは両司令塔が別途証跡を照合して閉じる。 + +## 記録の対向レビュー（2026-10-25 19:28 JST） + +Claudeは記録commit `49622cc` を読み取りレビューし、XML・logcatの数値、fingerprint、候補CI、PR63 headの一致を確認した。Orca receiptと初期imageのSHA256はClaude側では未照合（Codexが取得・記録）。指摘は、現head `43b1b3b` とCIの追記、PR63との統合手順の具体化、計画末尾の空行1行削除の3点。本追記と上記CI説明で対応した。 + +PR63との整合は次の順を提案し、実際のmerge/rebase/pushを行う承認とは区別する。PR64を先に統合する場合、PR63所有者Claudeが最新baseを取り込み、計画と調整ログの旧2026-10-25節を本記録への参照に置換する。状態行の「次はT13」とT12行の旧sample9/9を訂正し、T12全体の未完了ゲートを保持する。2026-10-18の統合履歴を失わず、10月18日→25日の順に並べる。競合解消後はCodexが差分を再確認し、新head承認・CIを確認する。両PRは現在未マージで、この手順は将来の統合時のもの。 + +記録のPR64 branchへの取り込み/push依頼は自動承認レビューが拒否し、ユーザーの明示回答待ち。Codexは許可不要の読み取りレビューとローカル修正まで完了し、取り込み/push/PR63変更を実施していない。[コードレビューと現head CIの報告](https://github.com/75py/Android-OverlayViewManager/pull/64#issuecomment-6396511235)は投稿済み。最終merge承認は記録反映後のheadに対して別途確認する。専用API31エミュレータ5582/5584を停止し、既存5554は起動したまま保持した。 diff --git a/docs/coordination/3.0.0/2026-10-31-release-validation.md b/docs/coordination/3.0.0/2026-10-31-release-validation.md new file mode 100644 index 0000000..46eacf3 --- /dev/null +++ b/docs/coordination/3.0.0/2026-10-31-release-validation.md @@ -0,0 +1,162 @@ +# 3.0.0 最終検証・リリースPR + +## 目的・担当の合意 + +2026-10-31 JST、ユーザーはCodexとClaude Codeへ、相談して妥当な案を選び、品質を落とさず過度に複雑にせずmain向けPR作成まで進めるよう指示した。mainへのマージ・タグ・正式配布は実行しない。配布先は既定のJitPackを維持する。 + +ClaudeはPR63およびplan/logの所有権をCodexへ移管することに画面上で明示合意。Codexは計画・ログ・PR63更新、Gradle/SDK/端末/consumer検証、相互承認後の統合とrelease PRを担当する。ClaudeはPR64、追加端末テスト、公開API・成果物・利用文書の対向レビューを担当する。新規サブエージェントは起動しない。 + +Orca runtime `52f3b92b-a534-4d1e-a1db-d0e22a749584`。Codex `term_cf3261ec-1c55-4dd7-b66a-bcd6fe532734`、Claude `term_de4fd3ba-d1a1-458a-8184-a64c4403a379`。Codex Run `run_18f7185e91aa` を現在端末へ再結合（generation 4）。分担提案 `msg_dd0ffaa4dd2f`、端末送信receipt `5b60386f-80bc-4065-bab6-641be797c60f`、受け入れ条件追加 `d13dc305-a9e4-4a22-8fdc-1c1d095d6d11`。Claudeのsandboxから現Orca socketへ接続できないため、受諾は端末の実際の返信で確認し、enqueueだけを合意としない。 + +## PR64・PR63の整合 + +Claudeが既存Codex記録 `49622cc` と `3e05597` をPR64へ取り込み、head `9974c488e3afa4462eeb675ba04f16ed27052c0f` をpush。Codexはtreeが `3e05597` と同一で、CI `41189303564` が成功したことを確認した。製品・端末テストは前回検証候補から変更されていない。Claudeの記録承認[6541798467](https://github.com/75py/Android-OverlayViewManager/pull/64#issuecomment-6541798467)とCodexのコード承認[6541804856](https://github.com/75py/Android-OverlayViewManager/pull/64#issuecomment-6541804856)、現head CI成功・base・CLEANを確認し、2026-10-31 18:40:54 JSTに通常mergeで `5c8219b500291230eb423e3ba961e52663cc9df4` へ統合した。PR63の古いSettings検証と「次はT13」の断定を訂正し、10月18日の採用経緯は保持する。 + +## 実行設定 + +既存のClaude Codeは本人報告で `claude-opus-5-5`（Opus 5.5）。本人が観測できるeffort内部値は40、端末画面はhigh表示。旧計画のFable 5.1指定とは区別する。今回ユーザーが既存Claude Codeへ同じ連携依頼を出しているため、そのセッションを維持しモデル設定を変更していない。Codexも既存セッションを継続し、追加workerは起動していない。 + +## 現在の検証結果 + +- `3e05597`（PR64 headとtree同一）でcore/opt-timber/sampleのDebug・Release assemble、4 module unit tests、3 module lint、core/sample androidTest APK compileを一括実行し成功。 +- unit tests: core 107、opt-timber 40、lint 12、sample 4、計163件。failure/error/skip 0。 +- lint: エラー0。警告 core 9、opt-timber 4、sample 61。警告内訳と最終差分は後続チェックで照合する。 +- API35専用AVDでcore 2/2・sample 9/9成功（skipなし、PR64を含む全既存suite）。`/private/tmp/ovm-release-api35-connected.log` と `ovm-release-evidence-20261031/api35-pr64` に結果を保存。 +- API23専用AVDでsample 6/6成功。core旧権限試験はSDK条件により対象0件（成功件数として加算しない）。追加DragGeometryTestでAPI23の拒否/許可とActivity権限不要を別途検証する。 +- Release成果物を `-Dmaven.repo.local=/private/tmp/ovm-release-m2-20261031` 付きpublishToMavenLocalで一時repositoryへ生成。core/opt-timberとも3.0.0、sourcesあり、AARにconsumer rulesあり、coreにlint.jarあり、POMにApache License Version 2.0を確認。旧fragment依存なし。Timberは意図どおりhostの明示依存、opt-timberからcoreはruntime依存なので利用例では両artifactを宣言する。 +- 別Gradleプロジェクト `/private/tmp/ovm-release-consumer-20261031` に上記2成果物とTimberを宣言し、Java/Kotlin双方で公開APIを使用。`:app:assembleRelease :app:lintRelease` が成功しR8のminifyReleaseWithR8を通過。core/opt-timberのソースprojectへの依存はない。同梱lintはJavaのtrue引数1箇所だけを検出しKotlinのfalse引数は検出せず。manifestのActivityから呼び出し、R8が利用箇所を丸ごと捨てるだけのfixtureにはしていない。 +- lint警告は対応環境固定に伴う新SDK/依存更新案、既存サンプルのローカライズ/RTL/アイコン、明示した画面外配置例等。coreのClickableViewAccessibility 2件は汎用Viewへのlistener設定/除去箇所で、クリック/drag分離は回帰試験対象。sampleのJavaScriptはローカルassetsのコード表示用途（既存T10レビュー済み）。新しい全面抑制やbaselineは追加しない。 +- buildログ: `/private/tmp/ovm-release-validation-build.log`。この一時パスだけを永続証跡とは扱わず、検証SHAと結果を本記録へ残す。 + +## 中間チェックポイント時点の受け入れ条件（最終状態は末尾） + +| 項目 | 状態 | +| --- | --- | +| PR63/64の現head相互承認・CI・統合 | PR64統合済み、PR63レビュー待ち | +| API23/26/35/36 core/sampleの最終端末試験 | 進行中 | +| 両scope、RTL、非ゼロ原点、edge-to-edge、画面外配置の実画面ドラッグとDOWN時no-jump | Claudeが追加試験を実装、Codexが実行 | +| 権限なしActivity操作、拒否→許可→再表示、回転・マルチウィンドウ | 既存証拠の照合と不足分の端末検証 | +| Release AAR/POM/sources/lint.jar/consumer rulesとJava/Kotlin/R8 consumer | Codexが最終検証 | +| 公開API・移行・配布・状態遷移の相互レビュー | 未完了 | +| release/3.0.0 → main PR | 上記完了後 | + +JitPackサービス上のビルドは、10月18日のユーザー判断に従いタグ作成後の確認として分離する。今回のrelease PR作成を、mainマージ・タグ・配布の実行とは扱わない。 + +## ドラッグ端末試験で見つかった不具合と修正合意 + +Claudeが追加した初期候補 `46cc42f` のAPI35試験は14件中7失敗/1skip。画面外配置では `getWindowVisibleDisplayFrame` が約±100000のplaceholderを返し、ドラッグで大きく飛ぶ。RTLでは未attachのViewのlayoutDirectionが未解決のため、初回STARTを左に解決していた。別の小さな移動量超過は、診断候補 `e934535` の注入/受信ログでAndroidのresamplingによる外挿を確認（18ms間隔で注入raw x=252、受信234.01562）。animation scaleを0にしても再現し、単純な描画待ちの問題ではなかった。 + +Claudeは全経路をspec差分方式へ置換する案Aを提案。Codexは初期クランプ後の新gestureに不感帯が生まれる回帰を指摘し、boundedの実位置rebasing維持を求めた。両者は案D（bounded既存維持、allowOutsideBoundsだけgravity/marginsを保持する差分方式、RIGHT/BOTTOMでは差分反転）に収束した。試験入力は40ms間隔へ変更し、製品側のraw座標処理はresampling対策で変更しない。 + +API35のsplit操作は利用できなかったが、Codexが専用AVDで `enable_freeform_support=1` と `am start --windowingMode 5` により、非ゼロ原点のfreeform（bounds 215,420–865,1500）を確認した。ClaudeがActivity scopeのbounded/画面外2試験を追加。freeformにならなければskip、なったのに原点ゼロならfailとする。設定はCodexが検証終了時に元のnullへ復元する。animation scaleの元値も一時JSONに保存して復元する。 + +候補 `39d4fb07ab511dc603298e791f74e7d2fb8f604d` はテスト変更 `f9deb0c` と製品修正を分離。core unit/lint・lint unit・API35の追加22件を検証中。最終承認・PR・統合は未完了。 + +API26の既存suiteはcore 2/2、sample 6/6成功（PR64系はSDK条件対象外）。fingerprintは `google/sdk_gphone_arm64/generic_arm64:8.0.0/OSR1.180418.028.A3/10734686:userdebug/dev-keys`。一時証拠 `ovm-release-evidence-20261031/api26-pr64` に保存した。 + +### PR65の差分レビューと補正 + +- `39d4fb0`: core115/lint12 unit成功、core lintエラー0。API35追加22件は21成功/1失敗/skip0。bounded freeformの失敗は、テストがwindow幅の中心とscreen座標を比較してframe外へ動かしたため。Claudeがscreen上のframe中心へ判定を修正した。 +- CodexがRTL未対応hostとXML明示LTRの上書きを指摘。Claudeは `FLAG_SUPPORTS_RTL` を尊重し、初回layoutで解決した方向を1回補正する方式を追加。show前measure案はhostのonMeasureを先に呼ぶ副作用、補正省略案はXML方向の欠落があるため不採用。 +- 初期補正案はlistener残留と失敗握り潰しがあったためCodexが差し戻し。`4fface2925606b5997a76c569cdfaa02b33464d6` は既存hide/external detach/releaseの解除経路へlistener解除を統合し、補正失敗をlastFailureへ記録する。hide/dispose/再show/外部detach/拒否/not-attachedの回帰を追加。全build/unit/lint/API35全suiteで検証中。 +- 続けてCodexはshow直後update前後のgravity比較と、同じlayoutイベント中にhostがdisposeする再入条件を指摘。最後に適用したgravityとの比較と状態guardを補う次候補をClaudeが担当する。 +- ActivityTestRuleの再生成後getActivity懸念は、実使用のrules 1.7.0 AARのLifecycleCallbackをjavapで確認し解消。Stage.RESUMED時にWeakReferenceを新Activityへ更新するため、既存の再生成試験は古いinstanceを検証していない。 + +### 最終製品候補 `1bfde2f47128f3ed79eac7c119359b19dd94828b` + +`4fface2` のAPI35全suiteはcore 2/2・sample 31/31成功、skipなし。追加22条件はすべて成功し、残りは既存sample試験。全Debug/Release buildとlintも成功。unitはcore124/Timber40/lint12/sample4（計180）成功。このAPI35実行は診断時のanimation scale=0を維持していたため、元設定（window/transition=1.0、animator=null）へ戻した上で次候補を再検証する。 + +`1bfde2f` は最後に成功したbackend gravityとの比較とlayout中のhide/dispose guard、3回帰試験を追加した。Codexは差分を再レビューし、指摘箇所の修正を確認。現候補のunitはcore127/Timber40/lint12/sample4（計183）成功、failure/error/skipなし。lintはエラー0、警告core9/Timber4/sample61。CI [41191255934](https://github.com/75py/Android-OverlayViewManager/actions/runs/41191255934)成功。 + +同一ビルドAPKをAPI別の専用AVDへ配り、端末テストを実行する。APKのSHA256: + +- core androidTest: `8ef39fd0dcabd5b31efc1abcf0e672255b7e1b1f68c892475d106c77742e36e7` +- sample debug: `cc2382bcc542999e7521f34255adb14cb25688e3ad27d9a97bbc353b91004e6f` +- sample androidTest: `a8b892c1724b02af2252bf0f2572cbcb5f037c1e5d3d10440a8a4a954dd549ac` + +API36のGradle全suiteと、独立したAPI35/26端末の直接instrumentationは同じAPKを使う。API35は元のanimation設定、freeform有効。API36のfreeform元値はnullで、検証後に戻す。直接実行は `adb -s SERIAL install -r -t APK`、`adb -s SERIAL shell am instrument -w -r [ -e class CLASS ] PACKAGE/androidx.test.runner.AndroidJUnitRunner`。成功は終了コードだけでなく、instrumentationのテスト完了件数、failure/error/skip、`OK`を確認する。 + +Claudeの最終レビューはAPI、移行ガイド、状態遷移、配布文書を対象にblockingなし。Timber dispose後の古い参照によるregisterは呼び出し誤りとして例外になり、今回の公開契約変更は行わない。テスト後の文書更新と現head承認は未完了。 + +最終候補のAPI35 DragGeometry22/22が元のanimation設定で成功（skip0）。freeform設定は元のnullへ復元し専用AVDを終了した。[12秒の操作録画](evidence/2026-10-31-drag-api35.mp4)はこの実行の抜粋で、全条件の代替証拠ではない。動画のデコードとフレーム内容を確認済み。 + +最終候補のAPI36全suiteはcore 2/2・sample 31/31成功、skip0。API26はcore 2/2・sample 26/26成功。API23/26ではfreeform2件（minSdk28）と別UID3件（minSdk31）がSDK条件で対象外で、26件は実行された試験数。API36のfreeform設定も元のnullへ戻し専用AVDを終了した。 + +最新AARの再生成後、独立consumerをclean・refresh-dependenciesしてJava/KotlinのRelease・R8・lintを再実行し成功（46 tasks、32秒）。lintは意図したJavaのtrue引数だけ `ALLOW_OUTSIDE_BOUNDS` を1件検出し、falseを指定したKotlin側は検出しない。その他3件はfixtureのicon/文字列/resource shrinkingに関する警告でエラーなし。 + +最終Release成果物のSHA256: + +| 成果物 | SHA256 | +| --- | --- | +| core AAR | `799c8d08d0dbeb4c3b26801e4a09ac082a0256ba6ea5aa3906f404cf8a2b15ef` | +| core POM | `dc5b9b513c68afd7e9fec497fc62c96b0d8c6f50b2d4125404cae1da5d06077f` | +| core sources | `8718a51ae2ce00abe592b031dd6b1b4c3156dc0bacf8e1fc470934595779dac9` | +| Timber AAR | `6698e7f985f552663e9c2fa4a935d8308977ae481d6938b414fcc4003f5fec6e` | +| Timber POM | `185a709cfbcc48465a285bd753c41853d1f86389374b5a7c251992ddd1e6097e` | +| Timber sources | `e371b0405f873710a09ef0b93b59d3c4e7fd5da0104ce7151d5e19ab162bfb76` | + +AAR内のclasses.jar/consumer rules、coreのlint.jar、sourcesとPOMを再確認。実行はrepositoryのGradle wrapperへ `-p /private/tmp/ovm-release-consumer-20261031 :app:clean :app:assembleRelease :app:lintRelease --refresh-dependencies` を指定した。一時consumer自身にwrapperはないため、最初の `./gradlew` は実行前に失敗し、正しいwrapper指定で実施した。 + +### API23/31で残った試験条件の問題 + +`1bfde2f`のAPI23最終結果はsample6成功/20失敗、API31はcore2成功・sample29成功/2失敗。途中のAPI23進捗を成功と誤読したCodexの端末連絡は撤回し、Claudeの文書完了/pushを保留した。API26/35/36の最終成功集計には影響しない。 + +API23は全dragで2〜9pxの移動方向への超過があり、40ms間隔だけでは不十分だった。製品frameは正常で、入力補間の影響を受信ログで確認する。CodexはMOVE後に同一座標のstationary MOVEを送って速度をゼロにしてから位置をassertする案を提案し、Claudeが調査する。期待位置/toleranceは緩めない。 + +API31はfreeform2件のみorigin=[0,0]で失敗。`dumpsys activity`ではmode=freeformなのにtask boundsが空で全画面になっていた。Codexが `am task resize 47 215 420 865 1500` を試し、指定された非ゼロboundsへ移動できることを確認。Claudeはテスト自身のtask IDとdisplay範囲からboundsを指定し、再生成後のRESUMED hostを取得する方式を検討する。手動検証sampleはforce-stopして次の試験から分離した。 + + +### テスト入力・freeform設定の再検証 + +候補 `2ac46f2d49d941d33822d528d392c0344df97be3` は製品コードを変えず、stationary MOVEとfreeform taskの明示resize/RESUMED Activity再取得を追加。API23のDrag20/20が成功（failure/error/skip 0）。受信ログで、注入252,441に対して初回受信258.43478,447.43478、stationary後252,441へ収束することを確認した。位置の期待値と許容差は変更していない。API35は通常・RTL画面外・freeform2件の代表4/4成功、skip0。 + +API31はDrag20成功/2失敗。freeformの非ゼロ原点216,384は成立したが、DOWN/MOVEを一切受信していなかった。試験中の`dumpsys input`ではhost/overlayともvisible=false、focus request NOT_VISIBLE。一方WindowManagerではSurface shown=true/HAS_DRAWN/isVisible=true、ActivityもRESUMED/visible=trueだった。座標計算の失敗と断定せず、専用API31のfreeform環境を再起動して切り分ける。生ログは`/private/tmp/ovm-api31-freeform-diagnostic`と`ovm-api31-freeform-window`に保存。 + +Claudeの上記診断ファイルのgrep/sed/cut/head/tailによる読取要求を全文確認し、代理許可した（receipt `2544eb41-1f97-41ed-88aa-5e683daf2b9a`）。初回Enterは自動承認レビューに現在入力不明として拒否されたため送信されず、同じ許可画面を直前に再確認して具体的なコマンドと読取限定の効果を示した再審査で許可された。恒久設定は変更していない。 + + +### 最終端末集計と判定 + +`c6bbe69ea5f293fb909f6d7aec93a1da4cda34cd` はfreeform hostが入力システムで表示されることを待ち、前提不成立ならその2件をassumption skipにする。overlayを作る前のhost条件を検査するため、overlayの移動失敗をskipへ変更するものではない。compile成功。`4b36c7db5928b5fd49696cc22a5ab872cac43c27` はコメントだけの補正で、検証対象の実行コードと同一。 + +| API | 実行結果・検証ソース | SDK対象外・未検証 | +| --- | --- | --- | +| 23 | 既存sample6件成功（PR64製品）、Drag20件成功（2ac46f2）。最終製品のDrag以外6件は1bfde2fでも成功 | core旧権限試験0件、freeform2件と別UID3件はSDK条件対象外 | +| 26 | core2・sample26件成功（1bfde2f）。最終入力方式の通常/RTL画面外2件再確認成功（c6bbe69） | freeform2件と別UID3件はSDK条件対象外 | +| 31 | core2・sampleの非freeform29件成功（1bfde2f）。最終Drag20成功/2skip（c6bbe69）。別UID3件も1bfde2fとPR64の初期/更新imageで成功 | freeform2件はhostが入力上非表示のため未検証。成功数に含めない | +| 35 | core2・sample31件成功（4fface2）。製品の最後のguard修正後Drag22件成功（1bfde2f、animation元値）。最終入力方式/前提条件の代表4件成功（c6bbe69、freeform2件含む） | skipなし | +| 36 | core2・sample31件成功（1bfde2f）。最終入力方式/前提条件の代表4件成功（c6bbe69、freeform2件含む） | skipなし | + +API31の再起動後に旧2ac46f2を再実行するとfreeform1成功/1失敗となり、不安定な環境前提と判断。最新c6bbe69では20成功/2skip/失敗0で確定した。合意済み必須matrixはAPI23/26/35/36であり、API31はAndroid12の別UID境界の追加確認。マルチウィンドウの受け入れ証拠はAPI35/36の非ゼロ原点freeformで、API31のskipで代用しない。両司令塔がこの区別に合意した（端末送信request `84640881-eb20-4cb5-81ea-0f8f95bb5360` とClaudeの返信）。 + +API35のc6bbe69は最初のフィルタ指定でRTLメソッド名を誤り3件だけ実行されたため、正しい`applicationScope_allowOutsideBounds_rtl`を単独実行して1件成功を補った。API26も同様に通常1件+RTL1件として集計した。存在しないメソッドが暗黙除外されるrunner挙動を、成功件数確認により検出した。重複を加算していない。 + +最終test APK SHA256は `42887ca59037029678dff346b1d634b8517861725622c6c385548c11b4ed0d92`、同ビルドsample APKは `78cd38d946e1bf2cc19fccb08ac01819014ba597f06ad149e8d7ae0c8d435906`。2ac46f2以降はtest/doc変更のみで製品コードは1bfde2fと同一。追加リリースビルド・全suite再実行は不要と両者で判断し、影響する入力/前提条件だけを再検証した。 + +API31/35/36のfreeform設定を元のnullへ復元し、専用API23/26/31/35/36エミュレータを終了した。無関係なemulator5554は操作していない。 + +既知の制約はREADME/移行ガイドへ記載: XMLで指定した方向が構成と異なると初回layoutまで推定側に表示され得ること、allowOutsideBoundsのfill gravityが移動でなくサイズを変えること、lintがBuilder呼出しのみを検査すること、Android側のopacity補正と別UIDタッチポリシー、JitPackタグ後のサービス上ビルド確認。これらを隠さず、未解決の必須指摘なしで最終承認へ進む。 + +使用した最終matrixのOS fingerprint: + +| API | fingerprint | +| --- | --- | +| 23 | `Android/sdk_google_phone_arm64/generic_arm64:6.0/MASTER/8690019:userdebug/test-keys` | +| 26 | `google/sdk_gphone_arm64/generic_arm64:8.0.0/OSR1.180418.028.A3/10734686:userdebug/dev-keys` | +| 31 | `Android/sdk_phone64_arm64/emulator64_arm64:12/SE1A.220621.001/8752307:userdebug/test-keys` | +| 35 | `google/sdk_gphone64_arm64/emu64a:15/AE3A.240806.043/12960925:userdebug/dev-keys` | +| 36 | `google/sdk_gphone64_arm64/emu64a:16/BE2A.250530.026.F3/13894323:userdebug/dev-keys` | + +### PR65統合・releaseへの最終ゲート + +PR65 head `ca3f7e0809a966e842d19ba7ea7d102a8ef48b86` の最終文書差分と検証説明を確認。API23行の単一SHA表記は実際の6+20件のソースへ訂正するよう依頼し、Codex承認にも正確な組合せを明記した。[対向承認6542296295](https://github.com/75py/Android-OverlayViewManager/pull/65#issuecomment-6542296295)、[CI41193177729成功](https://github.com/75py/Android-OverlayViewManager/actions/runs/41193177729)、base work/3.0.0、同一head、CLEANを再確認。`--match-head-commit`付き通常mergeで19:35:55 JSTに `497a5e2a6348ffbadd9455813d9bcf388012ebcc` へ統合した。 + +残る作業は本台帳PR63の現head対向承認/CI/統合と、合意済み統合SHAからのrelease/3.0.0作成・main向けPR。mainマージ、タグ、JitPack正式公開は行わない。最終PRには本記録・移行ガイド・既知制約・検証matrixを参照し、Claudeへ確認を依頼する。 + +### リリースPR作成完了 + +PR63 head `a47d95cb64f75fc87aa98c158b0bfc92af6b531a` に対する[Claude APPROVE 6542332736](https://github.com/75py/Android-OverlayViewManager/pull/63#issuecomment-6542332736)と[CI41193528060成功](https://github.com/75py/Android-OverlayViewManager/actions/runs/41193528060)、base・head・CLEANを確認。19:41:14 JSTに `395f2ff10109068451611a7f3573eb75b2fa923c` へ通常merge。承認済みa47d95cとtree差分なしを確認した。 + +同SHAからOrca管理worktree `release-3.0.0` / branch `release/3.0.0` を作成してpushし、[Release 3.0.0 PR #66](https://github.com/75py/Android-OverlayViewManager/pull/66)をmain向けに作成した。PR本文には移行ガイド、検証、既知制約、API31のfreeform未検証、JitPackのタグ後確認、承認/CI参照を記載。Claudeへ本文・base/head・統合SHAの最終確認を依頼した（request `d001c30b-5c8c-4822-b034-72d7f3905057`）。mainへはマージせず、タグと正式公開も行っていない。 + +この完了記録だけを `fix/3.0.0/release-checkpoint` からrelease向けPRでレビューし、現head承認・CI成功後に統合する。work/3.0.0への反映は同じ承認済みreleaseへのfast-forwardとし、未レビューの差分を直接追加しない。最終的なrelease head・CI・確認コメントはPR66で追跡できる。 diff --git a/docs/coordination/3.0.0/2026-11-01-remove-timber.md b/docs/coordination/3.0.0/2026-11-01-remove-timber.md new file mode 100644 index 0000000..46cb9cc --- /dev/null +++ b/docs/coordination/3.0.0/2026-11-01-remove-timber.md @@ -0,0 +1,111 @@ +# 2026-11-01 Timber連携の削除 + +状態: **PR68の対向承認・CI成功を確認し、`8794018` へ統合済み**。`work/3.0.0` も同期済み。文書追記後を含む最新release headのCI・Claude確認は [PR66](https://github.com/75py/Android-OverlayViewManager/pull/66) のchecksとSHA付きコメントで追跡する。 + +## 経緯 + +2026-11-01、ユーザーが「Timber対応はもう削除でいいかな、使わないし」と判断を示した。3.0.0は破壊的変更のリリースで、公開前に外せば互換性の負担が残らないため、Claudeはリリース前の削除を提案し、task branchで実施した。 + +同日、ユーザーは「codexと連携して進めて」と指示した。PRは[PR68](https://github.com/75py/Android-OverlayViewManager/pull/68)。 + +## 分担 + +- Claude: Opus 5.5 / high（`AGENTS.md` のFable 5.1 / highとは異なる実態を記録する。Codexと確認し、モデル切替と子エージェント起動は行わない）。修正、PR作成、本記録を担当。 +- Codex: 差分レビュー、隔離worktreeでの検証、push、JitPack座標の調査、`release/3.0.0` へのmerge操作を担当。Claude環境の `gh` トークンに `workflow` 権限がなくSSHも使えないため、`ci.yml` を含む `320f671` はCodexがpushした。 +- 共有計画: Codexが編集していないため、本PRに限りClaudeへ更新を移管した。過去のcheckpointは保持する。 +- 統合後: 統合SHAはPR66のコメントへ記録する。`work/3.0.0` は承認済み `release/3.0.0` へのfast-forwardで同期する。 +- 対象外: mainへのmerge、タグ、公開。ユーザーの判断を待つ。 + +連絡のrequest ID: + +| 内容 | request ID | +| --- | --- | +| 分担 | `1e42eea9-1bc7-41c7-b0ca-04e97f35a22b` | +| HTMLの指摘 | `979504a8-701b-4b8d-bc0a-b7a706d8ad1b` | +| JitPack座標 | `b9d136be-0144-4467-8933-c5d552af6987` | +| 検証速報 | `75f4b860-9f29-41e0-a9b2-6fadf202f2a5` | + +## Codexレビュー（`320f671`） + +SAMPLE番号の繰り上げ、`@RestrictTo` の維持、自前のTimber treeへの移行案内は妥当と判断された。HTML assetに `Log.w(TAG, ...)` を入れたのに `TAG` の宣言がないという指摘を受け、Sample1、Sample2、SampleOverrideScreenBrightnessの表示コードへ宣言を補った。 + +Codexは `a908cb4` の7ファイルの差分を確認し、指摘の解消と `diff --check` の成功を確認した。 + +READMEの未公開表記とCHANGELOGの `Unreleased` は、実際に公開前なので今は維持し、日付は公開決定時に確定する。 + +## 変更内容 + +- `opt-timber` モジュール（`DebugOverlayTree`、そのテスト、公開artifact `overlayviewmanager-opt-timber`）を削除。 +- `settings.gradle`、`jitpack.yml`、CI、`sample/build.gradle` から参照を削除。 +- `opt-timber` だけが使っていた `WeakReferenceCache` とそのテストを削除。`OverlayWindowManager` のKDocからopt-timberへの言及を削除。`@RestrictTo` のscope変更はしない。 +- sampleのTimberデモ（Activity、layout、asset、ボタン、文字列）を削除し、`SAMPLE4` を `SAMPLE3` に繰り上げ。ログは `android.util.Log` に置換し、表示用assetのコードも揃えた。 +- README、CHANGELOG、移行ガイド、AGENTS.md、設計書の注記を更新。過去の記録は書き換えない。 + +## 検証 + +- Claude側: Gradleと端末テストは未実行。サンドボックスからGradle daemonへ接続できない（`Could not connect to the Gradle daemon`）。sampleの `androidTest` が削除したActivity、ボタン、文字列を参照していないことはgrepで確認した。 + +Codex側の結果（実行はすべてCodex。`320f671` と `a908cb4` の差はHTML assetと文書のみ）: + +| 検証 | 対象 | 結果 | +| --- | --- | --- | +| Debug/Releaseビルド | `320f671` | 成功 | +| unit tests | `320f671` | 134件成功（core 118、lint 12、sample 4）、skip/error/failure 0。旧183件との差49件はTimber 40件と `WeakReferenceCacheTest` 9件で一致 | +| lint | `320f671` | core エラー0/警告9、sample エラー0/警告55 | +| publish | `320f671` | 成功。AAR、POM、sources、consumer rules、lint.jarを確認。Timberと `WeakReferenceCache` の残留なし | +| core単体のJava/Kotlin consumer | `320f671` | Release、R8、lint成功（45 tasks）。意図した `ALLOW_OUTSIDE_BOUNDS` 警告1件とfixture警告3件、エラー0 | +| API36 sample全suite | `320f671` | 31件成功（freeform2件を含む）、failure/error/skip 0、4分2秒 | +| 起動画面とHTML表示 | `a908cb4` で再構築したAPK | メニューからTimberが消えSAMPLE3になったこと、Sample1とSample3の `TAG` 宣言を実画面で確認 | +| CI | `a908cb4` | run `41286372506` 成功 | + +実行コマンド（review worktree）: + +```sh +export ANDROID_HOME=/Users/ai-seb/Library/Android/sdk +./gradlew :core:assembleDebug :sample:assembleDebug :core:testDebugUnitTest :lint:test :sample:testDebugUnitTest :core:lintDebug :sample:lintDebug :sample:assembleRelease :sample:assembleDebugAndroidTest :core:publishToMavenLocal -Dmaven.repo.local=/private/tmp/ovm-remove-timber-maven-20261101 +./gradlew -p /private/tmp/ovm-remove-timber-consumer-20261101 :app:assembleRelease :app:lintRelease --refresh-dependencies +ANDROID_SERIAL=emulator-5580 ./gradlew :sample:connectedDebugAndroidTest +./gradlew :sample:assembleDebug +``` + +最後の行は `a908cb4` のUI確認用の再構築。 + +成果物のSHA256（`320f671`）: + +- sample APK: `76077cf20b2f89876b70bcfc3ef41937470afaac4982beb645b0ebb8729692d5` +- test APK: `e0e93fb1aee652533953d4bc9835df7daf4d6c1bc7230a0ac9491a6675fa3576` +- core AAR: `91f0822266fdc43a62f3e306fbbee4fe4d275bf98e760c2293ec2bd33e48a529` + +画面の証拠: + +- [メニュー](evidence/2026-11-01-remove-timber-menu.png) +- [Sample1](evidence/2026-11-01-remove-timber-sample1.png) +- [Sample3](evidence/2026-11-01-remove-timber-sample3.png) + +端末matrixの判断: Codexは、coreの挙動変更が未使用helperの削除だけであるため、API23/26/35は2026-10-31の検証結果を維持し、sampleの実行をAPI36で再確認すると判断した。Claudeも同意した。API23/26/35は今回再実行していない。 + +専用のAPI36環境のfreeform設定は元のnullへ戻した。`emulator-5554` は操作していない。 + +観測の限界: Sample1の画像はシンタックスハイライトなしで写っている。起動直後のcaptureで、`run_prettify.js` はDOMContentLoadedと `setTimeout` で非同期に装飾するため、画像だけではハイライトの欠落を確定できない。表示文字と `TAG` 宣言は確認済み。描画タイミングと既存の装飾は今回の削除の受入条件ではなく、追加修正もrelease blockerの扱いもしない。 + +## JitPack座標 + +公開artifactが1つになる。旧形式 `com.github.75py.Android-OverlayViewManager:overlayviewmanager` が公開artifact1つのビルドでも使えるかは、文書から確認できなかった。 + +Codexが[JitPack公式の複数モジュールの説明](https://docs.jitpack.io/building/#multi-module-projects)を確認し、全モジュールを指定する `com.github.User:Repo:Tag` は公開モジュールが複数でも1つでも使える公式形式と判断した。この曖昧さを避けるため、READMEの座標を `com.github.75py:Android-OverlayViewManager:` へ変更し、移行ガイドにも座標の変更を記載した。 + +根拠の区別: + +- 公式仕様: 上記の文書に基づく判断。 +- 公開artifact1つの成果物: Codexがlocal Mavenとcore単体のJava/Kotlin R8 consumerで確認済み。 +- JitPackサービス上の実ビルドと座標解決: 未確認。従来どおりタグ後に確認する。 + +## 統合結果 + +CodexはPR68 head `d773e7e83890aeaa4eae9e95750c4fe2b8c02391` の全差分・記録を確認し、[対向承認](https://github.com/75py/Android-OverlayViewManager/pull/68#issuecomment-6555266404)を記録した。[CI41286948503成功](https://github.com/75py/Android-OverlayViewManager/actions/runs/41286948503)、base、同一head、CLEANをマージ直前に再確認し、`--match-head-commit` を指定した通常mergeで `8794018bcc6d67d338982bfaeaddef78db821540` へ統合した。承認headとtree差分がないことも確認した。 + +`release/3.0.0` と `work/3.0.0` を同SHAへ同期し、[PR66の本文と統合コメント](https://github.com/75py/Android-OverlayViewManager/pull/66#issuecomment-6555284723)を更新した。最終記録2ファイルはClaudeからCodexへ所有を戻した（request `d23b3f0d-44b7-49b5-a466-6d59c0f1b7b8` とClaudeの同意）。この追記は文書のみで、最終release headのCIとClaude確認はPR66で追跡する。 + +## 残る公開判断 + +mainへのmerge、タグ作成、正式公開は未実施。公開決定時にREADMEの未公開表記とCHANGELOGの日付を確定し、タグ後にJitPackサービス上のビルドと座標解決を確認する。 diff --git a/docs/coordination/3.0.0/2026-11-01-review-fixes.md b/docs/coordination/3.0.0/2026-11-01-review-fixes.md new file mode 100644 index 0000000..6f1eee1 --- /dev/null +++ b/docs/coordination/3.0.0/2026-11-01-review-fixes.md @@ -0,0 +1,188 @@ +# 2026-11-01 リリース前レビュー指摘への対応 + +最新: C1〜C4のユーザー決定を反映し、指定Gradle全タスクとAPI23/26/35のsample端末試験が成功。今回のPRの現head承認・CI・統合SHAは[PR66](https://github.com/75py/Android-OverlayViewManager/pull/66)のコメントで追跡する。 + +前回の完了状態: PR70・PR71を相互承認/CI成功後に統合済み。基点は PR66 の `a79dcb8254d83eaf72784f524f34a12d68668cb7`。今回の依頼は、妥当性確認、再現する問題の修正、回帰テスト、現headの相互レビューとCI成功を経た `release/3.0.0` への反映まで。mainマージ・タグ・正式公開は対象外。 + +## 所有と合意 + +- Claude Code: core全体（削除中再入、ドラッグalpha、A1 listener、A2破棄理由、Bの小修正、回帰テスト）と `docs/design/3.0.0-api.md` を単独所有。`fix/3.0.0/core-lifecycle-review`。Codexが対向レビューとGradle検証を担当。 +- Codex: CIのRelease/publish検証（A3）、未参照Timber画像の削除・残留調査（A4）、migrationのstdlib説明（A5）、本記録と計画、C1〜C4の推奨案、統合を担当。`fix/3.0.0/review-release-support`。Claudeが対向レビュー。 +- 分担はClaude端末で明示合意。Orca記録 `msg_b4335a09de6d`、提案request `9ac84ff7-e1c7-41b2-ba88-480fa053ba19`、詳細共有request `472c24d5-2e4e-4284-bc9f-7fc5ffbf0323`。同じcoreファイルの並行編集を避け、Gradle/SDKはCodexが直列化する。追加の子agentは起動しない。 +- 全タスクPRは `release/3.0.0` 向け。公開シグネチャ・enum・README未公開表記・CHANGELOG日付は変更しない。Cは提案のみで実装しない。 + +## 初期確認 + +coreでは `hide()` がbackend削除後に無条件でCONFIGUREDを書き、`dispose()` の公開入口は削除中フラグを確認していない。ドラッグは `spec.alpha` を直接変更し、UP/CANCELでbackup値を戻す。非DRAGGABLEの生成とacceptにも `setOnTouchListener(null)` があり、破棄後の分類は一律WINDOW_MANAGER_REJECTED。これらは静的確認であり、回帰テストによる再現結果と区別する。 + +A3: CIにはDebug・unit・lintのみでpublish処理がなかったため、`:core:assembleRelease :core:publishToMavenLocal` を追加。これはJitPackと同じ公開タスクの事前検証であり、JitPackサービスでの実際のビルド・座標解決の代替とは扱わない。 + +A4: `sample/screenshots/3.0.0/api36-timber.png` は参照なしで削除。設計書の現行スレッド説明等はClaude担当。移行ガイドの削除案内、CHANGELOG・計画・連携記録・設計書の明確な過去記述は維持する。AGENTSの古いコミット件名例は現行機能の説明ではない。 + +A5: Javaだけの利用アプリにもkotlin-stdlibが推移的に入ることを移行ガイドに追記。 + +## C1〜C4: 判断前の推奨案（履歴） + +以下は当初の提案。2026-11-01のユーザー決定は後述の「C1〜C4のユーザー決定と追加端末検証」で確定し、この提案より優先する。 + +### C1: OverlaySpec + +公開前に通常のclassへ設計し直し、Builderと明示的な更新APIを安定面にする案を推奨する。現在のdata classは追加プロパティがconstructor/copyのJVMシグネチャを変える。末尾への追加だけなら既存componentNは通常そのままだが、順序変更は分解代入の意味も変え得る。通常classにするだけで自動的に互換になるわけではなく、公開constructor/copyの設計と既存Java/Kotlin利用の移行を併せて確定する必要がある。現状維持なら3.xでは形を固定し、拡張用の別型/APIか次期majorで変更する方針が必要。今回は公開シグネチャ不変の依頼に従い何も変えない。 + +根拠: [Kotlinの後方互換性ガイド](https://kotlinlang.org/docs/api-guidelines-backward-compatibility.html#avoid-using-data-classes-in-your-api)。 + +### C2: internal adapterとテストsetter + +公開前の別PRでKotlin側をinternalへ絞り、Javaからの呼び出し可能面も個別に監査する案を推奨する。internalはKotlinモジュール境界であり、JVMではpublicになるので、それだけでJavaから隠せるわけではない。必要なメソッドのJvmSyntheticやテストfixtureの分離を併せて検討する。実際にsampleのJavaテストがsetApplicationInstanceを利用しているため、可視性だけを機械的に変更しない。今回は変更しない。 + +根拠: [KotlinのJava相互運用と可視性](https://kotlinlang.org/docs/java-to-kotlin-interop.html#visibility)、`sample/src/test/java/com/nagopy/android/overlayviewmanager/sample/Sample2OverlayControllerTest.java`。 + +### C3: ABI検査 + +C1/C2の決定後、3.0公開前にAPI baselineとCI検査を導入する案を推奨する。意図しないシグネチャ変更を検出できる。binary-compatibility-validatorはmaintenance modeだが重大修正と現行Kotlin対応は継続し、新機能はKotlin Gradle plugin側へ移行している。採用方法はAGP9.2.1のbuilt-in Kotlinとの対応を別PRで検証して決める。apiCheckだけでは動作互換やJavaに見えるinternalの全漏出を保証しないため、既存Java/Kotlin consumerも残す。今回はプラグイン追加やapiDumpをしない。 + +根拠: [公式binary-compatibility-validator README](https://github.com/Kotlin/binary-compatibility-validator)。 + +### C4: 記録類のmainへの収録 + +今回はAGENTS、計画、連携記録と証拠をmainにも維持する案を推奨する。レビュー・端末検証の根拠へ既に相互リンクがあり、約2MBのため現段階では分離の負担が利点を上回る。`.serena/` の追跡対象は共有project.ymlとgitignoreだけで、cache/local設定は除外済み。チームがSerenaを使わない方針なら、後日この共有設定だけを外す別PRを提案する。別ブランチへの退避は既存リンクの付け替えも必要で、ファイルを削除しても過去Git履歴の容量は消えない。今回は移動・削除・履歴改変をしない。 + +## 検証・レビュー・統合 + +### CI・文書側の基準検証 + +Codexがsupport worktreeで以下を実行して成功（148 tasks）。core118/lint12/sample4、計134 tests、failure/error/skipはすべて0。lintはcore警告9/sample警告55、エラー0。POMにkotlin-stdlib2.2.10の依存を確認。新しいcore回帰テストはまだ含まない。 + +```sh +ANDROID_HOME=/Users/ai-seb/Library/Android/sdk ./gradlew :core:assembleDebug :sample:assembleDebug :core:testDebugUnitTest :lint:test :sample:testDebugUnitTest :core:lintDebug :sample:lintDebug :core:assembleRelease :core:publishToMavenLocal -Dmaven.repo.local=/private/tmp/ovm-review-support-maven-20261101 +``` + +公開先を一時Maven repositoryへ隔離しているが、実行するpublishタスクはJitPackと同じ。`git diff --check` 成功。core修正後の検証、相互レビュー、CI、統合は未完了。 + + +### 再現と修正の検証 + +実装は既存Claude Code司令塔（Opus 5.5 / high）が担当し、Codexが直接レビュー・検証した。追加の子agentは起動していない。ClaudeのsandboxからOrca inboxを読めなかったため、補足と結果はterminal sendでも再共有し、双方の回答を確認した。 + +最初のテストcommit `a231952` は、旧製品コードに対して70件中18件失敗。仕様整理後のテストだけのcommit `b036288` は72件中21件失敗（Lifecycle10件中2、State32件中9、Drag30件中10）。後者は、spec.alphaを利用者の値として保持し、一時表示はwindow alphaとして検証する仕様に合わせたもの。旧実装の二重remove、DISPOSEDの上書き、host listenerの消失、Activity破棄後の誤分類、mode変更後のalpha残留、明示alphaの上書き、復元失敗後の透明度累積を再現した。追加テストだけでなく、既存のdragテストも実際のwindow alphaを検証するよう更新した。 + +`381e827` がcore修正、`e344aa5c05420b8c75be6a84b332090812c09ac4` がレビュー補正後の候補。CodexはNOT_ATTACHEDのKDocがdispose時のDISPOSEDを表現できていない点、設計書の「異なるspecだけを適用」が復元失敗後のequal update再適用と矛盾する点、通常CANCELのwindow alpha assertionを指摘し、Claudeが修正した（request `bdbebee7-b24c-4199-8e59-69a1402b5028`）。 + +| 指摘 | 結論・修正 | +| --- | --- | +| 削除中の再入 | 妥当。removeは一度だけ。再入hideはno-op、再入disposeは参照を解放しDISPOSEDを維持。通常の削除失敗はATTACHEDを保ちretry可能。再入disposeが既に解放した後の削除失敗は外側へ報告するがDISPOSEDを戻さない。この境界も文書化。 | +| drag alpha | 妥当。spec.alphaは利用者の値を保ち、windowだけを一時的に0.6倍。モード変更、UP/CANCEL、hide/disposeで終了し、明示値を古いbackupで上書きしない。復元失敗後はequal updateでも再適用できる。 | +| A1 | 妥当。非DRAGGABLEの生成・show・update・releaseはhost listenerを触らない。library listenerの切替だけsetOnTouchListenerを呼ぶ。DRAGGABLE中はlibraryがlistenerを所有し、hostが直接置換したlistenerも解除時に消える制約はPR71本文で明示した。 | +| A2 | 妥当。Activity破棄経由で処分したhandleのshow/updateはACTIVITY_DESTROYED。通常disposeは従来の分類を維持。 | +| A3/A4/A5/B | 指摘を確認し、CI公開タスク、Timberの現行記述/画像、stdlib説明、到達不能SDK分岐、例外判定コメント、MOVEログ、license headersを修正。 | + +`e344aa5` に対するCodexの実行コマンド: + +```sh +ANDROID_HOME=/Users/ai-seb/Library/Android/sdk ./gradlew :core:assembleDebug :sample:assembleDebug :core:testDebugUnitTest :lint:test :sample:testDebugUnitTest :core:lintDebug :sample:lintDebug :core:assembleRelease :core:publishToMavenLocal :sample:assembleDebugAndroidTest -Dmaven.repo.local=/private/tmp/ovm-review-core-maven-20261101 +ANDROID_HOME=/Users/ai-seb/Library/Android/sdk ./gradlew -p /private/tmp/ovm-review-core-consumer-20261101 :app:assembleRelease :app:lintRelease --refresh-dependencies +ANDROID_HOME=/Users/ai-seb/Library/Android/sdk ANDROID_SERIAL=emulator-5580 ./gradlew :sample:connectedDebugAndroidTest +``` + +- 最初のbuild/unit/lint/publishは176 tasks成功。unitはcore145/lint12/sample4の計161件、failure/error/skipは0。旧134件から27件増加。lintはcore警告6/sample警告55、エラー0。 +- 独立したJava/Kotlin consumerはR8有効のRelease・lint、45 tasks成功。意図的なALLOW_OUTSIDE_BOUNDS警告1件とfixture由来3件、エラー0。 +- Releaseのclassファイルをjavapで比較し、syntheticを除いたJavaから呼べるpublic/protected宣言15クラスに変更なし。追加helperはinternalかつJvmSynthetic。enum値も変更なし。API検査プラグインの導入ではなく、一時的な比較のみ。 +- API36 sample端末試験は31/31成功（freeform2件を含む）、failure/error/skip0、4分4秒。専用AVDのfreeform設定を元のnullへ復元しemulator5580を終了した。無関係の5554は操作していない。物理実機およびAPI23/26/31/35は今回未検証。今回の再入・モード切替の直接再現はRobolectric/backend callbackによるもので、実機再現とは区別する。 + +### PR70の統合 + +[PR70](https://github.com/75py/Android-OverlayViewManager/pull/70) head `e8f39de71899ff6d96bc12f290fc8e65e052d2a8` は、[Claude承認](https://github.com/75py/Android-OverlayViewManager/pull/70#issuecomment-6555757402)と[CI成功](https://github.com/75py/Android-OverlayViewManager/actions/runs/41290341804)、base/head/CLEANを再確認し、`--match-head-commit` の通常mergeで `87c753da35951cd1f4fde50c00b211e4bbd05455` へ統合。PR71の統合結果は次節。 + + +### PR71の統合と最終checkpoint + +[PR71](https://github.com/75py/Android-OverlayViewManager/pull/71) head `e344aa5c05420b8c75be6a84b332090812c09ac4` は、[Codex承認](https://github.com/75py/Android-OverlayViewManager/pull/71#issuecomment-6555825058)と[CI成功](https://github.com/75py/Android-OverlayViewManager/actions/runs/41290698222)、base/head/CLEAN/readyを確認し、`--match-head-commit` の通常mergeで `4b9b2a78cbc1ca89e1994c35d00343ae57bd7905` へ統合した。レビュー済みheadと統合SHAのcore/sampleソース/lint/build設定に差分なし。PR70のCI・文書・画像削除も同時に含む。PR71本文の検証コマンドはCodexが実行した一時Maven repository引数とconsumerを含む完全形に揃えた。 + +今回の記録追記は文書だけで製品/テスト/build変更なし。最終release headとwork/3.0.0の同期、SHA付きClaude確認、CIは[PR66](https://github.com/75py/Android-OverlayViewManager/pull/66)の最新コメント/checksで追跡する。mainへのマージ・タグ・正式公開は実行しない。この時点ではC1〜C4は提案のみでユーザー判断待ちだった。後述の追加依頼で判断が確定した。 + +再現情報（候補e344aa5）: + +- API36 fingerprint: `google/sdk_gphone64_arm64/emu64a:16/BE2A.250530.026.F3/13894323:userdebug/dev-keys` +- core Release AAR SHA256: `db6412e94c763f6e323f4c720eefada4c252a48c67b0ace30a0e8bc457e7cde8` +- sample Debug APK SHA256: `a0e55a5ee8697a6ec26ac17468944f53f6276e7452766e9e15ef91208ab91982` +- sample test APK SHA256: `e0e93fb1aee652533953d4bc9835df7daf4d6c1bc7230a0ac9491a6675fa3576` + +PR72初稿 `63cf89b` の対向レビューで、Claudeは計画冒頭の旧134 testsが「現行候補」と読める点を指摘した。Codexは「Timber削除時点の候補」と時点を明記して161件の最新結果と区別した。製品コードの追加変更はない。 + + +## C1〜C4のユーザー決定と追加端末検証 + +2026-11-01、ユーザーは `release/3.0.0` の `c1eafebdd04e2a3f77f84a6154d766c6d9a06980` を基点に、以下を明示決定した。上の推奨案を採用したという意味ではなく、この決定が現行方針となる。 + +| 項目 | ユーザー決定・今回の対応 | +| --- | --- | +| C1 | `OverlaySpec` はdata classを維持。3.xの新プロパティはデフォルト値付きで末尾に追加する。Kotlinのconstructor/copy呼び出しとJava Builder利用のソース互換を保つ一方、コンパイル済み中間ライブラリのconstructor/copyに関するバイナリ互換はマイナーバージョン間で保証しない。JavaはBuilderを使う。KDocと移行ガイドへ明記する。 | +| C2 | 現状維持。ユーザーの方針は `@RestrictTo(LIBRARY_GROUP)` とinternalパッケージ名の慣習で保護し、コードを変更しないこと。現実装には `LIBRARY_GROUP` に加え、より狭い `LIBRARY` やテスト用の `TESTS` もあり、それぞれの既存scopeを維持する。 | +| C3 | 3.0.0ではAPI互換チェックを導入しない。3.0.0タグをbaselineに、3.1着手前の導入タスクを計画に追加。binary-compatibility-validatorとKotlin Gradle plugin組み込みABI validationの比較、およびAGP 9のbuilt-in Kotlinとの組合せ検証を含む。 | +| C4 | 現状維持。AGENTS・計画・連携記録・共有設定をmainにもそのまま含める。移動や削除はしない。 | + +分担: Codexが専用worktree `codex-compatibility-device-validation` / `fix/3.0.0/compatibility-device-validation` でKDoc・migration・計画・本記録の編集、Gradle/AVD検証、PR、統合を所有する。既存Claude司令塔（Opus 5.5 / high）は対向レビューを担当し、元のcore KDoc所有権を今回の範囲でCodexへ移管した。端末送信request `008e4871-05f5-4d50-9e27-2e8956d18d94` に対しClaudeが明示合意し、Orca `msg_7b024f803e55` にも記録。追加子agentは起動しない。 + +受け入れ条件: 公開APIシグネチャ・enum・README未公開表記・CHANGELOG日付は不変。指定Gradle全タスクとPR CI成功、最低API23のsample connected試験を再実行し、可能なAPI26/35も実行。失敗時は修正せず原因・再現手順を報告する。release向けPRは現head対向承認とCI後に統合し、PR66へ統合SHA/CI結果をコメントする。mainマージ・タグ・正式公開はしない。検証結果は以下のとおり確定。PRの最終head承認・CI成功後に統合する。 + + +先行レビュー: `409b7ab` のKDoc/migration/C1/C3/C4にClaudeの必須指摘なし。C2について既存annotation scopeが一律LIBRARY_GROUPではなくLIBRARY等もあるとの指摘を受け、Codexが実宣言を確認し、ユーザー判断と現実装の違いを上表へ追記した。注釈自体は変更しない。 + + +### 追加検証の確定結果（2026-11-01） + +対象は `c1eafebdd04e2a3f77f84a6154d766c6d9a06980` にKDocだけを追記した `409b7ab808b510d00dfc30a489abb7cdd24aef6e` のcore/sample/test。今回の後続変更は文書のみ。PR71の修正済みコアを使い、製品の実装・テスト・ビルド設定は一切変更していない。OverlaySpecはコメントを除いた内容が基点と完全一致し、他のソース・enum・README・CHANGELOGに差分なし。 + +CodexがJDK17、Android SDK36、Gradle wrapperで以下を実行。すべて成功（148 tasks、22秒）、unitはcore145/lint12/sample4の計161件、failure/error/skip0。lintはcore警告6/sample警告55、エラー0。publish先は一時Maven repositoryへ隔離した。JitPackサービス上の確認ではない。 + +```sh +JAVA_HOME=/Users/ai-seb/.local/share/mise/installs/java/temurin-17.0.20+101 \ +ANDROID_HOME=/Users/ai-seb/Library/Android/sdk \ +./gradlew :core:assembleDebug :sample:assembleDebug :core:testDebugUnitTest :lint:test :sample:testDebugUnitTest :core:lintDebug :sample:lintDebug :core:assembleRelease :core:publishToMavenLocal \ + -Dmaven.repo.local=/private/tmp/ovm-c1234-maven-20261101 +``` + +物理実機は未接続。API23/26/35の専用AVDを順番に `emulator-5580` として起動し、各端末でフィルタを指定せず `:sample:connectedDebugAndroidTest` を実行した。無関係のemulator5554は操作していない。 + +| API | 端末 | 成功 / 実行 | failure / error / skip | Gradle実行の実測時間 | XMLの試験時間 | +| --- | --- | --- | --- | --- | --- | +| 23 | `OverlayViewManager_3_0_API_23` / Android SDK arm64-v8a | 26 / 26 | 0 / 0 / 0 | 220.09秒 | 215.058秒 | +| 26 | `OverlayViewManager_3_0_API_26` / Android SDK arm64-v8a | 26 / 26 | 0 / 0 / 0 | 202.95秒 | 199.205秒 | +| 35 | `OverlayViewManager_3_0_API_35` / Android SDK arm64-v8a | 31 / 31 | 0 / 0 / 0 | 244.88秒 | 240.730秒 | + +合計83件成功。API23/26ではfreeform2件（minSdk28）と別UID透過3件（minSdk31）がSDK条件で対象外。これらを実行成功や実行後のskipとして加算していない。API35は31件にfreeform2件と別UID3件を含み、skipなし。今回、端末試験の失敗はなく、製品・テストの修正や失敗後の再試行は行っていない。 + +API23/26はanimation設定を変更せず、API35もwindow/transition=1.0・animator=nullを維持。API35の `enable_freeform_support` の元値nullを保存して1へ変更し、試験終了後にdeleteしてnullへ復元した。専用AVDは全て終了済み。物理実機・API31・API36は今回再実行していない（API36のPR71後31件成功は前節の証拠）。 + +再現コマンド（APIごとにAVD名を23/26/35へ変え、起動完了・API値を確認してから実行）: + +```sh +/Users/ai-seb/Library/Android/sdk/emulator/emulator -avd OverlayViewManager_3_0_API_23 -port 5580 \ + -no-snapshot -no-window -no-audio -gpu swiftshader_indirect +``` + +起動コマンドを実行した端末はそのままにし、別の端末で起動完了を確認してから以下を実行する。freeform設定の行はAPI35のみ。 + +```sh +# API 35 only: record the original value, enable freeform, and restore it after testing. +/Users/ai-seb/Library/Android/sdk/platform-tools/adb -s emulator-5580 shell settings put global enable_freeform_support 1 +JAVA_HOME=/Users/ai-seb/.local/share/mise/installs/java/temurin-17.0.20+101 \ +ANDROID_HOME=/Users/ai-seb/Library/Android/sdk ANDROID_SERIAL=emulator-5580 \ +./gradlew :sample:connectedDebugAndroidTest +``` + +| API | fingerprint | +| --- | --- | +| 23 | `Android/sdk_google_phone_arm64/generic_arm64:6.0/MASTER/8690019:userdebug/test-keys` | +| 26 | `google/sdk_gphone_arm64/generic_arm64:8.0.0/OSR1.180418.028.A3/10734686:userdebug/dev-keys` | +| 35 | `google/sdk_gphone64_arm64/emu64a:15/AE3A.240806.043/12960925:userdebug/dev-keys` | + +一時的な生ログ・JUnit XML・端末情報・実行時間は `/private/tmp/ovm-c1234-evidence-20261101/` に保存。主なファイルは `build.log`、`api23-connected.log`（26/35も同様）、`api23-results/`、`api23-device.json`、`api23-run.json`。共有用の再現条件・確定結果は本記録に残した。 + +成果物SHA256: + +- `core/build/outputs/aar/core-release.aar`: `eb8ff9d04523e118d79eef3792a7f3ac6fbf198057247360216ee1687a66630d` +- `sample/build/outputs/apk/debug/sample-debug.apk`: `ee17acd78c3009f86169647d1c4d5dd470a093f88bbeabd6b8d41fc94d60448f` +- `sample/build/outputs/apk/androidTest/debug/sample-debug-androidTest.apk`: `e0e93fb1aee652533953d4bc9835df7daf4d6c1bc7230a0ac9491a6675fa3576` + +最終対向レビューはClaude司令塔が担当する。上記の端末・Gradle結果はCodexの実行であり、Claude自身による再実行ではない。統合後のrelease headとCIはPR66へコメントし、work/3.0.0にも同じrelease headを同期する。mainマージ・タグ・正式公開は実行しない。 diff --git a/docs/coordination/3.0.0/README.md b/docs/coordination/3.0.0/README.md new file mode 100644 index 0000000..1f19771 --- /dev/null +++ b/docs/coordination/3.0.0/README.md @@ -0,0 +1,43 @@ +# 3.0.0 司令塔間のやり取り・判断ログ + +このディレクトリをGit管理し、後から「誰が何を提案し、どう応答し、なぜ決めたか」を振り返れるようにする。2026-09-12 JSTに開始指示を受領し、CodexとClaudeの協議を開始した。 + +## 記録方法 + +- 話題ごとに `YYYY-MM-DD--.md` を作る。ユーザー指示による準備は `prep` を使う。 +- 各発言の日時（タイムゾーン付き）、司令塔名、内容の要旨を時系列で残す。逐語転載でないものは要旨と明記する。 +- 提案だけでなく相手の返答、異論、選択肢、判断根拠、未解決の質問、結論を残す。機密値や無関係な端末出力は記録しない。 +- OrcaのメッセージID・Task/Dispatch、PR URL・head SHAを参照する。ローカル端末ハンドルだけに依存しない。 +- 「ユーザー指示」「一方の提案」「回答待ち」「双方合意」「撤回・変更」を区別する。実在しない会話や承認を補わない。 +- 過去の判断を上書きせず、変更理由と旧判断へのリンクを付けて追記する。 +- 各司令塔は自分のworktreeで記録案を作り、Codexが共有計画・ログの統合を直列化する。同じログを並行編集しない。 +- 合意を担当へ渡す前、レビュー結論時、統合時に記録する。関連PRまたは文書PRでコミットし、実装開始後のマージは相互承認を経る。 +- 相互APPROVEの記録は対象PR/head SHAと元のレビューを参照する。Markdownの記載だけでレビュー済み扱いにしない。 +- `V3_0_0_PLAN.md` も節目に更新する。ユーザー許可による準備用先行コミットは、未実施の相互レビューとは区別して記録する。 + +## テンプレート + +```markdown +# : <話題> + +- 状態: 提案 / 回答待ち / 双方合意 / 撤回・変更 +- 関連タスク: +- 記録担当: +- 関連PR / head SHA: +- Orcaメッセージ / Task / Dispatch: + +## 背景・選択肢 + +## やり取り（発言要旨） + +| 日時・タイムゾーン | 発言者 | 提案・返答・異論 | 根拠・元メッセージ | +| --- | --- | --- | --- | + +## 判断結果・理由 + +## 未解決事項・次の担当 + +## 計画・実装・検証への影響 + +## 変更履歴・後続判断 +``` diff --git a/docs/coordination/3.0.0/evidence/2026-10-31-drag-api35.mp4 b/docs/coordination/3.0.0/evidence/2026-10-31-drag-api35.mp4 new file mode 100644 index 0000000..b1bc05c Binary files /dev/null and b/docs/coordination/3.0.0/evidence/2026-10-31-drag-api35.mp4 differ diff --git a/docs/coordination/3.0.0/evidence/2026-11-01-remove-timber-menu.png b/docs/coordination/3.0.0/evidence/2026-11-01-remove-timber-menu.png new file mode 100644 index 0000000..184da20 Binary files /dev/null and b/docs/coordination/3.0.0/evidence/2026-11-01-remove-timber-menu.png differ diff --git a/docs/coordination/3.0.0/evidence/2026-11-01-remove-timber-sample1.png b/docs/coordination/3.0.0/evidence/2026-11-01-remove-timber-sample1.png new file mode 100644 index 0000000..d08ad8a Binary files /dev/null and b/docs/coordination/3.0.0/evidence/2026-11-01-remove-timber-sample1.png differ diff --git a/docs/coordination/3.0.0/evidence/2026-11-01-remove-timber-sample3.png b/docs/coordination/3.0.0/evidence/2026-11-01-remove-timber-sample3.png new file mode 100644 index 0000000..e957900 Binary files /dev/null and b/docs/coordination/3.0.0/evidence/2026-11-01-remove-timber-sample3.png differ diff --git a/docs/design/3.0.0-api.md b/docs/design/3.0.0-api.md new file mode 100644 index 0000000..1f45c17 --- /dev/null +++ b/docs/design/3.0.0-api.md @@ -0,0 +1,374 @@ +# OverlayViewManager 3.0.0 approved API design (T01) + +Status: **Approved bilaterally for the 3.0.0 implementation plan** in [PR #22](https://github.com/75py/Android-OverlayViewManager/pull/22). Changes to these contracts require a new coordinator agreement. + +This document records the approved T01 design, originally proposed by Codex. It deliberately specifies externally observable behavior, not the internal class layout. T04--T09 may refine implementation details but must not change these contracts without reopening this proposal. + +The proposal wording and environment observations below preserve the original decision record. Current implementation progress and the validated toolchain are tracked in `V3_0_0_PLAN.md`; approval of this design does not mean all contracts are implemented yet. + +The `opt-timber` module and `DebugOverlayTree` described below were removed before release at the user's request; see `docs/coordination/3.0.0/2026-11-01-remove-timber.md`. + +## Evidence and scope + +### Facts observed in the 2.x tree + +* `OverlayViewManager` is a process singleton initialized by `init(Application)`. Its two factories create an application-scoped or an activity-scoped `OverlayView`; only the latter forces `TYPE_APPLICATION`. +* `OverlayView.show()`, `update()`, and `hide()` synchronously mutate `isVisible`, but `OverlayWindowManager` may post the corresponding `WindowManager` call to main and catches every exception. Thus `isVisible == true` can mean neither that `addView` succeeded nor that it has run. +* The mutable `WindowManager.LayoutParams` object is shared between the caller and a posted operation. A background `show()` followed by a main-thread `hide()` can execute as `remove` before `add`, and then leave a window attached. +* `ScreenMonitor` itself is a permission-requiring application overlay. Dragging an activity-scoped overlay can therefore require system-overlay permission, and toggling `setDraggable(false)` before `hide()` leaks a monitor request. +* `OverlayWindowManager.activityInstances` is a `WeakHashMap`, but its value contains an activity window manager. Its actual reachability must be verified in T08 rather than inferred from the weak key. In 2.x, `DebugOverlayTree` also mutated an `ArrayList` and a `TextView` directly from Timber's arbitrary logging thread. +* The 2.x public surface included `OverlayView`, `DraggableOnTouchListener`, permission dialog/launcher helpers, and size accessors; opt-timber published `DebugOverlayTree`. The lint rule specifically identifies `allowViewToExtendOutsideScreen`. + +### Non-goals + +3.0 does not add Compose APIs, background-service management, a system-wide accessibility overlay, automatic permission prompting, or automatic retry. An application overlay may outlive an Activity, but the host app remains responsible for foreground-service, background-start, and Play-policy compliance. + +## Decision: one synchronous main-thread contract + +**Proposed decision:** public API calls which create/configure a handle or mutate its window are `@MainThread`. The four mutating window operations (`show`, `update`, `hide`, and `dispose`) perform one complete `WindowManager` operation before returning an `OverlayResult`; they never enqueue a later show/hide/update. Factories and read-only accessors return their declared object/value, not an `OverlayResult`; `OverlayPermission` is immutable and may be queried from any thread. `OverlayResult` represents recoverable platform failures, while invalid arguments and calls from a non-main thread throw `IllegalArgumentException` or `IllegalStateException`. + +| Candidate | Benefit | Failure mode / cost | Decision | +| --- | --- | --- | --- | +| Main-thread-only synchronous calls | Operation order, attachment state, and result are observable together; simple JUnit/Robolectric and device tests; no stale posted work | Callers must switch from worker threads to main | **Adopt** | +| Public serialized async queue | Could accept worker calls | Needs futures/cancellation, a defined queue-drain state, snapshots, ordering semantics, and a way to report failures after return; easily recreates the present show/hide race | Reject for 3.0 | + +The library must use `Looper.getMainLooper()` identity, not merely a lock or `synchronized`, to enforce this. A later main-executor convenience is deliberately not part of 3.0; applications can use their own main executor. `state` and `lastFailure` are thread-safe read-only exceptions and may be read in every state, including `DISPOSED`; the effective immutable `spec` is read-only but remains `@MainThread`, including after disposal, and `view` remains main-thread-only. + +## Proposed public API + +Names below are signatures and contracts, not source code. Kotlin-facing names use idiomatic properties where harmless; the compiled API must expose the Java forms shown as well. + +```kotlin +class OverlayViewManager private constructor(application: Application) { + companion object { + @JvmStatic @MainThread fun init(application: Application) + @JvmStatic @MainThread fun getInstance(): OverlayViewManager + } + + fun newOverlayView(view: T, spec: OverlaySpec = OverlaySpec()): OverlayView + fun newOverlayView(view: T, activity: Activity, + spec: OverlaySpec = OverlaySpec()): OverlayView + fun overlayPermission(): OverlayPermission +} + +class OverlayView { + @get:MainThread val view: T // throws after disposal + val state: OverlayState // readable in every state + val lastFailure: OverlayFailure? // readable in every state; no retained Throwable + @get:MainThread val spec: OverlaySpec // effective immutable spec; Java getSpec(), readable on main in every state + @MainThread fun show(): OverlayResult + @MainThread fun update(spec: OverlaySpec): OverlayResult + @MainThread fun hide(): OverlayResult + @MainThread fun dispose(): OverlayResult +} + +enum class OverlayState { CONFIGURED, ATTACHED, DISPOSED } +enum class OverlayScope { ACTIVITY, APPLICATION } +enum class OverlayTouchMode { PASS_THROUGH, INTERACTIVE, DRAGGABLE } +enum class CrossUidPassThrough { SAME_UID_ONLY, WHEN_SYSTEM_ALLOWS } +enum class OverlayFailure { PERMISSION_DENIED, ACTIVITY_DESTROYED, INVALID_WINDOW_TOKEN, + WINDOW_MANAGER_REJECTED, ALREADY_HAS_PARENT, NOT_ATTACHED, + PASS_THROUGH_OPACITY_EXCEEDED, PASS_THROUGH_UNSUPPORTED } + +class OverlayResult { + val state: OverlayState + val changed: Boolean + val failure: OverlayFailure? // null on success/no-op + val cause: Throwable? // diagnostic only; null for preflight failures with no exception + val isSuccess: Boolean +} +``` + +The shipped Kotlin source retains the established `OverlayViewManager` / `OverlayView` class names, and has explicit Java-friendly overloads for both established factory shapes, with and without a spec. Java callers must be able to write the following without Kotlin types, coroutines, or `Result`: + +```java +OverlayViewManager.init(application); +OverlayViewManager manager = OverlayViewManager.getInstance(); +OverlayView overlay = manager.newOverlayView( + new TextView(application), + new OverlaySpec.Builder().setTouchMode(OverlayTouchMode.INTERACTIVE).build()); +OverlayResult result = overlay.show(); +if (!result.isSuccess()) { + // Show the host application's permission rationale or recover its Activity state. +} +``` + +The manager declares these four Java factory overloads explicitly; Java does not depend on Kotlin default arguments: + +```java +public OverlayView newOverlayView(T view); +public OverlayView newOverlayView(T view, OverlaySpec spec); +public OverlayView newOverlayView(T view, Activity activity); +public OverlayView newOverlayView(T view, Activity activity, OverlaySpec spec); +``` + +`OverlayViewManager.init` is idempotent only for the same `Application` object. Passing a different `Application` is an `IllegalStateException`; it must not replace process-level window or lifecycle state. `getInstance` before initialization is an `IllegalStateException`. Initialization, factory creation, and all mutating handle methods are main-thread calls, so a view and its listener are never configured concurrently with attachment. + +### `OverlaySpec` + +`OverlaySpec` is immutable and value-based. Its public Kotlin declaration is: + +```kotlin +data class OverlaySpec( + val width: Int = ViewGroup.LayoutParams.WRAP_CONTENT, + val height: Int = ViewGroup.LayoutParams.WRAP_CONTENT, + val gravity: Int = Gravity.TOP or Gravity.START, + val x: Int = 0, + val y: Int = 0, + val horizontalMargin: Float = 0f, + val verticalMargin: Float = 0f, + val alpha: Float = 1f, + val touchMode: OverlayTouchMode = OverlayTouchMode.PASS_THROUGH, + val crossUidPassThrough: CrossUidPassThrough = CrossUidPassThrough.SAME_UID_ONLY, + val allowOutsideBounds: Boolean = false, + val screenBrightness: Float? = null, +) { + init { + validate() + } +} +``` + +`Gravity.TOP or Gravity.START` is resolved at attachment using the view's current layout direction. The generated Kotlin `copy(...)` calls the primary constructor, so the same validation applies to direct construction and every copied value. Java uses this explicit nested builder surface and the value's `toBuilder()`: + +```java +public static final class Builder { + public Builder(); + public Builder(OverlaySpec source); + public Builder setWidth(int width); + public Builder setHeight(int height); + public Builder setGravity(int gravity); + public Builder setX(int x); + public Builder setY(int y); + public Builder setHorizontalMargin(float margin); + public Builder setVerticalMargin(float margin); + public Builder setAlpha(float alpha); + public Builder setTouchMode(OverlayTouchMode touchMode); + public Builder setCrossUidPassThrough(CrossUidPassThrough mode); + public Builder setAllowOutsideBounds(boolean allowOutsideBounds); + public Builder setScreenBrightness(Float brightness); + public OverlaySpec build(); +} + +public Builder toBuilder(); +``` + +All Kotlin constructor parameters have defaults, providing the no-argument default construction path. Builder setters/build, direct `OverlaySpec(...)`, generated `copy(...)`, and `toBuilder().build()` all enforce the same validation: `alpha` and margins are 0..1, dimensions are valid `ViewGroup.LayoutParams` constants or non-negative, and a brightness override is 0..1. Defaults are `WRAP_CONTENT`, top-start gravity, `(0, 0)` offsets, alpha `1f`, `PASS_THROUGH`, `SAME_UID_ONLY`, `allowOutsideBounds == false`, and no screen-brightness override. It contains only: + +* width, height, gravity, x/y offsets, horizontal/vertical margin, and alpha; +* `OverlayTouchMode`; +* for application `PASS_THROUGH`, `CrossUidPassThrough` (`SAME_UID_ONLY` by default, or the explicit `WHEN_SYSTEM_ALLOWS` opt-in described below); +* `allowOutsideBounds` (default false), which means only normal layout positioning. It **does not** promise drawing above system bars or navigation controls; +* an activity-only optional screen brightness override (`screenBrightness`), rejected when used with an application-scoped factory. + +Builder values are range-checked (`alpha` and margins are 0..1; dimensions are valid `ViewGroup.LayoutParams` constants or non-negative). `DRAGGABLE` implies an interactive window and uses the library listener; a custom `DraggableOnTouchListener` is not part of 3.0 public API. The library calls `View.setOnTouchListener` only to install its listener for `DRAGGABLE` and to remove it when the mode changes or the handle is released: creating or updating a non-draggable handle leaves a host listener in place. Because a View holds one listener, `DRAGGABLE` replaces a host listener, and leaving the mode does not restore it. Every overlay mode always includes `FLAG_NOT_FOCUSABLE`; `INTERACTIVE` and `DRAGGABLE` omit only `FLAG_NOT_TOUCHABLE`, so neither mode can acquire window focus or an IME target. The listener consumes a drag only after touch slop, preserves ordinary click delivery otherwise, uses the active window's insets/coordinates, and does not add a second monitor window. The drag's translucent feedback belongs to the window, not the spec: `spec.alpha` keeps the caller's value, an update during the drag is scaled rather than overwritten, and the feedback ends on UP, on CANCEL, when the mode leaves `DRAGGABLE`, and when the window is removed. A rejected restore keeps the spec and is reapplied by the next update or gesture. + +`OverlaySpec` is the primary 3.0 configuration surface. The current fluent layout/touch setters and no-argument `update()` cannot retain their present meaning because they mutate an in-flight `LayoutParams`; they are removed rather than silently becoming asynchronous. The `OverlayView` name, both `newOverlayView` factory names, `getView`, `getSpec`, and the existing static manager initialization names are retained to minimize source migration. `getSpec()` returns the current effective immutable specification rather than the original factory/update input and is a main-thread read, including after disposal: a successful drag updates its x/y values after the corresponding layout update succeeds. `update(spec)` compares its input to that effective spec (including a dragged position), creates and applies a private snapshot only when unequal or when a rejected drag restore left the window with the translucent feedback, and never exposes `WindowManager.LayoutParams`. + +The application scope always uses the platform-supported application overlay type on API 26+ and the supported legacy type only on retained lower API levels. The activity scope uses the activity's token/application window and must not use an application-overlay type. 3.0 never selects privileged `TYPE_SYSTEM_ERROR`/`TYPE_SYSTEM_OVERLAY`; `allowOutsideBounds` is not an authorization bypass. Insets, display cutouts, rotation, RTL, multi-window, and Android 15+ edge-to-edge are observable layout constraints rather than an undocumented "status bar height" adjustment. + +### Application pass-through and the Android 12 opacity budget + +`PASS_THROUGH` means the overlay uses `FLAG_NOT_TOUCHABLE`; it does **not** promise that another UID receives the touch. On Android 12+ a `TYPE_APPLICATION_OVERLAY` is untrusted, and the system may block a touch through it unless the per-UID opacity conditions are satisfied. Android documents both the runtime maximum (`InputManager.getMaximumObscuringOpacityForTouch()`) and the combined-opacity formula `1 - product(1 - alpha_i)`. [WindowManager.LayoutParams reference](https://developer.android.com/reference/android/view/WindowManager.LayoutParams), [InputManager reference](https://developer.android.com/reference/android/hardware/input/InputManager) + +The default `SAME_UID_ONLY` is intentionally conservative: it supports an application overlay being non-touchable while the host application's own window is below it, but makes no cross-UID delivery claim. In particular, a default-alpha (`1f`) application overlay is allowed in this mode but must be documented as unsuitable for reliable pass-through to another app. + +For cross-UID use, callers must set `CrossUidPassThrough.WHEN_SYSTEM_ALLOWS`. On API 31+ the library obtains the system maximum on every `show`/`update` that changes an application pass-through handle and maintains a conservative per-manager budget across **all attached library-managed application pass-through handles of this UID**, not just bounds it thinks overlap. The requested operation is rejected before `addView`/`updateViewLayout` with `PASS_THROUGH_OPACITY_EXCEEDED` when the combined value would exceed the system maximum; a default `alpha == 1f` therefore normally fails the opt-in instead of pretending to provide cross-UID pass-through. If the input service/value is unavailable, it fails with `PASS_THROUGH_UNSUPPORTED`. + +This admission check is deliberately narrower than a delivery guarantee: the library cannot account for raw `WindowManager` overlays made by the same app outside this manager, the target app may hide application overlays, and the platform remains authoritative. On API 23--30 the explicit option is accepted but is documented as platform-dependent rather than guaranteed. T06 must test the calculation (including multiple handles) and a cross-UID target with Android instrumentation on either an emulator or physical device; physical hardware is useful additional coverage, not a release gate. + +### Result, state, and retry semantics + +The following is the complete handle state machine. A handle accepts a `View` with no parent at factory creation. While `ATTACHED`, its parent must be the library window owned by that same handle; an externally-parented view is rejected with `ALREADY_HAS_PARENT`. A caller must not attach, detach, or reparent the managed view itself. + +| Call / pre-state | Success | Recoverable failure | No-op | +| --- | --- | --- | --- | +| `show`, CONFIGURED | `addView` returns -> registered `ATTACHED`, `changed=true` | remains `CONFIGURED`, result has failure | — | +| `show`, ATTACHED | — | — | success, `ATTACHED`, `changed=false` | +| `update(spec)`, ATTACHED | layout update succeeds -> `ATTACHED`, `changed=true`; an equal spec also applies when a rejected drag restore is pending | remains `ATTACHED`; last successfully applied effective spec remains in effect | equal to the effective spec with no pending restore -> success, `changed=false` | +| `update(spec)`, CONFIGURED | replace pending spec -> `CONFIGURED`, `changed=true` | validation error throws | equal to the effective spec -> success, `changed=false` | +| `hide`, ATTACHED | remove succeeds -> `CONFIGURED`, `changed=true` | other remove failure remains `ATTACHED` so caller can retry | `NOT_ATTACHED` reconciles to `CONFIGURED`, successful no-op, retaining the `NOT_ATTACHED` diagnostic | +| `hide`, CONFIGURED | — | — | success, `CONFIGURED`, `changed=false` (retaining an existing diagnostic) | +| `dispose`, CONFIGURED | release references/listeners -> `DISPOSED`, `changed=true` (retaining an existing diagnostic) | — | — | +| `dispose`, ATTACHED | remove then release -> `DISPOSED`, `changed=true` | other remove failure remains `ATTACHED`; caller must retry | `NOT_ATTACHED` reconciles then releases -> `DISPOSED`, retaining the diagnostic | +| `dispose`, DISPOSED | — | — | success, `DISPOSED`, `changed=false`, retaining any existing diagnostic | +| `show` or `update(spec)`, DISPOSED by `dispose` | — | `DISPOSED`, `WINDOW_MANAGER_REJECTED` | — | +| `show` or `update(spec)`, DISPOSED by Activity destruction | — | `DISPOSED`, `ACTIVITY_DESTROYED` | — | +| `hide`, called while a library removal runs | — | — | success, `changed=false`; the removal is not repeated | +| `dispose`, called while a library removal runs | release references/listeners -> `DISPOSED`, `changed=true`; the removal is not repeated | — | — | + +Library removal is synchronous, so its detach callbacks can re-enter the handle. A `dispose` from such a callback releases at once because the view is already leaving its window, and the removal's own caller then returns `DISPOSED` rather than overwriting it. If that removal fails, its caller reports the classified failure, and the handle stays `DISPOSED` without a retry. A removal failure without re-entry keeps the retry path in the table above. + +`ATTACHED` means that the latest library `WindowManager.addView`/replacement call returned successfully and has not subsequently been reconciled as detached. It is not a promise that pixels have been rendered, that `View.onAttachedToWindow` has already run, or that the overlay remains visible after a later platform/policy change. `getState()` and `getLastFailure()` are thread-safe and readable in every state, including `DISPOSED`; `getSpec()` is main-thread-only but readable there in every state, including `DISPOSED`. After disposal, `getSpec()` returns the final effective immutable value, not a Context-, View-, Activity-, listener-, `WindowManager`-, or `Throwable`-retaining object. `lastFailure` is cleared by the next ordinary successful direct operation. A successful `NOT_ATTACHED` reconciliation through `hide()` (no-op) or `dispose()` (release), and a repeated `dispose()` after forced Activity cleanup, preserves the `NOT_ATTACHED` or forced-cleanup diagnostic; it remains observable until a later ordinary successful direct call (or forever when disposal is terminal). `lastFailure` is set by the latest failed operation; the forced Activity-destruction failure is retained because no later window operation is valid. `OverlayResult.cause` is nullable even when `failure` is non-null: preflight classifications such as permission, opacity-budget, or not-attached reconciliation can have no platform exception, while a caught platform exception is supplied only on that returned result for diagnostics. `getView()` throws in `DISPOSED`, and disposal clears all library references to the View, Activity, listeners, and `WindowManager`; retaining the `OverlayView` object therefore cannot retain them. `dispose()` is deliberately not `Closeable.close()`: a result is required so that removal failure cannot be silently lost. The application owner must call it when the overlay's feature ends, and may retry a failed disposal while the handle remains `ATTACHED`. + +Activity destruction has a distinct terminal path. On `onDestroy`, the library attempts one immediate remove. It then clears every handle reference and transitions to `DISPOSED` regardless of the remove outcome, because retrying an Activity-owned window after its owner is destroyed is invalid. If removal throws, `getLastFailure()` becomes the classified failure and the exception is logged only for diagnostics; `DISPOSED` in this path means **library ownership and references are released**, not proof that the platform removal succeeded. A retained handle cannot attach again, and the design makes no claim that an unverified framework attachment was removed. + +An `update` which would require a platform window-type change follows explicit remove/add semantics: remove success then add success yields `ATTACHED`; if the add fails it yields `CONFIGURED` and reports the add failure. The implementation must not report `ATTACHED` after a failed re-add. This case should be rare because scope and touch mode define a stable type, but it is specified to avoid an undefined half-state. + +### External detach and permission reconciliation + +The handle registers an internal `OnAttachStateChangeListener` while it owns the View. A main-thread `onViewDetachedFromWindow` that was not caused by a successful library removal reconciles `ATTACHED` to `CONFIGURED`, records `NOT_ATTACHED` until a later ordinary successful direct operation clears it, and makes a later explicit `show()` a new registration attempt. This callback is a later observation, not proof that a successful `show()` rendered pixels synchronously. + +The next `update`, `hide`, or `dispose` also classifies a framework `not attached` remove/update failure as `NOT_ATTACHED`: `hide` then returns successful `CONFIGURED`/`changed=false` and `dispose` releases the handle with successful `DISPOSED`, while both retain that diagnostic. If the listener already reconciled the handle, an already-configured `hide` is the same successful no-op and an already-configured `dispose` releases successfully, also preserving the diagnostic. Thus `NOT_ATTACHED` is a reconciliation outcome, never a stuck `ATTACHED` state; an already-disposed `dispose` remains successful with `changed=false` and preserves any existing diagnostic, including forced Activity-cleanup failure. Any other update/remove failure leaves `ATTACHED`, because the library cannot infer whether the framework retained the window. Application overlay permission can be revoked or platform policy can hide/remove a window after registration: the library does not claim continuous visibility, and a failed later operation returns its classified failure. Once a detach is observed/reconciled, the owner rechecks permission and explicitly calls `show()` after restoring the condition; there is no background watcher or automatic re-add. + +There is no automatic retry, exponential backoff, or hidden permission watcher. `PERMISSION_DENIED`, a temporarily invalid activity token, and a transient framework rejection are reported immediately; after the app fixes the condition, it invokes `show`, `update`, `hide`, or `dispose` again on main. `OverlayResult.cause` contains a caught platform exception only when one exists; clients branch on `OverlayFailure`, not exception message text. + +## Permission and lifetime boundary + +`OverlayPermission` is an immutable, thread-safe helper: + +```kotlin +class OverlayPermission { + fun isGranted(context: Context): Boolean + fun settingsIntent(context: Context): Intent +} +``` + +For API 23+ `isGranted` delegates to `Settings.canDrawOverlays`; below the chosen minimum it has no behavior because 3.0 will not support that range. `settingsIntent` is a plain `ACTION_MANAGE_OVERLAY_PERMISSION` intent for the caller's package; it does not start an activity and has no Fragment/Dialog dependency. The host launches it from a visible Activity using its usual Activity Result API, rechecks permission on return, then calls `show()` itself. `showPermissionRequestDialog` and `requestOverlayPermission` are removed: a library cannot supply an application's rationale, lifecycle, or navigation policy. + +The application-scoped `newOverlayView(view, spec)` requires overlay permission for every `show`, including pass-through windows. It reports `PERMISSION_DENIED` before calling `WindowManager` if absent. The activity-scoped `newOverlayView(view, activity, spec)` never checks or requires `SYSTEM_ALERT_WINDOW`; it is bounded by the supplied Activity window and is disposed at that Activity's destruction. Factory creation rejects a finishing/destroyed activity. Activity recreation requires a new handle and a new view; implicit reattachment to the replacement Activity is prohibited. + +## Kotlin migration boundary + +The proposed implementation boundary is intentional rather than a mechanical conversion: + +* T04--T06 and T08 may implement the state machine, main-thread checker, window adapter, immutable spec, and activity lifecycle cleanup in Kotlin. Their public classes must use explicit visibility, AndroidX nullability annotations where needed, `@JvmStatic`, explicit manually-written Java overloads for both factory shapes (with and without `OverlaySpec`), and Java-friendly bean getters (`getState`, `getView`, `getSpec`, `isSuccess`). `@JvmOverloads` is only appropriate for non-ambiguous constructors; Kotlin default arguments do not replace these factory overloads. +* Keep the public runtime API JVM-first: no suspend functions, Flow, Kotlin `Result`, inline/value classes, default-interface-method requirements, or Kotlin-only collection types. Java and Kotlin compilation tests are mandatory for every public signature added or changed. +* `DraggableOnTouchListener` becomes internal (or is deleted) with no replacement hook in 3.0. The drag behavior belongs to the handle contract, which lets T05/T06 correct coordinate and touch behavior without exposing internal state. +* Historical, removed before release: T07 owned opt-timber. `DebugOverlayTree` may be converted to Kotlin only in its own mechanical commit, retaining `DebugOverlayTree.init(Application)`, Java-accessible setters, and a new explicit `dispose()` that unregisters lifecycle callbacks. Its `log` entry point remains safe from any thread through a locked bounded deque plus one posted main render. +* T09 owns lint. It must update the detector to the final 3.0 symbol(s) or remove this policy rule when `allowViewToExtendOutsideScreen` is removed; it must not retain a detector that matches unrelated same-named methods. + +## Public-name compatibility decision + +| Option | Benefit | Cost / risk | T01 recommendation | +| --- | --- | --- | --- | +| Keep `OverlayViewManager`, `OverlayView`, and both `newOverlayView` factory shapes; introduce immutable `OverlaySpec` and result-returning window operations | Existing imports, conceptual model, and most factory call sites survive; T04--T08 can focus on reliability instead of a package-wide rename | Fluent mutable setters and chained `show()` must change because their old success/ordering semantics are unsafe | **Adopt** | +| Rename to `OverlayManager` / `OverlayHandle` | Names distinguish manager and resource ownership more directly | Breaks every user import and lint/document/sample reference without fixing a lifecycle or threading defect | Reject for 3.0 | + +This is intentionally a minimum-breaking architecture: retain names where they carry no correctness cost, but make the necessary behavioral break at mutable layout state and `show`/`hide`/`update`/`dispose` results. A deprecated compatibility shim is not proposed because a fluent setter that appears synchronous while changing a later window operation would reintroduce the ambiguity that 3.0 is intended to remove. + +## 2.x breaking changes and migration examples + +| 2.x | 3.0 replacement / reason | +| --- | --- | +| `OverlayViewManager.init()` then global `getInstance()` | Same names remain; initialization is idempotent for the same application and rejects a different application. | +| `newOverlayView(view)` | Same factory name remains and accepts an immutable `OverlaySpec`; owner retains and disposes the returned `OverlayView`. | +| `newOverlayView(view, activity)` | Same activity factory name remains and accepts `OverlaySpec`; it is destroyed with that Activity. | +| Fluent mutable setters and `show()` returning `OverlayView` | Build immutable `OverlaySpec`, call `show()` and inspect `OverlayResult`; use `update(newSpec)` for a changed layout. | +| `isVisible()` | `getState() == OverlayState.ATTACHED`; it means the latest registration succeeded and has not been reconciled as detached, not that pixels are currently rendered. | +| `OverlayView.setOnClickListener(listener)` | Call `view.setOnClickListener(listener)` on the supplied View, on main before disposal; `OverlayView` no longer forwards a click-listener setter. | +| Permission dialog/launcher methods | host owns rationale and Activity Result; call `overlayPermission().settingsIntent()` and recheck. | +| `allowViewToExtendOutsideScreen(true)` | no direct replacement. In the observed 2.x implementation, a touchable pre-O overlay with this option selected privileged `TYPE_SYSTEM_ERROR`; 3.0 never selects it. Constrain UI using `WindowInsets` and explicitly design platform/system-bar behavior. | +| Custom `DraggableOnTouchListener` | no public replacement; use `DRAGGABLE` or implement an app-owned overlay interaction. | +| `getDisplayWidth/Height()` | host obtains bounds/insets for its target window; display-wide pixel values are ambiguous in multi-window. | +| `getX()` / `getY()` | `getSpec().getX()` / `getSpec().getY()` (Kotlin: `spec.x` / `spec.y`) on the main thread; these are fields of the effective immutable specification. | +| `setScreenBrightness(...)` | Set `OverlaySpec.screenBrightness` only for an activity-scoped factory; application-scoped overlays do not support a brightness override. | +| Off-main `show()`/`update()`/`hide()` calls (2.x posted WindowManager work) | 3.0 throws before any window operation because handle creation and mutation are main-thread-only; post the call to the main executor from the host application. | + +Kotlin migration: + +```kotlin +OverlayViewManager.init(application) +val view = TextView(activity).apply { + setOnClickListener { /* ordinary click delivery remains available with DRAGGABLE */ } +} +val overlay = OverlayViewManager.getInstance().newOverlayView( + view, + activity, + OverlaySpec(touchMode = OverlayTouchMode.DRAGGABLE) +) +check(overlay.show().isSuccess) +// Preserve the effective values and change only the requested fields. +overlay.update(overlay.spec.copy(x = 24, y = 48)) +``` + +Java application-overlay migration, including a permission retry owned by the app: + +```java +OverlayPermission permission = manager.overlayPermission(); +if (!permission.isGranted(activity)) { + permissionLauncher.launch(permission.settingsIntent(activity)); + return; +} +OverlayResult shown = overlay.show(); +if (!shown.isSuccess() && shown.getFailure() == OverlayFailure.PERMISSION_DENIED) { + // Permission may have been revoked between the check and show; do not auto-retry. +} +// A worker-thread caller migrates every handle operation by posting it to main. +new Handler(Looper.getMainLooper()).post(() -> { + // Java partial update starts with the effective specification. + OverlayResult updated = overlay.update( + overlay.getSpec().toBuilder().setAlpha(0.75f).build()); + OverlayResult disposed = overlay.dispose(); + // Inspect updated/disposed on main if the owner needs recovery logic. +}); +``` + +## Environment proposal (facts separated from decisions) + +| Item | Observed / official fact | T01 proposal | +| --- | --- | --- | +| Current tree | core/sample compile and target SDK 34, min SDK 21; Gradle 8.9; active AGP declaration 8.5.1 plus stale buildscript AGP 3.2.1 | T03 owns consolidating build definitions. | +| Android SDK | Android's current Android 16 setup page specifies `compileSdk = 36` and `targetSdk = 36`; Play's current requirement says new mobile apps/updates need target API 36 from 2026-08-31. [Android 16 setup](https://developer.android.com/about/versions/16/setup-sdk), [Play requirement](https://developer.android.com/google/play/requirements/target-sdk) | `compileSdk 36`, `targetSdk 36` for core and sample. Test edge-to-edge explicitly because it is enforced at target 35+ on Android 15+. | +| Minimum SDK | 2.x is API 21. This is a product-support policy, not derivable from a build tool page. | Recommend `minSdk 23` (Android 6): aligns the supported baseline with `Settings.canDrawOverlays` and removes untestable pre-M permission semantics. **Requires bilateral product approval**; retain 21 only if the project explicitly commits to API 21--22 device testing and legacy window behavior. | +| Build toolchain | The official AGP 9.2 release notes state Gradle 9.4.1 and JDK 17; official JDK guidance states AGP 8.x requires JDK 17. [AGP 9.2 notes](https://developer.android.com/build/releases/agp-9-2-0-release-notes), [JDK guidance](https://developer.android.com/build/jdks) | T03 should use AGP 9.2.x with Gradle 9.4.1 and a pinned JDK 17 toolchain, after verifying the exact patch release, Kotlin-plugin compatibility, lint API compatibility, and clean CI build. Do not infer a Kotlin-plugin version here. | +| Test OS matrix | Android 15 target behavior enforces edge-to-edge at target 35+. [Edge-to-edge guidance](https://developer.android.com/develop/ui/views/layout/edge-to-edge) | Device/instrumentation acceptance on an emulator or physical device: API 23 (minimum), API 26 (application overlay type boundary), API 35 (edge-to-edge), and API 36 (target/current). Cross-UID permission and touch tests on an emulator are valid evidence; physical-device coverage is additional confidence, not a gate. | + +The linked facts were verified on 2026-09-12. The proposed `minSdk`, exact AGP patch/Kotlin version, and all API names remain decisions pending coordinator approval and T03 compatibility validation. + +## Acceptance contract for follow-on tasks + +### T04 — state and thread processing + +* Test non-main public mutators fail before a `WindowManager` call; no posted operation remains to run later. +* Test add failure leaves `CONFIGURED`, `isSuccess == false`, a classified failure and nullable diagnostic cause, and permits an explicit show retry after permission is granted. +* Test preflight failures can return a non-null `OverlayFailure` with a null `cause`; a caught platform exception is exposed only by that result and is not retained by the handle. +* Test worker-show/main-hide cannot reorder; repeated show/hide/update no-ops and each state/result pair above are covered. +* Test update failure preserves attached state and last applied layout; remove/re-add failure never falsely reports attachment. + +### T05 — monitoring, coordinates, and permission boundary + +* Activity draggable overlay attaches with `SYSTEM_ALERT_WINDOW` denied and creates no application monitor window. +* No `ScreenMonitor`-style auxiliary application window exists; bounds are recomputed for rotation, RTL, insets, and multi-window as specified. +* Coordinate model: without `allowOutsideBounds`, the drag normalizes to an absolute `TOP|LEFT` gravity, and `x`/`y` are an offset from the target window's visible frame origin (`View.getWindowVisibleDisplayFrame().left`/`.top`), not the display's `(0, 0)` and not a fixed status-bar height; this makes multi-window/freeform and rotated frames with a non-zero left/top origin resolve correctly. With `allowOutsideBounds`, `FLAG_LAYOUT_NO_LIMITS` makes that frame a placeholder rectangle (about 100000px in each direction, seen on API 35) and the window is never clamped, so the drag keeps gravity and margins and adds the pointer's delta to `x`/`y`, inverted for right and bottom gravity. +* Permission settings return path tests denied -> grant -> explicit `show()` retry and grant -> revoke -> failed update/show. + +### T06 — touch and drag behavior + +* Cover DOWN/MOVE/UP/CANCEL, touch slop click-versus-drag, multi-pointer active-pointer changes, alpha restoration, and off-screen/bounds behavior. +* Verify a completed drag updates `getSpec().getX()`/`getY()`, equality is against that effective spec, Kotlin `copy` and Java `toBuilder` preserve unspecified values, and every touch mode remains `FLAG_NOT_FOCUSABLE`. +* Verify `SAME_UID_ONLY` and explicit cross-UID behavior against a different-UID target on Android 12+; calculate the conservative combined opacity for one and multiple library handles, reject over-budget requests, and accept emulator instrumentation as valid evidence. +* Cover API 26, API 35 edge-to-edge, and the documented system-bar limitation; no legacy privileged window type is selected. + +### T07 — Timber safety (historical, removed before release) + +These criteria applied to the Timber integration, which 3.0.0 does not ship. + +* Logging from multiple worker threads cannot mutate `TextView` off-main or corrupt the buffer. Rendering is coalesced, preserves ordered bounded output, and validates `maxLines`: values below 1 throw `IllegalArgumentException`, shrinking trims immediately, and a zero-length output is never passed through `setLength(-1)`. +* Activity registration/lifecycle and `dispose()` release all callbacks and overlay resources; Java API compatibility tests cover the public tree methods. + +### T08 — initialization and release + +* Same-application initialization is idempotent; a different application is rejected without replacing live state. +* Activity destruction attempts removal, then disposes handles/listeners and leaves no retained activity path even when removal fails. Verify the `WeakHashMap` concern with a reference-path or heap test, not assertion by weak key alone; assert the forced-disposal diagnostic rather than claiming framework detachment after a failed remove. +* Application overlays require explicit successful `dispose`; a failed removal remains retryable/attached and is reported. Repeated initialization never leaves an old monitor/window/listener. + +### T09 — lint and packaging + +* Update/remove the obsolete outside-screen detector based on the approved public API; test Java and Kotlin callers plus an unrelated same-named method. +* Publish lint in the AAR and validate it from a separate consumer. Its rule text must not claim system-bar access that 3.0 does not provide. + +## Bounded implementation ownership after approval + +* Codex T04--T06/T08: core API/state/window/lifecycle/drag work, sequentially because these touch the same core behavior. +* Claude T07 (historical, removed before release): opt-timber confinement and lifecycle cleanup; Claude T09: lint policy and packaging; both consume the approved names/contracts above. +* Claude T03: versions/toolchain only after this proposal and T02; it owns all Gradle/SDK edits and verifies unresolved compatibility facts. +* T10 documents the final approved API; it must not present this proposal as shipped behavior before implementation and joint approval. + +## Choices requiring bilateral coordinator approval + +1. Adopt immutable `OverlaySpec` and result-returning window operations while retaining the established `OverlayViewManager` / `OverlayView` names and factory shapes. +2. Adopt the strict main-thread contract and explicit `OverlayResult`, including no library async queue or automatic retry. +3. Adopt recommended `minSdk 23`; otherwise record the API 21--22 support/testing obligation and permission/type behavior. +4. Confirm whether an application overlay must offer screen-brightness configuration. This proposal disallows it (activity scope only) because screen brightness is window- and UX-sensitive. +5. Confirm the exact AGP 9.2.x/Kotlin plugin patch only after T03's clean compatibility validation. diff --git a/docs/migration/2.x-to-3.0.md b/docs/migration/2.x-to-3.0.md new file mode 100644 index 0000000..e5c6dd4 --- /dev/null +++ b/docs/migration/2.x-to-3.0.md @@ -0,0 +1,188 @@ +# Migrating from 2.x to 3.0.0 + +3.0.0 is a breaking API update and is currently unreleased. This guide uses the final API. The 2.x methods listed below are removed without deprecated bridges, so 2.x call sites stop compiling until they are migrated. + +The 3.0 core is implemented in Kotlin, so `kotlin-stdlib` is a transitive dependency even for Java-only applications. + +## Migration checklist + +1. Raise the application's minimum supported API to 23 or later and use a compatible build toolchain. +2. Initialize `OverlayViewManager` once from `Application.onCreate()` on the main thread. +3. Choose an Activity or application owner for each handle. Do not retain Activity contexts in application overlays. +4. Replace mutable fluent calls with an immutable `OverlaySpec`, and handle every operation's `OverlayResult`. +5. Move permission UI to the host and recheck permission after returning from Settings. +6. Implement explicit disposal and failure handling. Keep an application handle if removal fails. +7. Remove the `overlayviewmanager-opt-timber` dependency and `DebugOverlayTree` calls, then test your actual devices, window configurations, and touch targets. + +## API replacements + +| 2.x pattern | 3.0.0 replacement | +| --- | --- | +| `overlay.setWidth(...).setX(...).setAlpha(...)` | Pass `OverlaySpec` at creation, or call `update(newSpec)`. Kotlin: `copy`; Java: `toBuilder().setX(...).build()`. | +| `overlay.update()` | `overlay.update(spec)` returns a result and synchronously applies or stores configuration. | +| Chained `show()` / `hide()` calls | Read the returned `OverlayResult`; keep the handle separately. | +| `isVisible()` | `state == OverlayState.ATTACHED` (Java: `getState()`). This reports attachment, not visual occlusion. | +| `getX()` / `getY()` on the handle | `spec.x` / `spec.y` (Java: `getSpec().getX()` / `getY()`). | +| `setTouchable` / `setDraggable` | Select `PASS_THROUGH`, `INTERACTIVE` or `DRAGGABLE` in `OverlaySpec.touchMode`. | +| `overlay.setOnClickListener(...)` | `overlay.view.setOnClickListener(...)` (Java: `getView()`). | +| A custom public drag listener | Use `DRAGGABLE`; internal drag machinery is not a public extension API. | +| `allowViewToExtendOutsideScreen` | No equivalent for the old privileged-window behavior. Use `OverlaySpec.allowOutsideBounds` only for ordinary layout bounds; it does not guarantee system-bar placement. | +| `setScreenBrightness(...)` | `OverlaySpec.screenBrightness` on an Activity overlay only. | +| `manager.canDrawOverlays()` | `manager.overlayPermission().isGranted(context)` or a standalone `OverlayPermission`. | +| `requestOverlayPermission` / `showPermissionRequestDialog` / `PermissionRequestDialogFragment` | Host-owned rationale and Activity Result launch of `settingsIntent(context)`, followed by a fresh permission check. The library no longer ships a dialog, its strings or an AndroidX Fragment dependency. | +| `getDisplayWidth()` / `getDisplayHeight()` | Read the target host window's bounds and insets with a compatible fallback. | +| Dropping a reference after hiding | Explicitly `dispose()`; discard the sole application handle only after success. | +| `DebugOverlayTree` / `overlayviewmanager-opt-timber` | Removed with no replacement. A host that wants logs on screen can plant its own Timber tree that renders into an `OverlayView`. | +| Lint issue id `ALLOW_VIEW_TO_EXTEND_OUTSIDE_SCREEN` | `ALLOW_OUTSIDE_BOUNDS`, reported on `OverlaySpec.Builder.setAllowOutsideBounds(...)` unless the argument is the constant `false`. Rename the id in `lint.xml`, baselines and `@SuppressLint`. Kotlin constructor and `copy` arguments are not inspected. | + +Ordinary Android View methods such as `View.setAlpha()` and `View.setOnClickListener()` remain Android APIs. The migration removes the old methods on the overlay handle, not methods on every object with the same name. + +## Configuration in Java and Kotlin + +Java uses a builder and explicitly keeps the handle: + +```java +TextView label = new TextView(activity); +label.setText("Activity overlay"); +OverlaySpec spec = new OverlaySpec.Builder() + .setTouchMode(OverlayTouchMode.DRAGGABLE) + .setX(24) + .setY(48) + .build(); +OverlayView handle = OverlayViewManager.getInstance() + .newOverlayView(label, activity, spec); +OverlayResult shown = handle.show(); +if (!shown.isSuccess()) { + Log.w("Overlay", "Show failed: " + shown.getFailure(), shown.getCause()); +} +``` + +Kotlin uses defaults and immutable copies: + +```kotlin +val label = TextView(activity).apply { text = "Activity overlay" } +val handle = OverlayViewManager.getInstance().newOverlayView( + label, activity, OverlaySpec(touchMode = OverlayTouchMode.DRAGGABLE), +) +val shown = handle.show() +if (!shown.isSuccess) Log.w("Overlay", "Show failed: ${shown.failure}", shown.cause) +val moved = handle.update(handle.spec.copy(x = 24, y = 48)) +if (!moved.isSuccess) Log.w("Overlay", "Move failed: ${moved.failure}", moved.cause) +``` + +These fragments run on the main thread; their owner retains `handle` for later hiding or disposal. In Java, updating a single field is `handle.update(handle.getSpec().toBuilder().setX(24).build())`. + +### OverlaySpec compatibility within 3.x + +`OverlaySpec` remains a data class. New properties in 3.x will be appended at the end with default values, preserving source compatibility for Kotlin constructor/`copy` calls and Java Builder usage. Java callers must use `OverlaySpec.Builder` or `toBuilder()` rather than the primary constructor or generated `copy` method; direct Java constructor calls would require the new arguments. + +Binary compatibility of constructor/`copy` calls from already compiled intermediate libraries is **not guaranteed across 3.x minor versions**. Default values do not retain the previous JVM signatures. Recompile those libraries against the selected OverlayViewManager version when upgrading, even if their Kotlin source needs no changes. + +## Results, state, and retry + +`OverlayResult` exposes `state`, `changed`, `failure`, `cause` and `isSuccess`. In Java use `getState()`, `getChanged()`, `getFailure()`, `getCause()` and `isSuccess()`. Use the classified failure for recovery instead of parsing exception text. + +- `CONFIGURED`: reusable, currently not attached. A successful `hide()` returns here. +- `ATTACHED`: attached according to the handle. Another window or OS policy may still hide it visually. +- `DISPOSED`: resources released. Repeated hide/dispose is harmless; create a new handle to show again. Reading `view` after disposal throws. + +A recoverable show/update rejection preserves the effective configuration and relevant state. Examples include permission denial, an invalid window token, and opacity admission failure. External detachment can reconcile the state to `CONFIGURED`; use the returned state. `changed == false` alone is not a failure signal: successful no-ops also return false. Inspect `isSuccess` first. + +Application `show()` checks permission before attaching. Updates to an attached window rely on the platform's result rather than repeating a permission preflight; a SecurityException is classified as `PERMISSION_DENIED`. Hiding or disposing does not launch permission UI or request a grant. + +After a failed application-overlay disposal, keep the handle, owner and retry path. Do not null the field in a `finally` block. Explicit Activity disposal is also retryable, but the final Activity-destruction safety net releases references after one removal attempt regardless of its outcome. Invalid specs, invalid ownership arguments, and off-main-thread calls remain programming errors that can throw. + +## Application overlay and permission return + +An application overlay needs `SYSTEM_ALERT_WINDOW` in the manifest. The host owns its lifetime; a permission Activity must not be its sole owner. For example, put the following owner in your Application or an appropriately managed service. This Kotlin class uses an Application context and retains the handle after failed removal: + +```kotlin +class ApplicationOverlayOwner(private val app: Application) { + private var handle: OverlayView? = null + + fun show(): OverlayResult { + val current = handle ?: OverlayViewManager.getInstance().newOverlayView( + TextView(app).apply { text = "Application overlay" }, + OverlaySpec(touchMode = OverlayTouchMode.DRAGGABLE), + ).also { handle = it } + return current.show() + } + + fun dispose(): OverlayResult? { + val current = handle ?: return null + val result = current.dispose() + if (result.isSuccess) handle = null + return result + } +} +``` + +Call both methods on the main thread, inspect their results, and keep this owner reachable until disposal succeeds. Construct it after manager initialization. An Application-owned object is not a background execution guarantee; a long-running use case still needs host-managed Android lifecycle/service behavior. + +In the permission Activity, the following Kotlin members consume one explicit user show request. `owner` is the longer-lived owner above, obtained from your Application/service. `showButton` and `closeButton` are your UI controls; do not store the Activity in the owner. + +```kotlin +private val permission = OverlayPermission() +private var showRequested = false +private val settingsLauncher = registerForActivityResult( + ActivityResultContracts.StartActivityForResult(), +) { + val requested = showRequested + showRequested = false + if (requested && permission.isGranted(this)) showOwnedOverlay() +} + +private fun requestShow() { + if (permission.isGranted(this)) { + showRequested = false + showOwnedOverlay() + } else if (!showRequested) { + showRequested = true + try { + settingsLauncher.launch(permission.settingsIntent(this)) + } catch (failure: ActivityNotFoundException) { + showRequested = false + Log.w("Overlay", "Overlay permission settings are unavailable", failure) + } + } +} + +private fun showOwnedOverlay() { + val result = owner.show() + if (!result.isSuccess) Log.w("Overlay", "Show failed: ${result.failure}", result.cause) +} + +private fun requestClose() { + showRequested = false + val result = owner.dispose() ?: return + if (!result.isSuccess) Log.w("Overlay", "Close failed: ${result.failure}", result.cause) +} +``` + +Call `requestShow()` from the show button and `requestClose()` from the close button. Register the launcher during Activity initialization, not inside the button listener. After recreation this minimal example forgets the request and requires another user action; it never displays an overlay solely because Settings returned. A host that preserves pending UI requests can save and restore that flag, but must consume it once and allow cancellation. Denial causes no loop and no automatic retry. A grant can be revoked before `show()`, so the result check remains necessary. + +The Java [SampleStartActivity](../../sample/src/main/java/com/nagopy/android/overlayviewmanager/sample/SampleStartActivity.java) uses an Activity Result launcher to recheck permission and refresh its UI. It does not preserve a pending show request or show an overlay automatically on return: the user opens a sample and explicitly starts it. That is a simpler host policy than the Kotlin pending-request example above. + +The Java application example separates [Sample2Activity and its Service](../../sample/src/main/java/com/nagopy/android/overlayviewmanager/sample/Sample2Activity.java) from [Sample2OverlayController](../../sample/src/main/java/com/nagopy/android/overlayviewmanager/sample/Sample2OverlayController.java). The controller owns the application-context View and retains the handle if disposal fails, so an explicit retry can still reach it after Service destruction. + +## Geometry, touch, and screen brightness + +`OverlaySpec` holds window dimensions, gravity, offsets, margins, alpha and touch policy. Width/height accept nonnegative values, `MATCH_PARENT` or `WRAP_CONTENT`; normalized margins, alpha and optional brightness must be finite and between 0 and 1. Read bounds from the target window, accounting for insets and RTL. Host UI limits must work without an overlay grant. `allowOutsideBounds` does not override Android's protected display areas. The old pre-O `TYPE_SYSTEM_ERROR` behavior is not retained in 3.0.0. + +`PASS_THROUGH` and `WHEN_SYSTEM_ALLOWS` are separate decisions. The former makes this overlay non-touchable; the latter requests cross-UID pass-through where the platform allows it. It is not a promise that touches reach another application. The default `SAME_UID_ONLY` does not isolate touches by UID either; Android decides. For a non-touchable application overlay above `InputManager.getMaximumObscuringOpacityForTouch()` (0.8 by default), the outcome depends on whether the build includes the window manager's opacity clamp; the API level alone does not tell. A build with the clamp lowers the overlay to that maximum and lets the touch through, so a default-alpha overlay appears dimmed. A build without it keeps the overlay opaque and blocks the touch. On emulators, the API 36 image has the clamp, while the API 31 images, including the initial Android 12 release, do not. Overlapping overlays can exceed the combined limit either way. `WHEN_SYSTEM_ALLOWS` rejects an over-limit request with `PASS_THROUGH_OPACITY_EXCEEDED` instead. The library's managed opacity admission considers its registered pass-through overlays; it cannot account for every unrelated window on the device. Handle `PASS_THROUGH_OPACITY_EXCEEDED` and `PASS_THROUGH_UNSUPPORTED` explicitly. + +Set `screenBrightness` only in an Activity overlay's spec. For example, Java uses `new OverlaySpec.Builder().setScreenBrightness(0.5f).build()` with `newOverlayView(view, activity, spec)`. Kotlin uses `OverlaySpec(screenBrightness = 0.5f)`. Application-scope brightness is rejected. + +## Threading + +Manager initialization/access, handle factories, operations, and `view`/`spec` reads require the main thread. `state` and `lastFailure` are thread-safe reads, but reading them separately is not a combined atomic snapshot. `OverlayPermission` is immutable and thread-safe. + +## Sample reference + +- [Sample1Activity.kt](../../sample/src/main/kotlin/com/nagopy/android/overlayviewmanager/sample/Sample1Activity.kt): Kotlin Activity ownership, immutable configuration, View click handling and explicit disposal. +- [SampleAllOptionsActivity.java](../../sample/src/main/java/com/nagopy/android/overlayviewmanager/sample/SampleAllOptionsActivity.java): Java `toBuilder()` updates, result handling and host-window slider bounds. +- [SampleOverrideScreenBrightnessActivity.java](../../sample/src/main/java/com/nagopy/android/overlayviewmanager/sample/SampleOverrideScreenBrightnessActivity.java): Activity-scope brightness. + +## Release checks + +The repository currently uses JDK 17, SDK 36, Gradle 9.4.1 and AGP 9.2.1 with built-in Kotlin. Do not add a separate Kotlin Android plugin to these Android modules as part of migration. Version metadata is 3.0.0 and `jitpack.yml` publishes `overlayviewmanager`, so the dependency changes from `com.github.75py.Android-OverlayViewManager:overlayviewmanager` to `com.github.75py:Android-OverlayViewManager`; the first JitPack build of that coordinate can only be checked once a 3.0.0 tag exists. Device tests, including edge-to-edge positioning and cross-UID touch delivery, ran on emulators at API 23, 26, 31, 35 and 36; test your own devices, window configurations and touch targets as well. diff --git a/gradle.properties b/gradle.properties index 8ab88ef..c219740 100644 --- a/gradle.properties +++ b/gradle.properties @@ -21,6 +21,3 @@ org.gradle.parallel=true org.gradle.caching=true android.useAndroidX=true -android.enableJetifier=true - -android.nonFinalResIds=false diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties index 27fd028..f120264 100644 --- a/gradle/wrapper/gradle-wrapper.properties +++ b/gradle/wrapper/gradle-wrapper.properties @@ -1,6 +1,7 @@ #Sun Jul 14 15:19:43 JST 2024 distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists -distributionUrl=https\://services.gradle.org/distributions/gradle-8.9-bin.zip +distributionSha256Sum=2ab2958f2a1e51120c326cad6f385153bb11ee93b3c216c5fccebfdfbb7ec6cb +distributionUrl=https\://services.gradle.org/distributions/gradle-9.4.1-bin.zip zipStoreBase=GRADLE_USER_HOME zipStorePath=wrapper/dists diff --git a/jitpack.yml b/jitpack.yml new file mode 100644 index 0000000..19b0840 --- /dev/null +++ b/jitpack.yml @@ -0,0 +1,4 @@ +jdk: + - openjdk17 +install: + - ./gradlew :core:publishToMavenLocal diff --git a/lint/build.gradle b/lint/build.gradle index 2ad0ca8..b03226f 100644 --- a/lint/build.gradle +++ b/lint/build.gradle @@ -17,16 +17,18 @@ apply plugin: 'java-library' dependencies { - compileOnly 'com.android.tools.lint:lint-api:31.5.1' - compileOnly 'com.android.tools.lint:lint-checks:31.5.1' + compileOnly 'com.android.tools.lint:lint-api:32.2.1' + compileOnly 'com.android.tools.lint:lint-checks:32.2.1' testImplementation 'junit:junit:4.13.2' - testImplementation 'com.android.tools.lint:lint:31.5.1' - testImplementation 'com.android.tools.lint:lint-tests:31.5.1' + testImplementation 'com.android.tools.lint:lint:32.2.1' + testImplementation 'com.android.tools.lint:lint-tests:32.2.1' } -sourceCompatibility = "17" -targetCompatibility = "17" +java { + sourceCompatibility = JavaVersion.VERSION_17 + targetCompatibility = JavaVersion.VERSION_17 +} jar { manifest { diff --git a/lint/src/main/java/com/nagopy/android/overlayviewmanager/lint/IssueRegistry.java b/lint/src/main/java/com/nagopy/android/overlayviewmanager/lint/IssueRegistry.java index 8cc3b54..79ffb79 100644 --- a/lint/src/main/java/com/nagopy/android/overlayviewmanager/lint/IssueRegistry.java +++ b/lint/src/main/java/com/nagopy/android/overlayviewmanager/lint/IssueRegistry.java @@ -16,14 +16,34 @@ package com.nagopy.android.overlayviewmanager.lint; +import static com.android.tools.lint.detector.api.ApiKt.CURRENT_API; + +import com.android.tools.lint.client.api.Vendor; import com.android.tools.lint.detector.api.Issue; import java.util.Collections; import java.util.List; public class IssueRegistry extends com.android.tools.lint.client.api.IssueRegistry { + + private static final Vendor VENDOR = new Vendor( + "OverlayViewManager", + "com.nagopy.android:overlayviewmanager-lint", + "https://github.com/75py/Android-OverlayViewManager/issues", + null); + @Override public List getIssues() { - return Collections.singletonList(SetOverlayAboveNavigationViewsDetector.ALLOW_VIEW_TO_EXTEND_OUTSIDE_SCREEN); + return Collections.singletonList(SetOverlayAboveNavigationViewsDetector.ALLOW_OUTSIDE_BOUNDS); + } + + @Override + public int getApi() { + return CURRENT_API; + } + + @Override + public Vendor getVendor() { + return VENDOR; } } diff --git a/lint/src/main/java/com/nagopy/android/overlayviewmanager/lint/SetOverlayAboveNavigationViewsDetector.java b/lint/src/main/java/com/nagopy/android/overlayviewmanager/lint/SetOverlayAboveNavigationViewsDetector.java index 6050426..aa595d5 100644 --- a/lint/src/main/java/com/nagopy/android/overlayviewmanager/lint/SetOverlayAboveNavigationViewsDetector.java +++ b/lint/src/main/java/com/nagopy/android/overlayviewmanager/lint/SetOverlayAboveNavigationViewsDetector.java @@ -17,6 +17,7 @@ package com.nagopy.android.overlayviewmanager.lint; import com.android.tools.lint.detector.api.Category; +import com.android.tools.lint.detector.api.ConstantEvaluator; import com.android.tools.lint.detector.api.Detector; import com.android.tools.lint.detector.api.Implementation; import com.android.tools.lint.detector.api.Issue; @@ -24,38 +25,51 @@ import com.android.tools.lint.detector.api.LintFix; import com.android.tools.lint.detector.api.Scope; import com.android.tools.lint.detector.api.Severity; +import com.android.tools.lint.detector.api.SourceCodeScanner; import com.intellij.psi.PsiMethod; import org.jetbrains.uast.UCallExpression; +import org.jetbrains.uast.UExpression; import java.util.Collections; import java.util.List; -public class SetOverlayAboveNavigationViewsDetector extends Detector implements Detector.UastScanner { +public class SetOverlayAboveNavigationViewsDetector extends Detector implements SourceCodeScanner { - static final Issue ALLOW_VIEW_TO_EXTEND_OUTSIDE_SCREEN = Issue.create("ALLOW_VIEW_TO_EXTEND_OUTSIDE_SCREEN", - "Using OverlayView#allowViewToExtendOutsideScreen", + private static final String OVERLAY_SPEC_BUILDER_CLASS = "com.nagopy.android.overlayviewmanager.OverlaySpec.Builder"; + + static final Issue ALLOW_OUTSIDE_BOUNDS = Issue.create("ALLOW_OUTSIDE_BOUNDS", + "Using OverlaySpec.Builder#setAllowOutsideBounds", "If you use this method and show a wrong size view, you cannot do anything.", Category.MESSAGES, 5, Severity.WARNING, new Implementation(SetOverlayAboveNavigationViewsDetector.class, Scope.JAVA_FILE_SCOPE)); - @Override - public List getApplicableCallNames() { - return Collections.singletonList("com.nagopy.android.overlayviewmanager.OverlayView"); - } - @Override public List getApplicableMethodNames() { - return Collections.singletonList("allowViewToExtendOutsideScreen"); + return Collections.singletonList("setAllowOutsideBounds"); } @Override - public void visitMethod(JavaContext context, UCallExpression node, PsiMethod method) { - Object arg = node.getValueArguments().get(0); - String argStr = arg == null ? "" : arg.toString(); - if (arg != null && !argStr.equals("false")) { + public void visitMethodCall(JavaContext context, UCallExpression node, PsiMethod method) { + if (!context.getEvaluator().isMemberInClass(method, OVERLAY_SPEC_BUILDER_CLASS)) { + // A same-named method on an unrelated class must not be flagged. + return; + } + + List arguments = node.getValueArguments(); + if (arguments.size() != 1) { + // Guard against unexpected call shapes so an unrelated overload never throws. + return; + } + + UExpression argument = arguments.get(0); + String argumentSource = argument.asSourceString(); + // Warn unless the argument is provably the constant false; a Kotlin literal's + // toString is not its source text, so evaluate the constant instead. + Object constant = ConstantEvaluator.evaluate(context, argument); + if (!Boolean.FALSE.equals(constant)) { LintFix.GroupBuilder fixGrouper = fix().group(); String oldText = node.asSourceString(); // delete @@ -64,12 +78,12 @@ public void visitMethod(JavaContext context, UCallExpression node, PsiMethod met .text(oldText) .shortenNames() .reformat(true) - .with(oldText.replace(".allowViewToExtendOutsideScreen(" + argStr + ")", "")) + .with(oldText.replace(".setAllowOutsideBounds(" + argumentSource + ")", "")) .build() ); - context.report(ALLOW_VIEW_TO_EXTEND_OUTSIDE_SCREEN, node, context.getLocation(node), - "Please be careful with using allowViewToExtendOutsideScreen(true)", fixGrouper.build()); + context.report(ALLOW_OUTSIDE_BOUNDS, node, context.getLocation(node), + "Please be careful with using setAllowOutsideBounds(true)", fixGrouper.build()); } } } diff --git a/lint/src/test/java/com/nagopy/android/overlayviewmanager/lint/IssueRegistryTest.java b/lint/src/test/java/com/nagopy/android/overlayviewmanager/lint/IssueRegistryTest.java index 1a05d7b..3b019a4 100644 --- a/lint/src/test/java/com/nagopy/android/overlayviewmanager/lint/IssueRegistryTest.java +++ b/lint/src/test/java/com/nagopy/android/overlayviewmanager/lint/IssueRegistryTest.java @@ -1,18 +1,115 @@ package com.nagopy.android.overlayviewmanager.lint; +import org.junit.Before; import org.junit.Test; -import static com.nagopy.android.overlayviewmanager.lint.SetOverlayAboveNavigationViewsDetector.ALLOW_VIEW_TO_EXTEND_OUTSIDE_SCREEN; +import static com.android.tools.lint.detector.api.ApiKt.CURRENT_API; +import static com.nagopy.android.overlayviewmanager.lint.SetOverlayAboveNavigationViewsDetector.ALLOW_OUTSIDE_BOUNDS; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertTrue; import com.android.tools.lint.client.api.LintClient; +import com.android.tools.lint.client.api.Vendor; +import com.android.tools.lint.detector.api.Issue; + +import java.io.File; +import java.io.FileOutputStream; +import java.net.URL; +import java.net.URLClassLoader; +import java.util.List; +import java.util.jar.Attributes; +import java.util.jar.JarEntry; +import java.util.jar.JarOutputStream; +import java.util.jar.Manifest; public class IssueRegistryTest { + @Before + public void setUp() throws Exception { + // IssueRegistry's constructor requires LintClient.clientName to be initialized. + LintClient.clientName = "IssueRegistryTest"; + } + @Test public void getIssues() throws Exception { - LintClient.clientName = "LintClient.clientName"; - assertTrue(new IssueRegistry().getIssues().contains(ALLOW_VIEW_TO_EXTEND_OUTSIDE_SCREEN)); + assertTrue(new IssueRegistry().getIssues().contains(ALLOW_OUTSIDE_BOUNDS)); + } + + @Test + public void getApi_declaresAnApiLintCanLoad() throws Exception { + int api = new IssueRegistry().getApi(); + // lint refuses to load a registry whose api exceeds the runtime's CURRENT_API, + // and a nonpositive value is meaningless -- assert the contract itself rather + // than only comparing the same constant to itself. + assertTrue(api > 0); + assertTrue(api <= CURRENT_API); + // The registry builds against lint-api 32.2.1 (CURRENT_API == 16); a deliberate + // dependency bump must update this expectation. + assertEquals(16, api); + assertEquals(CURRENT_API, api); + } + + @Test + public void getVendor_declaresExactCoordinates() throws Exception { + Vendor vendor = new IssueRegistry().getVendor(); + assertNotNull(vendor); + assertEquals("OverlayViewManager", vendor.getVendorName()); + assertEquals("com.nagopy.android:overlayviewmanager-lint", vendor.getIdentifier()); + assertEquals("https://github.com/75py/Android-OverlayViewManager/issues", vendor.getFeedbackUrl()); + } + + @Test + public void registryLoadsThroughLintRegistryV2Manifest() throws Exception { + // Emulate the consumer-side loading path: a jar carrying the Lint-Registry-v2 + // manifest attribute must name a class that loads and instantiates cleanly. + String registryClass = IssueRegistry.class.getName(); + URL location = IssueRegistry.class.getResource("IssueRegistry.class"); + assertNotNull(location); + assertEquals("file", location.getProtocol()); + File classFile = new File(location.toURI()); + + Manifest manifest = new Manifest(); + manifest.getMainAttributes().put(Attributes.Name.MANIFEST_VERSION, "1.0"); + manifest.getMainAttributes().putValue("Lint-Registry-v2", registryClass); + + File jar = File.createTempFile("overlayviewmanager-lint", ".jar"); + jar.deleteOnExit(); + File packageDir = classFile.getParentFile(); + File[] lintClasses = packageDir.listFiles((dir, name) -> name.endsWith(".class")); + assertNotNull(lintClasses); + try (JarOutputStream out = new JarOutputStream(new FileOutputStream(jar), manifest)) { + for (File entry : lintClasses) { + out.putNextEntry(new JarEntry( + registryClass.substring(0, registryClass.lastIndexOf('.') + 1).replace('.', '/') + + entry.getName())); + java.nio.file.Files.copy(entry.toPath(), out); + out.closeEntry(); + } + } + + // Load through a separate class loader, as lint does for bundled lint jars. + // This module's own classes resolve child-first so the jar copies are used. + try (URLClassLoader loader = new URLClassLoader(new URL[]{jar.toURI().toURL()}, + IssueRegistryTest.class.getClassLoader()) { + @Override + public Class loadClass(String name) throws ClassNotFoundException { + if (name.startsWith("com.nagopy.android.overlayviewmanager.lint.")) { + return findClass(name); + } + return super.loadClass(name); + } + }) { + Class loaded = loader.loadClass(registryClass); + assertTrue(com.android.tools.lint.client.api.IssueRegistry.class.isAssignableFrom(loaded)); + Object instance = loaded.getDeclaredConstructor().newInstance(); + int api = (Integer) loaded.getMethod("getApi").invoke(instance); + assertTrue(api > 0); + assertTrue(api <= CURRENT_API); + @SuppressWarnings("unchecked") + List issues = (List) loaded.getMethod("getIssues").invoke(instance); + assertEquals(1, issues.size()); + } } -} \ No newline at end of file +} diff --git a/lint/src/test/java/com/nagopy/android/overlayviewmanager/lint/SetOverlayAboveNavigationViewsDetectorTest.java b/lint/src/test/java/com/nagopy/android/overlayviewmanager/lint/SetOverlayAboveNavigationViewsDetectorTest.java index d160dd3..2649256 100644 --- a/lint/src/test/java/com/nagopy/android/overlayviewmanager/lint/SetOverlayAboveNavigationViewsDetectorTest.java +++ b/lint/src/test/java/com/nagopy/android/overlayviewmanager/lint/SetOverlayAboveNavigationViewsDetectorTest.java @@ -9,16 +9,47 @@ import com.android.tools.lint.checks.infrastructure.TestMode; import static com.android.tools.lint.checks.infrastructure.TestFiles.java; +import static com.android.tools.lint.checks.infrastructure.TestFiles.kotlin; import static com.android.tools.lint.checks.infrastructure.TestLintTask.lint; public class SetOverlayAboveNavigationViewsDetectorTest { - private static final TestFile TEST_FILE = java( + private static final TestFile OVERLAY_SPEC_JAVA = java( "package com.nagopy.android.overlayviewmanager;\n" - + "public class OverlayView {\n" - + " public OverlayView setTouchable(boolean b) { return this; }\n" - + " public OverlayView allowViewToExtendOutsideScreen(boolean b) { return this; }\n" - + " public OverlayView show() { return this; }\n" + + "public class OverlaySpec {\n" + + " public static class Builder {\n" + + " public Builder setAllowOutsideBounds(boolean b) { return this; }\n" + + " public OverlaySpec build() { return new OverlaySpec(); }\n" + + " }\n" + + "}" + ); + + private static final TestFile OVERLAY_SPEC_KOTLIN = kotlin( + "package com.nagopy.android.overlayviewmanager\n" + + "class OverlaySpec {\n" + + " class Builder {\n" + + " private var allowOutsideBounds: Boolean = false\n" + + " fun setAllowOutsideBounds(value: Boolean): Builder = apply { allowOutsideBounds = value }\n" + + " fun build(): OverlaySpec = OverlaySpec()\n" + + " }\n" + + "}" + ); + + private static final TestFile OVERLAY_SPEC_WITH_NO_ARG_OVERLOAD = java( + "package com.nagopy.android.overlayviewmanager;\n" + + "public class OverlaySpec {\n" + + " public static class Builder {\n" + + " public Builder setAllowOutsideBounds(boolean b) { return this; }\n" + + " public Builder setAllowOutsideBounds() { return this; }\n" + + " public OverlaySpec build() { return new OverlaySpec(); }\n" + + " }\n" + + "}" + ); + + private static final TestFile UNRELATED_CLASS_WITH_SAME_NAMED_METHOD = java( + "package foo;\n" + + "public class NotOverlaySpecBuilder {\n" + + " public NotOverlaySpecBuilder setAllowOutsideBounds(boolean b) { return this; }\n" + "}" ); @@ -31,64 +62,155 @@ public void tearDown() throws Exception { } @Test - public void usingSetTouchableOnNavigationViews() throws Exception { - lint().files(TEST_FILE, + public void allowOutsideBounds_true_isFlagged() throws Exception { + lint().files(OVERLAY_SPEC_JAVA, java("package foo;\n" - + "import com.nagopy.android.overlayviewmanager.OverlayView;\n" + + "import com.nagopy.android.overlayviewmanager.OverlaySpec;\n" + "public class Example {\n" + " public void test() {\n" - + " OverlayView view = new OverlayView()\n" - + " .allowViewToExtendOutsideScreen(true)\n" - + " .show();\n" + + " new OverlaySpec.Builder()\n" + + " .setAllowOutsideBounds(true)\n" + + " .build();\n" + " }\n" + "}" ) - ).issues(SetOverlayAboveNavigationViewsDetector.ALLOW_VIEW_TO_EXTEND_OUTSIDE_SCREEN) + ).issues(SetOverlayAboveNavigationViewsDetector.ALLOW_OUTSIDE_BOUNDS) .allowMissingSdk() .run() .expectWarningCount(1) - .expectMatches("src/foo/Example\\.java:5: Warning: Please be careful with using allowViewToExtendOutsideScreen\\(true\\).+"); + .expectMatches("src/foo/Example\\.java:5: Warning: Please be careful with using setAllowOutsideBounds\\(true\\).+"); } @Test - public void usingSetTouchableOnNavigationViews_false() throws Exception { - lint().files(TEST_FILE, + public void allowOutsideBounds_false_isNotFlagged() throws Exception { + lint().files(OVERLAY_SPEC_JAVA, java("package foo;\n" - + "import com.nagopy.android.overlayviewmanager.OverlayView;\n" + + "import com.nagopy.android.overlayviewmanager.OverlaySpec;\n" + "public class Example {\n" + " public void test() {\n" - + " OverlayView view = new OverlayView()\n" - + " .setTouchable(true)\n" - + " .allowViewToExtendOutsideScreen(false)\n" - + " .show();\n" + + " new OverlaySpec.Builder()\n" + + " .setAllowOutsideBounds(false)\n" + + " .build();\n" + " }\n" + "}" ) - ).issues(SetOverlayAboveNavigationViewsDetector.ALLOW_VIEW_TO_EXTEND_OUTSIDE_SCREEN) + ).issues(SetOverlayAboveNavigationViewsDetector.ALLOW_OUTSIDE_BOUNDS) .allowMissingSdk() .run() .expectWarningCount(0); } @Test - public void usingSetTouchableOnNavigationViews_variable() throws Exception { - lint().files(TEST_FILE, + public void allowOutsideBounds_variable_isFlagged() throws Exception { + lint().files(OVERLAY_SPEC_JAVA, + java("package foo;\n" + + "import com.nagopy.android.overlayviewmanager.OverlaySpec;\n" + + "public class Example {\n" + + " public void test(boolean b) {\n" + + " new OverlaySpec.Builder()\n" + + " .setAllowOutsideBounds(b)\n" + + " .build();\n" + + " }\n" + + "}" + ) + ).issues(SetOverlayAboveNavigationViewsDetector.ALLOW_OUTSIDE_BOUNDS) + .allowMissingSdk() + .run() + .expectWarningCount(1) + .expectMatches("src/foo/Example\\.java:5: Warning: Please be careful with using setAllowOutsideBounds\\(true\\).+"); + } + + @Test + public void allowOutsideBounds_constantFalseVariable_isNotFlagged() throws Exception { + lint().files(OVERLAY_SPEC_JAVA, java("package foo;\n" - + "import com.nagopy.android.overlayviewmanager.OverlayView;\n" + + "import com.nagopy.android.overlayviewmanager.OverlaySpec;\n" + "public class Example {\n" + " public void test() {\n" + " boolean b = false;\n" - + " OverlayView view = new OverlayView()\n" - + " .allowViewToExtendOutsideScreen(b)\n" - + " .show();\n" + + " new OverlaySpec.Builder()\n" + + " .setAllowOutsideBounds(b)\n" + + " .build();\n" + " }\n" + "}" ) - ).issues(SetOverlayAboveNavigationViewsDetector.ALLOW_VIEW_TO_EXTEND_OUTSIDE_SCREEN) + ).issues(SetOverlayAboveNavigationViewsDetector.ALLOW_OUTSIDE_BOUNDS) .allowMissingSdk() .run() - .expectWarningCount(1) - .expectMatches("src/foo/Example\\.java:6: Warning: Please be careful with using allowViewToExtendOutsideScreen\\(true\\).+"); + .expectWarningCount(0); + } + + @Test + public void unrelatedClassWithSameNamedMethod_isNotFlagged() throws Exception { + lint().files(UNRELATED_CLASS_WITH_SAME_NAMED_METHOD, + java("package foo;\n" + + "public class Example {\n" + + " public void test() {\n" + + " new NotOverlaySpecBuilder().setAllowOutsideBounds(true);\n" + + " }\n" + + "}" + ) + ).issues(SetOverlayAboveNavigationViewsDetector.ALLOW_OUTSIDE_BOUNDS) + .allowMissingSdk() + .run() + .expectWarningCount(0); + } + + @Test + public void noArgOverload_doesNotThrowOrFlag() throws Exception { + lint().files(OVERLAY_SPEC_WITH_NO_ARG_OVERLOAD, + java("package foo;\n" + + "import com.nagopy.android.overlayviewmanager.OverlaySpec;\n" + + "public class Example {\n" + + " public void test() {\n" + + " new OverlaySpec.Builder()\n" + + " .setAllowOutsideBounds()\n" + + " .build();\n" + + " }\n" + + "}" + ) + ).issues(SetOverlayAboveNavigationViewsDetector.ALLOW_OUTSIDE_BOUNDS) + .allowMissingSdk() + .run() + .expectWarningCount(0); + } + + @Test + public void kotlinCaller_isFlagged() throws Exception { + lint().files(OVERLAY_SPEC_KOTLIN, + kotlin("package foo\n" + + "\n" + + "import com.nagopy.android.overlayviewmanager.OverlaySpec\n" + + "\n" + + "fun test() {\n" + + " OverlaySpec.Builder()\n" + + " .setAllowOutsideBounds(true)\n" + + " .build()\n" + + "}\n" + ) + ).issues(SetOverlayAboveNavigationViewsDetector.ALLOW_OUTSIDE_BOUNDS) + .allowMissingSdk() + .run() + .expectWarningCount(1); + } + + @Test + public void kotlinCaller_false_isNotFlagged() throws Exception { + lint().files(OVERLAY_SPEC_KOTLIN, + kotlin("package foo\n" + + "\n" + + "import com.nagopy.android.overlayviewmanager.OverlaySpec\n" + + "\n" + + "fun test() {\n" + + " OverlaySpec.Builder()\n" + + " .setAllowOutsideBounds(false)\n" + + " .build()\n" + + "}\n" + ) + ).issues(SetOverlayAboveNavigationViewsDetector.ALLOW_OUTSIDE_BOUNDS) + .allowMissingSdk() + .run() + .expectWarningCount(0); } } diff --git a/opt-timber/.gitignore b/opt-timber/.gitignore deleted file mode 100644 index 42afabf..0000000 --- a/opt-timber/.gitignore +++ /dev/null @@ -1 +0,0 @@ -/build \ No newline at end of file diff --git a/opt-timber/build.gradle.kts b/opt-timber/build.gradle.kts deleted file mode 100644 index a83e020..0000000 --- a/opt-timber/build.gradle.kts +++ /dev/null @@ -1,80 +0,0 @@ -plugins { - id("com.android.library") - id("org.jetbrains.kotlin.android") - id("maven-publish") -} - -android { - namespace = "com.nagopy.android.overlayviewmanager.opt.timber" - compileSdk = 34 - - defaultConfig { - minSdk = 21 - - testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner" - consumerProguardFiles("consumer-rules.pro") - } - - buildTypes { - release { - isMinifyEnabled = false - proguardFiles( - getDefaultProguardFile("proguard-android-optimize.txt"), - "proguard-rules.pro" - ) - } - } - compileOptions { - sourceCompatibility = JavaVersion.VERSION_17 - targetCompatibility = JavaVersion.VERSION_17 - } - kotlinOptions { - jvmTarget = "17" - } - - testOptions.unitTests.isReturnDefaultValues = true - testOptions.unitTests.isIncludeAndroidResources = true - - publishing { - singleVariant("release") { - withSourcesJar() - } - } -} - -dependencies { - implementation(project(":core")) - implementation("androidx.annotation:annotation:1.8.0") - compileOnly("com.jakewharton.timber:timber:4.7.1") - testImplementation("com.jakewharton.timber:timber:4.7.1") - - testImplementation("junit:junit:4.13.2") - testImplementation("org.mockito:mockito-core:5.12.0") - - androidTestImplementation("androidx.test.ext:junit:1.2.1") - androidTestImplementation("androidx.test.espresso:espresso-core:3.6.1") -} - - -publishing { - publications { - create("release") { - groupId = "com.nagopy.android" - artifactId = "overlayviewmanager-opt-timber" - version = rootProject.ext.get("publish_version_name") as String - afterEvaluate { - from(components["release"]) - } - - pom { - url = "https://github.com/75py/Android-OverlayViewManager" - - licenses { - license { - name = "Apache License Version 2.0" - } - } - } - } - } -} diff --git a/opt-timber/consumer-rules.pro b/opt-timber/consumer-rules.pro deleted file mode 100644 index e69de29..0000000 diff --git a/opt-timber/proguard-rules.pro b/opt-timber/proguard-rules.pro deleted file mode 100644 index 481bb43..0000000 --- a/opt-timber/proguard-rules.pro +++ /dev/null @@ -1,21 +0,0 @@ -# Add project specific ProGuard rules here. -# You can control the set of applied configuration files using the -# proguardFiles setting in build.gradle. -# -# For more details, see -# http://developer.android.com/guide/developing/tools/proguard.html - -# If your project uses WebView with JS, uncomment the following -# and specify the fully qualified class name to the JavaScript interface -# class: -#-keepclassmembers class fqcn.of.javascript.interface.for.webview { -# public *; -#} - -# Uncomment this to preserve the line number information for -# debugging stack traces. -#-keepattributes SourceFile,LineNumberTable - -# If you keep the line number information, uncomment this to -# hide the original source file name. -#-renamesourcefileattribute SourceFile \ No newline at end of file diff --git a/opt-timber/src/main/AndroidManifest.xml b/opt-timber/src/main/AndroidManifest.xml deleted file mode 100644 index a5918e6..0000000 --- a/opt-timber/src/main/AndroidManifest.xml +++ /dev/null @@ -1,4 +0,0 @@ - - - - \ No newline at end of file diff --git a/opt-timber/src/main/java/com/nagopy/android/overlayviewmanager/opt/timber/DebugOverlayTree.java b/opt-timber/src/main/java/com/nagopy/android/overlayviewmanager/opt/timber/DebugOverlayTree.java deleted file mode 100644 index 32ed94b..0000000 --- a/opt-timber/src/main/java/com/nagopy/android/overlayviewmanager/opt/timber/DebugOverlayTree.java +++ /dev/null @@ -1,196 +0,0 @@ -/* - * Copyright 2017 75py - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.nagopy.android.overlayviewmanager.opt.timber; - - -import android.app.Activity; -import android.app.Application; -import android.graphics.Color; -import androidx.annotation.VisibleForTesting; -import android.util.Log; -import android.view.Gravity; -import android.widget.TextView; - -import com.nagopy.android.overlayviewmanager.OverlayView; -import com.nagopy.android.overlayviewmanager.OverlayViewManager; -import com.nagopy.android.overlayviewmanager.internal.Logger; -import com.nagopy.android.overlayviewmanager.internal.SimpleActivityLifecycleCallbacks; -import com.nagopy.android.overlayviewmanager.internal.WeakReferenceCache; - -import java.util.ArrayList; - -import timber.log.Timber; - -import static android.view.ViewGroup.LayoutParams.MATCH_PARENT; - -/** - * [Option] Implementation of {@link Timber.Tree}. - */ -public class DebugOverlayTree extends Timber.DebugTree { - - @VisibleForTesting - ArrayList messages; - @VisibleForTesting - OverlayView overlayView; - @VisibleForTesting - WeakReferenceCache registeredActivities; - @VisibleForTesting - WeakReferenceCache runningActivities; - @VisibleForTesting - WeakReferenceCache registeredAndRunningActivities; - @VisibleForTesting - int threshold; - @VisibleForTesting - int maxLines; - - @VisibleForTesting - static DebugOverlayTree INSTANCE = new DebugOverlayTree(); - - /** - * Initialize and return the {@link Timber.Tree} implementation. - * Usage: Timber.plant(DebugOverlayTree.initApplicationInstance(this /* Application */)); - * - * @param application Your {@link Application} instance - * @return The {@link Timber.Tree} implementation - */ - public static DebugOverlayTree init(Application application) { - INSTANCE.initialize(application); - return INSTANCE; - } - - /** - * Return the {@link DebugOverlayTree} instance. The instance is singleton. - * - * @return instance - */ - public static DebugOverlayTree getInstance() { - if (INSTANCE.overlayView == null) { - throw new IllegalStateException("DebugOverlayTree is not initialized. Please call initApplicationInstance(Context)."); - } - return INSTANCE; - } - - @VisibleForTesting - DebugOverlayTree() { - overlayView = null; - } - - /** - * Inner method. Initialize members. - * - * @param application Application - */ - void initialize(Application application) { - messages = new ArrayList<>(); - threshold = Log.DEBUG; - maxLines = 5; - overlayView = OverlayViewManager.getInstance().newOverlayView(new TextView(application)) - .setAlpha(0.4f) - .setGravity(Gravity.BOTTOM) - .setWidth(MATCH_PARENT); - overlayView.getView().setTextColor(Color.WHITE); - overlayView.getView().setBackgroundColor(Color.BLACK); - - registeredActivities = new WeakReferenceCache<>(); - runningActivities = new WeakReferenceCache<>(); - registeredAndRunningActivities = new WeakReferenceCache<>(); - application.registerActivityLifecycleCallbacks(activityLifecycleCallbacks); - } - - /** - * Set minimum log level. - * - * @param threshold Log level - */ - public void setThreshold(int threshold) { - this.threshold = threshold; - } - - /** - * Set max line number. - * - * @param maxLines Max line number - */ - public void setMaxLines(int maxLines) { - this.maxLines = maxLines; - } - - /** - * Register the activity. If called, the debug view is displayed while the activity is visible. - * - * @param activity Activity - */ - public void register(Activity activity) { - registeredActivities.add(activity); - if (runningActivities.contains(activity)) { - registeredAndRunningActivities.add(activity); - overlayView.show(); - } - } - - @Override - protected void log(int priority, String tag, String message, Throwable t) { - if (priority < threshold) { - return; - } - - messages.add(tag + ": " + message); - while (messages.size() > maxLines) { - messages.remove(0); - } - - StringBuilder out = new StringBuilder(); - for (String msg : messages) { - out.append(msg); - out.append('\n'); - } - out.setLength(out.length() - 1); - overlayView.getView().setText(out.toString()); - } - - @VisibleForTesting - Application.ActivityLifecycleCallbacks activityLifecycleCallbacks = new SimpleActivityLifecycleCallbacks() { - - @Override - public void onActivityStarted(Activity activity) { - Logger.d("onActivityStarted %s", activity); - runningActivities.add(activity); - if (registeredActivities.contains(activity)) { - registeredAndRunningActivities.add(activity); - overlayView.show(); - } - } - - @Override - public void onActivityStopped(Activity activity) { - Logger.d("onActivityStopped %s", activity); - if (registeredActivities.contains(activity) || registeredActivities.isEmpty()) { - registeredAndRunningActivities.remove(activity); - if (registeredAndRunningActivities.isEmpty()) { - overlayView.hide(); - } - } - runningActivities.remove(activity); - } - - @Override - public void onActivityDestroyed(Activity activity) { - Logger.d("onActivityDestroyed %s", activity); - registeredActivities.remove(activity); - } - }; -} diff --git a/opt-timber/src/test/java/com/nagopy/android/overlayviewmanager/opt/timber/DebugOverlayTreeTest.java b/opt-timber/src/test/java/com/nagopy/android/overlayviewmanager/opt/timber/DebugOverlayTreeTest.java deleted file mode 100644 index 363437a..0000000 --- a/opt-timber/src/test/java/com/nagopy/android/overlayviewmanager/opt/timber/DebugOverlayTreeTest.java +++ /dev/null @@ -1,318 +0,0 @@ -package com.nagopy.android.overlayviewmanager.opt.timber; - -import android.app.Activity; -import android.app.Application; -import android.util.Log; -import android.view.WindowManager; -import android.widget.TextView; - -import com.nagopy.android.overlayviewmanager.OverlayView; -import com.nagopy.android.overlayviewmanager.OverlayViewManager; -import com.nagopy.android.overlayviewmanager.internal.OverlayWindowManager; -import com.nagopy.android.overlayviewmanager.internal.WeakReferenceCache; - -import org.junit.After; -import org.junit.Before; -import org.junit.Test; -import org.mockito.Mock; -import org.mockito.MockitoAnnotations; - -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.CoreMatchers.notNullValue; -import static org.hamcrest.CoreMatchers.nullValue; -import static org.junit.Assert.assertThat; -import static org.mockito.ArgumentMatchers.anyString; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.never; -import static org.mockito.Mockito.reset; -import static org.mockito.Mockito.times; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; - -public class DebugOverlayTreeTest { - - DebugOverlayTree debugOverlayTree; - - @Mock - OverlayWindowManager overlayWindowManager; - - @Mock - WindowManager windowManager; - - @Mock - Application application; - - @Mock - Activity activity; - - @Mock - WeakReferenceCache registeredActivitiesMock; - - @Mock - WeakReferenceCache runningActivitiesMock; - - @Mock - WeakReferenceCache registeredAndRunningActivitiesMock; - - @Mock - OverlayView overlayView; - - @Mock - TextView textView; - - @Before - public void setUp() throws Exception { - MockitoAnnotations.openMocks(this); - - when(application.getApplicationContext()).thenReturn(application); - OverlayViewManager.init(application); - OverlayWindowManager.setApplicationInstance(overlayWindowManager); - OverlayWindowManager.initApplicationInstance(windowManager); - - - debugOverlayTree = new DebugOverlayTree(); - assertThat(debugOverlayTree.overlayView, is(nullValue())); - - when(overlayView.getView()).thenReturn(textView); - } - - @After - public void tearDown() throws Exception { - } - - @Test(expected = IllegalStateException.class) - public void getInstance_noView() throws Exception { - DebugOverlayTree.INSTANCE.overlayView = null; - DebugOverlayTree.getInstance(); - } - - @Test - public void getInstance() throws Exception { - DebugOverlayTree.INSTANCE.overlayView = overlayView; - DebugOverlayTree.getInstance(); - } - - @Test - public void init() throws Exception { - DebugOverlayTree mock = mock(DebugOverlayTree.class); - DebugOverlayTree.INSTANCE = mock; - DebugOverlayTree.init(application); - - verify(mock, times(1)).initialize(application); - } - - @Test - public void initialize() throws Exception { - debugOverlayTree.initialize(application); - - assertThat(debugOverlayTree.messages, is(notNullValue())); - assertThat(debugOverlayTree.threshold, is(Log.DEBUG)); - assertThat(debugOverlayTree.maxLines, is(5)); - assertThat(debugOverlayTree.overlayView, is(notNullValue())); - assertThat(debugOverlayTree.registeredActivities, is(notNullValue())); - verify(application, times(1)).registerActivityLifecycleCallbacks(debugOverlayTree.activityLifecycleCallbacks); - } - - @Test - public void setThreshold() throws Exception { - debugOverlayTree.threshold = 0; - - debugOverlayTree.setThreshold(1); - assertThat(debugOverlayTree.threshold, is(1)); - } - - @Test - public void setMaxLines() throws Exception { - debugOverlayTree.maxLines = 0; - - debugOverlayTree.setMaxLines(1); - assertThat(debugOverlayTree.maxLines, is(1)); - } - - @Test - public void register_notRunning() throws Exception { - debugOverlayTree.registeredActivities = registeredActivitiesMock; - debugOverlayTree.runningActivities = runningActivitiesMock; - debugOverlayTree.registeredAndRunningActivities = registeredAndRunningActivitiesMock; - when(runningActivitiesMock.contains(activity)).thenReturn(false); - - debugOverlayTree.register(activity); - - verify(registeredActivitiesMock, times(1)).add(activity); - verify(runningActivitiesMock, times(1)).contains(activity); - verify(registeredAndRunningActivitiesMock, never()).add(activity); - verify(overlayView, never()).show(); - } - - @Test - public void register_running() throws Exception { - debugOverlayTree.overlayView = overlayView; - debugOverlayTree.registeredActivities = registeredActivitiesMock; - debugOverlayTree.runningActivities = runningActivitiesMock; - debugOverlayTree.registeredAndRunningActivities = registeredAndRunningActivitiesMock; - when(runningActivitiesMock.contains(activity)).thenReturn(true); - - debugOverlayTree.register(activity); - - verify(registeredActivitiesMock, times(1)).add(activity); - verify(runningActivitiesMock, times(1)).contains(activity); - verify(registeredAndRunningActivitiesMock, times(1)).add(activity); - verify(overlayView, times(1)).show(); - } - - @Test - public void log_threshold() throws Exception { - debugOverlayTree.initialize(application); - debugOverlayTree.overlayView = overlayView; - - debugOverlayTree.log(Log.VERBOSE, "tag", "message", null); - - verify(textView, never()).setText(anyString()); - } - - @Test - public void log() throws Exception { - debugOverlayTree.initialize(application); - debugOverlayTree.overlayView = overlayView; - - debugOverlayTree.log(Log.DEBUG, "tag", "message", null); - - verify(textView, times(1)).setText("tag: message"); - } - - @Test - public void log_multiLine() throws Exception { - debugOverlayTree.initialize(application); - debugOverlayTree.overlayView = overlayView; - debugOverlayTree.messages.add("tag: message"); - - debugOverlayTree.log(Log.DEBUG, "tag", "message2", null); - - verify(textView, times(1)).setText("tag: message\ntag: message2"); - } - - @Test - public void log_multiLine_max() throws Exception { - debugOverlayTree.initialize(application); - debugOverlayTree.overlayView = overlayView; - debugOverlayTree.messages.add("tag: message1"); - debugOverlayTree.messages.add("tag: message2"); - debugOverlayTree.messages.add("tag: message3"); - debugOverlayTree.messages.add("tag: message4"); - debugOverlayTree.messages.add("tag: message5"); - - debugOverlayTree.log(Log.DEBUG, "tag", "message6", null); - - verify(textView, times(1)).setText("tag: message2\n" + - "tag: message3\n" + - "tag: message4\n" + - "tag: message5\n" + - "tag: message6"); - } - - @Test - public void SimpleActivityLifecycleCallbacks_onActivityStarted() throws Exception { - debugOverlayTree.registeredActivities = registeredActivitiesMock; - debugOverlayTree.runningActivities = runningActivitiesMock; - debugOverlayTree.registeredAndRunningActivities = registeredAndRunningActivitiesMock; - debugOverlayTree.overlayView = overlayView; - { - when(registeredActivitiesMock.contains(activity)).thenReturn(false); - - debugOverlayTree.activityLifecycleCallbacks.onActivityStarted(activity); - - verify(registeredAndRunningActivitiesMock, never()).add(activity); - verify(overlayView, never()).show(); - } - reset(overlayView, registeredActivitiesMock, runningActivitiesMock, registeredAndRunningActivitiesMock); - { - when(registeredActivitiesMock.contains(activity)).thenReturn(true); - - debugOverlayTree.activityLifecycleCallbacks.onActivityStarted(activity); - - verify(runningActivitiesMock, times(1)).add(activity); - verify(overlayView, times(1)).show(); - } - } - - @Test - public void SimpleActivityLifecycleCallbacks_onActivityStopped() throws Exception { - debugOverlayTree.overlayView = overlayView; - debugOverlayTree.registeredActivities = registeredActivitiesMock; - debugOverlayTree.runningActivities = runningActivitiesMock; - debugOverlayTree.registeredAndRunningActivities = registeredAndRunningActivitiesMock; - { - when(registeredActivitiesMock.contains(activity)).thenReturn(false); - when(registeredActivitiesMock.isEmpty()).thenReturn(false); - - debugOverlayTree.activityLifecycleCallbacks.onActivityStopped(activity); - - verify(registeredAndRunningActivitiesMock, never()).remove(activity); - verify(overlayView, never()).hide(); - verify(runningActivitiesMock, times(1)).remove(activity); - } - { - reset(overlayView, registeredActivitiesMock, runningActivitiesMock, registeredAndRunningActivitiesMock); - { - when(registeredActivitiesMock.contains(activity)).thenReturn(true); - when(registeredActivitiesMock.isEmpty()).thenReturn(false); - when(registeredAndRunningActivitiesMock.isEmpty()).thenReturn(false); - - debugOverlayTree.activityLifecycleCallbacks.onActivityStopped(activity); - - verify(registeredAndRunningActivitiesMock, times(1)).isEmpty(); - verify(overlayView, never()).hide(); - verify(runningActivitiesMock, times(1)).remove(activity); - } - reset(overlayView, registeredActivitiesMock, runningActivitiesMock, registeredAndRunningActivitiesMock); - { - when(registeredActivitiesMock.contains(activity)).thenReturn(true); - when(registeredActivitiesMock.isEmpty()).thenReturn(false); - when(registeredAndRunningActivitiesMock.isEmpty()).thenReturn(true); - - debugOverlayTree.activityLifecycleCallbacks.onActivityStopped(activity); - - verify(registeredAndRunningActivitiesMock, times(1)).isEmpty(); - verify(overlayView, times(1)).hide(); - verify(runningActivitiesMock, times(1)).remove(activity); - } - reset(overlayView, registeredActivitiesMock, runningActivitiesMock, registeredAndRunningActivitiesMock); - { - when(registeredActivitiesMock.contains(activity)).thenReturn(false); - when(registeredActivitiesMock.isEmpty()).thenReturn(true); - when(registeredAndRunningActivitiesMock.isEmpty()).thenReturn(false); - - debugOverlayTree.activityLifecycleCallbacks.onActivityStopped(activity); - - verify(registeredAndRunningActivitiesMock, times(1)).isEmpty(); - verify(overlayView, never()).hide(); - verify(runningActivitiesMock, times(1)).remove(activity); - } - reset(overlayView, registeredActivitiesMock, runningActivitiesMock, registeredAndRunningActivitiesMock); - { - when(registeredActivitiesMock.contains(activity)).thenReturn(false); - when(registeredActivitiesMock.isEmpty()).thenReturn(true); - when(registeredAndRunningActivitiesMock.isEmpty()).thenReturn(true); - - debugOverlayTree.activityLifecycleCallbacks.onActivityStopped(activity); - - verify(registeredAndRunningActivitiesMock, times(1)).isEmpty(); - verify(overlayView, times(1)).hide(); - verify(runningActivitiesMock, times(1)).remove(activity); - } - reset(overlayView, registeredActivitiesMock, runningActivitiesMock, registeredAndRunningActivitiesMock); - } - } - - @Test - public void SimpleActivityLifecycleCallbacks_onActivityDestroyed() throws Exception { - { - debugOverlayTree.registeredActivities = registeredActivitiesMock; - - debugOverlayTree.activityLifecycleCallbacks.onActivityDestroyed(activity); - - verify(registeredActivitiesMock, times(1)).remove(activity); - } - } - -} \ No newline at end of file diff --git a/opt-timber/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker b/opt-timber/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker deleted file mode 100644 index 1f0955d..0000000 --- a/opt-timber/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker +++ /dev/null @@ -1 +0,0 @@ -mock-maker-inline diff --git a/sample/build.gradle b/sample/build.gradle index 84cb9d3..ea160c3 100644 --- a/sample/build.gradle +++ b/sample/build.gradle @@ -20,42 +20,44 @@ plugins { } android { - namespace 'com.nagopy.android.overlayviewmanager.sample' - compileSdk 34 + namespace = 'com.nagopy.android.overlayviewmanager.sample' + compileSdk = 36 defaultConfig { - applicationId 'com.nagopy.android.overlayviewmanager.sample' - minSdkVersion 21 - targetSdkVersion 34 - versionCode publish_version_code - versionName publish_version_name - testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner" + applicationId = 'com.nagopy.android.overlayviewmanager.sample' + minSdk = 23 + targetSdk = 36 + versionCode = publish_version_code + versionName = publish_version_name + testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner" } buildTypes { release { - minifyEnabled false - proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' + minifyEnabled = false + proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro' } } - dataBinding { - enabled = true + buildFeatures { + dataBinding = true + } + testOptions { + unitTests.returnDefaultValues = true + unitTests.includeAndroidResources = true } compileOptions { - sourceCompatibility JavaVersion.VERSION_17 - targetCompatibility JavaVersion.VERSION_17 + sourceCompatibility = JavaVersion.VERSION_17 + targetCompatibility = JavaVersion.VERSION_17 } } dependencies { implementation fileTree(include: ['*.jar'], dir: 'libs') implementation project(':core') - implementation project(':opt-timber') - implementation 'androidx.appcompat:appcompat:1.7.0' - implementation 'androidx.legacy:legacy-support-v4:1.0.0' + implementation 'androidx.appcompat:appcompat:1.8.0' implementation 'androidx.cardview:cardview:1.0.0' - implementation 'com.jakewharton.timber:timber:4.7.1' testImplementation 'junit:junit:4.13.2' - androidTestImplementation 'androidx.test:rules:1.6.1' - androidTestImplementation 'androidx.test:runner:1.6.1' - androidTestImplementation 'androidx.test.espresso:espresso-core:3.6.1' - androidTestImplementation 'androidx.test.uiautomator:uiautomator:2.3.0' + testImplementation 'org.robolectric:robolectric:4.16' + androidTestImplementation 'androidx.test:rules:1.7.0' + androidTestImplementation 'androidx.test:runner:1.7.0' + androidTestImplementation 'androidx.test.espresso:espresso-core:3.7.0' + androidTestImplementation 'androidx.test.uiautomator:uiautomator:2.4.0' } diff --git a/sample/screenshots/3.0.0/api36-all-options.png b/sample/screenshots/3.0.0/api36-all-options.png new file mode 100644 index 0000000..6847fbb Binary files /dev/null and b/sample/screenshots/3.0.0/api36-all-options.png differ diff --git a/sample/screenshots/3.0.0/api36-brightness.png b/sample/screenshots/3.0.0/api36-brightness.png new file mode 100644 index 0000000..22349d1 Binary files /dev/null and b/sample/screenshots/3.0.0/api36-brightness.png differ diff --git a/sample/screenshots/3.0.0/api36-sample1.png b/sample/screenshots/3.0.0/api36-sample1.png new file mode 100644 index 0000000..27ef3dd Binary files /dev/null and b/sample/screenshots/3.0.0/api36-sample1.png differ diff --git a/sample/screenshots/3.0.0/api36-sample2-start.png b/sample/screenshots/3.0.0/api36-sample2-start.png new file mode 100644 index 0000000..97e0b91 Binary files /dev/null and b/sample/screenshots/3.0.0/api36-sample2-start.png differ diff --git a/sample/screenshots/3.0.0/api36-sample2-stop.png b/sample/screenshots/3.0.0/api36-sample2-stop.png new file mode 100644 index 0000000..5b98c21 Binary files /dev/null and b/sample/screenshots/3.0.0/api36-sample2-stop.png differ diff --git a/sample/screenshots/3.0.0/api36-start.png b/sample/screenshots/3.0.0/api36-start.png new file mode 100644 index 0000000..cd8c680 Binary files /dev/null and b/sample/screenshots/3.0.0/api36-start.png differ diff --git a/sample/src/androidTest/AndroidManifest.xml b/sample/src/androidTest/AndroidManifest.xml index 48da656..76f4811 100644 --- a/sample/src/androidTest/AndroidManifest.xml +++ b/sample/src/androidTest/AndroidManifest.xml @@ -14,8 +14,13 @@ ~ limitations under the License. --> - - - + + + + + diff --git a/sample/src/androidTest/java/com/nagopy/android/overlayviewmanager/sample/CrossUidPassThroughTest.java b/sample/src/androidTest/java/com/nagopy/android/overlayviewmanager/sample/CrossUidPassThroughTest.java new file mode 100644 index 0000000..09fbe6d --- /dev/null +++ b/sample/src/androidTest/java/com/nagopy/android/overlayviewmanager/sample/CrossUidPassThroughTest.java @@ -0,0 +1,268 @@ +package com.nagopy.android.overlayviewmanager.sample; + +import android.app.Instrumentation; +import android.content.Context; +import android.graphics.Color; +import android.graphics.Point; +import android.hardware.input.InputManager; +import android.os.Build; +import android.os.Process; +import android.os.SystemClock; +import android.provider.Settings; +import android.util.Log; +import android.view.View; +import android.view.ViewGroup; + +import androidx.test.filters.SdkSuppress; +import androidx.test.platform.app.InstrumentationRegistry; +import androidx.test.runner.AndroidJUnit4; +import androidx.test.uiautomator.By; +import androidx.test.uiautomator.BySelector; +import androidx.test.uiautomator.UiDevice; +import androidx.test.uiautomator.UiObject2; +import androidx.test.uiautomator.Until; + +import com.nagopy.android.overlayviewmanager.CrossUidPassThrough; +import com.nagopy.android.overlayviewmanager.OverlayFailure; +import com.nagopy.android.overlayviewmanager.OverlayResult; +import com.nagopy.android.overlayviewmanager.OverlaySpec; +import com.nagopy.android.overlayviewmanager.OverlayState; +import com.nagopy.android.overlayviewmanager.OverlayTouchMode; +import com.nagopy.android.overlayviewmanager.OverlayView; +import com.nagopy.android.overlayviewmanager.OverlayViewManager; + +import org.junit.After; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.io.IOException; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; +import static org.junit.Assume.assumeTrue; + +/** + * Device check for application overlays in {@link OverlayTouchMode#PASS_THROUGH} above another + * application's window. Since Android 12 the input dispatcher drops touches that pass through a + * window owned by a different UID unless that window's opacity is at most + * {@link InputManager#getMaximumObscuringOpacityForTouch()}. Builds with the window manager's + * opacity clamp (an AOSP change from March 2022, absent from the initial Android 12 release) lower a + * non-touchable application overlay above that maximum to the maximum instead. + * + *

The touch target is {@link TapReceiverActivity}, which runs with the test APK's UID. System + * apps such as Settings are unsuitable: they hide non-system overlays while in front, so a tap + * reaches them without passing through the overlay at all. + */ +@SdkSuppress(minSdkVersion = Build.VERSION_CODES.S) +@RunWith(AndroidJUnit4.class) +public class CrossUidPassThroughTest { + + private static final String TAG = "CrossUidPassThroughTest"; + private static final long TIMEOUT_MS = 5000; + private static final long BLOCKED_OBSERVATION_MS = 3000; + private static final float ALPHA_TOLERANCE = 0.005f; + private static final Pattern DISPATCHED_ALPHA = Pattern.compile("[ ,]alpha=([0-9.]+)"); + /** {@code TYPE_APPLICATION_OVERLAY} as API 31 prints a window type in {@code dumpsys input}. */ + private static final Pattern OVERLAY_TYPE = + Pattern.compile("[ ,]type=(APPLICATION_OVERLAY|2038|0x0*7f6)(,|\\s|$)"); + private static final Pattern ANY_TYPE = Pattern.compile("[ ,]type="); + + @Rule + public GrantOverlayPermissionRule grantPermissionRule = new GrantOverlayPermissionRule(); + + private Instrumentation instrumentation; + private UiDevice device; + private Context context; + private OverlayView overlay; + private float dispatchedOverlayAlpha = Float.NaN; + private BySelector receiver; + + @Before + public void setUp() throws IOException { + instrumentation = InstrumentationRegistry.getInstrumentation(); + device = UiDevice.getInstance(instrumentation); + context = instrumentation.getTargetContext().getApplicationContext(); + Log.i(TAG, "Build fingerprint: " + Build.FINGERPRINT); + + String receiverPackage = instrumentation.getContext().getPackageName(); + int receiverUid = instrumentation.getContext().getApplicationInfo().uid; + assertNotEquals("The receiver must not share the sample app's UID", + context.getApplicationInfo().uid, receiverUid); + String started = device.executeShellCommand("am start -W --activity-clear-task -n " + + receiverPackage + "/" + TapReceiverActivity.class.getName()); + Log.i(TAG, "Tap receiver start: " + started.trim()); + assertNotNull("Tap receiver not shown", device.wait(Until.findObject( + By.pkg(receiverPackage).text(TapReceiverActivity.TAPS_PREFIX + 0)), TIMEOUT_MS)); + UiObject2 uid = device.findObject(By.pkg(receiverPackage) + .text(Pattern.compile(Pattern.quote(TapReceiverActivity.UID_PREFIX) + "\\d+"))); + assertNotNull("Tap receiver UID not shown", uid); + assertEquals("The receiver runs with an unexpected UID", + TapReceiverActivity.UID_PREFIX + receiverUid, uid.getText()); + assertNotEquals("The receiver runs in the sample app's UID", + TapReceiverActivity.UID_PREFIX + Process.myUid(), uid.getText()); + receiver = By.pkg(receiverPackage); + } + + @After + public void tearDown() { + if (overlay != null) { + instrumentation.runOnMainSync(() -> overlay.dispose()); + } + device.pressHome(); + } + + @Test + public void belowMaximumOpacity_whenSystemAllows_deliversTapToOtherApp() { + float alpha = maximumObscuringOpacity() / 2f; + + OverlayResult result = showFullScreenOverlay(alpha, CrossUidPassThrough.WHEN_SYSTEM_ALLOWS); + + assertTrue("show failed: " + result.getFailure(), result.isSuccess()); + tapReceiverThroughOverlay(); + assertTrue("The tap did not reach the receiver", awaitTaps(1, TIMEOUT_MS)); + } + + @Test + public void aboveMaximumOpacity_whenSystemAllows_isRejectedBeforeAttach() { + float maximum = maximumObscuringOpacity(); + assumeTrue("The device allows fully opaque pass-through", maximum < 1f); + float alpha = Math.min(1f, maximum + (1f - maximum) / 2f); + + OverlayResult result = showFullScreenOverlay(alpha, CrossUidPassThrough.WHEN_SYSTEM_ALLOWS); + + assertFalse(result.isSuccess()); + assertEquals(OverlayFailure.PASS_THROUGH_OPACITY_EXCEEDED, result.getFailure()); + assertEquals(OverlayState.CONFIGURED, overlay.getState()); + } + + @Test + public void opaqueSameUidOnly_followsThePlatformOpacityPolicy() { + // SAME_UID_ONLY only skips the library's opacity admission, so the platform decides. With + // the opacity clamp the overlay is lowered to the maximum and the tap arrives; without it + // the overlay stays opaque and the default untrusted-touch mode drops the tap. + float maximum = maximumObscuringOpacity(); + assumeTrue("The device allows fully opaque pass-through", maximum < 1f); + + OverlayResult result = showFullScreenOverlay(1f, CrossUidPassThrough.SAME_UID_ONLY); + + assertTrue("show failed: " + result.getFailure(), result.isSuccess()); + float dispatched = dispatchedOverlayAlpha; + Log.i(TAG, "Maximum obscuring opacity " + maximum + ", dispatched overlay alpha " + dispatched); + if (dispatched <= maximum + ALPHA_TOLERANCE) { + tapReceiverThroughOverlay(); + assertTrue("The platform lowered the overlay to " + dispatched + + " but the tap did not reach the receiver", awaitTaps(1, TIMEOUT_MS)); + } else { + String mode = Settings.Global.getString(context.getContentResolver(), "block_untrusted_touches"); + assumeTrue("Untrusted touches are not in block mode: " + mode, mode == null || "2".equals(mode)); + tapReceiverThroughOverlay(); + assertFalse("The platform delivered a tap through an overlay at alpha " + dispatched, + awaitTaps(1, BLOCKED_OBSERVATION_MS)); + assertTrue("The receiver's tap count changed unexpectedly", + device.hasObject(By.copy(receiver).text(TapReceiverActivity.TAPS_PREFIX + 0))); + } + } + + /** + * Waits until the input dispatcher lists the overlay as a visible application overlay of this + * UID and returns its alpha, the value the cross-UID opacity rule uses. Other lines of this UID, + * such as an invisible layer of unknown type, can precede it. The overlay is also listed as + * invisible while a window in front hides non-system overlays, in which case a tap never passes + * through it. API 31 prints {@code visible=} and {@code type=}; later APIs print + * {@code inputConfig=} flags, where {@code NOT_VISIBLE} marks an invisible window. + */ + private float awaitOverlayInputWindowAlpha() throws IOException { + String owner = "ownerUid=" + Process.myUid() + ","; + long deadline = SystemClock.uptimeMillis() + TIMEOUT_MS; + String[] lines; + do { + lines = device.executeShellCommand("dumpsys input").split("\n"); + for (String line : lines) { + Matcher alpha = DISPATCHED_ALPHA.matcher(line); + if (line.contains(owner) && isReadyOverlayInputWindow(line) && alpha.find()) { + Log.i(TAG, "Overlay input window: " + line.trim()); + return Float.parseFloat(alpha.group(1)); + } + } + SystemClock.sleep(100); + } while (SystemClock.uptimeMillis() < deadline); + for (String line : lines) { + if (line.contains(owner)) { + Log.i(TAG, "Input window of this UID: " + line.trim()); + } + } + throw new AssertionError("No visible overlay input window with " + owner + " in dumpsys input"); + } + + private static boolean isReadyOverlayInputWindow(String line) { + if (line.contains("visible=") && !line.contains("visible=true")) { + return false; + } + if (line.contains("inputConfig=") + && (line.contains("NOT_VISIBLE") || !line.contains("NOT_TOUCHABLE"))) { + return false; + } + return !ANY_TYPE.matcher(line).find() || OVERLAY_TYPE.matcher(line).find(); + } + + private float maximumObscuringOpacity() { + return context.getSystemService(InputManager.class).getMaximumObscuringOpacityForTouch(); + } + + private OverlayResult showFullScreenOverlay(float alpha, CrossUidPassThrough crossUid) { + OverlayResult[] result = new OverlayResult[1]; + instrumentation.runOnMainSync(() -> { + View view = new View(context); + view.setBackgroundColor(Color.MAGENTA); + OverlaySpec spec = new OverlaySpec.Builder() + .setWidth(ViewGroup.LayoutParams.MATCH_PARENT) + .setHeight(ViewGroup.LayoutParams.MATCH_PARENT) + .setTouchMode(OverlayTouchMode.PASS_THROUGH) + .setCrossUidPassThrough(crossUid) + .setAlpha(alpha) + .build(); + overlay = OverlayViewManager.getInstance().newOverlayView(view, spec); + result[0] = overlay.show(); + }); + instrumentation.waitForIdleSync(); + device.waitForIdle(); + if (result[0].isSuccess()) { + try { + dispatchedOverlayAlpha = awaitOverlayInputWindowAlpha(); + } catch (IOException exception) { + throw new AssertionError("dumpsys input failed", exception); + } + } + return result[0]; + } + + private void tapReceiverThroughOverlay() { + UiObject2 tapArea = device.findObject(By.copy(receiver).desc(TapReceiverActivity.TAP_AREA_DESCRIPTION)); + assertNotNull("Tap receiver not found under the overlay", tapArea); + Point target = tapArea.getVisibleCenter(); + boolean[] covered = new boolean[1]; + instrumentation.runOnMainSync(() -> { + View view = overlay.getView(); + int[] location = new int[2]; + view.getLocationOnScreen(location); + covered[0] = view.isAttachedToWindow() + && target.x >= location[0] && target.x < location[0] + view.getWidth() + && target.y >= location[1] && target.y < location[1] + view.getHeight(); + }); + assertTrue("The overlay does not cover the tap target " + target, covered[0]); + device.click(target.x, target.y); + } + + /** Returns whether the receiver shows exactly {@code taps} taps within {@code timeoutMs}. */ + private boolean awaitTaps(int taps, long timeoutMs) { + return device.wait(Until.hasObject(By.copy(receiver).text(TapReceiverActivity.TAPS_PREFIX + taps)), + timeoutMs); + } +} diff --git a/sample/src/androidTest/java/com/nagopy/android/overlayviewmanager/sample/DragGeometryTest.java b/sample/src/androidTest/java/com/nagopy/android/overlayviewmanager/sample/DragGeometryTest.java new file mode 100644 index 0000000..cfcfee4 --- /dev/null +++ b/sample/src/androidTest/java/com/nagopy/android/overlayviewmanager/sample/DragGeometryTest.java @@ -0,0 +1,724 @@ +package com.nagopy.android.overlayviewmanager.sample; + +import android.app.Activity; +import android.app.Instrumentation; +import android.app.UiAutomation; +import android.content.ComponentName; +import android.content.Context; +import android.content.res.Configuration; +import android.graphics.Color; +import android.graphics.Rect; +import android.os.Build; +import android.os.SystemClock; +import android.provider.Settings; +import android.util.DisplayMetrics; +import android.util.Log; +import android.view.Gravity; +import android.view.InputDevice; +import android.view.MotionEvent; +import android.view.View; +import android.view.ViewConfiguration; + +import androidx.test.filters.SdkSuppress; +import androidx.test.platform.app.InstrumentationRegistry; +import androidx.test.rule.ActivityTestRule; +import androidx.test.runner.AndroidJUnit4; +import androidx.test.runner.lifecycle.ActivityLifecycleMonitorRegistry; +import androidx.test.runner.lifecycle.Stage; +import androidx.test.uiautomator.UiDevice; + +import com.nagopy.android.overlayviewmanager.OverlayFailure; +import com.nagopy.android.overlayviewmanager.OverlayResult; +import com.nagopy.android.overlayviewmanager.OverlaySpec; +import com.nagopy.android.overlayviewmanager.OverlayState; +import com.nagopy.android.overlayviewmanager.OverlayTouchMode; +import com.nagopy.android.overlayviewmanager.OverlayView; +import com.nagopy.android.overlayviewmanager.OverlayViewManager; + +import org.junit.After; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.util.Arrays; +import java.util.Collection; +import java.util.Locale; +import java.util.concurrent.atomic.AtomicReference; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; +import static org.junit.Assume.assumeTrue; + +/** + * Proves on a device that a drag follows the finger: ACTION_DOWN leaves the window in place, and + * each move displaces the window by exactly the gesture. + * + * Positions come from {@link View#getLocationOnScreen}, which reflects the frame the window + * manager reported. Every case also drags back from the new position. That second ACTION_DOWN is + * hit-tested by the system, so it only reaches the overlay if the window really is there. + * + * Unit tests cover the arithmetic with a supplied frame; this class covers the real framework + * frames that they cannot. + */ +@RunWith(AndroidJUnit4.class) +public class DragGeometryTest { + + private static final String TAG = "DragGeometryTest"; + private static final int OVERLAY_SIZE_DP = 96; + private static final int START_X_DP = 24; + private static final int START_Y_DP = 48; + private static final int GESTURE_STEPS = 3; + private static final float MARGIN = .05f; + private static final int TOLERANCE_PX = 1; + private static final long DOWN_SETTLE_MS = 300; + /** + * Input resampling can predict a move past the pointer from the pointer's speed. That is right + * for a live finger, whose next event replaces it, but no event follows a single injected move, + * and the window would stay there. How far apart the moves must be varies by Android version, + * so each move is repeated at the same position, like a finger coming to rest. The speed is + * then zero and the view receives the exact position. + */ + private static final long MOVE_INTERVAL_MS = 40; + private static final long TIMEOUT_MS = 3000; + private static final long POLL_MS = 20; + + @Rule + public GrantOverlayPermissionRule grantPermissionRule = new GrantOverlayPermissionRule(); + + @Rule + public ActivityTestRule activityRule = + new ActivityTestRule<>(SampleStartActivity.class); + + private Instrumentation instrumentation; + private UiAutomation uiAutomation; + private UiDevice uiDevice; + private Activity host; + private View target; + private OverlayView overlay; + private boolean rotated; + private boolean freeform; + + @Before + public void setUp() { + instrumentation = InstrumentationRegistry.getInstrumentation(); + uiAutomation = instrumentation.getUiAutomation(); + uiDevice = UiDevice.getInstance(instrumentation); + host = activityRule.getActivity(); + uiDevice.waitForIdle(); + Log.i(TAG, "fingerprint=" + Build.FINGERPRINT); + } + + @After + public void tearDown() throws Exception { + if (overlay != null) { + instrumentation.runOnMainSync(() -> overlay.dispose()); + } + GrantOverlayPermissionRule.setOverlayOp("allow"); + if (rotated) { + uiDevice.setOrientationNatural(); + uiDevice.unfreezeRotation(); + } + if (freeform) { + instrumentation.runOnMainSync(() -> host.finish()); + uiDevice.waitForIdle(); + } + } + + @Test + public void activityScope_nonZeroFrameOrigin() { + showActivityOverlay(newView(host), spec(false)); + assertTrue("A visible status bar gives the frame a non-zero origin: " + frame(), + frame().top > 0 || frame().left > 0); + assertDragAndReturnTrackGesture(); + } + + @Test + public void applicationScope_nonZeroFrameOrigin() { + showApplicationOverlay(newView(host.getApplicationContext()), spec(false)); + assertTrue("A visible status bar gives the frame a non-zero origin: " + frame(), + frame().top > 0 || frame().left > 0); + assertDragAndReturnTrackGesture(); + } + + @Test + public void activityScope_rtl() { + showActivityOverlay(newView(rtlContext(host)), spec(false)); + assertStartGravityResolvedToRightEdge(); + assertDragAndReturnTrackGesture(); + } + + @Test + public void applicationScope_rtl() { + showApplicationOverlay(newView(rtlContext(host.getApplicationContext())), spec(false)); + assertStartGravityResolvedToRightEdge(); + assertDragAndReturnTrackGesture(); + } + + @Test + public void activityScope_edgeToEdgeHost() { + layOutHostEdgeToEdge(); + showActivityOverlay(newView(host), spec(false)); + assertDragAndReturnTrackGesture(); + } + + @Test + public void applicationScope_edgeToEdgeHost() { + layOutHostEdgeToEdge(); + showApplicationOverlay(newView(host.getApplicationContext()), spec(false)); + assertDragAndReturnTrackGesture(); + } + + @Test + public void activityScope_allowOutsideBounds_tracksPastTheScreenEdge() { + showActivityOverlay(newView(host), spec(true)); + assertDragAndReturnTrackGesture(); + assertDragPastLeftEdgeTracksGesture(); + } + + @Test + public void applicationScope_allowOutsideBounds_tracksPastTheScreenEdge() { + showApplicationOverlay(newView(host.getApplicationContext()), spec(true)); + assertDragAndReturnTrackGesture(); + assertDragPastLeftEdgeTracksGesture(); + } + + @Test + public void activityScope_outsideBoundsNotAllowed_staysOnScreen() { + showActivityOverlay(newView(host), spec(false)); + assertDragPastLeftEdgeStaysOnScreen(); + // A new gesture starts from where the window really is, with no dead zone. + assertDragAndReturnTrackGesture(); + } + + @Test + public void applicationScope_outsideBoundsNotAllowed_staysOnScreen() { + showApplicationOverlay(newView(host.getApplicationContext()), spec(false)); + assertDragPastLeftEdgeStaysOnScreen(); + // A new gesture starts from where the window really is, with no dead zone. + assertDragAndReturnTrackGesture(); + } + + @Test + public void activityScope_clampedAtShow_tracksFromItsRealLocation() { + showActivityOverlay(newView(host), clampedAtShowSpec()); + assertDragAndReturnTrackGesture(); + } + + @Test + public void applicationScope_clampedAtShow_tracksFromItsRealLocation() { + showApplicationOverlay(newView(host.getApplicationContext()), clampedAtShowSpec()); + assertDragAndReturnTrackGesture(); + } + + @Test + public void activityScope_bottomEndGravityWithMargins() { + showActivityOverlay(newView(host), spec(false, Gravity.BOTTOM | Gravity.END, MARGIN)); + assertDragAndReturnTrackGesture(); + } + + @Test + public void applicationScope_centerGravityWithMargins() { + showApplicationOverlay(newView(host.getApplicationContext()), + spec(false, Gravity.CENTER, MARGIN)); + assertDragAndReturnTrackGesture(); + } + + @Test + public void activityScope_allowOutsideBounds_bottomEndGravityWithMargins() { + showActivityOverlay(newView(host), spec(true, Gravity.BOTTOM | Gravity.END, MARGIN)); + assertDragAndReturnTrackGesture(); + } + + @Test + public void applicationScope_allowOutsideBounds_centerGravityWithMargins() { + showApplicationOverlay(newView(host.getApplicationContext()), + spec(true, Gravity.CENTER, MARGIN)); + assertDragAndReturnTrackGesture(); + } + + @Test + public void applicationScope_allowOutsideBounds_rtl() { + showApplicationOverlay(newView(rtlContext(host.getApplicationContext())), spec(true)); + assertStartGravityResolvedToRightEdge(); + assertDragAndReturnTrackGesture(); + } + + @Test + public void applicationScope_afterRotation() throws Exception { + showApplicationOverlay(newView(host.getApplicationContext()), spec(false)); + int naturalRotation = uiDevice.getDisplayRotation(); + rotated = true; + uiDevice.setOrientationLeft(); + uiDevice.waitForIdle(); + assumeTrue("Rotation is not available on this device", + uiDevice.getDisplayRotation() != naturalRotation); + awaitStableLocation(); + assertDragAndReturnTrackGesture(); + } + + @SdkSuppress(minSdkVersion = Build.VERSION_CODES.P) + @Test + public void activityScope_inFreeformWindow() throws Exception { + moveHostToFreeformWindow(); + showActivityOverlay(newView(host), spec(false)); + assertDragAndReturnTrackGesture(); + } + + @SdkSuppress(minSdkVersion = Build.VERSION_CODES.P) + @Test + public void activityScope_allowOutsideBounds_inFreeformWindow() throws Exception { + moveHostToFreeformWindow(); + showActivityOverlay(newView(host), spec(true)); + assertDragAndReturnTrackGesture(); + } + + @Test + public void activityScope_dragsWithoutOverlayPermission() throws Exception { + GrantOverlayPermissionRule.setOverlayOp("deny"); + awaitOverlayPermission(false); + + showActivityOverlay(newView(host), spec(false)); + + assertDragAndReturnTrackGesture(); + } + + @Test + public void applicationScope_deniedThenGrantedThenShown() throws Exception { + GrantOverlayPermissionRule.setOverlayOp("deny"); + awaitOverlayPermission(false); + View view = newView(host.getApplicationContext()); + OverlayResult denied = onMain(() -> { + overlay = OverlayViewManager.getInstance().newOverlayView(view, spec(false)); + return overlay.show(); + }); + assertEquals(OverlayFailure.PERMISSION_DENIED, denied.getFailure()); + assertEquals(OverlayState.CONFIGURED, denied.getState()); + + GrantOverlayPermissionRule.setOverlayOp("allow"); + awaitOverlayPermission(true); + assertShown(onMain(() -> overlay.show())); + target = view; + awaitAttached(); + assertDragAndReturnTrackGesture(); + + // A hidden overlay comes back where the drag left it, still draggable. + int[] draggedTo = locationOnScreen(); + assertTrue(onMain(() -> overlay.hide()).isSuccess()); + assertShown(onMain(() -> overlay.show())); + awaitAttached(); + awaitLocation("Re-shown overlay", draggedTo[0], draggedTo[1]); + assertDragAndReturnTrackGesture(); + } + + private OverlaySpec spec(boolean allowOutsideBounds) { + return spec(allowOutsideBounds, Gravity.TOP | Gravity.START, 0f); + } + + private OverlaySpec spec(boolean allowOutsideBounds, int gravity, float margin) { + return new OverlaySpec.Builder() + .setWidth(dp(OVERLAY_SIZE_DP)) + .setHeight(dp(OVERLAY_SIZE_DP)) + .setGravity(gravity) + .setHorizontalMargin(margin) + .setVerticalMargin(margin) + .setX(dp(START_X_DP)) + .setY(dp(START_Y_DP)) + .setTouchMode(OverlayTouchMode.DRAGGABLE) + .setAllowOutsideBounds(allowOutsideBounds) + .build(); + } + + /** An offset that puts the window past the left edge, where the system clamps it. */ + private OverlaySpec clampedAtShowSpec() { + return spec(false).toBuilder().setX(-dp(OVERLAY_SIZE_DP) * 2).build(); + } + + private View newView(Context context) { + return onMain(() -> { + View view = new TouchLoggingView(context); + view.setBackgroundColor(Color.MAGENTA); + return view; + }); + } + + /** + * An RTL configuration, as a device in an RTL locale would give the view. The direction stays + * inherited from the context, so nothing resolves it before the view is attached. + */ + private static Context rtlContext(Context base) { + Configuration configuration = new Configuration(base.getResources().getConfiguration()); + configuration.setLocale(new Locale("ar")); + return base.createConfigurationContext(configuration); + } + + private void showActivityOverlay(View view, OverlaySpec spec) { + assertShown(onMain(() -> { + overlay = OverlayViewManager.getInstance().newOverlayView(view, host, spec); + return overlay.show(); + })); + target = view; + awaitAttached(); + } + + private void showApplicationOverlay(View view, OverlaySpec spec) { + assertShown(onMain(() -> { + overlay = OverlayViewManager.getInstance().newOverlayView(view, spec); + return overlay.show(); + })); + target = view; + awaitAttached(); + } + + private void assertShown(OverlayResult result) { + assertTrue("show() failed: " + result.getFailure() + " cause=" + result.getCause(), + result.isSuccess()); + assertEquals(OverlayState.ATTACHED, result.getState()); + } + + private void layOutHostEdgeToEdge() { + instrumentation.runOnMainSync(() -> host.getWindow().getDecorView().setSystemUiVisibility( + View.SYSTEM_UI_FLAG_LAYOUT_STABLE + | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN + | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION)); + uiDevice.waitForIdle(); + } + + private void assertStartGravityResolvedToRightEdge() { + int[] location = locationOnScreen(); + int width = displayMetrics().widthPixels; + assertTrue("TOP|START under RTL belongs at the right edge, but left=" + location[0] + + " on a display " + width + "px wide", + location[0] + dp(OVERLAY_SIZE_DP) / 2 > width / 2); + } + + /** Drags toward the middle of the display, then back, so both window positions get hit-tested. */ + private void assertDragAndReturnTrackGesture() { + int[] start = locationOnScreen(); + Rect area = dragArea(); + int step = ViewConfiguration.get(host).getScaledTouchSlop() + dp(16); + int size = dp(OVERLAY_SIZE_DP); + int dx = (start[0] + size / 2 < area.centerX() ? 1 : -1) * step * GESTURE_STEPS; + int dy = (start[1] + size / 2 < area.centerY() ? 1 : -1) * step * GESTURE_STEPS; + + assertDragTracksGesture(size / 2, size / 2, dx, dy); + assertDragTracksGesture(size / 2, size / 2, -dx, -dy); + } + + /** The part of the display the window can use. The frame is a placeholder when it has no limits. */ + private Rect dragArea() { + Rect area = new Rect(0, 0, uiDevice.getDisplayWidth(), uiDevice.getDisplayHeight()); + assertTrue("The frame is off the display: " + frame(), area.intersect(frame())); + return area; + } + + private void assertDragPastLeftEdgeTracksGesture() { + int[] start = locationOnScreen(); + int touchOffsetX = dp(OVERLAY_SIZE_DP) - dp(8); + int dx = dp(8) - (start[0] + touchOffsetX); + + assertDragTracksGesture(touchOffsetX, dp(OVERLAY_SIZE_DP) / 2, dx, 0); + + assertTrue("The window should extend past the left edge, left=" + locationOnScreen()[0], + locationOnScreen()[0] < 0); + + // A new gesture on the part still on screen brings the window back. + assertDragTracksGesture(touchOffsetX, dp(OVERLAY_SIZE_DP) / 2, -dx, 0); + } + + private void assertDragPastLeftEdgeStaysOnScreen() { + int[] start = locationOnScreen(); + int touchOffsetX = dp(OVERLAY_SIZE_DP) - dp(8); + int startX = start[0] + touchOffsetX; + int y = start[1] + dp(OVERLAY_SIZE_DP) / 2; + long downTime = SystemClock.uptimeMillis(); + inject(downTime, MotionEvent.ACTION_DOWN, startX, y); + inject(downTime, MotionEvent.ACTION_MOVE, startX / 2, y); + inject(downTime, MotionEvent.ACTION_MOVE, dp(8), y); + inject(downTime, MotionEvent.ACTION_UP, dp(8), y); + awaitStableLocation(); + + int left = locationOnScreen()[0]; + assertTrue("Without allowOutsideBounds the window should stay on screen, left=" + left, + left >= 0); + assertTrue("The window should have moved to the frame's left edge, left=" + left + + ", start=" + start[0] + ", frame=" + frame(), + left < start[0] && left <= frame().left + TOLERANCE_PX); + } + + /** + * Presses the overlay at the given offset from its corner and moves the pointer by (dx, dy) in + * {@link #GESTURE_STEPS} moves. Each move must clear the touch slop, so that the first one + * starts the drag and has to carry the whole displacement so far. + */ + private void assertDragTracksGesture(int touchOffsetX, int touchOffsetY, int dx, int dy) { + int slop = ViewConfiguration.get(host).getScaledTouchSlop(); + assertTrue("Each gesture step must exceed the touch slop", + Math.max(Math.abs(dx), Math.abs(dy)) / GESTURE_STEPS >= slop); + + int[] origin = locationOnScreen(); + int startX = origin[0] + touchOffsetX; + int startY = origin[1] + touchOffsetY; + int lastX = startX; + int lastY = startY; + Log.i(TAG, "drag from=" + Arrays.toString(origin) + " by=(" + dx + "," + dy + ") frame=" + + frame() + " rotation=" + uiDevice.getDisplayRotation()); + + long downTime = SystemClock.uptimeMillis(); + inject(downTime, MotionEvent.ACTION_DOWN, startX, startY); + try { + SystemClock.sleep(DOWN_SETTLE_MS); + assertLocation("ACTION_DOWN must not move the window", origin[0], origin[1]); + + for (int i = 1; i <= GESTURE_STEPS; i++) { + int movedX = dx * i / GESTURE_STEPS; + int movedY = dy * i / GESTURE_STEPS; + lastX = startX + movedX; + lastY = startY + movedY; + SystemClock.sleep(MOVE_INTERVAL_MS); + inject(downTime, MotionEvent.ACTION_MOVE, lastX, lastY); + SystemClock.sleep(MOVE_INTERVAL_MS); + inject(downTime, MotionEvent.ACTION_MOVE, lastX, lastY); + awaitLocation("Move " + i + "/" + GESTURE_STEPS, origin[0] + movedX, origin[1] + movedY); + } + } finally { + inject(downTime, MotionEvent.ACTION_UP, lastX, lastY); + } + + awaitLocation("After ACTION_UP", origin[0] + dx, origin[1] + dy); + assertEquals("lastFailure=" + onMain(() -> overlay.getLastFailure()), + OverlayState.ATTACHED, onMain(() -> overlay.getState())); + assertEquals("The drag restores the spec's alpha", 1f, onMain(() -> overlay.getSpec().getAlpha()), 0f); + } + + private void inject(long downTime, int action, int x, int y) { + long eventTime = SystemClock.uptimeMillis(); + MotionEvent event = MotionEvent.obtain(downTime, eventTime, action, x, y, 0); + event.setSource(InputDevice.SOURCE_TOUCHSCREEN); + Log.i(TAG, "inject " + MotionEvent.actionToString(action) + " t=" + eventTime + + " x=" + x + " y=" + y); + try { + assertTrue("Could not inject " + MotionEvent.actionToString(action), + uiAutomation.injectInputEvent(event, true)); + } finally { + event.recycle(); + } + } + + private void awaitAttached() { + long deadline = SystemClock.uptimeMillis() + TIMEOUT_MS; + while (SystemClock.uptimeMillis() < deadline) { + if (onMain(() -> target.isAttachedToWindow() && target.getWidth() > 0)) { + awaitStableLocation(); + return; + } + SystemClock.sleep(POLL_MS); + } + fail("The overlay was not laid out"); + } + + private void awaitLocation(String description, int expectedX, int expectedY) { + long deadline = SystemClock.uptimeMillis() + TIMEOUT_MS; + while (SystemClock.uptimeMillis() < deadline) { + int[] location = locationOnScreen(); + if (near(location[0], expectedX) && near(location[1], expectedY)) { + return; + } + SystemClock.sleep(POLL_MS); + } + assertLocation(description, expectedX, expectedY); + } + + private void assertLocation(String description, int expectedX, int expectedY) { + int[] location = locationOnScreen(); + assertTrue(description + ": expected (" + expectedX + "," + expectedY + ") but was " + + Arrays.toString(location) + ", frame=" + frame(), + near(location[0], expectedX) && near(location[1], expectedY)); + } + + private static boolean near(int actual, int expected) { + return Math.abs(actual - expected) <= TOLERANCE_PX; + } + + /** Waits until the window has stopped moving, for steps that have no exact expected position. */ + private void awaitStableLocation() { + int[] previous = locationOnScreen(); + long deadline = SystemClock.uptimeMillis() + TIMEOUT_MS; + while (SystemClock.uptimeMillis() < deadline) { + SystemClock.sleep(DOWN_SETTLE_MS); + int[] current = locationOnScreen(); + if (Arrays.equals(previous, current)) { + return; + } + previous = current; + } + } + + private void awaitOverlayPermission(boolean granted) { + long deadline = SystemClock.uptimeMillis() + TIMEOUT_MS; + while (SystemClock.uptimeMillis() < deadline + && Settings.canDrawOverlays(host) != granted) { + SystemClock.sleep(POLL_MS); + } + if (granted) { + assertTrue("The overlay permission was not granted", Settings.canDrawOverlays(host)); + } else { + assertFalse("The overlay permission was not denied", Settings.canDrawOverlays(host)); + } + } + + /** + * Relaunches the host in a freeform window, which has a non-zero origin. The device must + * support freeform windows, as `settings put global enable_freeform_support 1` provides; the + * test skips otherwise and does not change that setting. + */ + private void moveHostToFreeformWindow() throws Exception { + instrumentation.runOnMainSync(() -> host.finish()); + uiDevice.waitForIdle(); + ComponentName component = + new ComponentName(instrumentation.getTargetContext(), SampleStartActivity.class); + GrantOverlayPermissionRule.executeShellCommand( + "am start -W --windowingMode 5 -n " + component.flattenToString()); + Activity freeformHost = awaitMultiWindowActivity(); + assumeTrue("The host did not enter a freeform window", freeformHost != null); + host = freeformHost; + freeform = true; + uiDevice.waitForIdle(); + + // A new freeform task may have empty bounds and cover the display, as on API 31. Resizing + // can recreate the Activity, so the host is looked up again afterwards. + int width = uiDevice.getDisplayWidth(); + int height = uiDevice.getDisplayHeight(); + GrantOverlayPermissionRule.executeShellCommand("am task resize " + host.getTaskId() + " " + + width / 5 + " " + height / 5 + " " + width * 4 / 5 + " " + height * 4 / 5); + Activity resizedHost = awaitActivityAwayFromTheDisplayOrigin(); + assumeTrue("The freeform window has no origin to test", resizedHost != null); + host = resizedHost; + uiDevice.waitForIdle(); + Log.i(TAG, "freeform origin=" + Arrays.toString(decorOrigin(host))); + + // On API 31 a task created with empty bounds may stay invisible after resizing, and touches + // then go to the launcher. Nothing about a drag can be tested there. + assumeTrue("The platform did not show the freeform window", awaitVisibleHostWindow()); + } + + /** + * Waits for the host's window to be visible to the input system. API 31 prints + * {@code visible=}; later APIs print {@code inputConfig=} flags with {@code NOT_VISIBLE}. + */ + private boolean awaitVisibleHostWindow() throws Exception { + String window = SampleStartActivity.class.getName(); + long deadline = SystemClock.uptimeMillis() + TIMEOUT_MS; + while (SystemClock.uptimeMillis() < deadline) { + for (String line : uiDevice.executeShellCommand("dumpsys input").split("\n")) { + if (!line.contains(window)) { + continue; + } + if (line.contains("visible=true") + || line.contains("inputConfig=") && !line.contains("NOT_VISIBLE")) { + return true; + } + } + SystemClock.sleep(POLL_MS); + } + return false; + } + + private Activity awaitActivityAwayFromTheDisplayOrigin() { + long deadline = SystemClock.uptimeMillis() + TIMEOUT_MS * 2; + while (SystemClock.uptimeMillis() < deadline) { + Activity activity = onMain(this::findMultiWindowActivity); + if (activity != null) { + int[] origin = decorOrigin(activity); + if (origin[0] > 0 && origin[1] > 0) { + return activity; + } + } + SystemClock.sleep(POLL_MS); + } + return null; + } + + private int[] decorOrigin(Activity activity) { + return onMain(() -> { + int[] origin = new int[2]; + activity.getWindow().getDecorView().getLocationOnScreen(origin); + return origin; + }); + } + + private Activity awaitMultiWindowActivity() { + long deadline = SystemClock.uptimeMillis() + TIMEOUT_MS * 2; + while (SystemClock.uptimeMillis() < deadline) { + Activity activity = onMain(this::findMultiWindowActivity); + if (activity != null) { + return activity; + } + SystemClock.sleep(POLL_MS); + } + return null; + } + + private Activity findMultiWindowActivity() { + Collection resumed = + ActivityLifecycleMonitorRegistry.getInstance().getActivitiesInStage(Stage.RESUMED); + for (Activity activity : resumed) { + if (activity instanceof SampleStartActivity && activity.isInMultiWindowMode()) { + return activity; + } + } + return null; + } + + private int[] locationOnScreen() { + return onMain(() -> { + int[] location = new int[2]; + target.getLocationOnScreen(location); + return location; + }); + } + + private Rect frame() { + return onMain(() -> { + Rect frame = new Rect(); + target.getWindowVisibleDisplayFrame(frame); + return frame; + }); + } + + private DisplayMetrics displayMetrics() { + return target.getResources().getDisplayMetrics(); + } + + private int dp(int value) { + return Math.round(value * host.getResources().getDisplayMetrics().density); + } + + private T onMain(MainCall call) { + AtomicReference result = new AtomicReference<>(); + instrumentation.runOnMainSync(() -> result.set(call.run())); + return result.get(); + } + + private interface MainCall { + T run(); + } + + /** Logs what the view receives, to compare it with the injected events. */ + private static final class TouchLoggingView extends View { + TouchLoggingView(Context context) { + super(context); + } + + @Override + public boolean dispatchTouchEvent(MotionEvent event) { + Log.i(TAG, "receive " + MotionEvent.actionToString(event.getActionMasked()) + + " t=" + event.getEventTime() + " rawX=" + event.getRawX() + + " rawY=" + event.getRawY() + " x=" + event.getX() + " y=" + event.getY() + + " history=" + event.getHistorySize()); + return super.dispatchTouchEvent(event); + } + } +} diff --git a/sample/src/androidTest/java/com/nagopy/android/overlayviewmanager/sample/GrantOverlayPermissionRule.java b/sample/src/androidTest/java/com/nagopy/android/overlayviewmanager/sample/GrantOverlayPermissionRule.java new file mode 100644 index 0000000..a37bd26 --- /dev/null +++ b/sample/src/androidTest/java/com/nagopy/android/overlayviewmanager/sample/GrantOverlayPermissionRule.java @@ -0,0 +1,52 @@ +package com.nagopy.android.overlayviewmanager.sample; + +import android.app.UiAutomation; +import android.os.ParcelFileDescriptor; + +import androidx.test.platform.app.InstrumentationRegistry; + +import org.junit.rules.TestRule; +import org.junit.runner.Description; +import org.junit.runners.model.Statement; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; + +/** + * Enables SYSTEM_ALERT_WINDOW for the test package via the appops shell command. + * GrantPermissionRule cannot grant it because "display over other apps" is an app-op + * rather than a runtime permission -- in particular `pm grant` fails on API 23. + */ +class GrantOverlayPermissionRule implements TestRule { + + @Override + public Statement apply(Statement base, Description description) { + return new Statement() { + @Override + public void evaluate() throws Throwable { + setOverlayOp("allow"); + base.evaluate(); + } + }; + } + + /** Sets the sample app's SYSTEM_ALERT_WINDOW app-op to the given mode, such as "allow" or "deny". */ + static void setOverlayOp(String mode) throws IOException { + String pkg = InstrumentationRegistry.getInstrumentation() + .getTargetContext().getPackageName(); + executeShellCommand("appops set " + pkg + " SYSTEM_ALERT_WINDOW " + mode); + } + + /** Runs a shell command and waits for it to finish. */ + static void executeShellCommand(String command) throws IOException { + UiAutomation automation = InstrumentationRegistry.getInstrumentation().getUiAutomation(); + try (ParcelFileDescriptor pfd = automation.executeShellCommand(command); + BufferedReader reader = new BufferedReader(new InputStreamReader( + new ParcelFileDescriptor.AutoCloseInputStream(pfd)))) { + while (reader.readLine() != null) { + // drain output + } + } + } +} diff --git a/sample/src/androidTest/java/com/nagopy/android/overlayviewmanager/sample/Sample1ActivityTest.java b/sample/src/androidTest/java/com/nagopy/android/overlayviewmanager/sample/Sample1ActivityTest.java index cbf8087..266c903 100644 --- a/sample/src/androidTest/java/com/nagopy/android/overlayviewmanager/sample/Sample1ActivityTest.java +++ b/sample/src/androidTest/java/com/nagopy/android/overlayviewmanager/sample/Sample1ActivityTest.java @@ -1,20 +1,21 @@ package com.nagopy.android.overlayviewmanager.sample; -import android.Manifest; import android.os.Build; -import androidx.test.InstrumentationRegistry; +import android.view.View; +import android.widget.TextView; +import androidx.test.platform.app.InstrumentationRegistry; import androidx.test.espresso.Espresso; import androidx.test.espresso.ViewInteraction; import androidx.test.espresso.matcher.RootMatchers; import androidx.test.filters.SdkSuppress; import androidx.test.rule.ActivityTestRule; -import androidx.test.rule.GrantPermissionRule; import androidx.test.runner.AndroidJUnit4; import androidx.test.uiautomator.UiDevice; -import com.nagopy.android.overlayviewmanager.OverlayViewManager; -import com.nagopy.android.overlayviewmanager.internal.ScreenMonitor; +import com.nagopy.android.overlayviewmanager.OverlaySpec; +import com.nagopy.android.overlayviewmanager.OverlayState; +import com.nagopy.android.overlayviewmanager.OverlayTouchMode; import org.junit.Before; import org.junit.Rule; @@ -33,13 +34,14 @@ import static org.hamcrest.Matchers.allOf; import static org.hamcrest.Matchers.is; import static org.hamcrest.Matchers.not; +import static org.junit.Assert.assertEquals; @SdkSuppress(minSdkVersion = Build.VERSION_CODES.JELLY_BEAN_MR2) @RunWith(AndroidJUnit4.class) public class Sample1ActivityTest { @Rule - public GrantPermissionRule grantPermissionRule = GrantPermissionRule.grant(Manifest.permission.SYSTEM_ALERT_WINDOW); + public GrantOverlayPermissionRule grantPermissionRule = new GrantOverlayPermissionRule(); @Rule public ActivityTestRule mActivityTestRule = new ActivityTestRule<>(Sample1Activity.class); @@ -49,10 +51,10 @@ public class Sample1ActivityTest { @Before public void setup() { + // SampleApplication already initialized OverlayViewManager on the main thread; init() is + // main-thread only, so the instrumentation thread must not call it again here. uiDevice = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation()); activity = mActivityTestRule.getActivity(); - - OverlayViewManager.init(activity.getApplication()); } private void waitALittle() { @@ -86,8 +88,10 @@ public void sampleStartActivityTest() throws Exception { appCompatButton2.perform(click()); waitALittle(); - ScreenMonitor.getInstance().cancelForce(); - + // state is a thread-safe read: the show() requested by the button succeeded. lastFailure + // is included so a failing run explains why the window was not attached. + assertEquals("lastFailure=" + activity.getOverlayView().getLastFailure(), + OverlayState.ATTACHED, activity.getOverlayView().getState()); ViewInteraction textView4 = onView( allOf(withId(R.id.sample_text_view), withText("click:0"), isDisplayed())) .inRoot(RootMatchers.withDecorView(not(is(activity.getWindow().getDecorView())))); @@ -99,8 +103,6 @@ public void sampleStartActivityTest() throws Exception { textView4.perform(click()); waitALittle(); - ScreenMonitor.getInstance().cancelForce(); - ViewInteraction textView6 = onView( allOf(withId(R.id.sample_text_view), withText("click:1"), isDisplayed())) .inRoot(RootMatchers.withDecorView(not(is(activity.getWindow().getDecorView())))); @@ -112,12 +114,17 @@ public void sampleStartActivityTest() throws Exception { for (int i = 0; i < 10; i++) { waitALittle(); - ScreenMonitor.getInstance().cancelForce(); - int[] location = new int[2]; - activity.overlayView.getView().getLocationOnScreen(location); - int w = activity.overlayView.getView().getMeasuredWidth(); - int h = activity.overlayView.getView().getMeasuredHeight(); + int[] size = new int[2]; + // OverlayView.getView() is main-thread only. + InstrumentationRegistry.getInstrumentation().runOnMainSync(() -> { + TextView view = activity.getOverlayView().getView(); + view.getLocationOnScreen(location); + size[0] = view.getMeasuredWidth(); + size[1] = view.getMeasuredHeight(); + }); + int w = size[0]; + int h = size[1]; int startX = location[0] + w / 2; int startY = location[1] + h / 2; int step = (int) (100 * new Random().nextDouble() + 50); @@ -155,5 +162,103 @@ public void sampleStartActivityTest() throws Exception { } uiDevice.drag(startX, startY, endX, endY, step); } + // Dragging moves the window but never detaches it. + assertEquals("lastFailure=" + activity.getOverlayView().getLastFailure(), + OverlayState.ATTACHED, activity.getOverlayView().getState()); + } + + @Test + public void hideThenShow_reattaches() { + waitALittle(); + + ViewInteraction button = onView(allOf(withId(R.id.button), isDisplayed())); + button.perform(click()); + waitALittle(); + assertEquals("lastFailure=" + activity.getOverlayView().getLastFailure(), + OverlayState.ATTACHED, activity.getOverlayView().getState()); + + button.perform(click()); + waitALittle(); + assertEquals("lastFailure=" + activity.getOverlayView().getLastFailure(), + OverlayState.CONFIGURED, activity.getOverlayView().getState()); + + button.perform(click()); + waitALittle(); + assertEquals("lastFailure=" + activity.getOverlayView().getLastFailure(), + OverlayState.ATTACHED, activity.getOverlayView().getState()); + } + + @Test + public void activityRecreated_rebuildsAndShowsOverlay() throws Exception { + waitALittle(); + + onView(allOf(withId(R.id.button), isDisplayed())).perform(click()); + waitALittle(); + assertEquals(OverlayState.ATTACHED, activity.getOverlayView().getState()); + + activity.runOnUiThread(() -> activity.recreate()); + waitALittle(); + Sample1Activity recreated = mActivityTestRule.getActivity(); + // The recreated Activity owns a fresh, unattached handle. + assertEquals(OverlayState.CONFIGURED, recreated.getOverlayView().getState()); + + onView(allOf(withId(R.id.button), isDisplayed())).perform(click()); + waitALittle(); + assertEquals("lastFailure=" + recreated.getOverlayView().getLastFailure(), + OverlayState.ATTACHED, recreated.getOverlayView().getState()); + } + + @Test + public void passThroughTouchMode_deliversClickToWindowBelow() { + waitALittle(); + + onView(allOf(withId(R.id.button), isDisplayed())).perform(click()); + waitALittle(); + assertEquals(OverlayState.ATTACHED, activity.getOverlayView().getState()); + + // Center the overlay on the toggle button so the same screen point is inside both. + InstrumentationRegistry.getInstrumentation().runOnMainSync(() -> { + View overlay = activity.getOverlayView().getView(); + View button = activity.findViewById(R.id.button); + int[] overlayPos = new int[2]; + int[] buttonPos = new int[2]; + overlay.getLocationOnScreen(overlayPos); + button.getLocationOnScreen(buttonPos); + OverlaySpec current = activity.getOverlayView().getSpec(); + OverlaySpec spec = current.toBuilder() + .setX(buttonPos[0] + button.getWidth() / 2 - overlay.getMeasuredWidth() / 2 + - overlayPos[0] + current.getX()) + .setY(buttonPos[1] + button.getHeight() / 2 - overlay.getMeasuredHeight() / 2 + - overlayPos[1] + current.getY()) + .build(); + activity.getOverlayView().update(spec); + }); + waitALittle(); + + int[] center = new int[2]; + InstrumentationRegistry.getInstrumentation().runOnMainSync(() -> { + View overlay = activity.getOverlayView().getView(); + int[] overlayPos = new int[2]; + overlay.getLocationOnScreen(overlayPos); + center[0] = overlayPos[0] + overlay.getMeasuredWidth() / 2; + center[1] = overlayPos[1] + overlay.getMeasuredHeight() / 2; + }); + + // In DRAGGABLE mode the overlay itself consumes the tap as a click. + uiDevice.click(center[0], center[1]); + waitALittle(); + assertEquals(OverlayState.ATTACHED, activity.getOverlayView().getState()); + InstrumentationRegistry.getInstrumentation().runOnMainSync(() -> + assertEquals("click:1", ((TextView) activity.getOverlayView().getView()).getText().toString())); + + // PASS_THROUGH mode lets the same tap reach the button below and hide the overlay. + InstrumentationRegistry.getInstrumentation().runOnMainSync(() -> + activity.getOverlayView().update(activity.getOverlayView().getSpec().toBuilder() + .setTouchMode(OverlayTouchMode.PASS_THROUGH).build())); + waitALittle(); + uiDevice.click(center[0], center[1]); + waitALittle(); + assertEquals("lastFailure=" + activity.getOverlayView().getLastFailure(), + OverlayState.CONFIGURED, activity.getOverlayView().getState()); } } diff --git a/sample/src/androidTest/java/com/nagopy/android/overlayviewmanager/sample/SampleAllOptionsActivityTest.java b/sample/src/androidTest/java/com/nagopy/android/overlayviewmanager/sample/SampleAllOptionsActivityTest.java index fb2488c..641cd3e 100644 --- a/sample/src/androidTest/java/com/nagopy/android/overlayviewmanager/sample/SampleAllOptionsActivityTest.java +++ b/sample/src/androidTest/java/com/nagopy/android/overlayviewmanager/sample/SampleAllOptionsActivityTest.java @@ -17,7 +17,6 @@ package com.nagopy.android.overlayviewmanager.sample; -import android.Manifest; import android.content.res.ColorStateList; import android.graphics.Color; import androidx.test.espresso.Espresso; @@ -29,9 +28,11 @@ import androidx.test.espresso.action.Tap; import androidx.test.espresso.assertion.ViewAssertions; import androidx.test.rule.ActivityTestRule; -import androidx.test.rule.GrantPermissionRule; import androidx.test.runner.AndroidJUnit4; import androidx.cardview.widget.CardView; + +import com.nagopy.android.overlayviewmanager.OverlayState; + import android.view.InputDevice; import android.view.MotionEvent; import android.view.View; @@ -49,12 +50,13 @@ import static androidx.test.espresso.matcher.ViewMatchers.withId; import static androidx.test.espresso.matcher.ViewMatchers.withText; import static org.hamcrest.Matchers.allOf; +import static org.junit.Assert.assertEquals; @RunWith(AndroidJUnit4.class) public class SampleAllOptionsActivityTest { @Rule - public GrantPermissionRule grantPermissionRule = GrantPermissionRule.grant(Manifest.permission.SYSTEM_ALERT_WINDOW); + public GrantOverlayPermissionRule grantPermissionRule = new GrantOverlayPermissionRule(); @Rule public ActivityTestRule mActivityTestRule = new ActivityTestRule<>(SampleAllOptionsActivity.class); @@ -107,27 +109,20 @@ public void run() { activity.binding.scrollView.smoothScrollTo(0, active.getBottom() - active.getMeasuredHeight()); active.setCardBackgroundColor(Color.argb(100, 255, 255, 0)); - switch (active.getId()) { - case R.id.parent_flags: - break; - case R.id.parent_width: - activity.overlayView.getView().setText("OverlayView#setWidth(int)"); - break; - case R.id.parent_height: - activity.overlayView.getView().setText("OverlayView#setHeight(int)"); - break; - case R.id.parent_xy: - activity.overlayView.getView().setText("OverlayView#setX(int), setY(int)"); - break; - case R.id.parent_alpha: - activity.overlayView.getView().setText("OverlayView#setAlpha(float)"); - break; - case R.id.parent_gravity: - activity.overlayView.getView().setText("OverlayView#setGravity(int)"); - break; - case R.id.parent_margins: - activity.overlayView.getView().setText("OverlayView#setVerticalMargin(float), setHorizontalMargin(float)"); - break; + if (active.getId() == R.id.parent_flags) { + return; + } else if (active.getId() == R.id.parent_width) { + activity.overlayView.getView().setText("OverlaySpec.Builder#setWidth(int)"); + } else if (active.getId() == R.id.parent_height) { + activity.overlayView.getView().setText("OverlaySpec.Builder#setHeight(int)"); + } else if (active.getId() == R.id.parent_xy) { + activity.overlayView.getView().setText("OverlaySpec.Builder#setX(int), setY(int)"); + } else if (active.getId() == R.id.parent_alpha) { + activity.overlayView.getView().setText("OverlaySpec.Builder#setAlpha(float)"); + } else if (active.getId() == R.id.parent_gravity) { + activity.overlayView.getView().setText("OverlaySpec.Builder#setGravity(int)"); + } else if (active.getId() == R.id.parent_margins) { + activity.overlayView.getView().setText("OverlaySpec.Builder#setVerticalMargin(float), setHorizontalMargin(float)"); } } }); @@ -149,6 +144,8 @@ public void sampleAllOptionsActivityTest() { ViewInteraction showButton = onView(withId(R.id.btn_show)); showButton.check(ViewAssertions.matches(withText("show()"))); performAndWait(showButton, scrollTo(), click()); + assertEquals("lastFailure=" + activity.overlayView.getLastFailure(), + OverlayState.ATTACHED, activity.overlayView.getState()); // Width if (!skipWidth) { @@ -305,6 +302,9 @@ public void sampleAllOptionsActivityTest() { } performAndWait(seekMarginHorizontal, scrollTo(), clickSeekBar(0)); } + // Every update() above kept the window attached. + assertEquals("lastFailure=" + activity.overlayView.getLastFailure(), + OverlayState.ATTACHED, activity.overlayView.getState()); } // https://qiita.com/yakitorizanmai/items/07c730db6bfccd5ff95f diff --git a/sample/src/androidTest/java/com/nagopy/android/overlayviewmanager/sample/SampleStartActivityTest.java b/sample/src/androidTest/java/com/nagopy/android/overlayviewmanager/sample/SampleStartActivityTest.java index 521bfe4..c829dfc 100644 --- a/sample/src/androidTest/java/com/nagopy/android/overlayviewmanager/sample/SampleStartActivityTest.java +++ b/sample/src/androidTest/java/com/nagopy/android/overlayviewmanager/sample/SampleStartActivityTest.java @@ -1,17 +1,13 @@ package com.nagopy.android.overlayviewmanager.sample; -import android.Manifest; import android.os.Build; import androidx.test.espresso.Espresso; import androidx.test.espresso.ViewInteraction; import androidx.test.rule.ActivityTestRule; -import androidx.test.rule.GrantPermissionRule; import androidx.test.runner.AndroidJUnit4; -import com.nagopy.android.overlayviewmanager.OverlayViewManager; -import org.junit.Before; import org.junit.Rule; import org.junit.Test; import org.junit.runner.RunWith; @@ -26,16 +22,11 @@ public class SampleStartActivityTest { @Rule - public GrantPermissionRule grantPermissionRule = GrantPermissionRule.grant(Manifest.permission.SYSTEM_ALERT_WINDOW); + public GrantOverlayPermissionRule grantPermissionRule = new GrantOverlayPermissionRule(); @Rule public ActivityTestRule mActivityTestRule = new ActivityTestRule<>(SampleStartActivity.class); - @Before - public void setup() { - OverlayViewManager.init(mActivityTestRule.getActivity().getApplication()); - } - @Test public void sampleStartActivityTest() throws Exception { Espresso.onIdle(); diff --git a/sample/src/androidTest/java/com/nagopy/android/overlayviewmanager/sample/TapReceiverActivity.java b/sample/src/androidTest/java/com/nagopy/android/overlayviewmanager/sample/TapReceiverActivity.java new file mode 100644 index 0000000..19fed9f --- /dev/null +++ b/sample/src/androidTest/java/com/nagopy/android/overlayviewmanager/sample/TapReceiverActivity.java @@ -0,0 +1,57 @@ +/* + * Copyright 2026 75py + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.nagopy.android.overlayviewmanager.sample; + +import android.app.Activity; +import android.os.Bundle; +import android.os.Process; +import android.view.Gravity; +import android.widget.LinearLayout; +import android.widget.TextView; + +/** + * Cross-UID touch target for {@link CrossUidPassThroughTest}. It is declared in the test APK's + * manifest, so it runs with the test APK's UID rather than the sample app's. It does not hide + * non-system overlays or filter obscured touches; it counts taps on its full-screen content and + * shows its UID. + */ +public class TapReceiverActivity extends Activity { + + static final String TAP_AREA_DESCRIPTION = "tap-receiver"; + static final String TAPS_PREFIX = "taps="; + static final String UID_PREFIX = "uid="; + + private int taps; + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + TextView uid = new TextView(this); + uid.setText(UID_PREFIX + Process.myUid()); + TextView count = new TextView(this); + count.setText(TAPS_PREFIX + taps); + + LinearLayout root = new LinearLayout(this); + root.setOrientation(LinearLayout.VERTICAL); + root.setGravity(Gravity.CENTER); + root.setContentDescription(TAP_AREA_DESCRIPTION); + root.addView(uid); + root.addView(count); + root.setOnClickListener(view -> count.setText(TAPS_PREFIX + ++taps)); + setContentView(root); + } +} diff --git a/sample/src/main/AndroidManifest.xml b/sample/src/main/AndroidManifest.xml index 7461975..7f9f38a 100644 --- a/sample/src/main/AndroidManifest.xml +++ b/sample/src/main/AndroidManifest.xml @@ -14,15 +14,11 @@ ~ limitations under the License. --> - + - - - + android:label="@string/title_sample3_override_brightness" /> diff --git a/sample/src/main/assets/Sample1Activity.html b/sample/src/main/assets/Sample1Activity.html index bd1d5f9..7465979 100644 --- a/sample/src/main/assets/Sample1Activity.html +++ b/sample/src/main/assets/Sample1Activity.html @@ -19,50 +19,54 @@ pre { white-space: pre-wrap; } -

    -
  • Show or hide an overlay click counter! -
  • The view is draggable. Try long-tapping and dragging it. +
  • Activity-scoped overlay written in Kotlin: no "display over other apps" permission is needed. +
  • Show or hide an overlay click counter. The view is draggable (OverlayTouchMode.DRAGGABLE) and still receives clicks. 
-public class Sample1Activity extends AppCompatActivity {
+private const val TAG = "Sample1Activity"
+
+class Sample1Activity : BaseSampleWithCodeActivity() {
+
+    lateinit var overlayView: OverlayView<TextView>
+        private set
 
-    OverlayView<TextView> overlayView;
-    int clickCounter = 0;
+    private var clickCounter = 0
 
-    @Override
-    protected void onCreate(@Nullable Bundle savedInstanceState) {
-        super.onCreate(savedInstanceState);
-        setContentView(R.layout.activity_sample1);
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_sample1)
 
-        TextView textView = createTextView();
-        overlayView = OverlayViewManager.create(textView)
-                .setTouchable(true)
-                .setDraggable(true)
-                .setOnClickListener(new View.OnClickListener() {
-                    @Override
-                    public void onClick(View view) {
-                        clickCounter++;
-                        overlayView.getView().setText("click:" + clickCounter);
-                    }
-                });
+        val textView = createTextView()
+        // Click handling stays on the View itself, even with OverlayTouchMode.DRAGGABLE.
+        textView.setOnClickListener {
+            clickCounter++
+            textView.text = "click:$clickCounter"
+        }
+        overlayView = OverlayViewManager.getInstance().newOverlayView(
+            textView,
+            this,
+            OverlaySpec(touchMode = OverlayTouchMode.DRAGGABLE),
+        )
     }
 
-    public void onClick(View view) {
-        if (overlayView.isVisible()) {
-            overlayView.hide();
-        } else {
-            overlayView.show();
+    fun onClick(view: View) {
+        val result = if (overlayView.state == OverlayState.ATTACHED) overlayView.hide() else overlayView.show()
+        if (!result.isSuccess) {
+            Log.w(TAG, "Sample1 show()/hide() failed: ${result.failure}", result.cause)
         }
     }
 
-    @Override
-    protected void onDestroy() {
-        overlayView.destroy();
-        super.onDestroy();
+    override fun onDestroy() {
+        // The library also disposes activity-scoped handles when the Activity is destroyed;
+        // disposing here keeps ownership explicit, and a repeated dispose() is a harmless no-op.
+        val disposed = overlayView.dispose()
+        if (!disposed.isSuccess) {
+            Log.w(TAG, "Sample1 dispose() failed: ${disposed.failure}", disposed.cause)
+        }
+        super.onDestroy()
     }
 }
- diff --git a/sample/src/main/assets/Sample2Activity.html b/sample/src/main/assets/Sample2Activity.html index e2623ff..af8afb2 100644 --- a/sample/src/main/assets/Sample2Activity.html +++ b/sample/src/main/assets/Sample2Activity.html @@ -19,68 +19,154 @@ pre { white-space: pre-wrap; } -
    -
  • OverlayView with android.app.Service -
  • Show ImageView during the Service is running -
  • Start Sample2Activity on click the overlay view +
  • Application-scoped OverlayView shown while an android.app.Service is running; needs "display over other apps" +
  • The handle is owned by an application-level controller, not by the Service: a failed dispose() keeps the handle so the user can retry it from this screen +
  • Tapping the draggable overlay starts Sample2Activity 
-public class Sample2Activity extends AppCompatActivity {
+final class Sample2OverlayController {
 
-    @Override
-    protected void onCreate(@Nullable Bundle savedInstanceState) {
-        super.onCreate(savedInstanceState);
-        setContentView(R.layout.activity_sample2);
+    /** Notified on the main thread whenever hasRetainedFailedDisposal() may have changed. */
+    interface Listener {
+        void onRetainedHandleChanged(boolean retainedAfterFailedDisposal);
+    }
+
+    private static final Sample2OverlayController INSTANCE = new Sample2OverlayController();
+
+    static Sample2OverlayController get() {
+        return INSTANCE;
     }
 
-    public void onClick(View view) {
-        if (isServiceRunning()) {
-            stopService(new Intent(this, Sample2Service.class));
-        } else {
-            startService(new Intent(this, Sample2Service.class));
+    @Nullable
+    private OverlayView<ImageView> overlayView;
+    private boolean retainedAfterFailedDisposal;
+    @Nullable
+    private Listener listener;
+
+    /** Creates the handle on first use with the application context and shows it. */
+    @MainThread
+    OverlayResult show(Context context) {
+        OverlayView<ImageView> handle = overlayView;
+        if (handle == null) {
+            Context appContext = context.getApplicationContext();
+            ImageView imageView = new ImageView(appContext);
+            imageView.setImageResource(R.mipmap.ic_launcher);
+            // Ordinary click delivery stays on the View itself, even while DRAGGABLE.
+            imageView.setOnClickListener(v -> appContext.startActivity(
+                    new Intent(appContext, Sample2Activity.class).setFlags(Intent.FLAG_ACTIVITY_NEW_TASK)));
+            handle = OverlayViewManager.getInstance().newOverlayView(
+                    imageView,
+                    new OverlaySpec.Builder().setTouchMode(OverlayTouchMode.DRAGGABLE).build());
+            overlayView = handle;
         }
+        OverlayResult result = handle.show();
+        setRetained(false);
+        return result;
     }
-}
 
-public class Sample2Service extends Service {
+    /** On failure the SAME handle is kept, still attached, so that a later explicit call can retry. */
+    @MainThread
+    OverlayResult dispose() {
+        OverlayView<ImageView> handle = overlayView;
+        if (handle == null) {
+            return new OverlayResult(OverlayState.DISPOSED, false, null, null);
+        }
+        OverlayResult result = handle.dispose();
+        if (result.isSuccess()) {
+            overlayView = null;
+        }
+        setRetained(!result.isSuccess());
+        return result;
+    }
 
-    OverlayView overlayView;
+    boolean hasRetainedFailedDisposal() {
+        return retainedAfterFailedDisposal;
+    }
+
+    @MainThread
+    void setListener(@Nullable Listener listener) {
+        this.listener = listener;
+    }
+
+    private void setRetained(boolean retained) {
+        retainedAfterFailedDisposal = retained;
+        Listener current = listener;
+        if (current != null) {
+            current.onRetainedHandleChanged(retained);
+        }
+    }
+}
+
+
+// Declared in the enclosing Sample2Activity.
+private static final String TAG = "Sample2Activity";
+
+public static class Sample2Service extends Service {
 
     @Override
     public void onCreate() {
         super.onCreate();
-        overlayView = OverlayView.create(createImageView())
-                .setTouchable(true)
-                .setDraggable(true)
-                .setOnClickListener(new View.OnClickListener() {
-                    @Override
-                    public void onClick(View view) {
-                        startActivity(new Intent(getApplicationContext(), Sample2Activity.class).setFlags(Intent.FLAG_ACTIVITY_NEW_TASK));
-                    }
-                }).show();
+        // Application-scoped overlays always require the permission. The host decides what to
+        // do when it is missing; this sample simply stops instead of asking the user again.
+        if (!OverlayViewManager.getInstance().overlayPermission().isGranted(this)) {
+            Log.w(TAG, "Overlay permission is not granted; Sample2Service stops without showing anything.");
+            stopSelf();
+            return;
+        }
+        OverlayResult shown = Sample2OverlayController.get().show(this);
+        if (!shown.isSuccess()) {
+            // e.g. PERMISSION_DENIED if the permission was revoked between the check and show().
+            Log.w(TAG, "Sample2Service show() failed: " + shown.getFailure(), shown.getCause());
+            stopSelf();
+        }
     }
 
     @Override
     public void onDestroy() {
-        overlayView.hide();
+        OverlayResult disposed = Sample2OverlayController.get().dispose();
+        if (!disposed.isSuccess()) {
+            // The controller keeps the handle; Sample2Activity offers the explicit retry.
+            Log.w(TAG, "Sample2Service dispose() failed: " + disposed.getFailure() + "; handle retained for retry", disposed.getCause());
+        }
         super.onDestroy();
     }
+}
+
+
+// Sample2Activity implements Sample2OverlayController.Listener. The Start / Stop button toggles
+// the Service; the retry control is shown by the controller's notification, never by a timer.
+@Override
+protected void onStart() {
+    super.onStart();
+    Sample2OverlayController.get().setListener(this);
+    onRetainedHandleChanged(Sample2OverlayController.get().hasRetainedFailedDisposal());
+}
 
-    @Nullable
-    @Override
-    public IBinder onBind(Intent intent) {
-        return null;
-    }
+@Override
+protected void onStop() {
+    Sample2OverlayController.get().setListener(null);
+    super.onStop();
+}
 
-    ImageView createImageView() {
-        ImageView imageView = new ImageView(this);
-        imageView.setId(R.id.sample_text_view);
-        imageView.setImageResource(R.mipmap.ic_launcher);
-        return imageView;
+@Override
+public void onRetainedHandleChanged(boolean retainedAfterFailedDisposal) {
+    retryDisposeButton.setVisibility(retainedAfterFailedDisposal ? View.VISIBLE : View.GONE);
+}
+
+public void onClick(View view) {
+    if (view.getId() == R.id.btn_retry_dispose) {
+        // Explicit, user-driven retry of a disposal that failed when the Service stopped.
+        OverlayResult disposed = Sample2OverlayController.get().dispose();
+        if (!disposed.isSuccess()) {
+            Log.w(TAG, "Retry of dispose() failed again: " + disposed.getFailure(), disposed.getCause());
+        }
+    } else if (isServiceRunning()) {
+        stopService(new Intent(this, Sample2Service.class));
+    } else {
+        startService(new Intent(this, Sample2Service.class));
     }
 }
- diff --git a/sample/src/main/assets/SampleOverrideScreenBrightnessActivity.html b/sample/src/main/assets/SampleOverrideScreenBrightnessActivity.html index 1561c4e..ac699e5 100644 --- a/sample/src/main/assets/SampleOverrideScreenBrightnessActivity.html +++ b/sample/src/main/assets/SampleOverrideScreenBrightnessActivity.html @@ -19,53 +19,67 @@ pre { white-space: pre-wrap; } - -
    -
  • Override brightness of the screen +
  • Override the screen brightness with a transparent activity-scoped overlay (OverlaySpec.screenBrightness) +
  • Brightness override is available for activity-scoped overlays only 
-public class SampleOverrideScreenBrightnessActivity extends BaseSampleWithCodeActivity implements SeekBarBindingAdapter.OnProgressChanged {
+public class SampleOverrideScreenBrightnessActivity extends BaseSampleWithCodeActivity implements SeekBar.OnSeekBarChangeListener {
 
-    OverlayView>View< overlayView;
+    private static final String TAG = "SampleBrightness";
+    private static final int INITIAL_BRIGHTNESS = 128;
+
+    OverlayView<View> overlayView;
     ActivitySampleOverrideScreenBrightnessBinding binding;
 
     @Override
     protected void onCreate(@Nullable Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
-
-        overlayView = OverlayViewManager.getInstance().newOverlayView(new View(this), this)
-                .setAlpha(0);
-
+        overlayView = OverlayViewManager.getInstance().newOverlayView(
+                new View(this),
+                this,
+                new OverlaySpec.Builder()
+                        .setAlpha(0f)
+                        .setScreenBrightness(INITIAL_BRIGHTNESS / 255f)
+                        .build());
         binding = DataBindingUtil.setContentView(this, R.layout.activity_sample_override_screen_brightness);
-        binding.setBrightness(128);
+        binding.setBrightness(INITIAL_BRIGHTNESS);
         binding.setOnProgressChanged(this);
         binding.setIsOverrideEnabled(false);
     }
 
     @Override
     protected void onDestroy() {
+        OverlayResult disposed = overlayView.dispose();
+        if (!disposed.isSuccess()) {
+            Log.w(TAG, "dispose() failed: " + disposed.getFailure(), disposed.getCause());
+        }
         super.onDestroy();
-        overlayView.hide();
     }
 
     public void onClick(View view) {
-        if (overlayView.isVisible()) {
-            overlayView.hide();
-            binding.setIsOverrideEnabled(false);
-        } else {
-            overlayView.show();
-            binding.setIsOverrideEnabled(true);
+        OverlayResult result = overlayView.getState() == OverlayState.ATTACHED
+                ? overlayView.hide()
+                : overlayView.show();
+        if (!result.isSuccess()) {
+            Log.w(TAG, "show()/hide() failed: " + result.getFailure(), result.getCause());
         }
+        binding.setIsOverrideEnabled(overlayView.getState() == OverlayState.ATTACHED);
     }
 
     @Override
     public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
-        overlayView.setScreenBrightness(progress / 255f).update();
+        // Start from the effective spec and change only the requested field.
+        OverlaySpec next = overlayView.getSpec().toBuilder()
+                .setScreenBrightness(progress / 255f)
+                .build();
+        OverlayResult updated = overlayView.update(next);
+        if (!updated.isSuccess()) {
+            Log.w(TAG, "update() failed: " + updated.getFailure(), updated.getCause());
+        }
         binding.setBrightness(progress);
     }
 }
- diff --git a/sample/src/main/assets/SampleTimberActivity.html b/sample/src/main/assets/SampleTimberActivity.html deleted file mode 100644 index 14d429e..0000000 --- a/sample/src/main/assets/SampleTimberActivity.html +++ /dev/null @@ -1,79 +0,0 @@ - - - - -
    -
  • The option feature for Timber users. -
  • Call DebugOverlayTree.getInstance().register(Activity). Timber's logs are displayed during the Activity is running. -
-
-public class SampleApplication extends Application {
-
-    @Override
-    public void onCreate() {
-        super.onCreate();
-
-        OverlayViewManager.init(this);
-
-        if(BuildConfig.DEBUG) {
-            // Initialize and plant DebugOverlayTree instance
-            Timber.plant(DebugOverlayTree.init(this));
-        }
-    }
-
-}
-
-
-public class SampleTimberActivity extends AppCompatActivity {
-
-    @Override
-    protected void onCreate(@Nullable Bundle savedInstanceState) {
-        super.onCreate(savedInstanceState);
-
-        // Register this Activity
-        DebugOverlayTree.getInstance().register(this);
-
-        setContentView(R.layout.activity_sample_timber);
-
-        Timber.d("onCreate");
-    }
-
-    @Override
-    protected void onStart() {
-        super.onStart();
-        Timber.d("onStart");
-    }
-
-    @Override
-    protected void onResume() {
-        super.onResume();
-        Timber.d("onStart");
-    }
-
-    public void onClick(View view) {
-        Timber.d("onClick %d", view.getId());
-    }
-
-}
-
- - diff --git a/sample/src/main/java/com/nagopy/android/overlayviewmanager/sample/Sample1Activity.java b/sample/src/main/java/com/nagopy/android/overlayviewmanager/sample/Sample1Activity.java deleted file mode 100644 index c2c28ea..0000000 --- a/sample/src/main/java/com/nagopy/android/overlayviewmanager/sample/Sample1Activity.java +++ /dev/null @@ -1,76 +0,0 @@ -/* - * Copyright 2017 75py - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.nagopy.android.overlayviewmanager.sample; - -import android.graphics.Color; -import android.os.Bundle; -import androidx.annotation.Nullable; -import androidx.core.widget.TextViewCompat; -import android.view.View; -import android.widget.TextView; - -import com.nagopy.android.overlayviewmanager.OverlayView; -import com.nagopy.android.overlayviewmanager.OverlayViewManager; - -public class Sample1Activity extends BaseSampleWithCodeActivity { - - OverlayView overlayView; - int clickCounter = 0; - - @Override - protected void onCreate(@Nullable Bundle savedInstanceState) { - super.onCreate(savedInstanceState); - setContentView(R.layout.activity_sample1); - - TextView textView = createTextView(); - overlayView = OverlayViewManager.getInstance().newOverlayView(textView, this) - .setTouchable(true) - .setDraggable(true) - .setOnClickListener(new View.OnClickListener() { - @Override - public void onClick(View view) { - clickCounter++; - overlayView.getView().setText("click:" + clickCounter); - } - }); - } - - public void onClick(View view) { - if (overlayView.isVisible()) { - overlayView.hide(); - } else { - overlayView.show(); - } - } - - @Override - protected void onDestroy() { - overlayView.hide(); - super.onDestroy(); - } - - TextView createTextView() { - TextView textView = new TextView(this); - textView.setId(R.id.sample_text_view); - TextViewCompat.setTextAppearance(textView, androidx.appcompat.R.style.TextAppearance_AppCompat_Large); - textView.setText("click:" + clickCounter); - textView.setTextColor(Color.WHITE); - textView.setBackgroundColor(Color.RED); - textView.setPadding(10, 10, 10, 10); - return textView; - } -} diff --git a/sample/src/main/java/com/nagopy/android/overlayviewmanager/sample/Sample2Activity.java b/sample/src/main/java/com/nagopy/android/overlayviewmanager/sample/Sample2Activity.java index e59c13a..66f1945 100644 --- a/sample/src/main/java/com/nagopy/android/overlayviewmanager/sample/Sample2Activity.java +++ b/sample/src/main/java/com/nagopy/android/overlayviewmanager/sample/Sample2Activity.java @@ -21,28 +21,66 @@ import android.content.Intent; import android.os.Bundle; import android.os.IBinder; -import androidx.annotation.Nullable; +import android.util.Log; import android.view.View; -import android.widget.ImageView; +import android.widget.Button; + +import androidx.annotation.Nullable; -import com.nagopy.android.overlayviewmanager.OverlayView; +import com.nagopy.android.overlayviewmanager.OverlayResult; import com.nagopy.android.overlayviewmanager.OverlayViewManager; import java.util.List; -public class Sample2Activity extends BaseSampleWithCodeActivity { +/** + * Application-scoped overlay shown while a {@link Service} runs, on top of other apps, so it needs + * the "display over other apps" permission for every show(). The handle itself is owned by the + * application-level {@link Sample2OverlayController}, not by the Service, so a failed disposal + * keeps a retry path after the Service is gone. + */ +public class Sample2Activity extends BaseSampleWithCodeActivity implements Sample2OverlayController.Listener { + + private static final String TAG = "Sample2Activity"; private ActivityManager activityManager; + private Button retryDisposeButton; @Override protected void onCreate(@Nullable Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_sample2); activityManager = (ActivityManager) getSystemService(ACTIVITY_SERVICE); + retryDisposeButton = findViewById(R.id.btn_retry_dispose); + } + + @Override + protected void onStart() { + super.onStart(); + // The controller reports every dispose()/show() outcome, so the retry control appears as + // soon as the Service's disposal fails, without polling or timers. + Sample2OverlayController.get().setListener(this); + onRetainedHandleChanged(Sample2OverlayController.get().hasRetainedFailedDisposal()); + } + + @Override + protected void onStop() { + Sample2OverlayController.get().setListener(null); + super.onStop(); + } + + @Override + public void onRetainedHandleChanged(boolean retainedAfterFailedDisposal) { + retryDisposeButton.setVisibility(retainedAfterFailedDisposal ? View.VISIBLE : View.GONE); } public void onClick(View view) { - if (isServiceRunning()) { + if (view.getId() == R.id.btn_retry_dispose) { + // Explicit, user-driven retry of a disposal that failed when the Service stopped. + OverlayResult disposed = Sample2OverlayController.get().dispose(); + if (!disposed.isSuccess()) { + Log.w(TAG, "Retry of dispose() failed again: " + disposed.getFailure(), disposed.getCause()); + } + } else if (isServiceRunning()) { stopService(new Intent(this, Sample2Service.class)); } else { startService(new Intent(this, Sample2Service.class)); @@ -62,25 +100,31 @@ private boolean isServiceRunning() { public static class Sample2Service extends Service { - OverlayView overlayView; - @Override public void onCreate() { super.onCreate(); - overlayView = OverlayViewManager.getInstance().newOverlayView(createImageView()) - .setTouchable(true) - .setDraggable(true) - .setOnClickListener(new View.OnClickListener() { - @Override - public void onClick(View view) { - startActivity(new Intent(getApplicationContext(), Sample2Activity.class).setFlags(Intent.FLAG_ACTIVITY_NEW_TASK)); - } - }).show(); + // Application-scoped overlays always require the permission. The host decides what to + // do when it is missing; this sample simply stops instead of asking the user again. + if (!OverlayViewManager.getInstance().overlayPermission().isGranted(this)) { + Log.w(TAG, "Overlay permission is not granted; Sample2Service stops without showing anything."); + stopSelf(); + return; + } + OverlayResult shown = Sample2OverlayController.get().show(this); + if (!shown.isSuccess()) { + // e.g. PERMISSION_DENIED if the permission was revoked between the check and show(). + Log.w(TAG, "Sample2Service show() failed: " + shown.getFailure(), shown.getCause()); + stopSelf(); + } } @Override public void onDestroy() { - overlayView.hide(); + OverlayResult disposed = Sample2OverlayController.get().dispose(); + if (!disposed.isSuccess()) { + // The controller keeps the handle; Sample2Activity offers the explicit retry. + Log.w(TAG, "Sample2Service dispose() failed: " + disposed.getFailure() + "; handle retained for retry", disposed.getCause()); + } super.onDestroy(); } @@ -89,12 +133,5 @@ public void onDestroy() { public IBinder onBind(Intent intent) { return null; } - - ImageView createImageView() { - ImageView imageView = new ImageView(this); - imageView.setId(R.id.sample_text_view); - imageView.setImageResource(R.mipmap.ic_launcher); - return imageView; - } } } diff --git a/sample/src/main/java/com/nagopy/android/overlayviewmanager/sample/Sample2OverlayController.java b/sample/src/main/java/com/nagopy/android/overlayviewmanager/sample/Sample2OverlayController.java new file mode 100644 index 0000000..c9a30a0 --- /dev/null +++ b/sample/src/main/java/com/nagopy/android/overlayviewmanager/sample/Sample2OverlayController.java @@ -0,0 +1,124 @@ +/* + * Copyright 2017 75py + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.nagopy.android.overlayviewmanager.sample; + +import android.content.Context; +import android.content.Intent; +import android.widget.ImageView; + +import androidx.annotation.MainThread; +import androidx.annotation.Nullable; + +import com.nagopy.android.overlayviewmanager.OverlayResult; +import com.nagopy.android.overlayviewmanager.OverlaySpec; +import com.nagopy.android.overlayviewmanager.OverlayState; +import com.nagopy.android.overlayviewmanager.OverlayTouchMode; +import com.nagopy.android.overlayviewmanager.OverlayView; +import com.nagopy.android.overlayviewmanager.OverlayViewManager; + +/** + * Application-owned holder of the Sample2 overlay handle. The handle outlives + * {@link Sample2Activity.Sample2Service}: when the Service is destroyed while the window cannot be + * removed, the sole handle is retained here so the user can retry {@link #dispose()} later from + * {@link Sample2Activity}. Nothing retries automatically. All methods are main-thread only. + */ +final class Sample2OverlayController { + + /** Notified on the main thread whenever {@link #hasRetainedFailedDisposal()} may have changed. */ + interface Listener { + void onRetainedHandleChanged(boolean retainedAfterFailedDisposal); + } + + private static final Sample2OverlayController INSTANCE = new Sample2OverlayController(); + + static Sample2OverlayController get() { + return INSTANCE; + } + + @Nullable + private OverlayView overlayView; + private boolean retainedAfterFailedDisposal; + @Nullable + private Listener listener; + + /** Package-private so a unit test can use a fresh instance instead of the process singleton. */ + Sample2OverlayController() { + } + + /** Creates the handle on first use with the application context and shows it. */ + @MainThread + OverlayResult show(Context context) { + OverlayView handle = overlayView; + if (handle == null) { + Context appContext = context.getApplicationContext(); + ImageView imageView = new ImageView(appContext); + imageView.setId(R.id.sample_image_view); + imageView.setImageResource(R.mipmap.ic_launcher); + // Ordinary click delivery stays on the View itself, even while DRAGGABLE. + imageView.setOnClickListener(v -> appContext.startActivity( + new Intent(appContext, Sample2Activity.class).setFlags(Intent.FLAG_ACTIVITY_NEW_TASK))); + handle = OverlayViewManager.getInstance().newOverlayView( + imageView, + new OverlaySpec.Builder().setTouchMode(OverlayTouchMode.DRAGGABLE).build()); + overlayView = handle; + } + OverlayResult result = handle.show(); + setRetained(false); + return result; + } + + /** + * Disposes the handle. On failure the same handle is kept, still attached, so that a later + * explicit call can retry; only a successful disposal drops it. + */ + @MainThread + OverlayResult dispose() { + OverlayView handle = overlayView; + if (handle == null) { + return new OverlayResult(OverlayState.DISPOSED, false, null, null); + } + OverlayResult result = handle.dispose(); + if (result.isSuccess()) { + overlayView = null; + } + setRetained(!result.isSuccess()); + return result; + } + + /** True while a handle exists, including one retained after a failed {@link #dispose()}. */ + boolean hasHandle() { + return overlayView != null; + } + + /** True only after a failed {@link #dispose()}, until a later dispose() succeeds or show() runs. */ + boolean hasRetainedFailedDisposal() { + return retainedAfterFailedDisposal; + } + + @MainThread + void setListener(@Nullable Listener listener) { + this.listener = listener; + } + + private void setRetained(boolean retained) { + retainedAfterFailedDisposal = retained; + Listener current = listener; + if (current != null) { + current.onRetainedHandleChanged(retained); + } + } +} diff --git a/sample/src/main/java/com/nagopy/android/overlayviewmanager/sample/SampleAllOptionsActivity.java b/sample/src/main/java/com/nagopy/android/overlayviewmanager/sample/SampleAllOptionsActivity.java index 0748f52..974d2ff 100644 --- a/sample/src/main/java/com/nagopy/android/overlayviewmanager/sample/SampleAllOptionsActivity.java +++ b/sample/src/main/java/com/nagopy/android/overlayviewmanager/sample/SampleAllOptionsActivity.java @@ -16,68 +16,81 @@ package com.nagopy.android.overlayviewmanager.sample; -import android.annotation.SuppressLint; -import androidx.databinding.DataBindingUtil; -import androidx.databinding.adapters.SeekBarBindingAdapter; +import static android.view.ViewGroup.LayoutParams.MATCH_PARENT; +import static android.view.ViewGroup.LayoutParams.WRAP_CONTENT; + import android.graphics.Color; +import android.graphics.Rect; +import android.os.Build; import android.os.Bundle; -import androidx.annotation.Nullable; -import androidx.core.widget.TextViewCompat; -import androidx.appcompat.app.AppCompatActivity; +import android.util.DisplayMetrics; +import android.util.Log; import android.view.Gravity; import android.view.View; -import android.widget.CheckBox; import android.widget.CompoundButton; import android.widget.RadioGroup; import android.widget.SeekBar; import android.widget.TextView; +import androidx.annotation.Nullable; +import androidx.appcompat.app.AppCompatActivity; +import androidx.core.widget.TextViewCompat; +import androidx.databinding.DataBindingUtil; + +import com.nagopy.android.overlayviewmanager.OverlayResult; +import com.nagopy.android.overlayviewmanager.OverlaySpec; +import com.nagopy.android.overlayviewmanager.OverlayState; +import com.nagopy.android.overlayviewmanager.OverlayTouchMode; import com.nagopy.android.overlayviewmanager.OverlayView; import com.nagopy.android.overlayviewmanager.OverlayViewManager; import com.nagopy.android.overlayviewmanager.sample.databinding.ActivitySampleAllOptionsBinding; import java.text.SimpleDateFormat; import java.util.Date; +import java.util.Locale; -import timber.log.Timber; - -import static android.view.ViewGroup.LayoutParams.MATCH_PARENT; -import static android.view.ViewGroup.LayoutParams.WRAP_CONTENT; - -// file:///Users/nagopy/workspace/201710//OverlayViewManager/library/build/reports/jacoco/jacocoTestDebugUnitTestReport/html/com.nagopy.android.overlayviewmanager/DraggableOnTouchListener.java.html#L24 -// file:///Users/nagopy/workspace/201710/OverlayViewManager/library/build/tmp/index.html -@SuppressLint("SetOverlayAboveNavigationViews") +/** + * Activity-scoped overlay driven by every {@link OverlaySpec} option. Each control derives a new + * immutable spec from the effective one ({@code overlayView.getSpec().toBuilder()...build()}), + * applies it with {@link OverlayView#update(OverlaySpec)} and prints the {@link OverlayResult}. + */ public class SampleAllOptionsActivity extends AppCompatActivity implements - CheckBox.OnCheckedChangeListener - , View.OnClickListener - , SeekBarBindingAdapter.OnProgressChanged + CompoundButton.OnCheckedChangeListener + , SeekBar.OnSeekBarChangeListener , RadioGroup.OnCheckedChangeListener { + private static final String TAG = "SampleAllOptionsActivity"; + ActivitySampleAllOptionsBinding binding; - OverlayViewManager overlayViewManager; OverlayView overlayView; + private boolean attachedBeforeStop; @Override protected void onCreate(@Nullable Bundle savedInstanceState) { super.onCreate(savedInstanceState); - Timber.d("onCreate %s", savedInstanceState); + Log.d(TAG, "onCreate " + savedInstanceState); - overlayViewManager = OverlayViewManager.getInstance(); - - overlayView = overlayViewManager.newOverlayView(createTextView(), this) - .setAlpha(0.9f) - .setOnClickListener(this); + TextView textView = createTextView(); + textView.setOnClickListener(v -> updateText("Clicked: %s", SimpleDateFormat.getTimeInstance().format(new Date()))); + overlayView = OverlayViewManager.getInstance().newOverlayView( + textView, + this, + new OverlaySpec.Builder().setAlpha(0.9f).build()); binding = DataBindingUtil.setContentView(this, R.layout.activity_sample_all_options); - binding.setOnCheckedChangeListener(this); binding.setOnProgressChanged(this); binding.setOnRadioCheckedChangeListener(this); - binding.setDisplayWidth(overlayViewManager.getDisplayWidth()); - binding.setDisplayHeight(overlayViewManager.getDisplayHeight()); + + // The slider ranges come from this Activity's window, not from the display or from the + // overlay permission. Multi-window and system bars make display-wide pixels ambiguous. + Rect bounds = hostWindowBounds(); + binding.setDisplayWidth(bounds.width()); + binding.setDisplayHeight(bounds.height()); + if (savedInstanceState == null) { - binding.xy.setXSeek(overlayViewManager.getDisplayWidth()); // Seekbar progress = 0 - binding.xy.setYSeek(overlayViewManager.getDisplayHeight()); // Seekbar progress = 0 + binding.xy.setXSeek(bounds.width()); // Seekbar progress = 0 + binding.xy.setYSeek(bounds.height()); // Seekbar progress = 0 binding.alpha.setAlphaPercentage(90); binding.gravity.setGravityCheckId(R.id.rbtn_top_start); binding.width.setWidthPixels(400); @@ -92,23 +105,32 @@ protected void onCreate(@Nullable Bundle savedInstanceState) { @Override protected void onStop() { super.onStop(); - overlayView.hide(); + attachedBeforeStop = overlayView.getState() == OverlayState.ATTACHED; + logIfFailed("hide()", overlayView.hide()); + } + + @Override + protected void onDestroy() { + logIfFailed("dispose()", overlayView.dispose()); + super.onDestroy(); } public void onClick(View view) { - switch (view.getId()) { - case R.id.sample_text_view: - overlayView.getView() - .setText("Clicked: " + SimpleDateFormat.getTimeInstance().format(new Date())); - break; - case R.id.btn_show: - overlayView.getView().setText("overlayView.show()"); - overlayView.show(); - break; - case R.id.btn_hide: - overlayView.hide(); - break; + if (view.getId() == R.id.btn_show) { + OverlayResult result = overlayView.show(); + updateText("overlayView.show()\n// %s", describe(result)); + logIfFailed("show()", result); + } else if (view.getId() == R.id.btn_hide) { + logIfFailed("hide()", overlayView.hide()); + } + } + + private Rect hostWindowBounds() { + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) { + return getWindowManager().getCurrentWindowMetrics().getBounds(); } + DisplayMetrics metrics = getResources().getDisplayMetrics(); + return new Rect(0, 0, metrics.widthPixels, metrics.heightPixels); } TextView createTextView() { @@ -123,136 +145,141 @@ TextView createTextView() { } private void updateText(String str, Object... args) { - String newText = String.format(str, args); - overlayView.getView().setText(newText); + overlayView.getView().setText(String.format(Locale.US, str, args)); + } + + /** + * Applies {@code next} with {@link OverlayView#update(OverlaySpec)} and shows both the code that + * produced it and the result on the overlay itself. {@code code} is the builder call chain for + * the changed field, e.g. {@code .setAlpha(0.90f)}. + */ + private void applySpec(OverlaySpec next, String code) { + OverlayResult result = overlayView.update(next); + updateText("overlayView.update(\n overlayView.getSpec().toBuilder()\n %s\n .build());\n// %s", code, describe(result)); + logIfFailed("update()", result); + } + + private OverlaySpec.Builder spec() { + return overlayView.getSpec().toBuilder(); + } + + private static String describe(OverlayResult result) { + if (result.isSuccess()) { + return result.getState() + (result.getChanged() ? "" : " (no change)"); + } + return "FAILED " + result.getFailure() + " (state " + result.getState() + ")"; + } + + private static void logIfFailed(String action, OverlayResult result) { + if (!result.isSuccess()) { + Log.w(TAG, action + " failed: " + result.getFailure(), result.getCause()); + } + } + + private static OverlayTouchMode touchMode(boolean touchable, boolean draggable) { + if (draggable) { + return OverlayTouchMode.DRAGGABLE; + } + return touchable ? OverlayTouchMode.INTERACTIVE : OverlayTouchMode.PASS_THROUGH; } @Override public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) { - Timber.d("onCheckedChanged id:%d, isChecked:%s", buttonView.getId(), isChecked); - switch (buttonView.getId()) { - case R.id.chk_touchable: - binding.flags.setIsTouchable(isChecked); - overlayView.setTouchable(isChecked).update(); - updateText("overlayView\n .setTouchable(%s)\n .update();", isChecked); - break; - case R.id.chk_draggable: - binding.flags.setIsDraggable(isChecked); - overlayView.setDraggable(isChecked).update(); - updateText("overlayView\n .setDraggable(%s)\n .update();", isChecked); - break; - case R.id.chk_allowViewToExtendOutsideScreen: - binding.flags.setAllowViewToExtendOutsideScreen(isChecked); - overlayView.allowViewToExtendOutsideScreen(isChecked).update(); - updateText("overlayView\n .allowViewToExtendOutsideScreen(%s)\n .update();", isChecked); - break; + Log.d(TAG, "onCheckedChanged id:" + buttonView.getId() + ", isChecked:" + isChecked); + if (buttonView.getId() == R.id.chk_touchable) { + binding.flags.setIsTouchable(isChecked); + OverlayTouchMode mode = touchMode(isChecked, binding.flags.getIsDraggable()); + applySpec(spec().setTouchMode(mode).build(), ".setTouchMode(OverlayTouchMode." + mode + ")"); + } else if (buttonView.getId() == R.id.chk_draggable) { + binding.flags.setIsDraggable(isChecked); + OverlayTouchMode mode = touchMode(binding.flags.getIsTouchable(), isChecked); + applySpec(spec().setTouchMode(mode).build(), ".setTouchMode(OverlayTouchMode." + mode + ")"); + } else if (buttonView.getId() == R.id.chk_allowViewToExtendOutsideScreen) { + binding.flags.setAllowViewToExtendOutsideScreen(isChecked); + // allowOutsideBounds lets the window extend past the parent bounds; it does not + // guarantee anything about drawing over system bars. + applySpec(spec().setAllowOutsideBounds(isChecked).build(), ".setAllowOutsideBounds(" + isChecked + ")"); } } @Override public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) { - Timber.d("onProgressChanged seekBarId:%d, progress:%d", seekBar.getId(), progress); - switch (seekBar.getId()) { - case R.id.seek_alpha: - binding.alpha.setAlphaPercentage(progress); - float alpha = progress / 100f; - overlayView.setAlpha(alpha).update(); - updateText("overlayView\n .setAlpha(%.2f)\n .update();", alpha); - break; - case R.id.seek_x: - binding.xy.setXSeek(progress); - int x = progress - binding.getDisplayWidth(); - overlayView.setX(x).update(); - updateText("overlayView\n .setX(%d)\n .update()", x); - break; - case R.id.seek_y: - binding.xy.setYSeek(progress); - int y = progress - binding.getDisplayHeight(); - overlayView.setY(y).update(); - updateText("overlayView\n .setY(%d)\n .update()", y); - break; - case R.id.seek_width_px: - binding.width.setWidthPixels(progress); - if (binding.width.getWidthCheckId() == R.id.rbtn_width_px) { - overlayView.setWidth(progress).update(); - updateText("overlayView\n .setWidth(%d)\n .update()", progress); - } - break; - case R.id.seek_height_px: - binding.height.setHeightPixels(progress); - if (binding.height.getHeightCheckId() == R.id.rbtn_height_px) { - overlayView.setHeight(progress).update(); - updateText("overlayView\n .setHeight(%d)\n .update()", progress); - } - break; - case R.id.seek_margin_vertical: - binding.margins.setVerticalMarginPercentage(progress); - float verticalMargin = progress / 100f; - overlayView.setVerticalMargin(verticalMargin).update(); - updateText("overlayView\n .setVerticalMargin(%.2f)\n .update()", verticalMargin); - break; - case R.id.seek_margin_horizontal: - binding.margins.setHorizontalMarginPercentage(progress); - float horizontalMargin = progress / 100f; - overlayView.setHorizontalMargin(horizontalMargin).update(); - updateText("overlayView\n .setHorizontalMargin(%.2f)\n .update()", horizontalMargin); - break; + Log.d(TAG, "onProgressChanged seekBarId:" + seekBar.getId() + ", progress:" + progress); + if (seekBar.getId() == R.id.seek_alpha) { + binding.alpha.setAlphaPercentage(progress); + float alpha = progress / 100f; + applySpec(spec().setAlpha(alpha).build(), String.format(Locale.US, ".setAlpha(%.2ff)", alpha)); + } else if (seekBar.getId() == R.id.seek_x) { + binding.xy.setXSeek(progress); + int x = progress - binding.getDisplayWidth(); + applySpec(spec().setX(x).build(), ".setX(" + x + ")"); + } else if (seekBar.getId() == R.id.seek_y) { + binding.xy.setYSeek(progress); + int y = progress - binding.getDisplayHeight(); + applySpec(spec().setY(y).build(), ".setY(" + y + ")"); + } else if (seekBar.getId() == R.id.seek_width_px) { + binding.width.setWidthPixels(progress); + if (binding.width.getWidthCheckId() == R.id.rbtn_width_px) { + applySpec(spec().setWidth(progress).build(), ".setWidth(" + progress + ")"); + } + } else if (seekBar.getId() == R.id.seek_height_px) { + binding.height.setHeightPixels(progress); + if (binding.height.getHeightCheckId() == R.id.rbtn_height_px) { + applySpec(spec().setHeight(progress).build(), ".setHeight(" + progress + ")"); + } + } else if (seekBar.getId() == R.id.seek_margin_vertical) { + binding.margins.setVerticalMarginPercentage(progress); + float verticalMargin = progress / 100f; + applySpec(spec().setVerticalMargin(verticalMargin).build(), String.format(Locale.US, ".setVerticalMargin(%.2ff)", verticalMargin)); + } else if (seekBar.getId() == R.id.seek_margin_horizontal) { + binding.margins.setHorizontalMarginPercentage(progress); + float horizontalMargin = progress / 100f; + applySpec(spec().setHorizontalMargin(horizontalMargin).build(), String.format(Locale.US, ".setHorizontalMargin(%.2ff)", horizontalMargin)); } } + @Override + public void onStartTrackingTouch(SeekBar seekBar) { + } + + @Override + public void onStopTrackingTouch(SeekBar seekBar) { + } + @Override public void onCheckedChanged(RadioGroup group, int checkedId) { - Timber.d("onCheckedChanged groupId:%d, checkedId:%d", group.getId(), checkedId); - switch (group.getId()) { - case R.id.rgrp_gravity: - binding.gravity.setGravityCheckId(checkedId); - overlayView.setGravity(getGravityValue(checkedId)).update(); - updateText("overlayView\n .setGravity(%s)\n .update()", getGravityValueString(checkedId)); - break; - case R.id.rgrp_width: - binding.width.setWidthCheckId(checkedId); - switch (checkedId) { - case R.id.rbtn_width_wc: - overlayView.setWidth(WRAP_CONTENT).update(); - updateText("overlayView\n .setWidth(WRAP_CONTENT)\n .update()"); - break; - case R.id.rbtn_width_mp: - overlayView.setWidth(MATCH_PARENT).update(); - updateText("overlayView\n .setWidth(MATCH_PARENT)\n .update()"); - break; - case R.id.rbtn_width_px: - overlayView.setWidth(binding.width.getWidthPixels()).update(); - binding.width.setWidthPixels(binding.width.getWidthPixels()); - updateText("overlayView\n .setWidth(%d)\n .update()", binding.width.getWidthPixels()); - break; - } - break; - case R.id.rgrp_height: - binding.height.setHeightCheckId(checkedId); - switch (checkedId) { - case R.id.rbtn_height_wc: - overlayView.setHeight(WRAP_CONTENT).update(); - updateText("overlayView\n .setHeight(WRAP_CONTENT)\n .update()"); - break; - case R.id.rbtn_height_mp: - overlayView.setHeight(MATCH_PARENT).update(); - updateText("overlayView\n .setHeight(MATCH_PARENT)\n .update()"); - break; - case R.id.rbtn_height_px: - overlayView.setHeight(binding.height.getHeightPixels()).update(); - binding.height.setHeightPixels(binding.height.getHeightPixels()); - updateText("overlayView\n .setHeight(%d)\n .update()", binding.height.getHeightPixels()); - break; - } - break; + Log.d(TAG, "onCheckedChanged groupId:" + group.getId() + ", checkedId:" + checkedId); + if (group.getId() == R.id.rgrp_gravity) { + binding.gravity.setGravityCheckId(checkedId); + applySpec(spec().setGravity(getGravityValue(checkedId)).build(), ".setGravity(Gravity." + getGravityValueString(checkedId) + ")"); + } else if (group.getId() == R.id.rgrp_width) { + binding.width.setWidthCheckId(checkedId); + if (checkedId == R.id.rbtn_width_wc) { + applySpec(spec().setWidth(WRAP_CONTENT).build(), ".setWidth(WRAP_CONTENT)"); + } else if (checkedId == R.id.rbtn_width_mp) { + applySpec(spec().setWidth(MATCH_PARENT).build(), ".setWidth(MATCH_PARENT)"); + } else if (checkedId == R.id.rbtn_width_px) { + int width = binding.width.getWidthPixels(); + applySpec(spec().setWidth(width).build(), ".setWidth(" + width + ")"); + } + } else if (group.getId() == R.id.rgrp_height) { + binding.height.setHeightCheckId(checkedId); + if (checkedId == R.id.rbtn_height_wc) { + applySpec(spec().setHeight(WRAP_CONTENT).build(), ".setHeight(WRAP_CONTENT)"); + } else if (checkedId == R.id.rbtn_height_mp) { + applySpec(spec().setHeight(MATCH_PARENT).build(), ".setHeight(MATCH_PARENT)"); + } else if (checkedId == R.id.rbtn_height_px) { + int height = binding.height.getHeightPixels(); + applySpec(spec().setHeight(height).build(), ".setHeight(" + height + ")"); + } } } private static final String KEY_FLAGS_IS_TOUCHABLE = "flags.IsTouchable"; private static final String KEY_FLAGS_IS_DRAGGABLE = "flags.IsDraggable"; - private static final String KEY_FLAGS_ALLOW_VIEW_TO_EXTEND_OUTSIDE_SCREEN = "flags.AllowViewToExtendOutsideScreen"; - private static final String KEY_XY_XSEEK = "xy.XSeek"; - private static final String KEY_XY_YSEEK = "xy.YSeek"; + private static final String KEY_FLAGS_ALLOW_OUTSIDE_BOUNDS = "flags.AllowOutsideBounds"; + private static final String KEY_XY_X = "xy.X"; + private static final String KEY_XY_Y = "xy.Y"; private static final String KEY_ALPHA_ALPHA_PERCENTAGE = "alpha.AlphaPercentage"; private static final String KEY_GRAVITY_GRAVITY_CHECK_ID = "gravity.GravityCheckId"; private static final String KEY_WIDTH_WIDTH_CHECK_ID = "width.WidthCheckId"; @@ -261,18 +288,18 @@ public void onCheckedChanged(RadioGroup group, int checkedId) { private static final String KEY_HEIGHT_HEIGHT_PIXELS = "height.HeightPixels"; private static final String KEY_MARGINS_VERTICAL_MARGIN_PERCENTAGE = "margins.VerticalMarginPercentage"; private static final String KEY_MARGINS_HORIZONTAL_MARGIN_PERCENTAGE = "margins.HorizontalMarginPercentage"; - - private static final String KEY_IS_VISIBLE = "isVisible"; + private static final String KEY_IS_ATTACHED = "isAttached"; @Override protected void onSaveInstanceState(Bundle outState) { - outState.putBoolean(KEY_IS_VISIBLE, overlayView.isVisible()); - overlayView.hide(); + // On API 28+ this runs after onStop(), which already hid the overlay; remember what the + // user saw before the stop instead of the current state. + outState.putBoolean(KEY_IS_ATTACHED, attachedBeforeStop || overlayView.getState() == OverlayState.ATTACHED); outState.putBoolean(KEY_FLAGS_IS_TOUCHABLE, binding.flags.getIsTouchable()); outState.putBoolean(KEY_FLAGS_IS_DRAGGABLE, binding.flags.getIsDraggable()); - outState.putBoolean(KEY_FLAGS_ALLOW_VIEW_TO_EXTEND_OUTSIDE_SCREEN, binding.flags.getAllowViewToExtendOutsideScreen()); - outState.putInt(KEY_XY_XSEEK, binding.xy.getXSeek() - binding.getDisplayWidth()); - outState.putInt(KEY_XY_YSEEK, binding.xy.getYSeek() - binding.getDisplayHeight()); + outState.putBoolean(KEY_FLAGS_ALLOW_OUTSIDE_BOUNDS, binding.flags.getAllowViewToExtendOutsideScreen()); + outState.putInt(KEY_XY_X, binding.xy.getXSeek() - binding.getDisplayWidth()); + outState.putInt(KEY_XY_Y, binding.xy.getYSeek() - binding.getDisplayHeight()); outState.putInt(KEY_ALPHA_ALPHA_PERCENTAGE, binding.alpha.getAlphaPercentage()); outState.putInt(KEY_GRAVITY_GRAVITY_CHECK_ID, binding.gravity.getGravityCheckId()); outState.putInt(KEY_WIDTH_WIDTH_CHECK_ID, binding.width.getWidthCheckId()); @@ -281,18 +308,16 @@ protected void onSaveInstanceState(Bundle outState) { outState.putInt(KEY_HEIGHT_HEIGHT_PIXELS, binding.height.getHeightPixels()); outState.putInt(KEY_MARGINS_VERTICAL_MARGIN_PERCENTAGE, binding.margins.getVerticalMarginPercentage()); outState.putInt(KEY_MARGINS_HORIZONTAL_MARGIN_PERCENTAGE, binding.margins.getHorizontalMarginPercentage()); - Timber.d("onSaveInstanceState %s", outState); super.onSaveInstanceState(outState); } @Override protected void onRestoreInstanceState(Bundle savedInstanceState) { - Timber.d("onRestoreInstanceState %s", savedInstanceState); boolean isTouchable = savedInstanceState.getBoolean(KEY_FLAGS_IS_TOUCHABLE); boolean isDraggable = savedInstanceState.getBoolean(KEY_FLAGS_IS_DRAGGABLE); - boolean allowViewToExtendOutsideScreen = savedInstanceState.getBoolean(KEY_FLAGS_ALLOW_VIEW_TO_EXTEND_OUTSIDE_SCREEN); - int x = savedInstanceState.getInt(KEY_XY_XSEEK); - int y = savedInstanceState.getInt(KEY_XY_YSEEK); + boolean allowOutsideBounds = savedInstanceState.getBoolean(KEY_FLAGS_ALLOW_OUTSIDE_BOUNDS); + int x = savedInstanceState.getInt(KEY_XY_X); + int y = savedInstanceState.getInt(KEY_XY_Y); int alphaPercentage = savedInstanceState.getInt(KEY_ALPHA_ALPHA_PERCENTAGE); int gravityCheckId = savedInstanceState.getInt(KEY_GRAVITY_GRAVITY_CHECK_ID); int widthCheckId = savedInstanceState.getInt(KEY_WIDTH_WIDTH_CHECK_ID); @@ -304,9 +329,10 @@ protected void onRestoreInstanceState(Bundle savedInstanceState) { binding.flags.setIsTouchable(isTouchable); binding.flags.setIsDraggable(isDraggable); - binding.flags.setAllowViewToExtendOutsideScreen(allowViewToExtendOutsideScreen); - binding.xy.setXSeek(x + binding.getDisplayWidth()); - binding.xy.setYSeek(y + binding.getDisplayHeight()); + binding.flags.setAllowViewToExtendOutsideScreen(allowOutsideBounds); + // The window may have changed size across the recreation; clamp to the new range. + binding.xy.setXSeek(Math.max(0, Math.min(x + binding.getDisplayWidth(), binding.getDisplayWidth() * 2))); + binding.xy.setYSeek(Math.max(0, Math.min(y + binding.getDisplayHeight(), binding.getDisplayHeight() * 2))); binding.alpha.setAlphaPercentage(alphaPercentage); binding.gravity.setGravityCheckId(gravityCheckId); binding.width.setWidthCheckId(widthCheckId); @@ -316,9 +342,9 @@ protected void onRestoreInstanceState(Bundle savedInstanceState) { binding.margins.setVerticalMarginPercentage(verticalMarginPercentage); binding.margins.setHorizontalMarginPercentage(horizontalMarginPercentage); - overlayView.setTouchable(isTouchable) - .setDraggable(isDraggable) - .allowViewToExtendOutsideScreen(allowViewToExtendOutsideScreen) + OverlaySpec restored = spec() + .setTouchMode(touchMode(isTouchable, isDraggable)) + .setAllowOutsideBounds(allowOutsideBounds) .setX(x) .setY(y) .setAlpha(alphaPercentage / 100f) @@ -330,58 +356,59 @@ protected void onRestoreInstanceState(Bundle savedInstanceState) { : heightCheckId == R.id.rbtn_height_mp ? MATCH_PARENT : heightPixels) .setVerticalMargin(verticalMarginPercentage / 100f) - .setHorizontalMargin(horizontalMarginPercentage / 100f); + .setHorizontalMargin(horizontalMarginPercentage / 100f) + .build(); + logIfFailed("update()", overlayView.update(restored)); - if (savedInstanceState.getBoolean(KEY_IS_VISIBLE)) { - overlayView.show(); + // Recreation needs a new handle and a new show(); the library never re-attaches implicitly. + if (savedInstanceState.getBoolean(KEY_IS_ATTACHED)) { + logIfFailed("show()", overlayView.show()); } super.onRestoreInstanceState(savedInstanceState); } int getGravityValue(int gravityCheckId) { - switch (gravityCheckId) { - case R.id.rbtn_top_start: - return Gravity.TOP | Gravity.START; - case R.id.rbtn_top_center_vertical: - return Gravity.TOP | Gravity.CENTER_HORIZONTAL; - case R.id.rbtn_top_end: - return Gravity.TOP | Gravity.END; - case R.id.rbtn_center_start: - return Gravity.CENTER_VERTICAL | Gravity.START; - case R.id.rbtn_center: - return Gravity.CENTER_VERTICAL | Gravity.CENTER_HORIZONTAL; - case R.id.rbtn_center_end: - return Gravity.CENTER_VERTICAL | Gravity.END; - case R.id.rbtn_bottom_start: - return Gravity.BOTTOM | Gravity.START; - case R.id.rbtn_bottom_center_vertical: - return Gravity.BOTTOM | Gravity.CENTER_HORIZONTAL; - case R.id.rbtn_bottom_end: - return Gravity.BOTTOM | Gravity.END; + if (gravityCheckId == R.id.rbtn_top_start) { + return Gravity.TOP | Gravity.START; + } else if (gravityCheckId == R.id.rbtn_top_center_vertical) { + return Gravity.TOP | Gravity.CENTER_HORIZONTAL; + } else if (gravityCheckId == R.id.rbtn_top_end) { + return Gravity.TOP | Gravity.END; + } else if (gravityCheckId == R.id.rbtn_center_start) { + return Gravity.CENTER_VERTICAL | Gravity.START; + } else if (gravityCheckId == R.id.rbtn_center) { + return Gravity.CENTER_VERTICAL | Gravity.CENTER_HORIZONTAL; + } else if (gravityCheckId == R.id.rbtn_center_end) { + return Gravity.CENTER_VERTICAL | Gravity.END; + } else if (gravityCheckId == R.id.rbtn_bottom_start) { + return Gravity.BOTTOM | Gravity.START; + } else if (gravityCheckId == R.id.rbtn_bottom_center_vertical) { + return Gravity.BOTTOM | Gravity.CENTER_HORIZONTAL; + } else if (gravityCheckId == R.id.rbtn_bottom_end) { + return Gravity.BOTTOM | Gravity.END; } return Gravity.NO_GRAVITY; } String getGravityValueString(int gravityCheckId) { - switch (gravityCheckId) { - case R.id.rbtn_top_start: - return "TOP | START"; - case R.id.rbtn_top_center_vertical: - return "TOP\n | CENTER_HORIZONTAL"; - case R.id.rbtn_top_end: - return "TOP | END"; - case R.id.rbtn_center_start: - return "\n CENTER_VERTICAL\n | START"; - case R.id.rbtn_center: - return "CENTER"; - case R.id.rbtn_center_end: - return "\n CENTER_VERTICAL\n | END"; - case R.id.rbtn_bottom_start: - return "BOTTOM | START"; - case R.id.rbtn_bottom_center_vertical: - return "BOTTOM\n | CENTER_HORIZONTAL"; - case R.id.rbtn_bottom_end: - return "BOTTOM | END"; + if (gravityCheckId == R.id.rbtn_top_start) { + return "TOP | Gravity.START"; + } else if (gravityCheckId == R.id.rbtn_top_center_vertical) { + return "TOP | Gravity.CENTER_HORIZONTAL"; + } else if (gravityCheckId == R.id.rbtn_top_end) { + return "TOP | Gravity.END"; + } else if (gravityCheckId == R.id.rbtn_center_start) { + return "CENTER_VERTICAL | Gravity.START"; + } else if (gravityCheckId == R.id.rbtn_center) { + return "CENTER"; + } else if (gravityCheckId == R.id.rbtn_center_end) { + return "CENTER_VERTICAL | Gravity.END"; + } else if (gravityCheckId == R.id.rbtn_bottom_start) { + return "BOTTOM | Gravity.START"; + } else if (gravityCheckId == R.id.rbtn_bottom_center_vertical) { + return "BOTTOM | Gravity.CENTER_HORIZONTAL"; + } else if (gravityCheckId == R.id.rbtn_bottom_end) { + return "BOTTOM | Gravity.END"; } return "NO_GRAVITY"; } diff --git a/sample/src/main/java/com/nagopy/android/overlayviewmanager/sample/SampleApplication.java b/sample/src/main/java/com/nagopy/android/overlayviewmanager/sample/SampleApplication.java index 4741009..bb590eb 100644 --- a/sample/src/main/java/com/nagopy/android/overlayviewmanager/sample/SampleApplication.java +++ b/sample/src/main/java/com/nagopy/android/overlayviewmanager/sample/SampleApplication.java @@ -19,9 +19,6 @@ import android.app.Application; import com.nagopy.android.overlayviewmanager.OverlayViewManager; -import com.nagopy.android.overlayviewmanager.opt.timber.DebugOverlayTree; - -import timber.log.Timber; public class SampleApplication extends Application { @@ -30,9 +27,6 @@ public void onCreate() { super.onCreate(); OverlayViewManager.init(this); - - Timber.plant(new Timber.DebugTree()); - Timber.plant(DebugOverlayTree.init(this)); } } diff --git a/sample/src/main/java/com/nagopy/android/overlayviewmanager/sample/SampleOverrideScreenBrightnessActivity.java b/sample/src/main/java/com/nagopy/android/overlayviewmanager/sample/SampleOverrideScreenBrightnessActivity.java index 7a1ed0b..c40e435 100644 --- a/sample/src/main/java/com/nagopy/android/overlayviewmanager/sample/SampleOverrideScreenBrightnessActivity.java +++ b/sample/src/main/java/com/nagopy/android/overlayviewmanager/sample/SampleOverrideScreenBrightnessActivity.java @@ -1,5 +1,5 @@ /* - * Copyright 2018 75py + * Copyright 2017 75py * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -16,55 +16,87 @@ package com.nagopy.android.overlayviewmanager.sample; -import androidx.databinding.DataBindingUtil; -import androidx.databinding.adapters.SeekBarBindingAdapter; import android.os.Bundle; -import androidx.annotation.Nullable; +import android.util.Log; import android.view.View; import android.widget.SeekBar; +import androidx.annotation.Nullable; +import androidx.databinding.DataBindingUtil; + +import com.nagopy.android.overlayviewmanager.OverlayResult; +import com.nagopy.android.overlayviewmanager.OverlaySpec; +import com.nagopy.android.overlayviewmanager.OverlayState; import com.nagopy.android.overlayviewmanager.OverlayView; import com.nagopy.android.overlayviewmanager.OverlayViewManager; import com.nagopy.android.overlayviewmanager.sample.databinding.ActivitySampleOverrideScreenBrightnessBinding; -public class SampleOverrideScreenBrightnessActivity extends BaseSampleWithCodeActivity implements SeekBarBindingAdapter.OnProgressChanged { +/** + * Activity-scoped, fully transparent overlay whose only job is to carry + * {@link OverlaySpec#getScreenBrightness()}. Brightness override is available for activity-scoped + * overlays only; application-scoped specs reject it. + */ +public class SampleOverrideScreenBrightnessActivity extends BaseSampleWithCodeActivity implements SeekBar.OnSeekBarChangeListener { + + private static final String TAG = "SampleBrightness"; + private static final int INITIAL_BRIGHTNESS = 128; OverlayView overlayView; ActivitySampleOverrideScreenBrightnessBinding binding; - @Override protected void onCreate(@Nullable Bundle savedInstanceState) { super.onCreate(savedInstanceState); - - overlayView = OverlayViewManager.getInstance().newOverlayView(new View(this), this) - .setAlpha(0); - + overlayView = OverlayViewManager.getInstance().newOverlayView( + new View(this), + this, + new OverlaySpec.Builder() + .setAlpha(0f) + .setScreenBrightness(INITIAL_BRIGHTNESS / 255f) + .build()); binding = DataBindingUtil.setContentView(this, R.layout.activity_sample_override_screen_brightness); - binding.setBrightness(128); + binding.setBrightness(INITIAL_BRIGHTNESS); binding.setOnProgressChanged(this); binding.setIsOverrideEnabled(false); } @Override protected void onDestroy() { - overlayView.hide(); + OverlayResult disposed = overlayView.dispose(); + if (!disposed.isSuccess()) { + Log.w(TAG, "dispose() failed: " + disposed.getFailure(), disposed.getCause()); + } super.onDestroy(); } public void onClick(View view) { - if (overlayView.isVisible()) { - overlayView.hide(); - binding.setIsOverrideEnabled(false); - } else { - overlayView.show(); - binding.setIsOverrideEnabled(true); + OverlayResult result = overlayView.getState() == OverlayState.ATTACHED + ? overlayView.hide() + : overlayView.show(); + if (!result.isSuccess()) { + Log.w(TAG, "show()/hide() failed: " + result.getFailure(), result.getCause()); } + binding.setIsOverrideEnabled(overlayView.getState() == OverlayState.ATTACHED); } @Override public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) { - overlayView.setScreenBrightness(progress / 255f).update(); + // Start from the effective spec and change only the requested field. + OverlaySpec next = overlayView.getSpec().toBuilder() + .setScreenBrightness(progress / 255f) + .build(); + OverlayResult updated = overlayView.update(next); + if (!updated.isSuccess()) { + Log.w(TAG, "update() failed: " + updated.getFailure(), updated.getCause()); + } binding.setBrightness(progress); } + + @Override + public void onStartTrackingTouch(SeekBar seekBar) { + } + + @Override + public void onStopTrackingTouch(SeekBar seekBar) { + } } diff --git a/sample/src/main/java/com/nagopy/android/overlayviewmanager/sample/SampleStartActivity.java b/sample/src/main/java/com/nagopy/android/overlayviewmanager/sample/SampleStartActivity.java index 479ef0e..e380e1f 100644 --- a/sample/src/main/java/com/nagopy/android/overlayviewmanager/sample/SampleStartActivity.java +++ b/sample/src/main/java/com/nagopy/android/overlayviewmanager/sample/SampleStartActivity.java @@ -17,64 +17,69 @@ package com.nagopy.android.overlayviewmanager.sample; import android.content.Intent; -import androidx.databinding.DataBindingUtil; import android.os.Bundle; +import android.util.Log; +import android.view.View; + +import androidx.activity.result.ActivityResultLauncher; +import androidx.activity.result.contract.ActivityResultContracts; import androidx.annotation.Nullable; import androidx.appcompat.app.AppCompatActivity; -import android.view.View; +import androidx.databinding.DataBindingUtil; +import com.nagopy.android.overlayviewmanager.OverlayPermission; import com.nagopy.android.overlayviewmanager.OverlayViewManager; import com.nagopy.android.overlayviewmanager.sample.databinding.ActivitySampleStartBinding; -import timber.log.Timber; - +/** + * Entry screen. Shows how the host application owns the "display over other apps" permission + * flow: check with {@link OverlayPermission#isGranted}, open the system settings screen through an + * Activity Result launcher, and re-check when the user comes back. The library never opens that + * screen on its own and never retries a show() for you. + */ public class SampleStartActivity extends AppCompatActivity { + private static final String TAG = "SampleStartActivity"; + ActivitySampleStartBinding binding; - OverlayViewManager overlayViewManager; + OverlayPermission overlayPermission; + + // The system settings screen returns no payload; the only reliable signal is to re-check the + // permission once the user is back. + private final ActivityResultLauncher permissionSettingsLauncher = registerForActivityResult( + new ActivityResultContracts.StartActivityForResult(), + result -> refreshPermissionState()); @Override protected void onCreate(@Nullable Bundle savedInstanceState) { super.onCreate(savedInstanceState); - binding = DataBindingUtil.setContentView(this, R.layout.activity_sample_start); - overlayViewManager = OverlayViewManager.getInstance(); - - if (savedInstanceState == null) { - if (!overlayViewManager.canDrawOverlays()) { - overlayViewManager.showPermissionRequestDialog(getSupportFragmentManager(), R.string.app_name); - } - } + overlayPermission = OverlayViewManager.getInstance().overlayPermission(); } @Override protected void onStart() { super.onStart(); - Timber.d("canDrawOverlays:%s", overlayViewManager.canDrawOverlays()); - binding.setCanDrawOverlays(overlayViewManager.canDrawOverlays()); + refreshPermissionState(); } public void onClick(View view) { - switch (view.getId()) { - case R.id.btn_requestPermission: - overlayViewManager.requestOverlayPermission(); - break; - case R.id.btn_sample_all_options: - startActivity(new Intent(this, SampleAllOptionsActivity.class)); - break; - case R.id.btn_sample1: - startActivity(new Intent(this, Sample1Activity.class)); - break; - case R.id.btn_sample2: - startActivity(new Intent(this, Sample2Activity.class)); - break; - case R.id.btn_sample_timber: - startActivity(new Intent(this, SampleTimberActivity.class)); - break; - case R.id.btn_sample_override_brightness: - startActivity(new Intent(this, SampleOverrideScreenBrightnessActivity.class)); - break; + if (view.getId() == R.id.btn_requestPermission) { + permissionSettingsLauncher.launch(overlayPermission.settingsIntent(this)); + } else if (view.getId() == R.id.btn_sample_all_options) { + startActivity(new Intent(this, SampleAllOptionsActivity.class)); + } else if (view.getId() == R.id.btn_sample1) { + startActivity(new Intent(this, Sample1Activity.class)); + } else if (view.getId() == R.id.btn_sample2) { + startActivity(new Intent(this, Sample2Activity.class)); + } else if (view.getId() == R.id.btn_sample_override_brightness) { + startActivity(new Intent(this, SampleOverrideScreenBrightnessActivity.class)); } } + private void refreshPermissionState() { + boolean granted = overlayPermission.isGranted(this); + Log.d(TAG, "overlay permission granted: " + granted); + binding.setCanDrawOverlays(granted); + } } diff --git a/sample/src/main/java/com/nagopy/android/overlayviewmanager/sample/SampleTimberActivity.java b/sample/src/main/java/com/nagopy/android/overlayviewmanager/sample/SampleTimberActivity.java deleted file mode 100644 index c786aaf..0000000 --- a/sample/src/main/java/com/nagopy/android/overlayviewmanager/sample/SampleTimberActivity.java +++ /dev/null @@ -1,54 +0,0 @@ -/* - * Copyright 2017 75py - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.nagopy.android.overlayviewmanager.sample; - -import android.os.Bundle; -import androidx.annotation.Nullable; -import android.view.View; - -import com.nagopy.android.overlayviewmanager.opt.timber.DebugOverlayTree; - -import timber.log.Timber; - -public class SampleTimberActivity extends BaseSampleWithCodeActivity { - - @Override - protected void onCreate(@Nullable Bundle savedInstanceState) { - super.onCreate(savedInstanceState); - DebugOverlayTree.getInstance().register(this); - setContentView(R.layout.activity_sample_timber); - - Timber.d("onCreate"); - } - - @Override - protected void onStart() { - super.onStart(); - Timber.d("onStart"); - } - - @Override - protected void onResume() { - super.onResume(); - Timber.d("onStart"); - } - - public void onClick(View view) { - Timber.d("onClick %d", view.getId()); - } - -} diff --git a/sample/src/main/java/com/nagopy/android/overlayviewmanager/sample/SeekBarChangeBindingAdapter.java b/sample/src/main/java/com/nagopy/android/overlayviewmanager/sample/SeekBarChangeBindingAdapter.java new file mode 100644 index 0000000..afa6abc --- /dev/null +++ b/sample/src/main/java/com/nagopy/android/overlayviewmanager/sample/SeekBarChangeBindingAdapter.java @@ -0,0 +1,35 @@ +/* + * Copyright 2026 75py + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.nagopy.android.overlayviewmanager.sample; + +import android.widget.SeekBar; + +import androidx.databinding.BindingAdapter; + +public final class SeekBarChangeBindingAdapter { + + private SeekBarChangeBindingAdapter() { + } + + // Binds the public SeekBar.OnSeekBarChangeListener instead of the + // data-binding-internal SeekBarBindingAdapter.OnProgressChanged, which is + // @RestrictTo(LIBRARY_GROUP) and trips the RestrictedApi lint check. + @BindingAdapter("android:onSeekBarChangeListener") + public static void setOnSeekBarChangeListener(SeekBar seekBar, SeekBar.OnSeekBarChangeListener listener) { + seekBar.setOnSeekBarChangeListener(listener); + } +} diff --git a/sample/src/main/kotlin/com/nagopy/android/overlayviewmanager/sample/Sample1Activity.kt b/sample/src/main/kotlin/com/nagopy/android/overlayviewmanager/sample/Sample1Activity.kt new file mode 100644 index 0000000..f088ea0 --- /dev/null +++ b/sample/src/main/kotlin/com/nagopy/android/overlayviewmanager/sample/Sample1Activity.kt @@ -0,0 +1,89 @@ +/* + * Copyright 2017 75py + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.nagopy.android.overlayviewmanager.sample + +import android.graphics.Color +import android.os.Bundle +import android.util.Log +import android.view.View +import android.widget.TextView +import androidx.core.widget.TextViewCompat +import com.nagopy.android.overlayviewmanager.OverlaySpec +import com.nagopy.android.overlayviewmanager.OverlayState +import com.nagopy.android.overlayviewmanager.OverlayTouchMode +import com.nagopy.android.overlayviewmanager.OverlayView +import com.nagopy.android.overlayviewmanager.OverlayViewManager + +private const val TAG = "Sample1Activity" + +/** + * Activity-scoped overlay written in Kotlin. It is bounded by this Activity's window, so it needs + * no "display over other apps" permission, and it is draggable while still delivering ordinary + * clicks to the View. + */ +class Sample1Activity : BaseSampleWithCodeActivity() { + + /** Owned by this Activity; exposed read-only for the instrumentation test. */ + lateinit var overlayView: OverlayView + private set + + private var clickCounter = 0 + + override fun onCreate(savedInstanceState: Bundle?) { + super.onCreate(savedInstanceState) + setContentView(R.layout.activity_sample1) + + val textView = createTextView() + // Click handling stays on the View itself, even with OverlayTouchMode.DRAGGABLE. + textView.setOnClickListener { + clickCounter++ + textView.text = "click:$clickCounter" + } + overlayView = OverlayViewManager.getInstance().newOverlayView( + textView, + this, + OverlaySpec(touchMode = OverlayTouchMode.DRAGGABLE), + ) + } + + /** Bound from the layout through `android:onClick`. */ + fun onClick(view: View) { + val result = if (overlayView.state == OverlayState.ATTACHED) overlayView.hide() else overlayView.show() + if (!result.isSuccess) { + Log.w(TAG, "Sample1 show()/hide() failed: ${result.failure}", result.cause) + } + } + + override fun onDestroy() { + // The library also disposes activity-scoped handles when the Activity is destroyed; + // disposing here keeps ownership explicit, and a repeated dispose() is a harmless no-op. + val disposed = overlayView.dispose() + if (!disposed.isSuccess) { + Log.w(TAG, "Sample1 dispose() failed: ${disposed.failure}", disposed.cause) + } + super.onDestroy() + } + + private fun createTextView(): TextView = TextView(this).apply { + id = R.id.sample_text_view + TextViewCompat.setTextAppearance(this, androidx.appcompat.R.style.TextAppearance_AppCompat_Large) + text = "click:$clickCounter" + setTextColor(Color.WHITE) + setBackgroundColor(Color.RED) + setPadding(10, 10, 10, 10) + } +} diff --git a/sample/src/main/res/layout/activity_sample1.xml b/sample/src/main/res/layout/activity_sample1.xml index 2111bfc..7a805ab 100644 --- a/sample/src/main/res/layout/activity_sample1.xml +++ b/sample/src/main/res/layout/activity_sample1.xml @@ -18,7 +18,8 @@ + android:layout_height="match_parent" + android:fitsSystemWindows="true">